Cleanup: style, use braces for compositor

12 files changed, 164 insertions, 82 deletions

diff --git a/source/blender/compositor/intern/COM_Converter.cpp b/source/blender/compositor/intern/COM_Converter.cpp
index d7fac8bb5b4..9dc55527f0d 100644
--- a/source/blender/compositor/intern/COM_Converter.cpp
+++ b/source/blender/compositor/intern/COM_Converter.cpp
@@ -130,8 +130,9 @@ Node *Converter::convert(bNode *b_node)
   Node *node = NULL;
 
   /* ignore undefined nodes with missing or invalid node data */
-  if (!nodeIsRegistered(b_node))
+  if (!nodeIsRegistered(b_node)) {
     return NULL;
+  }
 
   switch (b_node->type) {
     case CMP_NODE_COMPOSITE:
@@ -514,8 +515,9 @@ void Converter::convertResolution(NodeOperationBuilder &builder,
     TranslateOperation *translateOperation = new TranslateOperation();
     translateOperation->getInputSocket(1)->setResizeMode(COM_SC_NO_RESIZE);
     translateOperation->getInputSocket(2)->setResizeMode(COM_SC_NO_RESIZE);
-    if (!first)
+    if (!first) {
       first = translateOperation;
+    }
     SetValueOperation *xop = new SetValueOperation();
     xop->setValue(addX);
     builder.addLink(xop->getOutputSocket(), translateOperation->getInputSocket(1));
diff --git a/source/blender/compositor/intern/COM_Debug.cpp b/source/blender/compositor/intern/COM_Debug.cpp
index b977154db1a..8632b7ad0f0 100644
--- a/source/blender/compositor/intern/COM_Debug.cpp
+++ b/source/blender/compositor/intern/COM_Debug.cpp
@@ -53,19 +53,23 @@ DebugInfo::GroupStateMap DebugInfo::m_group_states;
 std::string DebugInfo::node_name(const Node *node)
 {
   NodeNameMap::const_iterator it = m_node_names.find(node);
-  if (it != m_node_names.end())
+  if (it != m_node_names.end()) {
     return it->second;
-  else
+  }
+  else {
     return "";
+  }
 }
 
 std::string DebugInfo::operation_name(const NodeOperation *op)
 {
   OpNameMap::const_iterator it = m_op_names.find(op);
-  if (it != m_op_names.end())
+  if (it != m_op_names.end()) {
     return it->second;
-  else
+  }
+  else {
     return "";
+  }
 }
 
 void DebugInfo::convert_started()
@@ -79,8 +83,9 @@ void DebugInfo::execute_started(const ExecutionSystem *system)
   m_group_states.clear();
   for (ExecutionSystem::Groups::const_iterator it = system->m_groups.begin();
        it != system->m_groups.end();
-       ++it)
+       ++it) {
     m_group_states[*it] = EG_WAIT;
+  }
 }
 
 void DebugInfo::node_added(const Node *node)
@@ -145,10 +150,12 @@ int DebugInfo::graphviz_operation(const ExecutionSystem *system,
   }
 
   len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "// OPERATION: %p\r\n", operation);
-  if (group)
+  if (group) {
     len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "\"O_%p_%p\"", operation, group);
-  else
+  }
+  else {
     len += snprintf(str + len, maxlen > len ? maxlen - len : 0, "\"O_%p\"", operation);
+  }
   len += snprintf(str + len,
                   maxlen > len ? maxlen - len : 0,
                   " [fillcolor=%s,style=filled,shape=record,label=\"{",
@@ -368,8 +375,9 @@ bool DebugInfo::graphviz_system(const ExecutionSystem *system, char *str, int ma
   /* operations not included in any group */
   for (int j = 0; j < totops; ++j) {
     NodeOperation *operation = system->m_operations[j];
-    if (op_groups.find(operation) != op_groups.end())
+    if (op_groups.find(operation) != op_groups.end()) {
       continue;
+    }
 
     op_groups[operation].push_back(std::string(""));
 
@@ -407,8 +415,9 @@ bool DebugInfo::graphviz_system(const ExecutionSystem *system, char *str, int ma
       NodeOperationInput *to = *it;
       NodeOperationOutput *from = to->getLink();
 
-      if (!from)
+      if (!from) {
         continue;
+      }
 
       std::string color;
       switch (from->getDataType()) {
diff --git a/source/blender/compositor/intern/COM_ExecutionGroup.cpp b/source/blender/compositor/intern/COM_ExecutionGroup.cpp
index 50caf51cf48..367362c2c66 100644
--- a/source/blender/compositor/intern/COM_ExecutionGroup.cpp
+++ b/source/blender/compositor/intern/COM_ExecutionGroup.cpp
@@ -96,8 +96,9 @@ bool ExecutionGroup::canContainOperation(NodeOperation *operation)
 
 bool ExecutionGroup::addOperation(NodeOperation *operation)
 {
-  if (!canContainOperation(operation))
+  if (!canContainOperation(operation)) {
     return false;
+  }
 
   if (!operation->isReadBufferOperation() && !operation->isWriteBufferOperation()) {
     m_complex = operation->isComplex();
@@ -342,8 +343,9 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
         startEvaluated = true;
         numberEvaluated++;
 
-        if (bTree->update_draw)
+        if (bTree->update_draw) {
           bTree->update_draw(bTree->udh);
+        }
       }
       else if (state == COM_ES_SCHEDULED) {
         finished = false;
@@ -401,8 +403,9 @@ MemoryBuffer *ExecutionGroup::constructConsolidatedMemoryBuffer(MemoryProxy *mem
 
 void ExecutionGroup::finalizeChunkExecution(int chunkNumber, MemoryBuffer **memoryBuffers)
 {
-  if (this->m_chunkExecutionStates[chunkNumber] == COM_ES_SCHEDULED)
+  if (this->m_chunkExecutionStates[chunkNumber] == COM_ES_SCHEDULED) {
     this->m_chunkExecutionStates[chunkNumber] = COM_ES_EXECUTED;
+  }
 
   atomic_add_and_fetch_u(&this->m_chunksFinished, 1);
   if (memoryBuffers) {
diff --git a/source/blender/compositor/intern/COM_MemoryBuffer.h b/source/blender/compositor/intern/COM_MemoryBuffer.h
index 12cd55c95a3..01a8a86bb15 100644
--- a/source/blender/compositor/intern/COM_MemoryBuffer.h
+++ b/source/blender/compositor/intern/COM_MemoryBuffer.h
@@ -158,10 +158,12 @@ class MemoryBuffer {
       case COM_MB_CLIP:
         break;
       case COM_MB_EXTEND:
-        if (x < 0)
+        if (x < 0) {
           x = 0;
-        if (x >= w)
+        }
+        if (x >= w) {
           x = w;
+        }
         break;
       case COM_MB_REPEAT:
         x = (x >= 0.0f ? (x % w) : (x % w) + w);
@@ -172,10 +174,12 @@ class MemoryBuffer {
       case COM_MB_CLIP:
         break;
       case COM_MB_EXTEND:
-        if (y < 0)
+        if (y < 0) {
           y = 0;
-        if (y >= h)
+        }
+        if (y >= h) {
           y = h;
+        }
         break;
       case COM_MB_REPEAT:
         y = (y >= 0.0f ? (y % h) : (y % h) + h);
@@ -197,10 +201,12 @@ class MemoryBuffer {
       case COM_MB_CLIP:
         break;
       case COM_MB_EXTEND:
-        if (x < 0)
+        if (x < 0) {
           x = 0.0f;
-        if (x >= w)
+        }
+        if (x >= w) {
           x = w;
+        }
         break;
       case COM_MB_REPEAT:
         x = fmodf(x, w);
@@ -211,10 +217,12 @@ class MemoryBuffer {
       case COM_MB_CLIP:
         break;
       case COM_MB_EXTEND:
-        if (y < 0)
+        if (y < 0) {
           y = 0.0f;
-        if (y >= h)
+        }
+        if (y >= h) {
           y = h;
+        }
         break;
       case COM_MB_REPEAT:
         y = fmodf(y, h);
diff --git a/source/blender/compositor/intern/COM_Node.cpp b/source/blender/compositor/intern/COM_Node.cpp
index b38493e19f2..df5a8e690d3 100644
--- a/source/blender/compositor/intern/COM_Node.cpp
+++ b/source/blender/compositor/intern/COM_Node.cpp
@@ -48,10 +48,12 @@ Node::Node(bNode *editorNode, bool create_sockets)
     bNodeSocket *input = (bNodeSocket *)editorNode->inputs.first;
     while (input != NULL) {
       DataType dt = COM_DT_VALUE;
-      if (input->type == SOCK_RGBA)
+      if (input->type == SOCK_RGBA) {
         dt = COM_DT_COLOR;
-      if (input->type == SOCK_VECTOR)
+      }
+      if (input->type == SOCK_VECTOR) {
         dt = COM_DT_VECTOR;
+      }
 
       this->addInputSocket(dt, input);
       input = input->next;
@@ -59,10 +61,12 @@ Node::Node(bNode *editorNode, bool create_sockets)
     bNodeSocket *output = (bNodeSocket *)editorNode->outputs.first;
     while (output != NULL) {
       DataType dt = COM_DT_VALUE;
-      if (output->type == SOCK_RGBA)
+      if (output->type == SOCK_RGBA) {
         dt = COM_DT_COLOR;
-      if (output->type == SOCK_VECTOR)
+      }
+      if (output->type == SOCK_VECTOR) {
         dt = COM_DT_VECTOR;
+      }
 
       this->addOutputSocket(dt, output);
       output = output->next;
diff --git a/source/blender/compositor/intern/COM_NodeGraph.cpp b/source/blender/compositor/intern/COM_NodeGraph.cpp
index 89f4542d42f..39dc946f3bc 100644
--- a/source/blender/compositor/intern/COM_NodeGraph.cpp
+++ b/source/blender/compositor/intern/COM_NodeGraph.cpp
@@ -60,8 +60,9 @@ bNodeSocket *NodeGraph::find_b_node_input(bNode *b_group_node, const char *ident
 {
   for (bNodeSocket *b_sock = (bNodeSocket *)b_group_node->inputs.first; b_sock;
        b_sock = b_sock->next) {
-    if (STREQ(b_sock->identifier, identifier))
+    if (STREQ(b_sock->identifier, identifier)) {
       return b_sock;
+    }
   }
   return NULL;
 }
@@ -70,8 +71,9 @@ bNodeSocket *NodeGraph::find_b_node_output(bNode *b_group_node, const char *iden
 {
   for (bNodeSocket *b_sock = (bNodeSocket *)b_group_node->outputs.first; b_sock;
        b_sock = b_sock->next) {
-    if (STREQ(b_sock->identifier, identifier))
+    if (STREQ(b_sock->identifier, identifier)) {
       return b_sock;
+    }
   }
   return NULL;
 }
@@ -149,8 +151,9 @@ void NodeGraph::add_bNode(const CompositorContext &context,
   else {
     /* regular nodes, handled in Converter */
     Node *node = Converter::convert(b_node);
-    if (node)
+    if (node) {
       add_node(node, b_ntree, key, is_active_group);
+    }
   }
 }
 
@@ -186,24 +189,28 @@ NodeOutput *NodeGraph::find_output(const NodeRange &node_range, bNodeSocket *b_s
 void NodeGraph::add_bNodeLink(const NodeRange &node_range, bNodeLink *b_nodelink)
 {
   /// \note: ignore invalid links
-  if (!(b_nodelink->flag & NODE_LINK_VALID))
+  if (!(b_nodelink->flag & NODE_LINK_VALID)) {
     return;
-  if ((b_nodelink->fromsock->flag & SOCK_UNAVAIL) || (b_nodelink->tosock->flag & SOCK_UNAVAIL))
+  }
+  if ((b_nodelink->fromsock->flag & SOCK_UNAVAIL) || (b_nodelink->tosock->flag & SOCK_UNAVAIL)) {
     return;
+  }
 
   /* Note: a DNA input socket can have multiple NodeInput in the compositor tree! (proxies)
    * The output then gets linked to each one of them.
    */
 
   NodeOutput *output = find_output(node_range, b_nodelink->fromsock);
-  if (!output)
+  if (!output) {
     return;
+  }
 
   NodeInputs inputs = find_inputs(node_range, b_nodelink->tosock);
   for (NodeInputs::const_iterator it = inputs.begin(); it != inputs.end(); ++it) {
     NodeInput *input = *it;
-    if (input->isLinked())
+    if (input->isLinked()) {
       continue;
+    }
     add_link(output, input);
   }
 }
@@ -232,8 +239,9 @@ void NodeGraph::add_proxies_skip(bNodeTree *b_ntree,
 
     /* look for first input with matching datatype for each output */
     for (input = (bNodeSocket *)b_node->inputs.first; input; input = input->next) {
-      if (input->type == output->type)
+      if (input->type == output->type) {
         break;
+      }
     }
 
     if (input) {
@@ -305,11 +313,13 @@ void NodeGraph::add_proxies_group(const CompositorContext &context,
   /* create proxy nodes for group input/output nodes */
   for (bNode *b_node_io = (bNode *)b_group_tree->nodes.first; b_node_io;
        b_node_io = b_node_io->next) {
-    if (b_node_io->type == NODE_GROUP_INPUT)
+    if (b_node_io->type == NODE_GROUP_INPUT) {
       add_proxies_group_inputs(b_node, b_node_io);
+    }
 
-    if (b_node_io->type == NODE_GROUP_OUTPUT && (b_node_io->flag & NODE_DO_OUTPUT))
+    if (b_node_io->type == NODE_GROUP_OUTPUT && (b_node_io->flag & NODE_DO_OUTPUT)) {
       add_proxies_group_outputs(b_node, b_node_io, context.isGroupnodeBufferEnabled());
+    }
   }
 
   add_bNodeTree(context, nodes_start, b_group_tree, key);
diff --git a/source/blender/compositor/intern/COM_NodeOperation.cpp b/source/blender/compositor/intern/COM_NodeOperation.cpp
index b0f7bf746fa..80243c10760 100644
--- a/source/blender/compositor/intern/COM_NodeOperation.cpp
+++ b/source/blender/compositor/intern/COM_NodeOperation.cpp
@@ -142,10 +142,12 @@ SocketReader *NodeOperation::getInputSocketReader(unsigned int inputSocketIndex)
 NodeOperation *NodeOperation::getInputOperation(unsigned int inputSocketIndex)
 {
   NodeOperationInput *input = getInputSocket(inputSocketIndex);
-  if (input && input->isConnected())
+  if (input && input->isConnected()) {
     return &input->getLink()->getOperation();
-  else
+  }
+  else {
     return NULL;
+  }
 }
 
 void NodeOperation::getConnectedInputSockets(Inputs *sockets)
@@ -216,8 +218,9 @@ SocketReader *NodeOperationInput::getReader()
 void NodeOperationInput::determineResolution(unsigned int resolution[2],
                                              unsigned int preferredResolution[2])
 {
-  if (m_link)
+  if (m_link) {
     m_link->determineResolution(resolution, preferredResolution);
+  }
 }
 
 /******************
diff --git a/source/blender/compositor/intern/COM_NodeOperation.h b/source/blender/compositor/intern/COM_NodeOperation.h
index 939d3e1f8a7..968dc171bd3 100644
--- a/source/blender/compositor/intern/COM_NodeOperation.h
+++ b/source/blender/compositor/intern/COM_NodeOperation.h
@@ -365,8 +365,9 @@ class NodeOperation : public SocketReader {
 
   inline void updateDraw()
   {
-    if (this->m_btree->update_draw)
+    if (this->m_btree->update_draw) {
       this->m_btree->update_draw(this->m_btree->udh);
+    }
   }
 
  protected:
diff --git a/source/blender/compositor/intern/COM_NodeOperationBuilder.cpp b/source/blender/compositor/intern/COM_NodeOperationBuilder.cpp
index 0f331a25ed9..853e0e768d3 100644
--- a/source/blender/compositor/intern/COM_NodeOperationBuilder.cpp
+++ b/source/blender/compositor/intern/COM_NodeOperationBuilder.cpp
@@ -70,8 +70,9 @@ void NodeOperationBuilder::convertToOperations(ExecutionSystem *system)
    * so multiple operations can use the same node input.
    */
   OpInputInverseMap inverse_input_map;
-  for (InputSocketMap::const_iterator it = m_input_map.begin(); it != m_input_map.end(); ++it)
+  for (InputSocketMap::const_iterator it = m_input_map.begin(); it != m_input_map.end(); ++it) {
     inverse_input_map[it->second].push_back(it->first);
+  }
 
   for (NodeGraph::Links::const_iterator it = m_graph.links().begin(); it != m_graph.links().end();
        ++it) {
@@ -153,8 +154,9 @@ void NodeOperationBuilder::mapOutputSocket(NodeOutput *node_socket,
 
 void NodeOperationBuilder::addLink(NodeOperationOutput *from, NodeOperationInput *to)
 {
-  if (to->isConnected())
+  if (to->isConnected()) {
     return;
+  }
 
   m_links.push_back(Link(from, to));
 
@@ -202,14 +204,17 @@ PreviewOperation *NodeOperationBuilder::make_preview_operation() const
 {
   BLI_assert(m_current_node);
 
-  if (!(m_current_node->getbNode()->flag & NODE_PREVIEW))
+  if (!(m_current_node->getbNode()->flag & NODE_PREVIEW)) {
     return NULL;
+  }
   /* previews only in the active group */
-  if (!m_current_node->isInActiveGroup())
+  if (!m_current_node->isInActiveGroup()) {
     return NULL;
+  }
   /* do not calculate previews of hidden nodes */
-  if (m_current_node->getbNode()->flag & NODE_HIDDEN)
+  if (m_current_node->getbNode()->flag & NODE_HIDDEN) {
     return NULL;
+  }
 
   bNodeInstanceHash *previews = m_context->getPreviewHash();
   if (previews) {
@@ -275,11 +280,13 @@ void NodeOperationBuilder::add_datatype_conversions()
     /* proxy operations can skip data type conversion */
     NodeOperation *from_op = &link.from()->getOperation();
     NodeOperation *to_op = &link.to()->getOperation();
-    if (!(from_op->useDatatypeConversion() || to_op->useDatatypeConversion()))
+    if (!(from_op->useDatatypeConversion() || to_op->useDatatypeConversion())) {
       continue;
+    }
 
-    if (link.from()->getDataType() != link.to()->getDataType())
+    if (link.from()->getDataType() != link.to()->getDataType()) {
       convert_links.push_back(link);
+    }
   }
   for (Links::const_iterator it = convert_links.begin(); it != convert_links.end(); ++it) {
     const Link &link = *it;
@@ -305,8 +312,9 @@ void NodeOperationBuilder::add_operation_input_constants()
     NodeOperation *op = *it;
     for (int k = 0; k < op->getNumberOfInputSockets(); ++k) {
       NodeOperationInput *input = op->getInputSocket(k);
-      if (!input->isConnected())
+      if (!input->isConnected()) {
         pending_inputs.push_back(input);
+      }
     }
   }
   for (Inputs::const_iterator it = pending_inputs.begin(); it != pending_inputs.end(); ++it) {
@@ -321,10 +329,12 @@ void NodeOperationBuilder::add_input_constant_value(NodeOperationInput *input,
   switch (input->getDataType()) {
     case COM_DT_VALUE: {
       float value;
-      if (node_input && node_input->getbNodeSocket())
+      if (node_input && node_input->getbNodeSocket()) {
         value = node_input->getEditorValueFloat();
-      else
+      }
+      else {
         value = 0.0f;
+      }
 
       SetValueOperation *op = new SetValueOperation();
       op->setValue(value);
@@ -334,10 +344,12 @@ void NodeOperationBuilder::add_input_constant_value(NodeOperationInput *input,
     }
     case COM_DT_COLOR: {
       float value[4];
-      if (node_input && node_input->getbNodeSocket())
+      if (node_input && node_input->getbNodeSocket()) {
         node_input->getEditorValueColor(value);
-      else
+      }
+      else {
         zero_v4(value);
+      }
 
       SetColorOperation *op = new SetColorOperation();
       op->setChannels(value);
@@ -347,10 +359,12 @@ void NodeOperationBuilder::add_input_constant_value(NodeOperationInput *input,
     }
     case COM_DT_VECTOR: {
       float value[3];
-      if (node_input && node_input->getbNodeSocket())
+      if (node_input && node_input->getbNodeSocket()) {
         node_input->getEditorValueVector(value);
-      else
+      }
+      else {
         zero_v3(value);
+      }
 
       SetVectorOperation *op = new SetVectorOperation();
       op->setVector(value);
@@ -387,8 +401,9 @@ void NodeOperationBuilder::resolve_proxies()
     /* we may not have a final proxy input link,
      * in that case it just gets dropped
      */
-    if (from)
+    if (from) {
       addLink(from, to);
+    }
   }
 }
 
@@ -426,8 +441,9 @@ void NodeOperationBuilder::determineResolutions()
       if (link.to()->getResizeMode() != COM_SC_NO_RESIZE) {
         NodeOperation &from_op = link.from()->getOperation();
         NodeOperation &to_op = link.to()->getOperation();
-        if (from_op.getWidth() != to_op.getWidth() || from_op.getHeight() != to_op.getHeight())
+        if (from_op.getWidth() != to_op.getWidth() || from_op.getHeight() != to_op.getHeight()) {
           convert_links.push_back(link);
+        }
       }
     }
     for (Links::const_iterator it = convert_links.begin(); it != convert_links.end(); ++it) {
@@ -443,8 +459,9 @@ NodeOperationBuilder::OpInputs NodeOperationBuilder::cache_output_links(
   OpInputs inputs;
   for (Links::const_iterator it = m_links.begin(); it != m_links.end(); ++it) {
     const Link &link = *it;
-    if (link.from() == output)
+    if (link.from() == output) {
       inputs.push_back(link.to());
+    }
   }
   return inputs;
 }
@@ -456,8 +473,9 @@ WriteBufferOperation *NodeOperationBuilder::find_attached_write_buffer_operation
     const Link &link = *it;
     if (link.from() == output) {
       NodeOperation &op = link.to()->getOperation();
-      if (op.isWriteBufferOperation())
+      if (op.isWriteBufferOperation()) {
         return (WriteBufferOperation *)(&op);
+      }
     }
   }
   return NULL;
@@ -466,8 +484,9 @@ WriteBufferOperation *NodeOperationBuilder::find_attached_write_buffer_operation
 void NodeOperationBuilder::add_input_buffers(NodeOperation * /*operation*/,
                                              NodeOperationInput *input)
 {
-  if (!input->isConnected())
+  if (!input->isConnected()) {
     return;
+  }
 
   NodeOperationOutput *output = input->getLink();
   if (output->getOperation().isReadBufferOperation()) {
@@ -505,8 +524,9 @@ void NodeOperationBuilder::add_output_buffers(NodeOperation *operation,
 {
   /* cache connected sockets, so we can safely remove links first before replacing them */
   OpInputs targets = cache_output_links(output);
-  if (targets.empty())
+  if (targets.empty()) {
     return;
+  }
 
   WriteBufferOperation *writeOperation = NULL;
   for (OpInputs::const_iterator it = targets.begin(); it != targets.end(); ++it) {
@@ -537,8 +557,9 @@ void NodeOperationBuilder::add_output_buffers(NodeOperation *operation,
   /* add readbuffer op for every former connected input */
   for (OpInputs::const_iterator it = targets.begin(); it != targets.end(); ++it) {
     NodeOperationInput *target = *it;
-    if (&target->getOperation() == writeOperation)
+    if (&target->getOperation() == writeOperation) {
       continue; /* skip existing write op links */
+    }
 
     ReadBufferOperation *readoperation = new ReadBufferOperation(
         operation->getOutputSocket()->getDataType());
@@ -557,20 +578,24 @@ void NodeOperationBuilder::add_complex_operation_buffers()
    * will invalidate iterators over the main m_operations
    */
   Operations complex_ops;
-  for (Operations::const_iterator it = m_operations.begin(); it != m_operations.end(); ++it)
-    if ((*it)->isComplex())
+  for (Operations::const_iterator it = m_operations.begin(); it != m_operations.end(); ++it) {
+    if ((*it)->isComplex()) {
       complex_ops.push_back(*it);
+    }
+  }
 
   for (Operations::const_iterator it = complex_ops.begin(); it != complex_ops.end(); ++it) {
     NodeOperation *op = *it;
 
     DebugInfo::operation_read_write_buffer(op);
 
-    for (int index = 0; index < op->getNumberOfInputSockets(); index++)
+    for (int index = 0; index < op->getNumberOfInputSockets(); index++) {
       add_input_buffers(op, op->getInputSocket(index));
+    }
 
-    for (int index = 0; index < op->getNumberOfOutputSockets(); index++)
+    for (int index = 0; index < op->getNumberOfOutputSockets(); index++) {
       add_output_buffers(op, op->getOutputSocket(index));
+    }
   }
 }
 
@@ -578,14 +603,16 @@ typedef std::set<NodeOperation *> Tags;
 
 static void find_reachable_operations_recursive(Tags &reachable, NodeOperation *op)
 {
-  if (reachable.find(op) != reachable.end())
+  if (reachable.find(op) != reachable.end()) {
     return;
+  }
   reachable.insert(op);
 
   for (int i = 0; i < op->getNumberOfInputSockets(); ++i) {
     NodeOperationInput *input = op->getInputSocket(i);
-    if (input->isConnected())
+    if (input->isConnected()) {
       find_reachable_operations_recursive(reachable, &input->getLink()->getOperation());
+    }
   }
 
   /* associated write-buffer operations are executed as well */
@@ -603,8 +630,9 @@ void NodeOperationBuilder::prune_operations()
     NodeOperation *op = *it;
 
     /* output operations are primary executed operations */
-    if (op->isOutputOperation(m_context->isRendering()))
+    if (op->isOutputOperation(m_context->isRendering())) {
       find_reachable_operations_recursive(reachable, op);
+    }
   }
 
   /* delete unreachable operations */
@@ -612,10 +640,12 @@ void NodeOperationBuilder::prune_operations()
   for (Operations::const_iterator it = m_operations.begin(); it != m_operations.end(); ++it) {
     NodeOperation *op = *it;
 
-    if (reachable.find(op) != reachable.end())
+    if (reachable.find(op) != reachable.end()) {
       reachable_ops.push_back(op);
-    else
+    }
+    else {
       delete op;
+    }
   }
   /* finally replace the operations list with the pruned list */
   m_operations = reachable_ops;
@@ -626,14 +656,16 @@ static void sort_operations_recursive(NodeOperationBuilder::Operations &sorted,
                                       Tags &visited,
                                       NodeOperation *op)
 {
-  if (visited.find(op) != visited.end())
+  if (visited.find(op) != visited.end()) {
     return;
+  }
   visited.insert(op);
 
   for (int i = 0; i < op->getNumberOfInputSockets(); ++i) {
     NodeOperationInput *input = op->getInputSocket(i);
-    if (input->isConnected())
+    if (input->isConnected()) {
       sort_operations_recursive(sorted, visited, &input->getLink()->getOperation());
+    }
   }
 
   sorted.push_back(op);
@@ -645,26 +677,30 @@ void NodeOperationBuilder::sort_operations()
   sorted.reserve(m_operations.size());
   Tags visited;
 
-  for (Operations::const_iterator it = m_operations.begin(); it != m_operations.end(); ++it)
+  for (Operations::const_iterator it = m_operations.begin(); it != m_operations.end(); ++it) {
     sort_operations_recursive(sorted, visited, *it);
+  }
 
   m_operations = sorted;
 }
 
 static void add_group_operations_recursive(Tags &visited, NodeOperation *op, ExecutionGroup *group)
 {
-  if (visited.find(op) != visited.end())
+  if (visited.find(op) != visited.end()) {
     return;
+  }
   visited.insert(op);
 
-  if (!group->addOperation(op))
+  if (!group->addOperation(op)) {
     return;
+  }
 
   /* add all eligible input ops to the group */
   for (int i = 0; i < op->getNumberOfInputSockets(); ++i) {
     NodeOperationInput *input = op->getInputSocket(i);
-    if (input->isConnected())
+    if (input->isConnected()) {
       add_group_operations_recursive(visited, &input->getLink()->getOperation(), group);
+    }
   }
 }
 
diff --git a/source/blender/compositor/intern/COM_OpenCLDevice.cpp b/source/blender/compositor/intern/COM_OpenCLDevice.cpp
index b47d78af975..0aa054b8c77 100644
--- a/source/blender/compositor/intern/COM_OpenCLDevice.cpp
+++ b/source/blender/compositor/intern/COM_OpenCLDevice.cpp
@@ -133,8 +133,9 @@ cl_mem OpenCLDevice::COM_clAttachMemoryBufferToKernelParameter(cl_kernel kernel,
   if (error != CL_SUCCESS) {
     printf("CLERROR[%d]: %s\n", error, clewErrorString(error));
   }
-  if (error == CL_SUCCESS)
+  if (error == CL_SUCCESS) {
     cleanup->push_back(clBuffer);
+  }
 
   error = clSetKernelArg(kernel, parameterIndex, sizeof(cl_mem), &clBuffer);
   if (error != CL_SUCCESS) {
@@ -263,8 +264,9 @@ cl_kernel OpenCLDevice::COM_clCreateKernel(const char *kernelname,
     printf("CLERROR[%d]: %s\n", error, clewErrorString(error));
   }
   else {
-    if (clKernelsToCleanUp)
+    if (clKernelsToCleanUp) {
       clKernelsToCleanUp->push_back(kernel);
+    }
   }
   return kernel;
 }
diff --git a/source/blender/compositor/intern/COM_SingleThreadedOperation.cpp b/source/blender/compositor/intern/COM_SingleThreadedOperation.cpp
index e6b018eeb94..029be6d44b1 100644
--- a/source/blender/compositor/intern/COM_SingleThreadedOperation.cpp
+++ b/source/blender/compositor/intern/COM_SingleThreadedOperation.cpp
@@ -44,8 +44,9 @@ void SingleThreadedOperation::deinitExecution()
 }
 void *SingleThreadedOperation::initializeTileData(rcti *rect)
 {
-  if (this->m_cachedInstance)
+  if (this->m_cachedInstance) {
     return this->m_cachedInstance;
+  }
 
   lockMutex();
   if (this->m_cachedInstance == NULL) {
diff --git a/source/blender/compositor/intern/COM_WorkScheduler.cpp b/source/blender/compositor/intern/COM_WorkScheduler.cpp
index e03a0aa6269..c3d1e0cf511 100644
--- a/source/blender/compositor/intern/COM_WorkScheduler.cpp
+++ b/source/blender/compositor/intern/COM_WorkScheduler.cpp
@@ -239,8 +239,9 @@ void WorkScheduler::initialize(bool use_opencl, int num_cpu_threads)
     g_program = NULL;
 
     if (clewInit() !=
-        CLEW_SUCCESS) /* this will check for errors and skip if already initialized */
+        CLEW_SUCCESS) { /* this will check for errors and skip if already initialized */
       return;
+    }
 
     if (clCreateContextFromType) {
       cl_uint numberOfPlatforms = 0;
@@ -251,8 +252,9 @@ void WorkScheduler::initialize(bool use_opencl, int num_cpu_threads)
       else if (error != CL_SUCCESS) {
         printf("CLERROR[%d]: %s\n", error, clewErrorString(error));
       }
-      if (G.f & G_DEBUG)
+      if (G.f & G_DEBUG) {
         printf("%u number of platforms\n", numberOfPlatforms);
+      }
       cl_platform_id *platforms = (cl_platform_id *)MEM_mallocN(
           sizeof(cl_platform_id) * numberOfPlatforms, __func__);
       error = clGetPlatformIDs(numberOfPlatforms, platforms, 0);
@@ -261,8 +263,9 @@ void WorkScheduler::initialize(bool use_opencl, int num_cpu_threads)
         cl_platform_id platform = platforms[indexPlatform];
         cl_uint numberOfDevices = 0;
         clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 0, 0, &numberOfDevices);
-        if (numberOfDevices <= 0)
+        if (numberOfDevices <= 0) {
           continue;
+        }
 
         cl_device_id *cldevices = (cl_device_id *)MEM_mallocN(
             sizeof(cl_device_id) * numberOfDevices, __func__);