Experimental parser: cleanup cursing

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 56 matching lines @@
 
 
 {#- entry actions must not change the value of the cursor
     unless they jump -#}
 {% macro dispatch_entry_action(type, value) -%}
   {% if type == 'store_token' %}
     stored_token = Token::{{value}};
   {% elif type == 'set_marker' %}
     marker_ = cursor_ - {{value}};
   {% elif type == 'set_has_escapes' %}
-     next_.has_escapes = true;
+    next_.has_escapes = true;
   {% elif type == 'octal_inside_string' %}
-     last_octal_end_ = cursor_;
-     next_.has_escapes = true;
+    last_octal_end_ = cursor_;
+    next_.has_escapes = true;
   {% elif type == 'line_terminator_in_multiline_comment' %}
-     has_multiline_comment_before_next_ = true;
+    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)}}
     }
   {% else %}
     uncompilable code for {{type}} {{value}}
   {% endif -%}
 {%- endmacro -%}
 
 
 {#- match actions must all explicitly jump or return -#}
 {% macro dispatch_match_action(type, value) -%}
   {% if type == 'terminate' %}
-    DO_EOS();
-    return;
+    {{dispatch_match_action('backtrack', ('1', 'EOS'))}}
   {% elif type == 'terminate_illegal' %}
     start_ = marker_;
-    BACKWARD(1);
-    DO_TOKEN(Token::ILLEGAL);
-    return;
+    {{dispatch_match_action('backtrack', ('1', 'ILLEGAL'))}}
   {% elif type == 'skip' %}
-    SKIP();
+    RESET_START();
     goto state_entry_0;
   {% elif type == 'skip_and_terminate' %}
-    SKIP();
+    RESET_START();
     --start_;
     {{dispatch_match_action('terminate', None)}}
   {% elif type == 'line_terminator' %}
-    DO_LINE_TERMINATOR();
+    RESET_START();
+    has_line_terminator_before_next_ = true;
     goto state_entry_0;
   {% elif type == 'token' %}
     DO_TOKEN(Token::{{value}})
     return;
   {% elif type == 'goto_start' %}
     goto state_entry_{{value[0]}};
   {% elif type == 'store_token_and_goto' %}
     stored_token = Token::{{value[0]}};
     goto after_entry_code_{{value[1]}};
   {% elif type == 'do_stored_token' %}
     DO_TOKEN(stored_token)
     return;
   {% elif type == 'do_token_and_go_forward' %}
-    DO_TOKEN_AND_GO_FORWARD(Token::{{value}})
+    DO_TOKEN(Token::{{value}});
+    FORWARD();
+    RESET_START();
     return;
   {% elif type == 'harmony_token' %}
     if (harmony_{{value[0]}}_) {
       DO_TOKEN(Token::{{value[1]}});
     } else {
       DO_TOKEN(Token::{{value[2]}});
     }
     return;
   {% elif type == 'store_harmony_token_and_goto' %}
     if (harmony_{{value[0]}}_) {
@@ skipping 133 matching lines @@
     {{ dispatch_match_action(match_action[0], match_action[1]) }}
     CRASH();
   {% else %}
     goto default_action;
   {%- endif %}
 
 {%- endmacro %}
 
 #include "lexer/experimental-scanner.h"
 
-#define PREPARE_TOKEN() {             \
-  next_.beg_pos = start_ - buffer_;   \
-  next_.end_pos = cursor_ - buffer_;  \
+#define RESET_START() {               \
   start_ = cursor_;                   \
 }
 
 #define DO_TOKEN(T) {                 \
-  PREPARE_TOKEN();                    \
+  next_.beg_pos = start_ - buffer_;   \
+  next_.end_pos = cursor_ - buffer_;  \
   next_.token = T;                    \
-}
-
-#define DO_TOKEN_AND_GO_FORWARD(T) {  \
-  PREPARE_TOKEN();                    \
-  FORWARD();                          \
-  next_.token = T;                    \
-  start_ = cursor_;                   \
-}
-
-#define DO_EOS() {                    \
-  cursor_ -= 1;                       \
-  DO_TOKEN(Token::EOS);               \
-}
-
-#define DO_LINE_TERMINATOR(s) {            \
-  start_ = cursor_;                        \
-  has_line_terminator_before_next_ = true; \
+  RESET_START();                      \
 }
 
 #define FORWARD() {                               \
-  if (++cursor_ >= buffer_end_) primary_char = 0; \
-  else primary_char = *(cursor_);                 \
+  cursor_++;                                      \
+  READ_CURSOR();                                  \
 }
 
 #define BACKWARD(n) {                             \
   cursor_ -= n;                                   \
+  READ_CURSOR();                                  \
+}
+
+#define READ_CURSOR() {                           \
   if (cursor_ >= buffer_end_) primary_char = 0;   \
   else primary_char = *(cursor_);                 \
 }
 
-#define SKIP() {                      \
-  start_ = cursor_;                   \
-}
-
 #ifdef DEBUG
 #define CRASH() { ((void(*)())0)(); }
 #else
 #define CRASH() { }
 #endif
 
 namespace v8 {
 namespace internal {
 template<>
 void ExperimentalScanner<{{char_type}}>::Scan() {
+
+  // Setup environment.
   next_.has_escapes = false;
-  // Setup environment.
   Token::Value stored_token;
   {{char_type}} primary_char;
-  if (cursor_ >= buffer_end_) primary_char = 0;
-  else primary_char = *(cursor_);
+  READ_CURSOR();
 
 {# first node is start node #}
 {% for dfa_state in dfa_states -%}
   {%- 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])}}
   CRASH();
 
   if (false) {
     // force use of stored_token
     stored_token = Token::ILLEGAL;
     // force use of state_entry_0
     goto state_entry_0;
   }
 }
 } }