PPAPI: make generator output a pointer to an array correctly.

ppapi/generators/idl_c_proto.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 """ Generator for C style prototypes and definitions """
 
 import glob
 import os
 import sys
@@ skipping 366 matching lines @@
   #   rtype - The store or return type of the object.
   #   name - The name of the object.
   #   arrays - A list of array dimensions as [] or [<fixed_num>].
   #   args -  None if not a function, otherwise a list of parameters.
   #
   def GetComponents(self, node, release, mode):
     self.LogEnter('GetComponents mode %s for %s %s' % (mode, node, release))
 
     # Generate passing type by modifying root type
     rtype = self.GetTypeByMode(node, release, mode)
+    # If this is an array output, change it from type* foo[] to type** foo.
+    # type* foo[] means an array of pointers to type, which is confusing.

[Justin Chuang, 2014/08/19 17:31:13]

nit: optionally elaborate more like this:

Function parameter with 'bar_t* foo[]' is ambiguous. It's legit for different
contexts:
   1. pass an array of pointers to bar_t objects.
   2. the caller prepares 'bar_t* ptr', and pass '&ptr'.
We only need the second context. 

[dmichael (off chromium), 2014/08/19 21:43:21]

I don't mean to come off as harsh, but I'm not sure what point you're trying to
make here. The IDL under discussion reads to me as "an array out-param", not an
"array of pointers":
[out, size_is(array_size)] PP_Size[] preview_sizes
...this currently generates to:
PP_Size* preview_sizes[]
...which is not what is the expressed intent from the IDL. I don't think it
matters whether that line of C has ambiguous intent or not; it's the wrong code
to generate based on the IDL.

If you're arguing that the _IDL_ is ambiguous, that's different. I think it
reads most clearly as "array out-param", so I think the fix is right,
personally.

+    arrayspec = [self.GetArraySpec(array) for array in node.GetListOf('Array')]
+    if mode == 'out' and len(arrayspec) == 1 and arrayspec[0] == '[]':
+      rtype += '*'
+      del arrayspec[0]
+
     if node.IsA('Enum', 'Interface', 'Struct'):
       rname = node.GetName()
     else:
       rname = node.GetType(release).GetName()
 
     if rname in CGen.RemapName:
       rname = CGen.RemapName[rname]
     if '%' in rtype:
       rtype = rtype % rname
     name = node.GetName()
-    arrayspec = [self.GetArraySpec(array) for array in node.GetListOf('Array')]
     callnode = node.GetOneOf('Callspec')
     if callnode:
       callspec = []
       for param in callnode.GetListOf('Param'):
         if not param.IsRelease(release):
           continue
         mode = self.GetParamMode(param)
         ptype, pname, parray, pspec = self.GetComponents(param, release, mode)
         callspec.append((ptype, pname, parray, pspec))
     else:
@@ skipping 370 matching lines @@
     if f.GetProperty('ERRORS') > 0:
       print 'Skipping %s' % f.GetName()
       continue
     for node in f.GetChildren()[2:]:
       print cgen.Define(node, ast.releases, comment=True, prefix='tst_')
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))