Git rid of "Anywhere" state and instead seed real states with Anywhere transitions.

This reduces the size of the table slightly, and makes the code a bit simpler.

This change was suggested by Paul Williams, because the anywhere transitions and
the real transitions should be mutually exclusive.

Author: Joshua Haberman

vtparse.c

@@ -105,8 +105,8 @@ static void do_state_change(vtparse_t *parser, state_change_t change, char ch)
          *   3. the entry action of the new state
          */
 
-        vtparse_action_t exit_action = EXIT_ACTIONS[parser->state];
-        vtparse_action_t entry_action = ENTRY_ACTIONS[new_state];
+        vtparse_action_t exit_action = EXIT_ACTIONS[parser->state-1];
+        vtparse_action_t entry_action = ENTRY_ACTIONS[new_state-1];
 
         if(exit_action)
             do_action(parser, exit_action, 0);
@@ -131,16 +131,8 @@ void vtparse(vtparse_t *parser, unsigned char *data, int len)
     for(i = 0; i < len; i++)
     {
         unsigned char ch = data[i];
-
-        /* If a transition is defined from the "anywhere" state, always
-         * use that.  Otherwise use the transition from the current state. */
-
-        state_change_t change = STATE_TABLE[VTPARSE_STATE_ANYWHERE][ch];
-
-        if(!change)
-            change = STATE_TABLE[parser->state][ch];
-
-        do_state_change(parser, change, data[i]);
+        state_change_t change = STATE_TABLE[parser->state-1][ch];
+        do_state_change(parser, change, ch);
     }
 }
 

vtparse_check_tables.rb

@@ -8,13 +8,9 @@
 
 table = {}
 
-anywhere_array = expand_ranges($states[:ANYWHERE])
-
 $state_tables.each { |state, table|
-    next if state == :ANYWHERE
-
     table.each_with_index { |val, i|
-        if not (val or $state_tables[:ANYWHERE][i])
+        if not val
             raise "No transition defined from state #{state}, char 0x#{i.to_s(16)}!"
         end
     }

vtparse_gen_c_tables.rb

@@ -10,7 +10,7 @@ def pad(len)
 File.open("vtparse_table.h", "w") { |f|
     f.puts "typedef enum {"
     $states_in_order.each_with_index { |state, i|
-        f.puts "   VTPARSE_STATE_#{state.to_s.upcase} = #{i},"
+        f.puts "   VTPARSE_STATE_#{state.to_s.upcase} = #{i+1},"
     }
     f.puts "} vtparse_state_t;"
     f.puts
@@ -25,7 +25,7 @@ def pad(len)
     f.puts "extern vtparse_action_t ENTRY_ACTIONS[#{$states_in_order.length}];"
     f.puts "extern vtparse_action_t EXIT_ACTIONS[#{$states_in_order.length}];"
     f.puts "extern char *ACTION_NAMES[#{$actions_in_order.length+1}];"
-    f.puts "extern char *STATE_NAMES[#{$states_in_order.length}];"
+    f.puts "extern char *STATE_NAMES[#{$states_in_order.length+1}];"
     f.puts
 }
 
@@ -43,14 +43,15 @@ def pad(len)
     f.puts "};"
     f.puts
     f.puts "char *STATE_NAMES[] = {"
+    f.puts "   \"<no state>\","
     $states_in_order.each { |state|
         f.puts "   \"#{state.to_s}\","
     }
     f.puts "};"
     f.puts
     f.puts "state_change_t STATE_TABLE[#{$states_in_order.length}][256] = {"
-    $states_in_order.each { |state|
-        f.puts "  {  /* VTPARSE_STATE_#{state.to_s.upcase} */"
+    $states_in_order.each_with_index { |state, i|
+        f.puts "  {  /* VTPARSE_STATE_#{state.to_s.upcase} = #{i} */"
         $state_tables[state].each_with_index { |state_change, i|
             if not state_change
                 f.puts "    0,"

vtparse_tables.rb

@@ -12,14 +12,14 @@ def transition_to(state)
 
 $states = {}
 
-$states[:ANYWHERE] = {
+$anywhere_transitions = {
     0x18       => [:execute, transition_to(:GROUND)],
     0x1a       => [:execute, transition_to(:GROUND)],
     0x80..0x8f => [:execute, transition_to(:GROUND)],
     0x91..0x97 => [:execute, transition_to(:GROUND)],
     0x99       => [:execute, transition_to(:GROUND)],
     0x9a       => [:execute, transition_to(:GROUND)],
-    0x9c       => [:execute, transition_to(:GROUND)],
+    0x9c       => transition_to(:GROUND),
     0x1b       => transition_to(:ESCAPE),
     0x98       => transition_to(:SOS_PM_APC_STRING),
     0x9e       => transition_to(:SOS_PM_APC_STRING),
@@ -34,9 +34,6 @@ def transition_to(state)
     0x19       => :execute,
     0x1c..0x1f => :execute,
     0x20..0x7f => :print,
-    0x80..0x8f => :execute,
-    0x91..0x9a => :execute,
-    0x9c       => :execute
 }
 
 $states[:ESCAPE] = {
@@ -144,7 +141,6 @@ def transition_to(state)
     0x19       => :ignore,
     0x1c..0x1f => :ignore,
     0x20..0x7f => :ignore,
-    0x9c       => transition_to(:GROUND)
 }
 
 $states[:DCS_PARAM] = {
@@ -167,7 +163,6 @@ def transition_to(state)
     0x1c..0x1f => :put,
     0x20..0x7e => :put,
     0x7f       => :ignore,
-    0x9c       => transition_to(:GROUND),
     :on_exit   => :unhook
 }
 
@@ -176,7 +171,6 @@ def transition_to(state)
     0x19       => :ignore,
     0x1c..0x1f => :ignore,
     0x20..0x7f => :ignore,
-    0x9c       => transition_to(:GROUND)
 }
 
 $states[:OSC_STRING] = {
@@ -185,24 +179,16 @@ def transition_to(state)
     0x19       => :ignore,
     0x1c..0x1f => :ignore,
     0x20..0x7f => :osc_put,
-    0x9c       => transition_to(:GROUND),
     :on_exit   => :osc_end
 }
 
-$states.each { |state, transitions|
-    transitions.each { |keys, actions|
-        if not actions.kind_of?(Array)
-            $states[state][keys] = [actions]
-        end
-    }
-}
-
 
 # get the list of actions implicit in the tables
 
 action_names = {}
 $states.each { |state, transitions|
     transitions.each { |keys, actions|
+        actions = [actions] if !actions.kind_of?(Array)
         actions.each { |action|
             if action.kind_of?(Symbol)
                 action_names[action] = 1
@@ -213,8 +199,10 @@ def transition_to(state)
 
 # establish an ordering to the states and actions
 
-$actions_in_order = action_names.keys.sort { |a1, a2| a1.to_s <=> a2.to_s } + [:error]
-$states_in_order = $states.keys.sort       { |s1, s2| s1.to_s <=> s2.to_s }
+$actions_in_order = action_names.keys.sort   { |a1, a2| a1.to_s <=> a2.to_s } + [:error]
+$states_in_order  = $states.keys.sort  { |s1, s2| s1.to_s <=> s2.to_s }
+
+
 
 #
 # Expand the above range-based data structures (which are convenient
@@ -242,4 +230,22 @@ def expand_ranges(hash_with_ranges_as_keys)
     $state_tables[state] = expand_ranges(transitions)
 }
 
+# seed all the states with the anywhere transitions
+$anywhere_transitions = expand_ranges($anywhere_transitions)
+
+$state_tables.each { |state, transitions|
+    $anywhere_transitions.each_with_index { |transition, i|
+        next if transition.nil?
+        if transitions[i]
+            raise "State #{state} already had a transition defined for 0x#{i.to_s(16)}, but " + \
+                  "that transition is also an anywhere transition!"
+        end
+        transitions[i] = transition
+    }
+}
+
+# for consistency, make all transitions *lists* of actions
+$state_tables.each { |state, transitions|
+    transitions.map! { |t| t.kind_of?(Array) ? t : [t] }
+}