title: Implementation of grammar using Bison. Grammar control flow unexpected
body: <p>Abstract grammar. Actual grammar follows:</p>
  
  <pre><code>start -&gt;  t1  V1;
  
  V1 --&gt;   t2   V1
         | t3   V2
         ;
  
  V2 --&gt;   t4
         | /* Empty */
         ;
  </code></pre>
  
  <p>When the control is in V2 and token t3 is encountered. The control goes back to V1. All right to this point. </p>
  
  <p><strong>But the control doesn't stop at V1 to trigger t3, but goes back to start, this is the problem.</strong></p>
  
  <p>The actual grammar. Explanation follows.</p>
  
  <pre><code>%{
  #include &lt;stdio.h&gt;
  #include &lt;stdlib.h&gt;
  #include &lt;sys/types.h&gt;
  
  void yyerror (char *s); 
  extern FILE *yyin;
  
  %}
  
  %token MAIN   
  
  %token INT_DT INT_LIT   /* t_INT_DT --&gt; Integer Data type, i.e. "int"
                           * t_INT_LIT --&gt; An integer, i.e. "5".
                           */
  
  %token VAR              // A variable
  
  %token SCANF  PRINTF    // For the printf and the scanf statements.
  
  %token IF     ELSE      // For the if and else statements.
  %token GOTO
  
  %token OPRTR            // For the operator in an expression.
  
  /* Begining of a basic block, BBS, Basic Block Statement.
   * BBS_ST = "&lt;bb "
   * BBS_END1 "&gt;:"
   * BBS_END2   "&gt;;"
   * Example:   
   * &lt;bb 2&gt;:
   *      Statements;
   *      goto &lt;bb 3&gt;;
   */
  %token BBS_ST   // "&lt;bb "// it is "&lt;bb ".
  %token BBS_END1 // "&gt;:" 
  %token BBS_END2 // "&gt;;" 
  
  // Opening and closing Braces, i.e. { &amp; }
  %token OP_BR  // "{" 
  %token CL_BR  // "}"
  
  // For opening and closing Parantheses, ( &amp; )
  %token OP_PR  //"("  
  %token CL_PR  //")"
  
  %token EQUAL  // "="
  %token COMMA  // ","       
  %token NBSP   // "&amp;"
  %token SM_CLN // ";"       // For ";" 
  
  %token RETURN           // For the return statement.
  
  %start begin
  
  %%
  
  begin:   MAIN    main   ;
  
  main:    OP_BR    functn   CL_BR   ;
  
  functn:   INT_DT   VAR      SM_CLN   functn  /*Recursion to stay in functn */
          | BBS_ST   INT_LIT  BBS_END1  bb     
          ;
  
  bb:    SCANF    var_List   CL_PR    SM_CLN  bb
      |  PRINTF   var_List   CL_PR    SM_CLN  bb
      |  VAR      EQUAL      expr     SM_CLN  bb
      |  IF       OP_PR      expr     CL_PR   bb
      |  ELSE     bb
      |  GOTO     BBS_ST     INT_LIT  BBS_END2
      |  RETURN   SM_CLN    
      |  /* Empty Rule. */  
      ;  /* bb has can't catch BBS_ST as first token, thus it must return
          * to the calling rule and functn can catch BBS_ST. */
  
  var_List:    COMMA   VAR   var_List 
            |  /* Empty Rule. */ 
            ;
  
  expr:     VAR      expr2 
        |   INT_LIT  expr2  
        ;
  
  expr2:    OPRTR    expr3  
         |  /* Empty Rule */
         ;
  
  expr3:    VAR     
         |  INT_LIT  
         ;
  
  %%
  int main (int argc, char *argv[])
  {
      #if YYDEBUG == 1
          extern int yydebug;
          yydebug = 1;
      #endif
  
      if (argc == 2)
      {
          yyin = fopen (argv [1], "r");
          if (yyin == NULL)
              perror (argv [1]); 
      }
  
      yyparse ();
  
      fclose (yyin);
      return 0;    
  }
  
  
  void yyerror (char *s)
  {
      printf ("Error: %s\n", s);
  }
  </code></pre>
  
  <hr>
  
  <p><strong>Implementation of ideas suggested in answers till now, but this doesn't help.</strong></p>
  
  <pre><code>begin:  MAIN main ; 
  
  main:   OP_BR   functn_Decls   CL_BR 
          ; 
  
  functn_Decls:   functn_Decls INT_DT VAR SM_CLN 
                | functn 
                ; 
  
  functn:    functn BBS_ST INT_LIT BBS_END1 
          |  bb 
          ; 
  
  bb:    bb   stmnt 
      |  /* Empty Rule */ 
      ; 
  
  stmnt:   t1  // terminals only. 
         ; 
  
  var_List:   t2 // terminal just for illustration. 
              ;
  
  expr:  t3 // terminal just for illustration.
         ;
  </code></pre>
  
  <hr>
  
  <p>Error causing input:</p>
  
  <pre><code>main ()
  {
    &lt;bb 2&gt;:
    goto &lt;bb 4&gt;;
  
    &lt;bb 3&gt;:
  }
  </code></pre>
  
  <p>Error:</p>
  
  <p>At <code>&lt;bb</code> the token BBS_ST is triggered. 
  At this time the control is in bb, like bb --> <strong>Waiting for a token</strong>
  Since no rule in bb starts with BBS_ST, it returns to the calling rule.</p>
  
  <p>Now the calling rule is functn, which has a rule starting with BBS_ST.
  Problem is that, this rule is not invoke.</p>
  
  <p>Instead the control reaches the parent of functn at <strong>P1</strong>.
  If at P1 I add <strong>BBS_ST</strong>, It catches this token.</p>
  
  <p>Please point out why is it happening like this?</p>
  
  <p>Corresponding Flex file:</p>
  
  <pre><code>%{
      // Include the file
      #include "Parse_One_Line2.tab.h"
      extern YYSTYPE  yylval;
      extern char    *yytext;
  %}
  
  LB   ^[ \t]*
  CH   [a-zA-Z]
  DI   [0-9]
  
  %%
  
  {LB}main[ ]*\([.]*\)    return MAIN; // the main() call.
  
  {LB}int[ ]              return INT_DT;
  
  [+-]?{CH}({CH}{DI}_)*   return VAR; 
  
  [+-]?[0-9]+             return INT_LIT;  
  
  {LB}scanf[ ]?\(\".*\"   return SCANF;
  
  {LB}printf[ ]?\(\".*\"  return PRINTF;
  
  {LB}if[ ]               return IF; // If statement.
  
  {LB}else[ ]             return ELSE; // If statement.
  
  {LB}goto[ ]             return GOTO;
  
  {LB}return              return RETURN;
  
  \{CLOBBER\};            ;// Ignore it.
  
  "&lt;bb "                  return BBS_ST;  // next integer is a BB Index.
  
  "&gt;:"                    return BBS_END1; // token Greater than Colon.
  
  "&gt;;"                    return BBS_END2;
  
  ^;;[^\n]*[\n]           ; // Ignore it, comment.
  
  "+"|"-"|"*"|"/"|"%"|"=="|"&gt;="|"&lt;="|"&lt;"|"&gt;"|"!=" return OPRTR; 
  
  ^[{]                    return OP_BR; // It is "{".
  
  ^[}]                    return CL_BR; // It is "}".
  
  "("                     return OP_PR; // Paranthesis Open
  
  ")"                     return CL_PR; // Paranthesis Close
  
  
  ";"                     return SM_CLN;
  
  "="                     return EQUAL;
  
  "&amp;"                     return NBSP;
  
  ","                     return COMMA;
  
  [\n]                    ; /* Skip these characters. */
  
  .                       ; /* Skip.   */
  
  %%
  
  
  int yywrap (void)
  {
      return 1;
  }
  </code></pre>
  
  <p>The Output file using YYDEBUG flag.</p>
  
  <pre><code>Starting parse
  Entering state 0
  Reading a token: Next token is token MAIN ()
  Shifting token MAIN ()
  Entering state 1
  Reading a token: Next token is token OP_BR ()
  Shifting token OP_BR ()
  Entering state 3
  Reading a token: Next token is token INT_DT ()
  Shifting token INT_DT ()
  Entering state 6
  Reading a token: Next token is token VAR ()
  Shifting token VAR ()
  Entering state 9
  Reading a token: Next token is token SM_CLN ()
  Shifting token SM_CLN ()
  Entering state 12
  Reading a token: Next token is token BBS_ST ()
  Shifting token BBS_ST ()
  Entering state 7
  Reading a token: Next token is token INT_LIT ()
  Shifting token INT_LIT ()
  Entering state 10
  Reading a token: Next token is token BBS_END1 ()
  Shifting token BBS_END1 ()
  Entering state 13
  Reading a token: Next token is token GOTO ()
  Shifting token GOTO ()
  Entering state 20
  Reading a token: Next token is token BBS_ST ()
  Shifting token BBS_ST ()
  Entering state 29
  Reading a token: Next token is token INT_LIT ()
  Shifting token INT_LIT ()
  Entering state 38
  Reading a token: Next token is token BBS_END2 ()
  Shifting token BBS_END2 ()
  Entering state 47
  Reducing stack by rule 10 (line 76):
     $1 = token GOTO ()
     $2 = token BBS_ST ()
     $3 = token INT_LIT ()
     $4 = token BBS_END2 ()
  -&gt; $$ = nterm bb ()
  Stack now 0 1 3 6 9 12 7 10 13
  Entering state 22
  Reducing stack by rule 4 (line 68):
     $1 = token BBS_ST ()
     $2 = token INT_LIT ()
     $3 = token BBS_END1 ()
     $4 = nterm bb ()
  -&gt; $$ = nterm functn ()
  Stack now 0 1 3 6 9 12
  Entering state 14
  Reducing stack by rule 3 (line 67):
     $1 = token INT_DT ()
     $2 = token VAR ()
     $3 = token SM_CLN ()
     $4 = nterm functn ()
  -&gt; $$ = nterm functn ()
  Stack now 0 1 3
  Entering state 8
  Reading a token: Next token is token BBS_ST ()
  Error: popping nterm functn ()
  Stack now 0 1 3
  Error: popping token OP_BR ()
  Stack now 0 1
  Error: popping token MAIN ()
  Stack now 0
  Cleanup: discarding lookahead token BBS_ST ()
  Stack now 0
  </code></pre>