In reuse mode, use block-local options instead of last block options.

Last block options are used as "global" or "final" options in certain
cases for code generation: namely, when generating state dispatch and
condition enum, which are accumulated over all blocks. In reuse mode,
however, state dispatch is generated in every block, so it should use
block-local options.

This partially fixes #282 "Options -f, -c and -r do not combine well".

Author: skvadrik

src/codegen/code.h

@@ -700,12 +700,13 @@ struct OutputBlock {
     std::vector<OutputFragment> fragments;
     bool used_yyaccept;
     bool have_user_code;
+    bool is_reuse_block;
     std::vector<std::string> types;
     std::set<std::string> stags;
     std::set<std::string> mtags;
     const opt_t *opts;
 
-    explicit OutputBlock(const loc_t &loc);
+    OutputBlock(const loc_t &loc, bool reuse);
     ~OutputBlock();
     FORBID_COPY(OutputBlock);
 };
@@ -743,7 +744,7 @@ class Output {
     OutputBlock &block();
     size_t blockid() const;
     bool open ();
-    void new_block(Opt &opts, const loc_t &loc);
+    void new_block(Opt &opts, const loc_t &loc, bool reuse);
     void header_mode(bool on);
     bool in_header() const;
     void wraw (const char *s, const char *e);

src/codegen/gen_program.cc

@@ -42,14 +42,15 @@ static uint32_t write_converting_newlines(const std::string &str, FILE *f)
     return lines;
 }
 
-OutputBlock::OutputBlock(const loc_t &loc)
+OutputBlock::OutputBlock(const loc_t &loc, bool reuse)
     : loc(loc)
-    , fragments ()
-    , used_yyaccept (false)
-    , have_user_code (false)
-    , types ()
-    , stags ()
-    , mtags ()
+    , fragments()
+    , used_yyaccept(false)
+    , have_user_code(false)
+    , is_reuse_block(reuse)
+    , types()
+    , stags()
+    , mtags()
     , opts(NULL)
 {}
 
@@ -128,9 +129,9 @@ void Output::wdelay_stmt(uint32_t ind, Code *stmt)
     block().fragments.push_back(f);
 }
 
-void Output::new_block(Opt &opts, const loc_t &loc)
+void Output::new_block(Opt &opts, const loc_t &loc, bool reuse)
 {
-    OutputBlock *b = new OutputBlock(loc);
+    OutputBlock *b = new OutputBlock(loc, reuse);
     b->opts = opts.snapshot();
     pblocks->push_back(b);
 
@@ -174,19 +175,18 @@ bool Output::emit_blocks(const std::string &fname, blocks_t &blocks,
 
     fix_first_block_opts(blocks);
 
-    // global options are last block's options
+    // global options are last block options
     const opt_t *globopt = block().opts;
 
     unsigned int line_count = 1;
     for (unsigned int j = 0; j < blocks.size(); ++j) {
-        OutputBlock & b = *blocks[j];
-        const opt_t *bopt = b.opts;
+        OutputBlock &b = *blocks[j];
 
         CodegenContext gctx =
             { allocator
             , scratchbuf
-            , globopt
-            , bopt
+            , b.is_reuse_block ? b.opts : globopt
+            , b.opts
             , msg
             , b.loc
             , global_types
@@ -208,7 +208,7 @@ bool Output::emit_blocks(const std::string &fname, blocks_t &blocks,
 
             RenderContext rctx =
                 { os
-                , bopt
+                , b.opts
                 , msg
                 , f.indent
                 , filename.c_str()

src/compile.cc

@@ -129,11 +129,11 @@ void compile(Scanner &input, Output &output, Opt &opts)
     const loc_t &loc0 = input.tok_loc();
 
     output.header_mode(1);
-    output.new_block(opts, loc0);
+    output.new_block(opts, loc0, false /* reuse */);
     output.wversion_time();
 
     output.header_mode(0);
-    output.new_block(opts, loc0);
+    output.new_block(opts, loc0, false /* reuse */);
     output.wversion_time();
     output.wdelay_stmt(0, code_line_info_input(alc, loc0));
 
@@ -161,7 +161,7 @@ void compile(Scanner &input, Output &output, Opt &opts)
 
         // start new output block with accumulated options
         const loc_t &loc = input.cur_loc();
-        output.new_block(opts, loc);
+        output.new_block(opts, loc, mode == Scanner::Reuse);
 
         if (mode == Scanner::Rules) {
             // save AST and options for future use