Allow enum values in IDL files to be simple arithmetic expressions.

ppapi/generators/idl_parser.py

 #!/usr/bin/python
 #
 # Copyright (c) 2011 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """ Parser for PPAPI IDL """
 
 #
 # IDL Parser
@@ skipping 395 matching lines @@
     if self.parse_debug: DumpReduction('value', p)
 
 # Integers are numbers which may not be floats used in cases like array sizes.
   def p_integer(self, p):
     """integer : HEX
                | INT
                | OCT"""
     p[0] = p[1]
     if self.parse_debug: DumpReduction('integer', p)
 
-# Numbers are integers or floats.
-  def p_number(self, p):
-    """number : FLOAT
-              | HEX
-              | INT
-              | OCT"""
+#
+# Expression
+#
+# A simple arithmetic expression.
+#
+  precedence = (
+    ('left','|','&','^'),
+    ('left','LSHIFT','RSHIFT'),
+    ('left','+','-'),
+    ('left','*','/'),
+    ('right','UMINUS','~'),
+    )
+
+  def p_expression_binop(self, p):
+    """expression : expression LSHIFT expression
+                  | expression RSHIFT expression
+                  | expression '|' expression
+                  | expression '&' expression
+                  | expression '^' expression
+                  | expression '+' expression
+                  | expression '-' expression
+                  | expression '*' expression
+                  | expression '/' expression"""
+    p[0] = "%s %s %s" % (str(p[1]), str(p[2]), str(p[3]))
+    if self.parse_debug: DumpReduction('expression_binop', p)
+
+  def p_expression_unop(self, p):
+    """expression : '-' expression %prec UMINUS
+                  | '~' expression %prec '~'"""
+    p[0] = "%s%s" % (str(p[1]), str(p[2]))
+    if self.parse_debug: DumpReduction('expression_unop', p)
+
+  def p_expression_term(self, p):
+    "expression : '(' expression ')'"
+    p[0] = "%s%s%s" % (str(p[1]), str(p[2]), str(p[3]))
+    if self.parse_debug: DumpReduction('expression_term', p)
+
+  def p_expression_symbol(self, p):
+    "expression : SYMBOL"
     p[0] = p[1]
-    if self.parse_debug: DumpReduction('number', p)
+    if self.parse_debug: DumpReduction('expression_symbol', p)
 
-  def p_number_lshift(self, p):
-    """number : integer LSHIFT INT"""
-    p[0] = "%s << %s" % (p[1], p[3])
-    if self.parse_debug: DumpReduction('number_lshift', p)
+  def p_expression_integer(self, p):
+    "expression : integer"
+    p[0] = p[1]
+    if self.parse_debug: DumpReduction('expression_integer', p)
 
 #
 # Array List
 #
 # Defined a list of array sizes (if any).
 #
   def p_arrays(self, p):
     """arrays : '[' ']' arrays
               | '[' integer ']' arrays
               | """
@@ skipping 77 matching lines @@
 #
 # An enumeration is a set of named integer constants.  An enumeration
 # is valid type which can be referenced in other definitions.
 #
   def p_enum_block(self, p):
     """enum_block : modifiers ENUM SYMBOL '{' enum_list '}' ';'"""
     p[0] = self.BuildNamed('Enum', p, 3, ListFromConcat(p[1], p[5]))
     if self.parse_debug: DumpReduction('enum_block', p)
 
   def p_enum_list(self, p):
-    """enum_list : modifiers SYMBOL '=' number enum_cont
+    """enum_list : modifiers SYMBOL '=' expression enum_cont
                  | modifiers SYMBOL enum_cont"""
     if len(p) > 4:
       val  = self.BuildAttribute('VALUE', p[4])
       enum = self.BuildNamed('EnumItem', p, 2, ListFromConcat(val, p[1]))
       p[0] = ListFromConcat(enum, p[5])
     else:
       enum = self.BuildNamed('EnumItem', p, 2, p[1])
       p[0] = ListFromConcat(enum, p[3])
     if self.parse_debug: DumpReduction('enum_list', p)
 
@@ skipping 472 matching lines @@
   ast = ParseFiles(filenames)
   errs = ast.GetProperty('ERRORS')
   if errs:
     ErrOut.Log('Found %d error(s).' % errs);
   InfoOut.Log("%d files processed." % len(filenames))
   return errs
 
 if __name__ == '__main__':
   sys.exit(Main(sys.argv[1:]))