Experimental parser: some tuple removal

tools/lexer_generator/code_generator.jinja

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 47 matching lines @@
       {%- endif -%}
     {%- else -%}
       uncompilable code for {{encoding}} {{r[0]}} {{r[1]}}
     {%- endif -%}
   {%- endfor -%}
 {%- endmacro -%}
 
 
 {#- entry actions must not change the value of the cursor
     unless they jump -#}
-{% macro dispatch_entry_action(type, value) -%}
+{% macro dispatch_entry_action(type, args) -%}
   {% if type == 'store_token' %}
-    stored_token = Token::{{value}};
+    stored_token = Token::{{args[0]}};
   {% elif type == 'set_marker' %}
-    marker = cursor_ - {{value}};
+    marker = cursor_ - {{args[0]}};
   {% elif type == 'set_has_escapes' %}
     next_.has_escapes = true;
   {% elif type == 'octal_inside_string' %}
     last_octal_end_ = cursor_;
     next_.has_escapes = true;
   {% elif type == 'line_terminator_in_multiline_comment' %}
     has_multiline_comment_before_next_ = true;
   {% elif type == 'check_escaped_identifier_start' %}
     if (!ValidIdentifierStart()) goto default_action;
     next_.has_escapes = true;
   {% elif type == 'check_escaped_identifier_part' %}
     if (!ValidIdentifierPart()) goto default_action;
     next_.has_escapes = true;
   {% elif type == 'if_line_terminator_backtrack' %}
     if (!has_line_terminator_before_next_) {
-      {{dispatch_match_action('backtrack', value)}}
+      {{dispatch_match_action('backtrack', args)}}
     }
   {% else %}
-    uncompilable code for {{type}} {{value}}
+    uncompilable code for {{type}} {{args}}
   {% endif -%}
 {%- endmacro -%}
 
 
 {#- match actions must all explicitly jump or return -#}
-{% macro dispatch_match_action(type, value) -%}
+{% macro dispatch_match_action(type, args) -%}
   {% if type == 'terminate' %}
     {{dispatch_match_action('backtrack', ('1', 'EOS'))}}
   {% elif type == 'terminate_illegal' %}
     start_ = marker;
     {{dispatch_match_action('backtrack', ('1', 'ILLEGAL'))}}
   {% elif type == 'skip' %}
     RESET_START();
     {%- if encoding == 'utf16'-%}
       next_.is_onebyte = true;
     {%- endif -%}
     goto state_entry_0;
   {% elif type == 'skip_and_terminate' %}
     RESET_START();
     --start_;
     {{dispatch_match_action('terminate', None)}}
   {% elif type == 'line_terminator' %}
     RESET_START();
     {%- if encoding == 'utf16'-%}
       next_.is_onebyte = true;
     {%- endif -%}
     has_line_terminator_before_next_ = true;
     goto state_entry_0;
   {% elif type == 'token' %}
-    DO_TOKEN(Token::{{value}})
+    DO_TOKEN(Token::{{args[0]}})
     return;
   {% elif type == 'goto_start' %}
-    {{ jump(value[0]) }}
+    {{ jump(args[0]|int) }}
   {% elif type == 'store_token_and_goto' %}
-    stored_token = Token::{{value[0]}};
-    {{ jump(value[1]) }}
+    stored_token = Token::{{args[0]}};
+    {{ jump(args[1]|int) }}
   {% elif type == 'do_stored_token' %}
     DO_TOKEN(stored_token)
     return;
   {% elif type == 'do_token_and_go_forward' %}
-    DO_TOKEN(Token::{{value}});
+    DO_TOKEN(Token::{{args[0]}});
     FORWARD();
     RESET_START();
     return;
   {% elif type == 'harmony_token' %}
-    if (harmony_{{value[0]}}_) {
-      DO_TOKEN(Token::{{value[1]}});
+    if (harmony_{{args[0]}}_) {
+      DO_TOKEN(Token::{{args[1]}});
     } else {
-      DO_TOKEN(Token::{{value[2]}});
+      DO_TOKEN(Token::{{args[2]}});
     }
     return;
   {% elif type == 'store_harmony_token_and_goto' %}
-    if (harmony_{{value[0]}}_) {
-      stored_token = Token::{{value[1]}};
+    if (harmony_{{args[0]}}_) {
+      stored_token = Token::{{args[1]}};
     } else {
-      stored_token = Token::{{value[2]}};
+      stored_token = Token::{{args[2]}};
     }
-    {{ jump(value[3]) }}
+    {{ jump(args[3]|int) }}
   {% elif type == 'octal_number' %}
     last_octal_end_ = cursor_;
     DO_TOKEN(Token::NUMBER);
     return;
   {% elif type == 'backtrack' %}
-    BACKWARD({{value[0]}});
-    DO_TOKEN(Token::{{value[1]}});
+    BACKWARD({{args[0]}});
+    DO_TOKEN(Token::{{args[1]}});
     return;
   {% else %}
-    uncompilable code for {{type}} {{value}}
+    uncompilable code for {{type}} {{args}}
   {% endif -%}
 {%- endmacro -%}
 
 
 {%- macro long_char_check() -%}
   {%- if encoding == 'utf16'-%}
     primary_char > {{upper_bound}}
   {%- elif encoding == 'utf8'-%}
     primary_char < 0
   {%- else -%}
@@ skipping 42 matching lines @@
 
   {% if debug_print %}
     fprintf(stderr,
             "state {{state.node_number}}, start %d, cursor %d\n",
             start_ - buffer_,
             cursor_ - buffer_);
   {% endif -%}
 
   {%- set entry_action = state.entry_action -%}
   {%- if entry_action %}
-    {{ dispatch_entry_action(entry_action[0], entry_action[1]) }}
+    {{ dispatch_entry_action(entry_action.name(), entry_action.args()) }}
   {%- endif %}
 
   {{ write_label('after_entry_code', node_number) }}
 
   {%- if debug_print %}
     fprintf(stderr, "char at hand is %c (%d)\n", primary_char, primary_char);
   {% endif -%}
 
   {%- macro do_transition(jump_id) -%}
     {%- set transition_state_id = jump_table[jump_id][0] -%}
@@ skipping 39 matching lines @@
       {%- for key, jump_id in state['deferred_transitions'] %}
         if ({{do_key(key)}}) { // long_char transition
           {{ do_transition(jump_id) }}
         }
       {% endfor -%}
     }
   {%- endif -%}
 
   {%- set match_action = state.match_action -%}
   {%- if match_action %}
-    {{ dispatch_match_action(match_action[0], match_action[1]) }}
+    {{ dispatch_match_action(match_action.name(), match_action.args()) }}
     CRASH();
   {% else %}
     goto default_action;
   {%- endif %}
 
 {%- endmacro %}
 
 #include "lexer/experimental-scanner.h"
 
 #define RESET_START() {               \
@@ skipping 43 matching lines @@
   {%- if not dfa_state['inline'] %}
     {{ do_dfa_state(dfa_state['node_number']) }}
   {%- endif -%}
 {%- endfor %}
 
   // Execute the default action.
   default_action:
 {%- if debug_print %}
     fprintf(stderr, "default action\n");
 {% endif -%}
-    {{dispatch_match_action(default_action[0], default_action[1])}}
+    {{dispatch_match_action(default_action.name(), default_action.args())}}
   CRASH();
 
   if (false) {
     // force use of stored_token
     stored_token = Token::ILLEGAL;
     // force use of marker
     marker = NULL;
     // force use of state_entry_0
     goto state_entry_0;
   }
 }
 } }