Various indenting fixes in AST front-end (mostly space vs tab issues)

Signed-off-by: Clifford Wolf <clifford@clifford.at>

diff --git a/frontends/ast/ast.cc b/frontends/ast/ast.cc
index cc275959a9d7a05f086b48672d4ed05c320112b2..2c1561552941d6b46f2dac676d3f4b662796088e 100644 (file)
--- a/frontends/ast/ast.cc
+++ b/frontends/ast/ast.cc
@@ -172,8 +172,7 @@ bool AstNode::get_bool_attribute(RTLIL::IdString id)
 
        AstNode *attr = attributes.at(id);
        if (attr->type != AST_CONSTANT)
-               log_file_error(attr->filename, attr->linenum, "Attribute `%s' with non-constant value!\n",
-                              id.c_str());
+               log_file_error(attr->filename, attr->linenum, "Attribute `%s' with non-constant value!\n", id.c_str());
 
        return attr->integer != 0;
 }
@@ -969,8 +968,7 @@ static AstModule* process_module(AstNode *ast, bool defer, AstNode *original_ast
 
                for (auto &attr : ast->attributes) {
                        if (attr.second->type != AST_CONSTANT)
-                               log_file_error(ast->filename, ast->linenum, "Attribute `%s' with non-constant value!\n",
-                                              attr.first.c_str());
+                               log_file_error(ast->filename, ast->linenum, "Attribute `%s' with non-constant value!\n", attr.first.c_str());
                        current_module->attributes[attr.first] = attr.second->asAttrConst();
                }
                for (size_t i = 0; i < ast->children.size(); i++) {
@@ -1061,8 +1059,7 @@ void AST::process(RTLIL::Design *design, AstNode *ast, bool dump_ast1, bool dump
                        if (design->has((*it)->str)) {
                                RTLIL::Module *existing_mod = design->module((*it)->str);
                                if (!nooverwrite && !overwrite && !existing_mod->get_bool_attribute("\\blackbox")) {
-                                       log_file_error((*it)->filename, (*it)->linenum, "Re-definition of module `%s'!\n",
-                                                      (*it)->str.c_str());
+                                       log_file_error((*it)->filename, (*it)->linenum, "Re-definition of module `%s'!\n", (*it)->str.c_str());
                                } else if (nooverwrite) {
                                        log("Ignoring re-definition of module `%s' at %s:%d.\n",
                                                        (*it)->str.c_str(), (*it)->filename.c_str(), (*it)->linenum);

diff --git a/frontends/ast/genrtlil.cc b/frontends/ast/genrtlil.cc
index 59c309665bfc52a04ffe39c9e27a414b999a3de7..9531dd3561b85402de139cb84ffea81065af5d00 100644 (file)
--- a/frontends/ast/genrtlil.cc
+++ b/frontends/ast/genrtlil.cc
@@ -55,8 +55,7 @@ static RTLIL::SigSpec uniop2rtlil(AstNode *that, std::string type, int result_wi
        if (gen_attributes)
                for (auto &attr : that->attributes) {
                        if (attr.second->type != AST_CONSTANT)
-                               log_file_error(that->filename, that->linenum, "Attribute `%s' with non-constant value!\n",
-                                              attr.first.c_str());
+                               log_file_error(that->filename, that->linenum, "Attribute `%s' with non-constant value!\n", attr.first.c_str());
                        cell->attributes[attr.first] = attr.second->asAttrConst();
                }
 
@@ -89,8 +88,7 @@ static void widthExtend(AstNode *that, RTLIL::SigSpec &sig, int width, bool is_s
        if (that != NULL)
                for (auto &attr : that->attributes) {
                        if (attr.second->type != AST_CONSTANT)
-                               log_file_error(that->filename, that->linenum, "Attribute `%s' with non-constant value!\n",
-                                              attr.first.c_str());
+                               log_file_error(that->filename, that->linenum, "Attribute `%s' with non-constant value!\n", attr.first.c_str());
                        cell->attributes[attr.first] = attr.second->asAttrConst();
                }
 
@@ -117,8 +115,7 @@ static RTLIL::SigSpec binop2rtlil(AstNode *that, std::string type, int result_wi
 
        for (auto &attr : that->attributes) {
                if (attr.second->type != AST_CONSTANT)
-                       log_file_error(that->filename, that->linenum, "Attribute `%s' with non-constant value!\n",
-                                      attr.first.c_str());
+                       log_file_error(that->filename, that->linenum, "Attribute `%s' with non-constant value!\n", attr.first.c_str());
                cell->attributes[attr.first] = attr.second->asAttrConst();
        }
 
@@ -152,8 +149,7 @@ static RTLIL::SigSpec mux2rtlil(AstNode *that, const RTLIL::SigSpec &cond, const
 
        for (auto &attr : that->attributes) {
                if (attr.second->type != AST_CONSTANT)
-                       log_file_error(that->filename, that->linenum, "Attribute `%s' with non-constant value!\n",
-                                      attr.first.c_str());
+                       log_file_error(that->filename, that->linenum, "Attribute `%s' with non-constant value!\n", attr.first.c_str());
                cell->attributes[attr.first] = attr.second->asAttrConst();
        }
 
@@ -480,8 +476,7 @@ struct AST_INTERNAL::ProcessGenerator
 
                                for (auto &attr : ast->attributes) {
                                        if (attr.second->type != AST_CONSTANT)
-                                               log_file_error(ast->filename, ast->linenum, "Attribute `%s' with non-constant value!\n",
-                                                              attr.first.c_str());
+                                               log_file_error(ast->filename, ast->linenum, "Attribute `%s' with non-constant value!\n", attr.first.c_str());
                                        sw->attributes[attr.first] = attr.second->asAttrConst();
                                }
 
@@ -648,8 +643,7 @@ void AstNode::detectSignWidthWorker(int &width_hint, bool &sign_hint, bool *foun
                                while (left_at_zero_ast->simplify(true, true, false, 1, -1, false, false)) { }
                                while (right_at_zero_ast->simplify(true, true, false, 1, -1, false, false)) { }
                                if (left_at_zero_ast->type != AST_CONSTANT || right_at_zero_ast->type != AST_CONSTANT)
-                                       log_file_error(filename, linenum, "Unsupported expression on dynamic range select on signal `%s'!\n",
-                                                      str.c_str());
+                                       log_file_error(filename, linenum, "Unsupported expression on dynamic range select on signal `%s'!\n", str.c_str());
                                this_width = left_at_zero_ast->integer - right_at_zero_ast->integer + 1;
                                delete left_at_zero_ast;
                                delete right_at_zero_ast;
@@ -778,7 +772,7 @@ void AstNode::detectSignWidthWorker(int &width_hint, bool &sign_hint, bool *foun
                                while (children[0]->simplify(true, false, false, 1, -1, false, true) == true) { }
                                if (children[0]->type != AST_CONSTANT)
                                        log_file_error(filename, linenum, "System function %s called with non-const argument!\n",
-                                                      RTLIL::unescape_id(str).c_str());
+                                                       RTLIL::unescape_id(str).c_str());
                                width_hint = max(width_hint, int(children[0]->asInt(true)));
                        }
                        break;
@@ -799,8 +793,7 @@ void AstNode::detectSignWidthWorker(int &width_hint, bool &sign_hint, bool *foun
        default:
                for (auto f : log_files)
                        current_ast->dumpAst(f, "verilog-ast> ");
-               log_file_error(filename, linenum, "Don't know how to detect sign and width for %s node!\n",
-                              type2str(type).c_str());
+               log_file_error(filename, linenum, "Don't know how to detect sign and width for %s node!\n", type2str(type).c_str());
        }
 
        if (*found_real)
@@ -892,11 +885,9 @@ RTLIL::SigSpec AstNode::genRTLIL(int width_hint, bool sign_hint)
        // create an RTLIL::Wire for an AST_WIRE node
        case AST_WIRE: {
                        if (current_module->wires_.count(str) != 0)
-                               log_file_error(filename, linenum, "Re-definition of signal `%s'!\n",
-                                              str.c_str());
+                               log_file_error(filename, linenum, "Re-definition of signal `%s'!\n", str.c_str());
                        if (!range_valid)
-                               log_file_error(filename, linenum, "Signal `%s' with non-constant width!\n",
-                                              str.c_str());
+                               log_file_error(filename, linenum, "Signal `%s' with non-constant width!\n", str.c_str());
 
                        log_assert(range_left >= range_right || (range_left == -1 && range_right == 0));
 
@@ -910,8 +901,7 @@ RTLIL::SigSpec AstNode::genRTLIL(int width_hint, bool sign_hint)
 
                        for (auto &attr : attributes) {
                                if (attr.second->type != AST_CONSTANT)
-                                       log_file_error(filename, linenum, "Attribute `%s' with non-constant value!\n",
-                                                      attr.first.c_str());
+                                       log_file_error(filename, linenum, "Attribute `%s' with non-constant value!\n", attr.first.c_str());
                                wire->attributes[attr.first] = attr.second->asAttrConst();
                        }
                }
@@ -920,16 +910,14 @@ RTLIL::SigSpec AstNode::genRTLIL(int width_hint, bool sign_hint)
        // create an RTLIL::Memory for an AST_MEMORY node
        case AST_MEMORY: {
                        if (current_module->memories.count(str) != 0)
-                               log_file_error(filename, linenum, "Re-definition of memory `%s'!\n",
-                                              str.c_str());
+                               log_file_error(filename, linenum, "Re-definition of memory `%s'!\n", str.c_str());
 
                        log_assert(children.size() >= 2);
                        log_assert(children[0]->type == AST_RANGE);
                        log_assert(children[1]->type == AST_RANGE);
 
                        if (!children[0]->range_valid || !children[1]->range_valid)
-                               log_file_error(filename, linenum, "Memory `%s' with non-constant width or size!\n",
-                                              str.c_str());
+                               log_file_error(filename, linenum, "Memory `%s' with non-constant width or size!\n", str.c_str());
 
                        RTLIL::Memory *memory = new RTLIL::Memory;
                        memory->attributes["\\src"] = stringf("%s:%d", filename.c_str(), linenum);
@@ -946,8 +934,7 @@ RTLIL::SigSpec AstNode::genRTLIL(int width_hint, bool sign_hint)
 
                        for (auto &attr : attributes) {
                                if (attr.second->type != AST_CONSTANT)
-                                       log_file_error(filename, linenum, "Attribute `%s' with non-constant value!\n",
-                                                      attr.first.c_str());
+                                       log_file_error(filename, linenum, "Attribute `%s' with non-constant value!\n", attr.first.c_str());
                                memory->attributes[attr.first] = attr.second->asAttrConst();
                        }
                }
@@ -966,8 +953,7 @@ RTLIL::SigSpec AstNode::genRTLIL(int width_hint, bool sign_hint)
        case AST_REALVALUE:
                {
                        RTLIL::SigSpec sig = realAsConst(width_hint);
-                       log_file_warning(filename, linenum, "converting real value %e to binary %s.\n",
-                                        realvalue, log_signal(sig));
+                       log_file_warning(filename, linenum, "converting real value %e to binary %s.\n", realvalue, log_signal(sig));
                        return sig;
                }
 
@@ -994,8 +980,7 @@ RTLIL::SigSpec AstNode::genRTLIL(int width_hint, bool sign_hint)
                        }
                        else if (id2ast->type == AST_PARAMETER || id2ast->type == AST_LOCALPARAM) {
                                if (id2ast->children[0]->type != AST_CONSTANT)
-                                       log_file_error(filename, linenum, "Parameter %s does not evaluate to constant value!\n",
-                                                      str.c_str());
+                                       log_file_error(filename, linenum, "Parameter %s does not evaluate to constant value!\n", str.c_str());
                                chunk = RTLIL::Const(id2ast->children[0]->bits);
                                goto use_const_chunk;
                        }
@@ -1010,13 +995,11 @@ RTLIL::SigSpec AstNode::genRTLIL(int width_hint, bool sign_hint)
                                is_interface = true;
                        }
                        else {
-                               log_file_error(filename, linenum, "Identifier `%s' doesn't map to any signal!\n",
-                                               str.c_str());
+                               log_file_error(filename, linenum, "Identifier `%s' doesn't map to any signal!\n", str.c_str());
                        }
 
                        if (id2ast->type == AST_MEMORY)
-                               log_file_error(filename, linenum, "Identifier `%s' does map to an unexpanded memory!\n",
-                                              str.c_str());
+                               log_file_error(filename, linenum, "Identifier `%s' does map to an unexpanded memory!\n", str.c_str());
 
                        // If identifier is an interface, create a RTLIL::SigSpec with a dummy wire with a attribute called 'is_interface'
                        // This makes it possible for the hierarchy pass to see what are interface connections and then replace them
@@ -1051,8 +1034,7 @@ RTLIL::SigSpec AstNode::genRTLIL(int width_hint, bool sign_hint)
                                        while (left_at_zero_ast->simplify(true, true, false, 1, -1, false, false)) { }
                                        while (right_at_zero_ast->simplify(true, true, false, 1, -1, false, false)) { }
                                        if (left_at_zero_ast->type != AST_CONSTANT || right_at_zero_ast->type != AST_CONSTANT)
-                                               log_file_error(filename, linenum, "Unsupported expression on dynamic range select on signal `%s'!\n",
-                                                              str.c_str());
+                                               log_file_error(filename, linenum, "Unsupported expression on dynamic range select on signal `%s'!\n", str.c_str());
                                        int width = left_at_zero_ast->integer - right_at_zero_ast->integer + 1;
                                        AstNode *fake_ast = new AstNode(AST_NONE, clone(), children[0]->children.size() >= 2 ?
                                                        children[0]->children[1]->clone() : children[0]->children[0]->clone());
@@ -1081,7 +1063,7 @@ RTLIL::SigSpec AstNode::genRTLIL(int width_hint, bool sign_hint)
                                        if (chunk.offset >= source_width || chunk.offset + chunk.width < 0) {
                                                if (chunk.width == 1)
                                                        log_file_warning(filename, linenum, "Range select out of bounds on signal `%s': Setting result bit to undef.\n",
-                                                                        str.c_str());
+                                                                       str.c_str());
                                                else
                                                        log_file_warning(filename, linenum, "Range select [%d:%d] out of bounds on signal `%s': Setting all %d result bits to undef.\n",
                                                                        children[0]->range_left, children[0]->range_right, str.c_str(), chunk.width);
@@ -1098,10 +1080,10 @@ RTLIL::SigSpec AstNode::genRTLIL(int width_hint, bool sign_hint)
                                                }
                                                if (add_undef_bits_lsb)
                                                        log_file_warning(filename, linenum, "Range [%d:%d] select out of bounds on signal `%s': Setting %d LSB bits to undef.\n",
-                                                                        children[0]->range_left, children[0]->range_right, str.c_str(), add_undef_bits_lsb);
+                                                                       children[0]->range_left, children[0]->range_right, str.c_str(), add_undef_bits_lsb);
                                                if (add_undef_bits_msb)
                                                        log_file_warning(filename, linenum, "Range [%d:%d] select out of bounds on signal `%s': Setting %d MSB bits to undef.\n",
-                                                                        children[0]->range_left, children[0]->range_right, str.c_str(), add_undef_bits_msb);
+                                                                       children[0]->range_left, children[0]->range_right, str.c_str(), add_undef_bits_msb);
                                        }
                                }
                        }
@@ -1436,8 +1418,7 @@ RTLIL::SigSpec AstNode::genRTLIL(int width_hint, bool sign_hint)
 
                        for (auto &attr : attributes) {
                                if (attr.second->type != AST_CONSTANT)
-                                       log_file_error(filename, linenum, "Attribute `%s' with non-constant value!\n",
-                                                      attr.first.c_str());
+                                       log_file_error(filename, linenum, "Attribute `%s' with non-constant value!\n", attr.first.c_str());
                                cell->attributes[attr.first] = attr.second->asAttrConst();
                        }
 
@@ -1459,9 +1440,9 @@ RTLIL::SigSpec AstNode::genRTLIL(int width_hint, bool sign_hint)
                                                new_right.append(right[i]);
                                        }
                                log_file_warning(filename, linenum, "Ignoring assignment to constant bits:\n"
-                                                "    old assignment: %s = %s\n    new assignment: %s = %s.\n",
-                                                log_signal(left), log_signal(right),
-                                                log_signal(new_left), log_signal(new_right));
+                                               "    old assignment: %s = %s\n    new assignment: %s = %s.\n",
+                                               log_signal(left), log_signal(right),
+                                               log_signal(new_left), log_signal(new_right));
                                left = new_left;
                                right = new_right;
                        }
@@ -1494,14 +1475,14 @@ RTLIL::SigSpec AstNode::genRTLIL(int width_hint, bool sign_hint)
                                        IdString paraname = child->str.empty() ? stringf("$%d", ++para_counter) : child->str;
                                        if (child->children[0]->type == AST_REALVALUE) {
                                                log_file_warning(filename, linenum, "Replacing floating point parameter %s.%s = %f with string.\n",
-                                                                log_id(cell), log_id(paraname), child->children[0]->realvalue);
+                                                               log_id(cell), log_id(paraname), child->children[0]->realvalue);
                                                auto strnode = AstNode::mkconst_str(stringf("%f", child->children[0]->realvalue));
                                                strnode->cloneInto(child->children[0]);
                                                delete strnode;
                                        }
                                        if (child->children[0]->type != AST_CONSTANT)
                                                log_file_error(filename, linenum, "Parameter %s.%s with non-constant value!\n",
-                                                              log_id(cell), log_id(paraname));
+                                                               log_id(cell), log_id(paraname));
                                        cell->parameters[paraname] = child->children[0]->asParaConst();
                                        continue;
                                }
@@ -1522,8 +1503,7 @@ RTLIL::SigSpec AstNode::genRTLIL(int width_hint, bool sign_hint)
                        }
                        for (auto &attr : attributes) {
                                if (attr.second->type != AST_CONSTANT)
-                                       log_file_error(filename, linenum, "Attribute `%s' with non-constant value!\n",
-                                                      attr.first.c_str());
+                                       log_file_error(filename, linenum, "Attribute `%s' with non-constant value!\n", attr.first.c_str());
                                cell->attributes[attr.first] = attr.second->asAttrConst();
                        }
                }
@@ -1551,18 +1531,17 @@ RTLIL::SigSpec AstNode::genRTLIL(int width_hint, bool sign_hint)
 
                                if (GetSize(children) > 1)
                                        log_file_error(filename, linenum, "System function %s got %d arguments, expected 1 or 0.\n",
-                                                      RTLIL::unescape_id(str).c_str(), GetSize(children));
+                                                       RTLIL::unescape_id(str).c_str(), GetSize(children));
 
                                if (GetSize(children) == 1) {
                                        if (children[0]->type != AST_CONSTANT)
                                                log_file_error(filename, linenum, "System function %s called with non-const argument!\n",
-                                                              RTLIL::unescape_id(str).c_str());
+                                                               RTLIL::unescape_id(str).c_str());
                                        width = children[0]->asInt(true);
                                }
 
                                if (width <= 0)
-                                       log_file_error(filename, linenum, "Failed to detect width of %s!\n",
-                                                      RTLIL::unescape_id(str).c_str());
+                                       log_file_error(filename, linenum, "Failed to detect width of %s!\n", RTLIL::unescape_id(str).c_str());
 
                                Cell *cell = current_module->addCell(myid, str.substr(1));
                                cell->attributes["\\src"] = stringf("%s:%d", filename.c_str(), linenum);
@@ -1589,8 +1568,7 @@ RTLIL::SigSpec AstNode::genRTLIL(int width_hint, bool sign_hint)
                for (auto f : log_files)
                        current_ast->dumpAst(f, "verilog-ast> ");
                type_name = type2str(type);
-               log_file_error(filename, linenum, "Don't know how to generate RTLIL code for %s node!\n",
-                              type_name.c_str());
+               log_file_error(filename, linenum, "Don't know how to generate RTLIL code for %s node!\n", type_name.c_str());
        }
 
        return RTLIL::SigSpec();

diff --git a/frontends/ast/simplify.cc b/frontends/ast/simplify.cc
index 9688b77bcbf548c3e0e93c701d5991e6c2b380de..bb4c9735de8b9cabccc89805e7411cc73d11ca1d 100644 (file)
--- a/frontends/ast/simplify.cc
+++ b/frontends/ast/simplify.cc
@@ -196,7 +196,7 @@ bool AstNode::simplify(bool const_fold, bool at_zero, bool in_lvalue, int stage,
                int nargs = GetSize(children);
                if (nargs < 1)
                        log_file_error(filename, linenum, "System task `%s' got %d arguments, expected >= 1.\n",
-                                      str.c_str(), int(children.size()));
+                                       str.c_str(), int(children.size()));
 
                // First argument is the format string
                AstNode *node_string = children[0];
@@ -240,7 +240,7 @@ bool AstNode::simplify(bool const_fold, bool at_zero, bool in_lvalue, int stage,
                                        case 'X':
                                                if (next_arg >= GetSize(children))
                                                        log_file_error(filename, linenum, "Missing argument for %%%c format specifier in system task `%s'.\n",
-                                                                      cformat, str.c_str());
+                                                                       cformat, str.c_str());
 
                                                node_arg = children[next_arg++];
                                                while (node_arg->simplify(true, false, false, stage, width_hint, sign_hint, false)) { }
@@ -745,7 +745,7 @@ bool AstNode::simplify(bool const_fold, bool at_zero, bool in_lvalue, int stage,
 
                if (current_scope.at(modname)->type != AST_CELL)
                        log_file_error(filename, linenum, "Defparam argument `%s . %s` does not match a cell!\n",
-                                      RTLIL::unescape_id(modname).c_str(), RTLIL::unescape_id(paramname).c_str());
+                                       RTLIL::unescape_id(modname).c_str(), RTLIL::unescape_id(paramname).c_str());
 
                AstNode *paraset = new AstNode(AST_PARASET, children[1]->clone(), GetSize(children) > 2 ? children[2]->clone() : NULL);
                paraset->str = paramname;
@@ -893,7 +893,7 @@ bool AstNode::simplify(bool const_fold, bool at_zero, bool in_lvalue, int stage,
                        if (children[0]->type == AST_REALVALUE) {
                                RTLIL::Const constvalue = children[0]->realAsConst(width);
                                log_file_warning(filename, linenum, "converting real value %e to binary %s.\n",
-                                                children[0]->realvalue, log_signal(constvalue));
+                                               children[0]->realvalue, log_signal(constvalue));
                                delete children[0];
                                children[0] = mkconst_bits(constvalue.bits, sign_hint);
                                did_something = true;
@@ -1312,8 +1312,7 @@ bool AstNode::simplify(bool const_fold, bool at_zero, bool in_lvalue, int stage,
        if (type == AST_PRIMITIVE)
        {
                if (children.size() < 2)
-                       log_file_error(filename, linenum, "Insufficient number of arguments for primitive `%s'!\n",
-                                      str.c_str());
+                       log_file_error(filename, linenum, "Insufficient number of arguments for primitive `%s'!\n", str.c_str());
 
                std::vector<AstNode*> children_list;
                for (auto child : children) {
@@ -1328,8 +1327,7 @@ bool AstNode::simplify(bool const_fold, bool at_zero, bool in_lvalue, int stage,
                if (str == "bufif0" || str == "bufif1" || str == "notif0" || str == "notif1")
                {
                        if (children_list.size() != 3)
-                               log_file_error(filename, linenum, "Invalid number of arguments for primitive `%s'!\n",
-                                              str.c_str());
+                               log_file_error(filename, linenum, "Invalid number of arguments for primitive `%s'!\n", str.c_str());
 
                        std::vector<RTLIL::State> z_const(1, RTLIL::State::Sz);
 
@@ -1416,8 +1414,7 @@ bool AstNode::simplify(bool const_fold, bool at_zero, bool in_lvalue, int stage,
                        while (left_at_zero_ast->simplify(true, true, false, stage, -1, false, false)) { }
                        while (right_at_zero_ast->simplify(true, true, false, stage, -1, false, false)) { }
                        if (left_at_zero_ast->type != AST_CONSTANT || right_at_zero_ast->type != AST_CONSTANT)
-                               log_file_error(filename, linenum, "Unsupported expression on dynamic range select on signal `%s'!\n",
-                                              str.c_str());
+                               log_file_error(filename, linenum, "Unsupported expression on dynamic range select on signal `%s'!\n", str.c_str());
                        result_width = abs(int(left_at_zero_ast->integer - right_at_zero_ast->integer)) + 1;
                }
                did_something = true;
@@ -1788,11 +1785,11 @@ skip_dynamic_range_lvalue_expansion:;
 
                                if (GetSize(children) != 1 && GetSize(children) != 2)
                                        log_file_error(filename, linenum, "System function %s got %d arguments, expected 1 or 2.\n",
-                                                      RTLIL::unescape_id(str).c_str(), int(children.size()));
+                                                       RTLIL::unescape_id(str).c_str(), int(children.size()));
 
                                if (!current_always_clocked)
                                        log_file_error(filename, linenum, "System function %s is only allowed in clocked blocks.\n",
-                                                      RTLIL::unescape_id(str).c_str());
+                                                       RTLIL::unescape_id(str).c_str());
 
                                if (GetSize(children) == 2)
                                {
@@ -1857,11 +1854,11 @@ skip_dynamic_range_lvalue_expansion:;
                        {
                                if (GetSize(children) != 1)
                                        log_file_error(filename, linenum, "System function %s got %d arguments, expected 1.\n",
-                                                      RTLIL::unescape_id(str).c_str(), int(children.size()));
+                                                       RTLIL::unescape_id(str).c_str(), int(children.size()));
 
                                if (!current_always_clocked)
                                        log_file_error(filename, linenum, "System function %s is only allowed in clocked blocks.\n",
-                                                      RTLIL::unescape_id(str).c_str());
+                                                       RTLIL::unescape_id(str).c_str());
 
                                AstNode *present = children.at(0)->clone();
                                AstNode *past = clone();
@@ -1875,15 +1872,13 @@ skip_dynamic_range_lvalue_expansion:;
 
                                else if (str == "\\$rose")
                                        newNode = new AstNode(AST_LOGIC_AND,
-                                               new AstNode(AST_LOGIC_NOT,
-                                                       new AstNode(AST_BIT_AND, past, mkconst_int(1,false))),
+                                                       new AstNode(AST_LOGIC_NOT, new AstNode(AST_BIT_AND, past, mkconst_int(1,false))),
                                                        new AstNode(AST_BIT_AND, present, mkconst_int(1,false)));
 
                                else if (str == "\\$fell")
                                        newNode = new AstNode(AST_LOGIC_AND,
-                                               new AstNode(AST_BIT_AND, past, mkconst_int(1,false)),
-                                               new AstNode(AST_LOGIC_NOT,
-                                                       new AstNode(AST_BIT_AND, present, mkconst_int(1,false))));
+                                                       new AstNode(AST_BIT_AND, past, mkconst_int(1,false)),
+                                                       new AstNode(AST_LOGIC_NOT, new AstNode(AST_BIT_AND, present, mkconst_int(1,false))));
 
                                else
                                        log_abort();
@@ -1901,7 +1896,7 @@ skip_dynamic_range_lvalue_expansion:;
                        {
                                if (children.size() != 1)
                                        log_file_error(filename, linenum, "System function %s got %d arguments, expected 1.\n",
-                                                      RTLIL::unescape_id(str).c_str(), int(children.size()));
+                                                       RTLIL::unescape_id(str).c_str(), int(children.size()));
 
                                AstNode *buf = children[0]->clone();
                                while (buf->simplify(true, false, false, stage, width_hint, sign_hint, false)) { }
@@ -1926,11 +1921,11 @@ skip_dynamic_range_lvalue_expansion:;
                        {
                                if (str == "\\$bits" && children.size() != 1)
                                        log_file_error(filename, linenum, "System function %s got %d arguments, expected 1.\n",
-                                                      RTLIL::unescape_id(str).c_str(), int(children.size()));
+                                                       RTLIL::unescape_id(str).c_str(), int(children.size()));
 
                                if (str == "\\$size" && children.size() != 1 && children.size() != 2)
                                        log_file_error(filename, linenum, "System function %s got %d arguments, expected 1 or 2.\n",
-                                                      RTLIL::unescape_id(str).c_str(), int(children.size()));
+                                                       RTLIL::unescape_id(str).c_str(), int(children.size()));
 
                                int dim = 1;
                                if (str == "\\$size" && children.size() == 2) {
@@ -2004,18 +1999,18 @@ skip_dynamic_range_lvalue_expansion:;
                                if (func_with_two_arguments) {
                                        if (children.size() != 2)
                                                log_file_error(filename, linenum, "System function %s got %d arguments, expected 2.\n",
-                                                              RTLIL::unescape_id(str).c_str(), int(children.size()));
+                                                               RTLIL::unescape_id(str).c_str(), int(children.size()));
                                } else {
                                        if (children.size() != 1)
                                                log_file_error(filename, linenum, "System function %s got %d arguments, expected 1.\n",
-                                                              RTLIL::unescape_id(str).c_str(), int(children.size()));
+                                                               RTLIL::unescape_id(str).c_str(), int(children.size()));
                                }
 
                                if (children.size() >= 1) {
                                        while (children[0]->simplify(true, false, false, stage, width_hint, sign_hint, false)) { }
                                        if (!children[0]->isConst())
                                                log_file_error(filename, linenum, "Failed to evaluate system function `%s' with non-constant argument.\n",
-                                                              RTLIL::unescape_id(str).c_str());
+                                                               RTLIL::unescape_id(str).c_str());
                                        int child_width_hint = width_hint;
                                        bool child_sign_hint = sign_hint;
                                        children[0]->detectSignWidth(child_width_hint, child_sign_hint);
@@ -2026,7 +2021,7 @@ skip_dynamic_range_lvalue_expansion:;
                                        while (children[1]->simplify(true, false, false, stage, width_hint, sign_hint, false)) { }
                                        if (!children[1]->isConst())
                                                log_file_error(filename, linenum, "Failed to evaluate system function `%s' with non-constant argument.\n",
-                                                              RTLIL::unescape_id(str).c_str());
+                                                               RTLIL::unescape_id(str).c_str());
                                        int child_width_hint = width_hint;
                                        bool child_sign_hint = sign_hint;
                                        children[1]->detectSignWidth(child_width_hint, child_sign_hint);
@@ -2114,7 +2109,7 @@ skip_dynamic_range_lvalue_expansion:;
                        {
                                if (GetSize(children) < 2 || GetSize(children) > 4)
                                        log_file_error(filename, linenum, "System function %s got %d arguments, expected 2-4.\n",
-                                                      RTLIL::unescape_id(str).c_str(), int(children.size()));
+                                                       RTLIL::unescape_id(str).c_str(), int(children.size()));
 
                                AstNode *node_filename = children[0]->clone();
                                while (node_filename->simplify(true, false, false, stage, width_hint, sign_hint, false)) { }
@@ -3278,12 +3273,12 @@ void AstNode::replace_variables(std::map<std::string, AstNode::varinfo_t> &varia
                if (!children.empty()) {
                        if (children.size() != 1 || children.at(0)->type != AST_RANGE)
                                log_file_error(filename, linenum, "Memory access in constant function is not supported\n%s:%d: ...called from here.\n",
-                                              fcall->filename.c_str(), fcall->linenum);
+                                               fcall->filename.c_str(), fcall->linenum);
                        children.at(0)->replace_variables(variables, fcall);
                        while (simplify(true, false, false, 1, -1, false, true)) { }
                        if (!children.at(0)->range_valid)
                                log_file_error(filename, linenum, "Non-constant range\n%s:%d: ... called from here.\n",
-                                              fcall->filename.c_str(), fcall->linenum);
+                                               fcall->filename.c_str(), fcall->linenum);
                        offset = min(children.at(0)->range_left, children.at(0)->range_right);
                        width = min(std::abs(children.at(0)->range_left - children.at(0)->range_right) + 1, width);
                }
@@ -3323,7 +3318,7 @@ AstNode *AstNode::eval_const_function(AstNode *fcall)
                        while (child->simplify(true, false, false, 1, -1, false, true)) { }
                        if (!child->range_valid)
                                log_file_error(child->filename, child->linenum, "Can't determine size of variable %s\n%s:%d: ... called from here.\n",
-                                              child->str.c_str(), fcall->filename.c_str(), fcall->linenum);
+                                               child->str.c_str(), fcall->filename.c_str(), fcall->linenum);
                        variables[child->str].val = RTLIL::Const(RTLIL::State::Sx, abs(child->range_left - child->range_right)+1);
                        variables[child->str].offset = min(child->range_left, child->range_right);
                        variables[child->str].is_signed = child->is_signed;
@@ -3367,15 +3362,15 @@ AstNode *AstNode::eval_const_function(AstNode *fcall)
 
                        if (stmt->children.at(1)->type != AST_CONSTANT)
                                log_file_error(stmt->filename, stmt->linenum, "Non-constant expression in constant function\n%s:%d: ... called from here. X\n",
-                                              fcall->filename.c_str(), fcall->linenum);
+                                               fcall->filename.c_str(), fcall->linenum);
 
                        if (stmt->children.at(0)->type != AST_IDENTIFIER)
                                log_file_error(stmt->filename, stmt->linenum, "Unsupported composite left hand side in constant function\n%s:%d: ... called from here.\n",
-                                              fcall->filename.c_str(), fcall->linenum);
+                                               fcall->filename.c_str(), fcall->linenum);
 
                        if (!variables.count(stmt->children.at(0)->str))
                                log_file_error(stmt->filename, stmt->linenum, "Assignment to non-local variable in constant function\n%s:%d: ... called from here.\n",
-                                              fcall->filename.c_str(), fcall->linenum);
+                                               fcall->filename.c_str(), fcall->linenum);
 
                        if (stmt->children.at(0)->children.empty()) {
                                variables[stmt->children.at(0)->str].val = stmt->children.at(1)->bitsAsConst(variables[stmt->children.at(0)->str].val.bits.size());
@@ -3383,7 +3378,7 @@ AstNode *AstNode::eval_const_function(AstNode *fcall)
                                AstNode *range = stmt->children.at(0)->children.at(0);
                                if (!range->range_valid)
                                        log_file_error(range->filename, range->linenum, "Non-constant range\n%s:%d: ... called from here.\n",
-                                                      fcall->filename.c_str(), fcall->linenum);
+                                                       fcall->filename.c_str(), fcall->linenum);
                                int offset = min(range->range_left, range->range_right);
                                int width = std::abs(range->range_left - range->range_right) + 1;
                                varinfo_t &v = variables[stmt->children.at(0)->str];
@@ -3415,7 +3410,7 @@ AstNode *AstNode::eval_const_function(AstNode *fcall)
 
                        if (cond->type != AST_CONSTANT)
                                log_file_error(stmt->filename, stmt->linenum, "Non-constant expression in constant function\n%s:%d: ... called from here.\n",
-                                              fcall->filename.c_str(), fcall->linenum);
+                                               fcall->filename.c_str(), fcall->linenum);
 
                        if (cond->asBool()) {
                                block->children.insert(block->children.begin(), stmt->children.at(1)->clone());
@@ -3436,7 +3431,7 @@ AstNode *AstNode::eval_const_function(AstNode *fcall)
 
                        if (num->type != AST_CONSTANT)
                                log_file_error(stmt->filename, stmt->linenum, "Non-constant expression in constant function\n%s:%d: ... called from here.\n",
-                                              fcall->filename.c_str(), fcall->linenum);
+                                               fcall->filename.c_str(), fcall->linenum);
 
                        block->children.erase(block->children.begin());
                        for (int i = 0; i < num->bitsAsConst().as_int(); i++)
@@ -3474,7 +3469,7 @@ AstNode *AstNode::eval_const_function(AstNode *fcall)
 
                                        if (cond->type != AST_CONSTANT)
                                                log_file_error(stmt->filename, stmt->linenum, "Non-constant expression in constant function\n%s:%d: ... called from here.\n",
-                                                              fcall->filename.c_str(), fcall->linenum);
+                                                               fcall->filename.c_str(), fcall->linenum);
 
                                        found_match = cond->asBool();
                                        delete cond;
@@ -3504,7 +3499,7 @@ AstNode *AstNode::eval_const_function(AstNode *fcall)
                }
 
                log_file_error(stmt->filename, stmt->linenum, "Unsupported language construct in constant function\n%s:%d: ... called from here.\n",
-                              fcall->filename.c_str(), fcall->linenum);
+                               fcall->filename.c_str(), fcall->linenum);
                log_abort();
        }