mojo: Specialize native type arrays.

mojo/public/tools/bindings/generators/mojom_python_generator.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 Python source files from a mojom.Module."""
 
 import re
 from itertools import ifilter
 
 import mojom.generate.generator as generator
@@ skipping 19 matching lines @@
   mojom.DPPIPE:                "_descriptor.TYPE_HANDLE",
   mojom.MSGPIPE:               "_descriptor.TYPE_HANDLE",
   mojom.SHAREDBUFFER:          "_descriptor.TYPE_HANDLE",
   mojom.NULLABLE_HANDLE:       "_descriptor.TYPE_NULLABLE_HANDLE",
   mojom.NULLABLE_DCPIPE:       "_descriptor.TYPE_NULLABLE_HANDLE",
   mojom.NULLABLE_DPPIPE:       "_descriptor.TYPE_NULLABLE_HANDLE",
   mojom.NULLABLE_MSGPIPE:      "_descriptor.TYPE_NULLABLE_HANDLE",
   mojom.NULLABLE_SHAREDBUFFER: "_descriptor.TYPE_NULLABLE_HANDLE",
 }
 
+# int64 integers are not handled by array.array

[Chris Masone, 2014/09/09 14:20:26]

Hm. That's a bit of an issue, as many CrOS platforms are 64 bit, and integers
are that wide by default. Is there a way to work around this?

[qsr, 2014/09/09 14:30:20]

 Hum... Not sure to understand why this is an issue. That would only be used to
efficiently handle array of 64 bytes integer in generated struct. This is quite
a rare type in the mojom files anyway, so the fact that we use a python list to
represent those and encode those instead of a array.array is not that much of an
issue. It would be great to have a closer to native representation for those,
but I don't think the performance hit is such a problem given that I do not
expect those to be used a lot. For example, right now in chromium:

git grep int64\\\[ -- \*.mojom | wc -l
0

[sdefresne, 2014/09/10 08:40:00]

Maybe expand the comment to say that int64/uint64 array are supported but
storage is not optimized (ie. they are plain python list, not array.array).

[qsr, 2014/09/10 09:23:38]

Done.

+_kind_to_typecode = {
+  mojom.INT8:   "'b'",
+  mojom.UINT8:  "'B'",
+  mojom.INT16:  "'h'",
+  mojom.UINT16: "'H'",
+  mojom.INT32:  "'i'",
+  mojom.UINT32: "'I'",
+  mojom.FLOAT:  "'f'",
+  mojom.DOUBLE: "'d'",
+}
+
 
 def NameToComponent(name):
   # insert '_' between anything and a Title name (e.g, HTTPEntry2FooBar ->
   # HTTP_Entry2_FooBar)
   name = re.sub('([^_])([A-Z][^A-Z_]+)', r'\1_\2', name)
   # insert '_' between non upper and start of upper blocks (e.g.,
   # HTTP_Entry2_FooBar -> HTTP_Entry2_Foo_Bar)
   name = re.sub('([^A-Z_])([A-Z])', r'\1_\2', name)
   return [x.lower() for x in name.split('_')]
 
@@ skipping 42 matching lines @@
 
 def GetStructClass(kind):
   name = []
   if kind.imported_from:
     name.append(kind.imported_from['python_module'])
   name.append(GetNameForElement(kind))
   return '.'.join(name)
 
 def GetFieldType(kind, field=None):
   if mojom.IsAnyArrayKind(kind):
-    arguments = [ GetFieldType(kind.kind) ]
+    if kind.kind in _kind_to_typecode:
+      arguments = [ _kind_to_typecode[kind.kind] ]
+    else:
+      arguments = [ GetFieldType(kind.kind) ]
     if mojom.IsNullableKind(kind):
       arguments.append("nullable=True")
     if mojom.IsFixedArrayKind(kind):
       arguments.append("length=%d" % kind.length)
-    return "_descriptor.ArrayType(%s)" % ", ".join(arguments)
+    if kind.kind in _kind_to_typecode:
+      return "_descriptor.NativeArrayType(%s)" % ", ".join(arguments)
+    else:
+      return "_descriptor.PointerArrayType(%s)" % ", ".join(arguments)
 
   if mojom.IsStructKind(kind):
     arguments = [ GetStructClass(kind) ]
     if mojom.IsNullableKind(kind):
       arguments.append("nullable=True")
     return "_descriptor.StructType(%s)" % ", ".join(arguments)
 
   if mojom.IsEnumKind(kind):
     return GetFieldType(mojom.INT32)
 
@@ skipping 115 matching lines @@
   def GetImports(self):
     for each in self.module.imports:
       each['python_module'] = each['module_name'].replace('.mojom', '_mojom')
     return self.module.imports
 
   def GetJinjaParameters(self):
     return {
       'lstrip_blocks': True,
       'trim_blocks': True,
     }