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 410 matching lines @@
               | OCT"""
     p[0] = p[1]
     if self.parse_debug: DumpReduction('number', 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)
 
 #
+# Expression
+#
+# A simple arithmetic expression.
+#
+  precedence = (
+    ('left','LSHIFT','RSHIFT'),
+    ('left','+','-'),
+    ('left','*','/'),
+    ('right','UMINUS'),
+    )
+
+  def p_expression_binop(self, p):
+    """expression : expression '+' expression
+                  | expression '-' expression
+                  | expression '*' expression
+                  | expression '/' expression
+                  | expression LSHIFT expression
+                  | expression RSHIFT expression"""
+    if p[2] == '+'  : p[0] = p[1] + p[3]

[noelallen1, 2011/10/05 23:35:51]

I think what you really want to do, is take a bunch of strings, and concatenate
them. For example, if someone passes a symbol you can't do str(SYMBOL) + int(5).
 
Maybe replace this all with:
 p[0] = "(%s %s %s)" % (str(p[1]), str(p[2]), str(p[3]))

+    elif p[2] == '-': p[0] = p[1] - p[3]
+    elif p[2] == '*': p[0] = p[1] * p[3]
+    elif p[2] == '/': p[0] = p[1] / p[3]
+    elif p[2] == 'LSHIFT': p[0] = p[1] << p[3]
+    elif p[2] == 'RSHIFT': p[0] = p[1] >> p[3]
+    if self.parse_debug: DumpReduction('expression_binop', p)
+
+  def p_expression_uminus(self, p):
+    "expression : '-' expression %prec UMINUS"
+    p[0] = -p[2]
+    if self.parse_debug: DumpReduction('expression_uminus', p)
+
+  def p_expression_term(self, p):
+    "expression : '(' expression ')'"
+    p[0] = p[2]
+    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('expression_symbol', p)
+
+  def p_expression_number(self, p):
+    "expression : number"
+    p[0] = p[1]

[noelallen1, 2011/10/05 23:35:51]

only allow INT, HEX, OCT?  No float

+    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
               | """
     # If there are 3 tokens plus a return slot it is an unsized array
     if len(p) == 4:
@@ skipping 75 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:]))