Mojo: Mojom: Detect (lexically) bad or missing ordinals.

mojo/public/bindings/pylib/parse/mojo_lexer.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.
 
 import re
 import sys
 import os.path
 
 # Try to load the ply module, if not, then assume it is in the third_party
 # directory.
@@ skipping 143 matching lines @@
   floating_constant = \
       '(((('+fractional_constant+')'+ \
       exponent_part+'?)|([0-9]+'+exponent_part+'))[FfLl]?)'
   binary_exponent_part = r'''([pP][+-]?[0-9]+)'''
   hex_fractional_constant = \
       '((('+hex_digits+r""")?\."""+hex_digits+')|('+hex_digits+r"""\.))"""
   hex_floating_constant = \
       '('+hex_prefix+'('+hex_digits+'|'+hex_fractional_constant+')'+ \
       binary_exponent_part+'[FfLl]?)'
 
+  # Ordinals
+  ordinal = r'@[0-9]+'
+  missing_ordinal_value = r'@'
+  # Don't allow ordinal values in octal (even invalid octal, like 09) or
+  # hexadecimal.
+  octal_or_hex_ordinal_disallowed = r'@((0[0-9]+)|('+hex_prefix+hex_digits+'))'
+
   ##
   ## Rules for the normal state
   ##
   t_ignore = ' \t\r'
 
   # Newlines
   def t_NEWLINE(self, t):
     r'\n+'
     t.lexer.lineno += t.value.count("\n")
 
@@ skipping 23 matching lines @@
   t_RBRACKET          = r'\]'
   t_LBRACE            = r'\{'
   t_RBRACE            = r'\}'
   t_LANGLE            = r'<'
   t_RANGLE            = r'>'
   t_COMMA             = r','
   t_DOT               = r'\.'
   t_SEMI              = r';'
 
   t_STRING_LITERAL    = string_literal
-  t_ORDINAL           = r'@[0-9]*'
 
   # The following floating and integer constants are defined as
   # functions to impose a strict order (otherwise, decimal
   # is placed before the others because its regex is longer,
   # and this is bad)
   #
   @TOKEN(floating_constant)
   def t_FLOAT_CONST(self, t):
     return t
 
@@ skipping 35 matching lines @@
     msg = "Invalid char constant %s" % t.value
     self._error(msg, t)
 
   # unmatched string literals are caught by the preprocessor
 
   @TOKEN(bad_string_literal)
   def t_BAD_STRING_LITERAL(self, t):
     msg = "String contains invalid escape code"
     self._error(msg, t)
 
+  # Handle ordinal-related tokens in the right order:
+  @TOKEN(octal_or_hex_ordinal_disallowed)
+  def t_OCTAL_OR_HEX_ORDINAL_DISALLOWED(self, t):
+    msg = "Octal and hexadecimal ordinal values not allowed"
+    self._error(msg, t)
+
+  @TOKEN(ordinal)
+  def t_ORDINAL(self, t):
+    return t
+
+  @TOKEN(missing_ordinal_value)
+  def t_BAD_ORDINAL(self, t):
+    msg = "Missing ordinal value"
+    self._error(msg, t)
+
   @TOKEN(identifier)
   def t_NAME(self, t):
     t.type = self.keyword_map.get(t.value, "NAME")
     return t
 
   # Ignore C and C++ style comments
   def t_COMMENT(self, t):
     r'(/\*(.|\n)*?\*/)|(//.*(\n[ \t]*//.*)*)'
     pass
 
   def t_error(self, t):
     msg = 'Illegal character %s' % repr(t.value[0])
     self._error(msg, t)