Mojo: add support for {double,float}.{INFINITY,NEGATIVE_INFINITY,NAN}

mojo/public/tools/bindings/pylib/mojom/parse/parser.py

 # Copyright 2014 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.
 
 """Generates a syntax tree from a Mojo IDL file."""
 
 import imp
 import os.path
 import sys
 
@@ skipping 301 matching lines @@
                   | NAME EQUALS identifier_wrapped"""
     p[0] = ast.EnumValue(p[1], p[3] if len(p) == 4 else None,
                          filename=self.filename, lineno=p.lineno(1))
 
   def p_const(self, p):
     """const : CONST typename NAME EQUALS constant SEMI"""
     p[0] = ast.Const(p[3], p[2], p[5])
 
   def p_constant(self, p):
     """constant : literal
                 | identifier_wrapped"""

[viettrungluu, 2014/08/21 16:42:18]

If you didn't add a lexer token for these, wouldn't these still be accepted as
identifier(_wrapped)? And shouldn't we just use that mechanism?

     p[0] = p[1]
 
   def p_identifier_wrapped(self, p):
     """identifier_wrapped : identifier"""
     p[0] = ('IDENTIFIER', p[1])
 
   # TODO(vtl): Make this produce a "wrapped" identifier (probably as an
   # |ast.Identifier|, to be added) and get rid of identifier_wrapped.
   def p_identifier(self, p):
     """identifier : NAME
@@ skipping 16 matching lines @@
     p[0] = ''.join(p[1:])
 
   def p_int_const(self, p):
     """int_const : INT_CONST_DEC
                  | INT_CONST_HEX"""
     p[0] = p[1]
 
   def p_float(self, p):
     """float : FLOAT_CONST
              | PLUS FLOAT_CONST
-             | MINUS FLOAT_CONST"""
+             | MINUS FLOAT_CONST
+             | FLOAT_BUILTIN"""
     p[0] = ''.join(p[1:])
 
   def p_error(self, e):
     if e is None:
       # Unexpected EOF.
       # TODO(vtl): Can we figure out what's missing?
       raise ParseError(self.filename, "Unexpected end of file")
 
     raise ParseError(self.filename, "Unexpected %r:" % e.value, lineno=e.lineno,
                      snippet=self._GetSnippet(e.lineno))
 
   def _GetSnippet(self, lineno):
     return self.source.split('\n')[lineno - 1]
 
 
 def Parse(source, filename):
   lexer = Lexer(filename)
   parser = Parser(lexer, source, filename)
 
   lex.lex(object=lexer)
   yacc.yacc(module=parser, debug=0, write_tables=0)
 
   tree = yacc.parse(source)
   return tree