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 24 matching lines @@
 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_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.
@@ skipping 444 matching lines @@
     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*
 
@@ skipping 160 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 262 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))