From 4bdc0d718dda45b0cd31a1e6c7d955bcd164f152 Mon Sep 17 00:00:00 2001
From: Sam Gateau <sam@highfidelity.io>
Date: Tue, 23 Dec 2014 14:29:26 -0800
Subject: [PATCH] Fixing typo and syntax

---
 tools/scribe/src/TextTemplate.cpp | 291 +++++++++++++++---------------
 1 file changed, 145 insertions(+), 146 deletions(-)

diff --git a/tools/scribe/src/TextTemplate.cpp b/tools/scribe/src/TextTemplate.cpp
index e4bc8fcf6d..6508a9787b 100755
--- a/tools/scribe/src/TextTemplate.cpp
+++ b/tools/scribe/src/TextTemplate.cpp
@@ -72,10 +72,10 @@ void TextTemplate::Config::addIncludePath(const char* path) {
 }
 
 bool TextTemplate::loadFile(const ConfigPointer& config, const char* filename, String& source) {
-    String s(filename);
+    String sourceFile(filename);
     String fullfilename;
     for (unsigned int i = 0; i < config->_paths.size(); i++) {
-        fullfilename = config->_paths[i] + s;
+        fullfilename = config->_paths[i] + sourceFile;
         std::ifstream ifs;
         ifs.open(fullfilename.c_str());
         if (ifs.is_open()) {
@@ -622,7 +622,6 @@ const BlockPointer TextTemplate::processStepFunc(const BlockPointer& block, Stri
         return block;
     }
 
-
     // DOes the func already exists ?
     if (_config->_funcs.findFunc(varName.c_str())) {
         logError(block, "Declaring a new func named <%s> already exists", func.c_str());
@@ -719,183 +718,183 @@ int TextTemplate::generateTree(std::ostream& dst, const BlockPointer& block, Var
 int TextTemplate::evalBlockGeneration(std::ostream& dst, const BlockPointer& block, Vars& vars, BlockPointer& branch) {
     switch (block->command.type) {
     case Command::BLOCK: {
-            branch = block;
-            return 1;
-        }
-        break;
+        branch = block;
+        return 1;
+    }
+    break;
     case Command::VAR: {
-            Vars::iterator it = vars.find(block->command.arguments.front());
-            if (it != vars.end()) {
-                dst << (*it).second;
-            } else {
-                BlockPointer funcBlock = _config->_funcs.findFunc(block->command.arguments.front().c_str());
-                if (funcBlock) {
-                    // before diving in the func tree, let's modify the vars with the local defs:
-                    int nbParams = std::min(block->command.arguments.size(), funcBlock->command.arguments.size());
-                    std::vector< String > paramCache;
-                    paramCache.push_back("");
-                    String val;
-                    for (int i = 1; i < nbParams; i++) {
-                        val = block->command.arguments[i];
-                        if ((val[0] == Tag::VAR) && (val[val.length()-1] == Tag::VAR)) {
-                            val = val.substr(1, val.length()-2);
-                            Vars::iterator it = vars.find(val);
-                            if (it != vars.end()) {
-                                val = (*it).second;
-                            }
-                        }
-
-                        Vars::iterator it = vars.find(funcBlock->command.arguments[i]);
+        Vars::iterator it = vars.find(block->command.arguments.front());
+        if (it != vars.end()) {
+            dst << (*it).second;
+        } else {
+            BlockPointer funcBlock = _config->_funcs.findFunc(block->command.arguments.front().c_str());
+            if (funcBlock) {
+                // before diving in the func tree, let's modify the vars with the local defs:
+                int nbParams = std::min(block->command.arguments.size(), funcBlock->command.arguments.size());
+                std::vector< String > paramCache;
+                paramCache.push_back("");
+                String val;
+                for (int i = 1; i < nbParams; i++) {
+                    val = block->command.arguments[i];
+                    if ((val[0] == Tag::VAR) && (val[val.length()-1] == Tag::VAR)) {
+                        val = val.substr(1, val.length()-2);
+                        Vars::iterator it = vars.find(val);
                         if (it != vars.end()) {
-                            paramCache.push_back((*it).second);
-                            (*it).second = val;
-                        } else {
-                            vars.insert(Vars::value_type(funcBlock->command.arguments[i], val));
-                            paramCache.push_back("");
+                            val = (*it).second;
                         }
                     }
 
-                    generateTree(dst, funcBlock, vars);
-
-                    for (int i = 1; i < nbParams; i++) {
-                        vars[ funcBlock->command.arguments[i] ] = paramCache[i];
+                    Vars::iterator it = vars.find(funcBlock->command.arguments[i]);
+                    if (it != vars.end()) {
+                        paramCache.push_back((*it).second);
+                        (*it).second = val;
+                    } else {
+                        vars.insert(Vars::value_type(funcBlock->command.arguments[i], val));
+                        paramCache.push_back("");
                     }
                 }
-            }
-            branch = block;
-            return 1;
-        }
-        break;
-    case Command::IFBLOCK: {
-            // ok, go through the branches and pick the first one that goes
-            for (auto child: block->blocks) {
-                int numPasses = evalBlockGeneration(dst, child, vars, branch);
-                if (numPasses > 0) {
-                    return numPasses;
+
+                generateTree(dst, funcBlock, vars);
+
+                for (int i = 1; i < nbParams; i++) {
+                    vars[ funcBlock->command.arguments[i] ] = paramCache[i];
                 }
             }
         }
-        break;
+        branch = block;
+        return 1;
+    }
+    break;
+    case Command::IFBLOCK: {
+        // ok, go through the branches and pick the first one that goes
+        for (auto child: block->blocks) {
+            int numPasses = evalBlockGeneration(dst, child, vars, branch);
+            if (numPasses > 0) {
+                return numPasses;
+            }
+        }
+    }
+    break;
     case Command::IF:
     case Command::ELIF: {
-            if (!block->command.arguments.empty()) {
-                // Just one argument means check for the var beeing defined
-                if (block->command.arguments.size() == 1) {
-                    Vars::iterator it = vars.find(block->command.arguments.front());
-                    if (it != vars.end()) {
+        if (!block->command.arguments.empty()) {
+            // Just one argument means check for the var beeing defined
+            if (block->command.arguments.size() == 1) {
+                Vars::iterator it = vars.find(block->command.arguments.front());
+                if (it != vars.end()) {
+                    branch = block;
+                    return 1;
+                }
+            } else if (block->command.arguments.size() == 2) {
+                if (block->command.arguments[0].compare("not") == 0) {
+                    Vars::iterator it = vars.find(block->command.arguments[1]);
+                    if (it == vars.end()) {
                         branch = block;
                         return 1;
                     }
-                } else if (block->command.arguments.size() == 2) {
-                    if (block->command.arguments[0].compare("not") == 0) {
-                        Vars::iterator it = vars.find(block->command.arguments[1]);
-                        if (it == vars.end()) {
-                            branch = block;
-                            return 1;
-                        }
+                }
+            } else if (block->command.arguments.size() == 3) {
+                if (block->command.arguments[1].compare("and") == 0) {
+                    Vars::iterator itL = vars.find(block->command.arguments[0]);
+                    Vars::iterator itR = vars.find(block->command.arguments[2]);
+                    if ((itL != vars.end()) && (itR != vars.end())) {
+                        branch = block;
+                        return 1;
                     }
-                } else if (block->command.arguments.size() == 3) {
-                    if (block->command.arguments[1].compare("and") == 0) {
-                        Vars::iterator itL = vars.find(block->command.arguments[0]);
-                        Vars::iterator itR = vars.find(block->command.arguments[2]);
-                        if ((itL != vars.end()) && (itR != vars.end())) {
+                } else if (block->command.arguments[1].compare("or") == 0) {
+                    Vars::iterator itL = vars.find(block->command.arguments[0]);
+                    Vars::iterator itR = vars.find(block->command.arguments[2]);
+                    if ((itL != vars.end()) || (itR != vars.end())) {
+                        branch = block;
+                        return 1;
+                    }
+                } else if (block->command.arguments[1].compare("==") == 0) {
+                    Vars::iterator itL = vars.find(block->command.arguments[0]);
+                    if (itL != vars.end()) {
+                        if ((*itL).second.compare(block->command.arguments[2]) == 0) {
                             branch = block;
                             return 1;
                         }
-                    } else if (block->command.arguments[1].compare("or") == 0) {
-                        Vars::iterator itL = vars.find(block->command.arguments[0]);
-                        Vars::iterator itR = vars.find(block->command.arguments[2]);
-                        if ((itL != vars.end()) || (itR != vars.end())) {
-                            branch = block;
-                            return 1;
-                        }
-                    } else if (block->command.arguments[1].compare("==") == 0) {
-                        Vars::iterator itL = vars.find(block->command.arguments[0]);
-                        if (itL != vars.end()) {
-                            if ((*itL).second.compare(block->command.arguments[2]) == 0) {
-                                branch = block;
-                                return 1;
-                            }
-                        }
                     }
                 }
-
             }
+
+        }
+        return 0;
+    }
+    break;
+    case Command::ELSE: {
+        branch = block;
+        return 1;
+    }
+    break;
+    case Command::ENDIF: {
+        branch = block;
+        return 1;
+    }
+    break;
+    case Command::DEF: {
+        if (block->command.arguments.size()) {
+            // THe actual value of the var defined sneeds to be evaluated:
+            String val;
+            for (int t = 1; t < block->command.arguments.size(); t++) {
+                // detect if a param is a var
+                int len = block->command.arguments[t].length();
+                if ((block->command.arguments[t][0] == Tag::VAR)
+                    && (block->command.arguments[t][len-1] == Tag::VAR)) {
+                    String var = block->command.arguments[t].substr(1, len-2);
+                    Vars::iterator it = vars.find(var);
+                    if (it != vars.end()) {
+                        val += (*it).second;
+                    }
+                } else {
+                    val += block->command.arguments[t];
+                }
+            }
+
+            Vars::iterator it = vars.find(block->command.arguments.front());
+            if (it == vars.end()) {
+                vars.insert(Vars::value_type(block->command.arguments.front(), val));
+            } else {
+                (*it).second = val;
+            }
+
+            branch = block;
+            return 1;
+        } else {
+            branch = block;
             return 0;
         }
-        break;
-    case Command::ELSE: {
-            branch = block;
-            return 1;
-        }
-        break;
-    case Command::ENDIF: {
-            branch = block;
-            return 1;
-        }
-        break;
-    case Command::DEF: {
-            if (block->command.arguments.size()) {
-                // THe actual value of the var defined sneeds to be evaluated:
-                String val;
-                for (int t = 1; t < block->command.arguments.size(); t++) {
-                    // detect if a param is a var
-                    int len = block->command.arguments[t].length();
-                    if ((block->command.arguments[t][0] == Tag::VAR)
-                        && (block->command.arguments[t][len-1] == Tag::VAR)) {
-                        String var = block->command.arguments[t].substr(1, len-2);
-                        Vars::iterator it = vars.find(var);
-                        if (it != vars.end()) {
-                            val += (*it).second;
-                        }
-                    } else {
-                        val += block->command.arguments[t];
-                    }
-                }
-
-                Vars::iterator it = vars.find(block->command.arguments.front());
-                if (it == vars.end()) {
-                    vars.insert(Vars::value_type(block->command.arguments.front(), val));
-                } else {
-                    (*it).second = val;
-                }
-
-                branch = block;
-                return 1;
-            } else {
-                branch = block;
-                return 0;
-            }
-        }
-        break;
+    }
+    break;
 
     case Command::INCLUDE: {
-            TextTemplatePointer include = _config->findInclude(block->command.arguments.front().c_str());
-            if (include && !include->_root->blocks.empty()) {
-                if (&include->_root) {
-                    generateTree(dst, include->_root, vars);
-                }
+        TextTemplatePointer include = _config->findInclude(block->command.arguments.front().c_str());
+        if (include && !include->_root->blocks.empty()) {
+            if (&include->_root) {
+                generateTree(dst, include->_root, vars);
             }
-
-            branch = block;
-            return 1;
         }
-        break;
+
+        branch = block;
+        return 1;
+    }
+    break;
 
     case Command::FUNC: {
-            branch = block;
-            return 1;
-        }
-        break;
+        branch = block;
+        return 1;
+    }
+    break;
 
     case Command::ENDFUNC: {
-            branch = block;
-            return 1;
-        }
-        break;
+        branch = block;
+        return 1;
+    }
+    break;
 
     default: {
-        }
+    }
     }
 
     return 0;