Change table data_processing_immediate to use the new notation. Also

src/trusted/validator_arm/dgen_input.py

 #!/usr/bin/python
 #
 # Copyright (c) 2012 The Native Client Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 #
 
 """
 A simple recursive-descent parser for the table file format.
 
 The grammar implemented here is roughly (taking some liberties with whitespace
 and comment parsing):
 
 table_file ::= classdef* table+ eof ;
 
 action         ::= decoder_action | decoder_method | '"'
 action_arch    ::= 'arch' ':=' word
 action_option  ::= (action_rule |
                     action_pattern |
                     action_safety |
                     action_arch |
                     action_other) ';'
-action_options_deprecated ::= (id (word (rule_restrict id?)?)?)?
+action_options_deprecated ::= (id (word (rule_restrict_deprecated id?)?)?)?
 action_other   ::= word ':=' bit_expr
 action_pattern ::= 'pattern' ':=' word rule_restrict?
 action_safety  ::= 'safety' ':=' safety_check ('&' safety_check)*
 action_rule    ::= 'rule' ':=' id
 arch           ::= '(' word+ ')'
 bit_check      ::= column '=' bitpattern
 bit_expr       ::= bit_expr1 ('if' bit_expr 'else' bit_expr)?  # conditional
 bit_expr1      ::= bit_expr2 (('&' bit_expr2)* | ('|' bit_expr2)*)?
 bit_expr2      ::= bit_expr3 | 'not' bit_expr2
 bit_expr3      ::= bit_expr4 ('in' 'bitset'? bit_set)?
@@ skipping 11 matching lines @@
 bit_expr10     ::= int | id | bit_check | bit_set | '(' bit_expr ')' | call
 bit_set        ::= '{' (bit_expr (',' bit_expr)*)? '}'
 bitpattern     ::= word | negated_word
 call           ::= word '(' (bit_expr (',' bit_expr)*)? ')'
 citation       ::= '(' word+ ')'
 column         ::= id '(' int (':' int)? ')'
 classdef       ::= 'class' word ':' word
 decoder        ::= id ('=>' id)?
 decoder_action ::= '=" (decoder (fields? action_option* |
                                  action_options_deprecated arch?)
-                       | '*' int action_option*)
+                       | '*' (int | id) action_option*)
 decoder_method ::= '->' id
 default_row    ::= 'else' ':' action
 fields         ::= '{' column (',' column)* '}'
 footer         ::= '+' '-' '-'
 header         ::= "|" column+
 int            ::= word     (where word is a sequence of digits)
 id             ::= word     (where word is sequence of letters, digits and _)
 negated_word   ::= '~' word
 parenthesized_exp ::= '(' (word | punctuation)+ ')'
 pat_row        ::= pattern+ action
 pattern        ::= bitpattern | '-' | '"'
 row            ::= '|' (pat_row | default_row)
-rule_restrict  ::= ('&' bitpattern)* ('&' 'other' ':' id)?
+rule_restrict  ::= ('&' bit_expr)* ('&' 'other' ':' id)?
+rule_restrict_deprecated ::= ('&' bitpattern)* ('&' 'other' ':' id)?
 safety_check   ::= id | bit_expr1 ('=>' id)?     # note: single id only at end.
 table          ::= table_desc table_actions header row+ footer
-table_actions  ::= ( ('*' int decoder fields? action_options*)+ footer)?
+table_actions  ::= ( ('*' (int | id) decoder fields? action_options*)+ footer)?
 table_desc     ::= '+' '-' '-' id citation?
 
 Note that action_options_deprecated is deprecated, and one should generate
 a sequence of action_option's. For action_options_depcrected, the interpretation
 is as follows:
    id[1] = Arm rule action corresponds to.
    word = Bit pattern of rule.
    rule_restrict = Name defining additional constraints (parse and safety)
           for match.
 """
@@ skipping 422 matching lines @@
     """Parses 'action_options*'."""
     while True:
       if self._is_action_option():
         self._action_option(context)
       else:
         return
 
   def _decoder_action(self, starred_actions):
     """decoder_action ::= '=" (decoder (fields? action_option* |
                                         action_options_deprecated arch?)
-                              | '*' int action_option*)
+                              | '*' (int | id) action_option*)
     """
     self._read_token('=')
     if self._next_token().kind == '*':
       return self._decoder_action_extend(starred_actions)
 
     (baseline, actual) = self._decoder()
     action = dgen_core.DecoderAction(baseline, actual)
     context = action.st
     if self._next_token().kind == '{':
       fields = self._fields(context)
       if not context.define('fields', fields, False):
         raise Exception('multiple field definitions.')
       self._decoder_action_options(context)
     elif self._is_action_option():
       self._decoder_action_options(context)
     else:
       context.define('rule', self._read_id_or_none(True))
       context.define('pattern', self._read_id_or_none(False))
-      self._rule_restrict(context)
+      self._rule_restrict_deprecated(context)
       other_restrictions = self._read_id_or_none(True)
       if other_restrictions:
         context.define('safety', [other_restrictions])
       if self._next_token().kind == '(':
         context.define('arch', self._arch())
     return action
 
   def _decoder_action_extend(self, starred_actions):
-    """'*' int action_option*
+    """'*' (int | id) action_option*
 
        Helper function to _decoder_action."""
     self._read_token('*')
-    index = self._int()
+    if self._is_int():
+      index = self._int()
+    else:
+      index = self._id()
     indexed_action = starred_actions.get(index)
     if not indexed_action:
       self._unexpected("Can't find decoder action *%s" % index)
 
     # Create an initial copy, and define starred action as
     # inheriting definition.
     action = dgen_core.DecoderAction(indexed_action.baseline,
                                      indexed_action.actual)
     action.st.inherits(indexed_action.st)
 
@@ skipping 147 matching lines @@
     Passed in sequence of patterns and action from last row,
     and returns list of patterns and action from this row.
     """
     self._read_token('|')
     if self._next_token().kind == 'else':
       return self._default_row(table, starred_actions, last_action)
     else:
       return self._pat_row(table, starred_actions, last_patterns, last_action)
 
   def _rule_restrict(self, context):
+    """ rule_restrict  ::= ('&' bit_expr)* ('&' 'other' ':' id)? """
+
+    restrictions = context.find('constraints')
+    if not restrictions:
+      context.define('constraints', dgen_core.RuleRestrictions())
+    while self._next_token().kind == '&':
+      self._read_token('&')
+      if self._next_token().kind == 'other':
+        self._read_token('other')
+        self._read_token(':')
+        restrictions.safety = self._id()
+        return
+      else:
+        restrictions.add(self._bit_expr(context))
+
+  def _rule_restrict_deprecated(self, context):
     """ rule_restrict  ::= ('&' bitpattern)* ('&' 'other' ':' id)? """
 
     restrictions = context.find('constraints')
     if not restrictions:
       context.define('constraints', dgen_core.RuleRestrictions())
     while self._next_token().kind == '&':
       self._read_token('&')
       if self._next_token().kind == 'other':
         self._read_token('other')
         self._read_token(':')
         restrictions.safety = self._id()
         return
       else:
-        restrictions.add(self._bitpattern32())
+        restrictions.add(
+            dgen_core.BitPattern.parse(self._bitpattern32(),
+                                       dgen_core.BitField('constraint', 31, 0)))
 
   def _safety_check(self, context):
     """safety_check   ::= id | bit_expr ('=>' id)?
 
        Parses safety check and returns it.
        """
     if self._is_name_semicolon():
       # This is a special case where we are picking up a instruction
       # tester suffix.
       check = self._id()
@@ skipping 11 matching lines @@
     starred_actions = self._table_actions()
     self._header(table)
     (pattern, action) = self._row(table, starred_actions)
     while not self._next_token().kind == '+':
       (pattern, action) = self._row(table, starred_actions, pattern, action)
     if not decoder.add(table):
       self._unexpected('Multiple tables with name %s' % table.name)
     self._footer()
 
   def _table_actions(self):
-    """table_actions ::= ( ('*' int decoder fields? action_options*)+
+    """table_actions ::= ( ('*' (int | id) decoder fields? action_options*)+
                            footer)?"""
     starred_actions = {}
     if self._next_token().kind != '*': return starred_actions
     while self._next_token().kind == '*':
       self._read_token('*')
-      index = self._int()
+      if self._is_int():
+        index = self._int()
+      else:
+        index = self._id()
 
       (baseline, actual) = self._decoder()
       action = dgen_core.DecoderAction(baseline, actual)
       context = action.st
       if self._next_token().kind == '{':
         fields = self._fields(context)
         if not context.define('fields', fields, False):
           raise Exception('multiple field definitions.')
         self._decoder_action_options(context)
       elif self._is_action_option():
@@ skipping 224 matching lines @@
       return re.sub(r'#.*', '', line).strip()
     else:
       self._reached_eof = True
       return ''
 
   #-------- Error reporting ------
 
   def _unexpected(self, context='Unexpected line in input'):
     """"Reports that we didn't find the expected context. """
     raise Exception('Line %d: %s' % (self._line_no, context))