Experimental parser: remove match actions

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 50 matching lines @@
     {%- endif -%}
   {%- endfor -%}
 {%- endmacro -%}
 
 
 {#- entry actions must not change the value of the cursor
     unless they jump -#}
 {% macro dispatch_entry_action(type, args) -%}
   {% if type == 'store_token' %}
     stored_token = Token::{{args[0]}};
+  {% elif type == 'no_op' %}
+    {# TODO(dcarney): remove #}
   {% elif type == 'set_marker' %}
     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 == 'store_token' %}
+    stored_token = Token::{{args[0]}};
+  {% elif type == 'store_harmony_token' %}
+    if (harmony_{{args[0]}}_) {
+      stored_token = Token::{{args[1]}};
+    } else {
+      stored_token = Token::{{args[2]}};
+    }
   {% 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', args)}}
     }
@@ skipping 23 matching lines @@
   {% 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::{{args[0]}})
     return;
-  {% elif type == 'goto_start' %}
-    {{ jump(args[0]|int) }}
-  {% elif type == 'store_token_and_goto' %}
-    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::{{args[0]}});
     FORWARD();
     RESET_START();
     return;
   {% elif type == 'harmony_token' %}
     if (harmony_{{args[0]}}_) {
       DO_TOKEN(Token::{{args[1]}});
     } else {
       DO_TOKEN(Token::{{args[2]}});
     }
     return;
-  {% elif type == 'store_harmony_token_and_goto' %}
-    if (harmony_{{args[0]}}_) {
-      stored_token = Token::{{args[1]}};
-    } else {
-      stored_token = Token::{{args[2]}};
-    }
-    {{ jump(args[3]|int) }}
   {% elif type == 'octal_number' %}
     last_octal_end_ = cursor_;
     DO_TOKEN(Token::NUMBER);
     return;
   {% elif type == 'backtrack' %}
     BACKWARD({{args[0]}});
     DO_TOKEN(Token::{{args[1]}});
     return;
   {% else %}
     uncompilable code for {{type}} {{args}}
@@ skipping 25 matching lines @@
   {%- else -%}
     uncompilable code for {{encoding}}
   {%- endif -%}
 {%- endmacro -%}
 
 
 {%- macro write_label(label_name, node_number) %}
   {%- set state = dfa_states[node_number] -%}
   {%- set used = state['entry_points'][label_name] -%}
   {%- set long_label = label_name ~ '_' ~ node_number -%}
+  {%- set inlined = 'inlined' if state['inline'] else 'not inlined' -%}
   {% if used -%}
-    {{long_label}}:
+    {{long_label}}: // {{inlined}}
   {%- else -%}
-    // {{long_label}}:
+    // {{long_label}}: {{inlined}}
   {%- endif %}
 {% endmacro -%}
 
 
 {%- macro do_dfa_state(node_number) -%}
 
   {%- set state = dfa_states[node_number] -%}
 
   {{ write_label('state_entry', node_number) }}
 
-  {% if not state['can_elide_read'] -%}
+  {% if not state['elide_read'] -%}
     READ_CURSOR();
   {%- endif -%}
 
   {% 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.name(), entry_action.args()) }}
+  {%- set action = state['action'].term() -%}
+  {%- if action %}
+    {%- if not state['total_transitions'] -%}
+      {{ dispatch_match_action(action.name(), action.args()) }}
+    {%- else -%}
+      {{ dispatch_entry_action(action.name(), action.args()) }}
+    {%- endif -%}
   {%- 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) -%}
+  {%- macro do_transition(jump_id, do_forward = True) -%}
     {%- set transition_state_id = jump_table[jump_id][0] -%}
     {%- set inline_transition = jump_table[jump_id][1] == 'inline' %}
-    FORWARD();
+    {%- if do_forward %}
+      FORWARD();
+    {% endif %}
     {%- if inline_transition %}
       {{ do_dfa_state(transition_state_id) }}
     {% else %}
       {{ jump(jump_id) }}
     {% endif %}
   {%- endmacro -%}
 
   {%- if state['switch_transitions'] -%}
     switch(primary_char) {
     {%- for ranges, jump_id in state['switch_transitions'] %}
@@ skipping 25 matching lines @@
       next_.is_onebyte = false;
       {{long_char_create()}}
       {%- 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.name(), match_action.args()) }}
-    CRASH();
-  {% else %}
-    goto default_action;
-  {%- endif %}
+  {%- if state['omega_transition'] %}
+    {{ do_transition(state['omega_transition'], False) }}
+  {%- endif -%}
+
+  goto default_action; {# this is wrong, should be CRASH(); #}
 
 {%- endmacro %}
 
 #include "lexer/experimental-scanner.h"
 
 #define RESET_START() {               \
   start_ = cursor_;                   \
 }
 
 #define DO_TOKEN(T) {                 \
@@ skipping 39 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.name(), default_action.args())}}
+    {%- set action = default_action.term() -%}
+    {{dispatch_match_action(action.name(), 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;
   }
 }
 } }