mojom: Add associative arrays to the mojom language.

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 219 matching lines @@
                 | nonnullable_typename"""
     if len(p) == 2:
       p[0] = p[1]
     else:
       p[0] = p[1] + "?"
 
   def p_nonnullable_typename(self, p):
     """nonnullable_typename : basictypename
                             | array
                             | fixed_array
+                            | associated_array

[viettrungluu, 2014/09/29 19:34:47]

"associated" -> "associative"

                             | interfacerequest"""
     p[0] = p[1]
 
   def p_basictypename(self, p):
     """basictypename : identifier
                      | handletype"""
     p[0] = p[1]
 
   def p_handletype(self, p):
     """handletype : HANDLE
@@ skipping 18 matching lines @@
 
   def p_fixed_array(self, p):
     """fixed_array : typename LBRACKET INT_CONST_DEC RBRACKET"""
     value = int(p[3])
     if value == 0 or value > _MAX_ARRAY_SIZE:
       raise ParseError(self.filename, "Fixed array size %d invalid" % value,
                        lineno=p.lineno(3),
                        snippet=self._GetSnippet(p.lineno(3)))
     p[0] = p[1] + "[" + p[3] + "]"
 
+  def p_associated_array(self, p):
+    """associated_array : typename LBRACKET basictypename RBRACKET"""

[viettrungluu, 2014/09/29 19:34:47]

a) It seems dubious/incorrect to allow "handletypes" as keys.
b) I'm not sure about the syntax, but note that the grammar is dubious and
parses things "backwards"[*], which is unfortunate. (This is an existing
problem, even with arrays.)
c) Allowing even arbitrary identifiers but not handletypes for keys is probably
not what you want. This allows structs as keys, which may then contain handles.
(Of course, not allowing arbitrary-ish things may preclude allowing strings.)

[*] E.g., the type of "string foo[int32][double];" is parsed as double -> (int32
-> string), whereas you probably want it to mean int32 -> (double -> string).

[yzshen1, 2014/09/29 19:53:24]

About the "backward" issue, I am not sure whether changing it will make other
things less clear. For example:

string[int][handle]?

The trailing '?' means "the whole thing is nullable", which seems natural to
associate with the outermost array.

[Elliot Glaysher, 2014/10/02 19:54:03]

Fixed by changing the grammar to look for "identifier".
This is large and thorny enough that I'm not going to deal with it in the
general case. I've fixed this in translate.py for the specific case of
associative arrays.

The actual fix to this is "rewrite the mojom compiler".
Fixed this by adding type checks at a later phase once we have typing
information.

+    p[0] = p[1] + "{" + p[3] + "}"
+
   def p_interfacerequest(self, p):
     """interfacerequest : identifier AMP"""
     p[0] = p[1] + "&"
 
   def p_ordinal_1(self, p):
     """ordinal : """
     p[0] = None
 
   def p_ordinal_2(self, p):
     """ordinal : ORDINAL"""
@@ skipping 86 matching lines @@
 
 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