Support pointers in the NaCl bindings generator.

nacl_bindings_generator/interface_dsl.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.
 
 class Interface(object):
   def __init__(self):
     self.functions = []
 
   def Func(self, name, return_type):
     f = Function(self, len(self.functions), name, return_type)
     self.functions.append(f)
     return f
 
   def Finalize(self):
     for f in self.functions:
       f.Finalize()
 
 class Function(object):
   def __init__(self, parent, uid, name, return_type):
     self.parent = parent
     self.uid = uid
     self.name = name
     self.return_type = return_type
     self.params = []
     self.param_by_name = {}
     self.result_param = None
+    self.broken_in_nacl = False
 
   def Param(self, name, param_type=None):
     p = Param(self, len(self.params), name, param_type)
     self.params.append(p)
     self.param_by_name[name] = p
     return p
 
   def ParamList(self):
     return [param.param_type + ' ' + param.name for param in self.params]
 
   def ParamDecl(self):
     if self.params:
       return ', '.join(self.ParamList())
     else:
       return 'void'
 
+  def IsBrokenInNaCl(self):
+    self.broken_in_nacl = True
+
   def Finalize(self):
     self.result_param = Param(self, len(self.params), 'result')
     self.result_param.Out(self.return_type).AlwaysWritten()
 
 class Param(object):
   def __init__(self, parent, uid, name, param_type=None):
     self.parent = parent
     self.uid = uid
     self.name = name
     self.base_type = param_type
     self.param_type = param_type
     self.size = None
     self.is_input = False
     self.is_output = False
     self.is_array = False
     self.is_struct = False
     self.is_extensible = False
     self.is_optional = False
     self.is_always_written = False
+    self.is_pointer = False
 
   def GetSizeParam(self):
     assert self.size
     return self.parent.param_by_name[self.size]
 
   def In(self, ty):
     self.base_type = ty
     self.param_type = ty
     self.is_input = True
+    self.is_pointer = ty.endswith('*')
     return self
 
   def InArray(self, ty, size):
     self.base_type = ty
     self.param_type = 'const ' + ty + '*'
     self.size = size
     self.is_input = True
     self.is_array = True
     return self
 
   # An "extensible" struct is one where we don't know the exact size - rather
   # the first 4 bytes of the struct declare the length of the struct.  This
   # allows forwards and backwards compatibility with additive changes to the
   # structure definition.
   def InExtensibleStruct(self, ty):
     self.base_type = ty
     self.param_type = 'const struct ' + ty + '*'
     self.is_input = True
     self.is_struct = True
     self.is_extensible = True
     return self
 
   def InOut(self, ty):
     self.base_type = ty
     self.param_type = ty + '*'
     self.is_input = True
     self.is_output = True
+    self.is_pointer = ty.endswith('*')
     return self
 
   def Out(self, ty):
     self.base_type = ty
     self.param_type = ty + '*'
     self.is_output = True
+    self.is_pointer = ty.endswith('*')
     return self
 
   def OutArray(self, ty, size):
     self.base_type = ty
     self.param_type = ty + '*'
     self.size = size
     self.is_array = True
     self.is_output = True
     return self
 
@@ skipping 23 matching lines @@
   def AlwaysWritten(self):
     assert self.is_output, self
     self.is_always_written = True
     return self
 
   def IsScalar(self):
     return not self.is_array and not self.is_struct
 
   def IsPassedByValue(self):
     return not self.is_output and self.IsScalar()