Fixed cppcheck 'style' warnings.

Used the following command to run cppcheck:

   cppcheck --enable=all --inconclusive --std=posix --quiet --force -I. src/

diff --git a/re2c/src/adfa/adfa.h b/re2c/src/adfa/adfa.h
index cc198b5b3ee6714dc0308a2a0a6b3e18ed73d7f3..31d6174ebb7486b1faed36d166242a43420424c1 100644 (file)
--- a/re2c/src/adfa/adfa.h
+++ b/re2c/src/adfa/adfa.h
@@ -104,7 +104,7 @@ private:
        void findBaseState ();
        void hoist_tags();
        void hoist_tags_and_skip(const opt_t *opts);
-       void count_used_labels (std::set<label_t> & used, label_t prolog, label_t start, bool force_start, bool fFlag) const;
+       void count_used_labels(std::set<label_t> &used, label_t start, label_t initial, bool force_start, bool fFlag) const;
        void emit_body (OutputFile &, uint32_t &, const std::set<label_t> & used_labels, label_t initial) const;
        void emit_dot(OutputFile &o, bool last_cond) const;
 

diff --git a/re2c/src/ast/ast.cc b/re2c/src/ast/ast.cc
index 710a6024063dd6732a98c9b8191cb9f1102dcb5c..67e9959e13c0a9553e1a3830d509dc51cebd2484 100644 (file)
--- a/re2c/src/ast/ast.cc
+++ b/re2c/src/ast/ast.cc
@@ -80,10 +80,10 @@ const AST *ast_cat(const AST *a1, const AST *a2)
        return ast;
 }
 
-const AST *ast_iter(const AST *r, uint32_t n, uint32_t m)
+const AST *ast_iter(const AST *a, uint32_t n, uint32_t m)
 {
-       AST *ast = new AST(r->line, r->column, AST::ITER);
-       ast->iter.ast = r;
+       AST *ast = new AST(a->line, a->column, AST::ITER);
+       ast->iter.ast = a;
        ast->iter.min = n;
        ast->iter.max = m;
        return ast;
@@ -105,24 +105,24 @@ const AST *ast_tag(uint32_t l, uint32_t c, const std::string *n, bool h)
        return ast;
 }
 
-const AST *ast_cap(const AST *r)
+const AST *ast_cap(const AST *a)
 {
-       AST *ast = new AST(r->line, r->column, AST::CAP);
-       ast->cap = r;
+       AST *ast = new AST(a->line, a->column, AST::CAP);
+       ast->cap = a;
        return ast;
 }
 
-const AST *ast_ref(const AST *r, const std::string &n)
+const AST *ast_ref(const AST *a, const std::string &n)
 {
-       AST *ast = new AST(r->line, r->column, AST::REF);
-       ast->ref.ast = r;
+       AST *ast = new AST(a->line, a->column, AST::REF);
+       ast->ref.ast = a;
        ast->ref.name = new std::string(n);
        return ast;
 }
 
-bool ast_need_wrap(const AST *ast)
+bool ast_need_wrap(const AST *a)
 {
-       switch (ast->type) {
+       switch (a->type) {
                case AST::ITER:
                case AST::NIL:
                case AST::STR:

diff --git a/re2c/src/ast/ast.h b/re2c/src/ast/ast.h
index 56646dea47c8549384a0fd86e8420895d53d0a7a..f059485df385ee9be787c5d49eb320267af9501d 100644 (file)
--- a/re2c/src/ast/ast.h
+++ b/re2c/src/ast/ast.h
@@ -119,14 +119,14 @@ const AST *ast_str(uint32_t l, uint32_t c, std::vector<ASTChar> *chars, bool ica
 const AST *ast_cls(uint32_t l, uint32_t c, std::vector<ASTRange> *ranges, bool negated);
 const AST *ast_dot(uint32_t l, uint32_t c);
 const AST *ast_default(uint32_t l, uint32_t c);
-const AST *ast_alt(const AST *r1, const AST *r2);
-const AST *ast_cat(const AST *r1, const AST *r2);
-const AST *ast_iter(const AST *r, uint32_t n, uint32_t m);
-const AST *ast_diff(const AST *r1, const AST *r2);
+const AST *ast_alt(const AST *a1, const AST *a2);
+const AST *ast_cat(const AST *a1, const AST *a2);
+const AST *ast_iter(const AST *a, uint32_t n, uint32_t m);
+const AST *ast_diff(const AST *a1, const AST *a2);
 const AST *ast_tag(uint32_t l, uint32_t c, const std::string *n, bool h);
-const AST *ast_cap(const AST *r);
-const AST *ast_ref(const AST *r, const std::string &n);
-bool ast_need_wrap(const AST *ast);
+const AST *ast_cap(const AST *a);
+const AST *ast_ref(const AST *a, const std::string &n);
+bool ast_need_wrap(const AST *a);
 
 void validate_mode(Scanner::ParseMode mode, bool rflag, bool rules, Scanner &input);
 void validate_ast(const specs_t &specs, bool cflag);

diff --git a/re2c/src/ast/input.h b/re2c/src/ast/input.h
index f331e12807e1cc3bb3447d86a32579dd7a7ed87e..faee2f9431aa7da6e71e5ffeed1c30db56e731a3 100644 (file)
--- a/re2c/src/ast/input.h
+++ b/re2c/src/ast/input.h
@@ -13,7 +13,7 @@ struct Input
        FILE * file;
        std::string file_name;
 
-       Input (const char * fn);
+       explicit Input (const char * fn);
        ~Input ();
        bool open ();
 

diff --git a/re2c/src/ast/scanner.h b/re2c/src/ast/scanner.h
index 0d7d60dfa5d34cbd9c55f9250b58e992fdc464fd..9ff5122bd7c47f32abe85bdf78a4c06eca0aba53 100644 (file)
--- a/re2c/src/ast/scanner.h
+++ b/re2c/src/ast/scanner.h
@@ -55,7 +55,7 @@ class Scanner: private ScannerState
        Input & in;
        Warn &warn;
 
-       void fill (uint32_t);
+       void fill(uint32_t need);
        void lex_end_of_comment(OutputFile &out);
        void lex_tags(OutputFile &out, bool mtags);
        void set_sourceline ();

diff --git a/re2c/src/code/emit.h b/re2c/src/code/emit.h
index 2bcd9afa11c60b8dc3d593278fcdbfab6009f493..ddef595b2760d1a245566c468b1d9856224fd45b 100644 (file)
--- a/re2c/src/code/emit.h
+++ b/re2c/src/code/emit.h
@@ -17,7 +17,7 @@ std::string vartag_name(tagver_t ver, const std::string &prefix);
 std::string vartag_expr(tagver_t ver, const std::string &prefix, const std::string &expression);
 std::string tagname(const Tag &tag);
 
-inline std::string indent(uint32_t n, const std::string s)
+inline std::string indent(uint32_t n, const std::string &s)
 {
        std::string ind;
        for (; n --> 0; ind += s);

diff --git a/re2c/src/code/emit_action.cc b/re2c/src/code/emit_action.cc
index 0299538a249ee2e6c6fa5f5b7bbf25a594fdc843..c5632e69ebe5922259216b77c3752654d14aa1e3 100644 (file)
--- a/re2c/src/code/emit_action.cc
+++ b/re2c/src/code/emit_action.cc
@@ -375,7 +375,7 @@ void gen_fintags(OutputFile &o, uint32_t ind, const DFA &dfa, const Rule &rule)
        const std::string
                &prefix = opts->tags_prefix,
                &expression = opts->tags_expression;
-       std::string name, expr;
+       std::string expr;
        const std::vector<Tag> &tags = dfa.tags;
        const tagver_t *fins = dfa.finvers;
 

diff --git a/re2c/src/code/go.h b/re2c/src/code/go.h
index 2931050b8ebbe19e0a4f008dff2997f36571388a..40b3df95178d4fd3a1ea336b00a25263c1461cfb 100644 (file)
--- a/re2c/src/code/go.h
+++ b/re2c/src/code/go.h
@@ -49,7 +49,7 @@ struct Cases
        Cases(const Span *spans, uint32_t nspans, bool skip);
        ~Cases();
        void emit(OutputFile &o, uint32_t ind, const DFA &dfa) const;
-       void used_labels(std::set<label_t> &used);
+       void used_labels(std::set<label_t> &used) const;
        FORBID_COPY(Cases);
 };
 
@@ -67,8 +67,8 @@ struct Binary
        If * els;
        Binary (const Span * s, uint32_t n, const State * next, bool skip);
        ~Binary ();
-       void emit (OutputFile &o, uint32_t ind, const DFA &dfa);
-       void used_labels (std::set<label_t> & used);
+       void emit (OutputFile &o, uint32_t ind, const DFA &dfa) const;
+       void used_labels (std::set<label_t> & used) const;
 
        FORBID_COPY (Binary);
 };
@@ -89,8 +89,8 @@ struct Linear
        Linear(const Span *s, uint32_t n, const State *next, bool skip);
        ~Linear();
        void add_branch(const Cond *cond, const State *to, tcid_t tags, bool skip);
-       void emit(OutputFile &o, uint32_t ind, const DFA &dfa);
-       void used_labels(std::set<label_t> &used);
+       void emit(OutputFile &o, uint32_t ind, const DFA &dfa) const;
+       void used_labels(std::set<label_t> &used) const;
        FORBID_COPY(Linear);
 };
 
@@ -108,8 +108,8 @@ struct If
        } info;
        If (type_t t, const Span * sp, uint32_t nsp, const State * next, bool skip);
        ~If ();
-       void emit (OutputFile & o, uint32_t ind, const DFA &dfa);
-       void used_labels (std::set<label_t> & used);
+       void emit (OutputFile & o, uint32_t ind, const DFA &dfa) const;
+       void used_labels (std::set<label_t> & used) const;
 };
 
 struct SwitchIf
@@ -126,8 +126,8 @@ struct SwitchIf
        } info;
        SwitchIf (const Span * sp, uint32_t nsp, const State * next, bool sflag, bool skip);
        ~SwitchIf ();
-       void emit (OutputFile & o, uint32_t ind, const DFA &dfa);
-       void used_labels (std::set<label_t> & used);
+       void emit (OutputFile & o, uint32_t ind, const DFA &dfa) const;
+       void used_labels (std::set<label_t> & used) const;
 };
 
 struct GoBitmap
@@ -140,8 +140,8 @@ struct GoBitmap
                uint32_t hSpans, const bitmap_t * bm, const State * bm_state,
                const State * next, bool sflag);
        ~GoBitmap ();
-       void emit (OutputFile & o, uint32_t ind, const DFA &dfa);
-       void used_labels (std::set<label_t> & used);
+       void emit (OutputFile & o, uint32_t ind, const DFA &dfa) const;
+       void used_labels (std::set<label_t> & used) const;
 
        FORBID_COPY (GoBitmap);
 };
@@ -152,8 +152,8 @@ struct CpgotoTable
        const State ** table;
        CpgotoTable (const Span * span, uint32_t nSpans);
        ~CpgotoTable ();
-       void emit (OutputFile & o, uint32_t ind);
-       void used_labels (std::set<label_t> & used);
+       void emit (OutputFile & o, uint32_t ind) const;
+       void used_labels (std::set<label_t> & used) const;
 
 private:
        label_t max_label () const;
@@ -168,8 +168,8 @@ struct Cpgoto
        Cpgoto (const Span * span, uint32_t nSpans, const Span * hspan,
                uint32_t hSpans, const State * next, bool sflag);
        ~Cpgoto ();
-       void emit (OutputFile & o, uint32_t ind, const DFA &dfa);
-       void used_labels (std::set<label_t> & used);
+       void emit (OutputFile & o, uint32_t ind, const DFA &dfa) const;
+       void used_labels (std::set<label_t> & used) const;
 
        FORBID_COPY (Cpgoto);
 };
@@ -178,9 +178,9 @@ struct Dot
 {
        const State * from;
        Cases * cases;
-       Dot (const Span * sp, uint32_t nsp, const State * from);
+       Dot(const Span *sp, uint32_t nsp, const State *s);
        ~Dot ();
-       void emit (OutputFile & o, const DFA &dfa);
+       void emit (OutputFile & o, const DFA &dfa) const;
 
        FORBID_COPY (Dot);
 };
@@ -210,8 +210,8 @@ struct Go
        Go ();
        ~Go ();
        void init(const State* from, const opt_t *opts, bitmaps_t &bitmaps);
-       void emit (OutputFile & o, uint32_t ind, const DFA &dfa);
-       void used_labels (std::set<label_t> & used);
+       void emit (OutputFile & o, uint32_t ind, const DFA &dfa) const;
+       void used_labels (std::set<label_t> & used) const;
 
        Go (const Go & g)
                : nSpans (g.nSpans)

diff --git a/re2c/src/code/go_emit.cc b/re2c/src/code/go_emit.cc
index 8c4ecd8245f6c7edc1d59c3f0c57ceee70f7336f..11a4beb7b6dc7b83d8a99ae3aa1064c142a1335d 100644 (file)
--- a/re2c/src/code/go_emit.cc
+++ b/re2c/src/code/go_emit.cc
@@ -84,7 +84,7 @@ void Cases::emit(OutputFile &o, uint32_t ind, const DFA &dfa) const
        o.wind(ind).ws("}\n");
 }
 
-void Binary::emit(OutputFile &o, uint32_t ind, const DFA &dfa)
+void Binary::emit(OutputFile &o, uint32_t ind, const DFA &dfa) const
 {
        output_if(o, ind, cond->compare, cond->value);
        o.ws("{\n");
@@ -94,7 +94,7 @@ void Binary::emit(OutputFile &o, uint32_t ind, const DFA &dfa)
        o.wind(ind).ws("}\n");
 }
 
-void Linear::emit(OutputFile &o, uint32_t ind, const DFA &dfa)
+void Linear::emit(OutputFile &o, uint32_t ind, const DFA &dfa) const
 {
        for (uint32_t i = 0; i < nbranches; ++i) {
                const Branch &b = branches[i];
@@ -108,7 +108,7 @@ void Linear::emit(OutputFile &o, uint32_t ind, const DFA &dfa)
        }
 }
 
-void If::emit(OutputFile &o, uint32_t ind, const DFA &dfa)
+void If::emit(OutputFile &o, uint32_t ind, const DFA &dfa) const
 {
        switch (type) {
                case BINARY: info.binary->emit(o, ind, dfa); break;
@@ -116,7 +116,7 @@ void If::emit(OutputFile &o, uint32_t ind, const DFA &dfa)
        }
 }
 
-void SwitchIf::emit(OutputFile &o, uint32_t ind, const DFA &dfa)
+void SwitchIf::emit(OutputFile &o, uint32_t ind, const DFA &dfa) const
 {
        switch (type) {
                case SWITCH: info.cases->emit(o, ind, dfa); break;
@@ -124,7 +124,7 @@ void SwitchIf::emit(OutputFile &o, uint32_t ind, const DFA &dfa)
        }
 }
 
-void GoBitmap::emit (OutputFile & o, uint32_t ind, const DFA &dfa)
+void GoBitmap::emit (OutputFile & o, uint32_t ind, const DFA &dfa) const
 {
        const opt_t *opts = o.block().opts;
        std::string yych = output_hgo (o, ind, dfa, hgo);
@@ -159,7 +159,7 @@ label_t CpgotoTable::max_label () const
        return max;
 }
 
-void CpgotoTable::emit (OutputFile & o, uint32_t ind)
+void CpgotoTable::emit (OutputFile & o, uint32_t ind) const
 {
        const opt_t *opts = o.block().opts;
        o.wind(ind).ws("static void *").wstring(opts->yytarget).ws("[256] = {\n");
@@ -185,7 +185,7 @@ void CpgotoTable::emit (OutputFile & o, uint32_t ind)
        o.wind(--ind).ws("};\n");
 }
 
-void Cpgoto::emit (OutputFile & o, uint32_t ind, const DFA &dfa)
+void Cpgoto::emit (OutputFile & o, uint32_t ind, const DFA &dfa) const
 {
        std::string yych = output_hgo (o, ind, dfa, hgo);
        o.ws("{\n");
@@ -194,7 +194,7 @@ void Cpgoto::emit (OutputFile & o, uint32_t ind, const DFA &dfa)
        o.wind(--ind).ws("}\n");
 }
 
-void Dot::emit(OutputFile &o, const DFA &dfa)
+void Dot::emit(OutputFile &o, const DFA &dfa) const
 {
        const std::string &prefix = o.block().opts->tags_prefix;
        const uint32_t n = cases->cases_size;
@@ -220,7 +220,7 @@ void Dot::emit(OutputFile &o, const DFA &dfa)
        }
 }
 
-void Go::emit (OutputFile & o, uint32_t ind, const DFA &dfa)
+void Go::emit (OutputFile & o, uint32_t ind, const DFA &dfa) const
 {
        if (type == DOT) {
                info.dot->emit (o, dfa);

diff --git a/re2c/src/code/go_used_labels.cc b/re2c/src/code/go_used_labels.cc
index e5e064b092cbc71d8e1e78961c57f521bfa171af..939fec72ec417752313c6c2298157eaa70d6a27e 100644 (file)
--- a/re2c/src/code/go_used_labels.cc
+++ b/re2c/src/code/go_used_labels.cc
@@ -11,7 +11,7 @@
 namespace re2c
 {
 
-void Cases::used_labels (std::set<label_t> & used)
+void Cases::used_labels (std::set<label_t> & used) const
 {
        for (uint32_t i = 0; i < cases_size; ++i)
        {
@@ -19,13 +19,13 @@ void Cases::used_labels (std::set<label_t> & used)
        }
 }
 
-void Binary::used_labels (std::set<label_t> & used)
+void Binary::used_labels (std::set<label_t> & used) const
 {
        thn->used_labels (used);
        els->used_labels (used);
 }
 
-void Linear::used_labels (std::set<label_t> & used)
+void Linear::used_labels (std::set<label_t> & used) const
 {
        for (uint32_t i = 0; i < nbranches; ++i) {
                const State *to = branches[i].to;
@@ -35,7 +35,7 @@ void Linear::used_labels (std::set<label_t> & used)
        }
 }
 
-void If::used_labels (std::set<label_t> & used)
+void If::used_labels (std::set<label_t> & used) const
 {
        switch (type)
        {
@@ -48,7 +48,7 @@ void If::used_labels (std::set<label_t> & used)
        }
 }
 
-void SwitchIf::used_labels (std::set<label_t> & used)
+void SwitchIf::used_labels (std::set<label_t> & used) const
 {
        switch (type)
        {
@@ -61,7 +61,7 @@ void SwitchIf::used_labels (std::set<label_t> & used)
        }
 }
 
-void GoBitmap::used_labels (std::set<label_t> & used)
+void GoBitmap::used_labels (std::set<label_t> & used) const
 {
        if (hgo != NULL)
        {
@@ -74,7 +74,7 @@ void GoBitmap::used_labels (std::set<label_t> & used)
        }
 }
 
-void CpgotoTable::used_labels (std::set<label_t> & used)
+void CpgotoTable::used_labels (std::set<label_t> & used) const
 {
        for (uint32_t i = 0; i < TABLE_SIZE; ++i)
        {
@@ -82,7 +82,7 @@ void CpgotoTable::used_labels (std::set<label_t> & used)
        }
 }
 
-void Cpgoto::used_labels (std::set<label_t> & used)
+void Cpgoto::used_labels (std::set<label_t> & used) const
 {
        if (hgo != NULL)
        {
@@ -91,7 +91,7 @@ void Cpgoto::used_labels (std::set<label_t> & used)
        table->used_labels (used);
 }
 
-void Go::used_labels (std::set<label_t> & used)
+void Go::used_labels (std::set<label_t> & used) const
 {
        switch (type)
        {

diff --git a/re2c/src/code/output.cc b/re2c/src/code/output.cc
index b78cf560e213451e32721f0a84e05f2b83afb461..4ee267f430681c0840c22f8f74ea7178e3e49cb7 100644 (file)
--- a/re2c/src/code/output.cc
+++ b/re2c/src/code/output.cc
@@ -22,7 +22,7 @@ OutputFragment::~OutputFragment()
        if (type == STAGS || type == MTAGS) delete tags;
 }
 
-uint32_t OutputFragment::count_lines ()
+uint32_t OutputFragment::count_lines () const
 {
        uint32_t lines = 0;
        const std::string content = stream.str ();

diff --git a/re2c/src/code/output.h b/re2c/src/code/output.h
index 6e0be3f65e0ce7844398d62bfb6d499eb48ccb4b..0d9382db798efde5e05ff11ff1ef6894f107498c 100644 (file)
--- a/re2c/src/code/output.h
+++ b/re2c/src/code/output.h
@@ -66,7 +66,7 @@ struct OutputFragment
 
        OutputFragment (type_t t, uint32_t i);
        ~OutputFragment ();
-       uint32_t count_lines ();
+       uint32_t count_lines () const;
 };
 
 struct OutputBlock

diff --git a/re2c/src/code/print.cc b/re2c/src/code/print.cc
index d6c66c168fca7538652183dce9026b7a6da60f0b..d24f06d04f892e09821d152271408c937d137f42 100644 (file)
--- a/re2c/src/code/print.cc
+++ b/re2c/src/code/print.cc
@@ -81,13 +81,13 @@ static void prtChOrHexForSpan(std::ostream& o, uint32_t c, uint32_t szcunit, boo
        }
 }
 
-void printSpan(std::ostream& o, uint32_t lb, uint32_t ub, uint32_t szcunit, bool ebcdic, bool dot)
+void printSpan(std::ostream& o, uint32_t l, uint32_t u, uint32_t szcunit, bool ebcdic, bool dot)
 {
        o << "[";
-       prtChOrHexForSpan(o, lb, szcunit, ebcdic, dot);
-       if (ub - lb > 1) {
+       prtChOrHexForSpan(o, l, szcunit, ebcdic, dot);
+       if (u - l > 1) {
                o << "-";
-               prtChOrHexForSpan(o, ub - 1, szcunit, ebcdic, dot);
+               prtChOrHexForSpan(o, u - 1, szcunit, ebcdic, dot);
        }
        o << "]";
 }

diff --git a/re2c/src/conf/opt.h b/re2c/src/conf/opt.h
index 91d41954388fba38568130dd4f6486d63c097dc9..bb0b8191aaede341692315c71c1cb25e89a24b9e 100644 (file)
--- a/re2c/src/conf/opt.h
+++ b/re2c/src/conf/opt.h
@@ -278,7 +278,7 @@ public:
        void unset_encoding(Enc::type_t t)        { user.encoding.unset(t); }
        void set_encoding_policy(Enc::policy_t p) { user.encoding.setPolicy(p); }
 #define MUTOPT1 MUTOPT
-#define MUTOPT(type, name, value) void set_##name (type arg) { user.name = arg; diverge = true; }
+#define MUTOPT(type, name, value) void set_##name (const type &arg) { user.name = arg; diverge = true; }
        RE2C_MUTOPTS
 #undef MUTOPT1
 #undef MUTOPT

diff --git a/re2c/src/conf/warn.cc b/re2c/src/conf/warn.cc
index 2170aa07d93801ca40d455261c259b9a3ba13398..fe1ded7a66f1fb921f0803b12fe95bc5d80dd1d0 100644 (file)
--- a/re2c/src/conf/warn.cc
+++ b/re2c/src/conf/warn.cc
@@ -74,7 +74,7 @@ void Warn::set_all_error ()
        }
 }
 
-void Warn::fail (type_t t, uint32_t line, const char * s)
+void Warn::fail (type_t t, uint32_t line, const char * s) const
 {
        if (mask[t] & WARNING)
        {

diff --git a/re2c/src/conf/warn.h b/re2c/src/conf/warn.h
index de4856ed87d5bc1f9d89e45946943334786e627e..cef97e4ee3306d372854bce6598531800f503afd 100644 (file)
--- a/re2c/src/conf/warn.h
+++ b/re2c/src/conf/warn.h
@@ -54,7 +54,7 @@ public:
        void set (type_t t, option_t o);
        void set_all ();
        void set_all_error ();
-       void fail (type_t t, uint32_t line, const char * s);
+       void fail (type_t t, uint32_t line, const char * s) const;
 
        void condition_order (uint32_t line);
        void empty_class (uint32_t line);

diff --git a/re2c/src/dfa/cfg/cfg.h b/re2c/src/dfa/cfg/cfg.h
index 65b15d1878dae22dc583b283003dfc17a5a3923a..7a64f8fe1774c0cbadd762c05ef6564a7ac68888 100644 (file)
--- a/re2c/src/dfa/cfg/cfg.h
+++ b/re2c/src/dfa/cfg/cfg.h
@@ -1,6 +1,7 @@
 #ifndef _RE2C_DFA_CFG_CFG_
 #define _RE2C_DFA_CFG_CFG_
 
+#include "src/util/forbid_copy.h"
 #include "src/dfa/dfa.h"
 
 namespace re2c {
@@ -16,6 +17,7 @@ struct cfg_bb_t
        const Rule *rule;
 
        cfg_bb_t(const cfg_ix_t *sb, const cfg_ix_t *se, tcmd_t *&c, const Rule *r);
+       FORBID_COPY(cfg_bb_t);
 };
 
 // control flow graph

diff --git a/re2c/src/dfa/closure.cc b/re2c/src/dfa/closure.cc
index 04bda906964023d66dd5465b7976f49c351e3c9a..194e6181d7dee27bad900db1fa1e9f259a2315e0 100644 (file)
--- a/re2c/src/dfa/closure.cc
+++ b/re2c/src/dfa/closure.cc
@@ -8,10 +8,8 @@
 namespace re2c
 {
 
-static void closure_posix(const closure_t &clos1, closure_t &clos,
-       closure_t *shadow, Tagpool &tagpool, const std::vector<Tag> &tags);
-static void closure_leftmost(const closure_t &clos1, closure_t &clos,
-       closure_t *shadow, Tagpool &tagpool);
+static void closure_posix(const closure_t &init, closure_t &done, closure_t *shadow, Tagpool &tagpool, const std::vector<Tag> &tags);
+static void closure_leftmost(const closure_t &init, closure_t &done, closure_t *shadow, Tagpool &tagpool);
 static int32_t compare_posix(const clos_t &c1, const clos_t &c2, Tagpool &tagpool, const std::vector<Tag> &tags);
 static void prune(closure_t &clos, std::valarray<Rule> &rules);
 static void lower_lookahead_to_transition(closure_t &clos);

diff --git a/re2c/src/dfa/dump.cc b/re2c/src/dfa/dump.cc
index e884a609c08daddb242da15bff1f3e3f6d2b675e..8c11c25ce5da530d558eb68f1c0989b20660ba9f 100644 (file)
--- a/re2c/src/dfa/dump.cc
+++ b/re2c/src/dfa/dump.cc
@@ -35,7 +35,7 @@ dump_dfa_t::~dump_dfa_t()
        fprintf(stderr, "}\n");
 }
 
-uint32_t dump_dfa_t::index(const nfa_state_t *s)
+uint32_t dump_dfa_t::index(const nfa_state_t *s) const
 {
        return static_cast<uint32_t>(s - base);
 }

diff --git a/re2c/src/dfa/dump.h b/re2c/src/dfa/dump.h
index ae6b85a60e7b63b9418a22554e91a5e03f5203a2..3381ac4c80de73cbc688af4145e43c21a1426b98 100644 (file)
--- a/re2c/src/dfa/dump.h
+++ b/re2c/src/dfa/dump.h
@@ -23,7 +23,7 @@ struct dump_dfa_t
        void state0(const closure_t &clos);
        void state(const closure_t &clos, size_t state, size_t symbol, bool isnew);
        void final(size_t state, const nfa_state_t *port);
-       uint32_t index(const nfa_state_t *s);
+       uint32_t index(const nfa_state_t *s) const;
        FORBID_COPY(dump_dfa_t);
 };
 

diff --git a/re2c/src/dfa/find_state.h b/re2c/src/dfa/find_state.h
index d5a6d13a0f5af4eea8194e2a33f522b148ace394..e7a584991d3748e9e628d3df292f5acf25a9f783 100644 (file)
--- a/re2c/src/dfa/find_state.h
+++ b/re2c/src/dfa/find_state.h
@@ -64,9 +64,9 @@ private:
        tagver_t *actlhs;
 
 public:
-       kernels_t(Tagpool &tagpool, tcpool_t &tcpool, const std::vector<Tag> &tags);
+       kernels_t(Tagpool &tagp, tcpool_t &tcp, const std::vector<Tag> &ts);
        ~kernels_t();
-       void init(tagver_t v, size_t k);
+       void init(tagver_t v, size_t nkern);
        size_t size() const;
        const kernel_t* operator[](size_t idx) const;
        result_t insert(const closure_t &clos, tcmd_t *acts, tagver_t maxver);

diff --git a/re2c/src/dfa/tcmd.cc b/re2c/src/dfa/tcmd.cc
index d7e142ebec547ab21a8668c364cd245eabf76105..a7ad22e963836b23e62e9f0e974d270b2521067a 100644 (file)
--- a/re2c/src/dfa/tcmd.cc
+++ b/re2c/src/dfa/tcmd.cc
@@ -73,9 +73,7 @@ bool tcmd_t::isadd(const tcmd_t *x)
 
 bool tcmd_t::topsort(tcmd_t **phead, uint32_t *indeg)
 {
-       tcmd_t
-               *x0 = *phead, **px, *x,
-               *y0 = NULL, **py, **py1;
+       tcmd_t *x0 = *phead, *x, *y0 = NULL, **py;
        bool nontrivial_cycles = false;
 
        // initialize in-degree
@@ -90,8 +88,7 @@ bool tcmd_t::topsort(tcmd_t **phead, uint32_t *indeg)
                // reached end of list
                if (!x0) break;
 
-               px = &x0;
-               py1 = py;
+               tcmd_t **px = &x0, **py1 = py;
                for (x = x0; x; x = x->next) {
                        if (indeg[x->lhs] == 0) {
                                --indeg[x->rhs];

diff --git a/re2c/src/dfa/tcmd.h b/re2c/src/dfa/tcmd.h
index 0badf03761f770b0266dd93d9c6ba64c4319c8d3..948efe98a48d5073626173a8f84ccf1be2fe7738 100644 (file)
--- a/re2c/src/dfa/tcmd.h
+++ b/re2c/src/dfa/tcmd.h
@@ -21,9 +21,9 @@ struct tcmd_t
        static bool equal(const tcmd_t &x, const tcmd_t &y);
        static bool equal_history(const tagver_t *h, const tagver_t *g);
        static bool topsort(tcmd_t **phead, uint32_t *indeg);
-       static bool iscopy(const tcmd_t *cmd);
-       static bool isset(const tcmd_t *cmd);
-       static bool isadd(const tcmd_t *cmd);
+       static bool iscopy(const tcmd_t *x);
+       static bool isset(const tcmd_t *x);
+       static bool isadd(const tcmd_t *x);
        FORBID_COPY(tcmd_t);
 };
 

diff --git a/re2c/src/nfa/nfa.h b/re2c/src/nfa/nfa.h
index 1df0f20a7814214cb1c12cf9b40cd3588733789c..9dcd75618ce5bcdb40ca609ed3b43a1be48c8419 100644 (file)
--- a/re2c/src/nfa/nfa.h
+++ b/re2c/src/nfa/nfa.h
@@ -107,7 +107,7 @@ struct nfa_t
        std::vector<Tag> &tags;
        nfa_state_t *root;
 
-       nfa_t(const RESpec &spec);
+       explicit nfa_t(const RESpec &spec);
        ~nfa_t();
 
        FORBID_COPY(nfa_t);

diff --git a/re2c/src/re/encoding/utf8/utf8_range.h b/re2c/src/re/encoding/utf8/utf8_range.h
index 0cedeb45d8e7508f5ec4b19dee23b10003cfee29..8231ad195bc2e93d098d42fd4bc1184a44dc582f 100644 (file)
--- a/re2c/src/re/encoding/utf8/utf8_range.h
+++ b/re2c/src/re/encoding/utf8/utf8_range.h
@@ -9,9 +9,9 @@ namespace re2c {
 
 struct RangeSuffix;
 
-void UTF8addContinuous(RangeSuffix * & p, utf8::rune l, utf8::rune h, uint32_t n);
-void UTF8splitByContinuity(RangeSuffix * & p, utf8::rune l, utf8::rune h, uint32_t n);
-void UTF8splitByRuneLength(RangeSuffix * & p, utf8::rune l, utf8::rune h);
+void UTF8addContinuous(RangeSuffix * & root, utf8::rune l, utf8::rune h, uint32_t n);
+void UTF8splitByContinuity(RangeSuffix * & root, utf8::rune l, utf8::rune h, uint32_t n);
+void UTF8splitByRuneLength(RangeSuffix * & root, utf8::rune l, utf8::rune h);
 
 } // namespace re2c
 

diff --git a/re2c/src/skeleton/control_flow.cc b/re2c/src/skeleton/control_flow.cc
index 062f31c7b77bc95b407fa282b8c0743f099fb024..a1b3a20485eec02ee3869702e89101e4192d074e 100644 (file)
--- a/re2c/src/skeleton/control_flow.cc
+++ b/re2c/src/skeleton/control_flow.cc
@@ -23,7 +23,7 @@ struct ucf_t
        path_t prefix;
        ucf_size_t size;
 
-       ucf_t(size_t nnodes): loops(nnodes), paths(),
+       explicit ucf_t(size_t nnodes): loops(nnodes), paths(),
                prefix(0), size(ucf_size_t::from32(0u)) {}
 };
 

diff --git a/re2c/src/skeleton/skeleton.h b/re2c/src/skeleton/skeleton.h
index 25bc20d8066a19843ce2882fe9d5abc3b44b1fb1..26c2b36375d877970606269914df8183c2757b48 100644 (file)
--- a/re2c/src/skeleton/skeleton.h
+++ b/re2c/src/skeleton/skeleton.h
@@ -80,7 +80,7 @@ struct Skeleton
        const std::vector<Tag> &tags;
        const tagver_t *finvers;
 
-       Skeleton(const dfa_t &dfa, const opt_t *opts, size_t def,
+       Skeleton(const dfa_t &dfa, const opt_t *op, size_t def,
                const std::string &dfa_name, const std::string &dfa_cond,
                uint32_t dfa_line);
        ~Skeleton ();

diff --git a/re2c/src/util/wrap_iter.h b/re2c/src/util/wrap_iter.h
index 4b5bd5115d46988362737a8be492bd8021717f12..419c18f72ec137463d11ef945c473db4968bab23 100644 (file)
--- a/re2c/src/util/wrap_iter.h
+++ b/re2c/src/util/wrap_iter.h
@@ -16,7 +16,7 @@ class wrap_citer_t
        citer_t cur;
 
 public:
-       wrap_citer_t(const container_t &c): beg(c.begin()), end(c.end()), cur(beg) {}
+       explicit wrap_citer_t(const container_t &c): beg(c.begin()), end(c.end()), cur(beg) {}
        wrap_citer_t& operator++() { if (++cur == end) cur = beg; return *this; }
        cpval_t operator->() const { return cur.operator->(); }
 };