webruby 0.2.7 → 0.9.1

data/modules/emscripten/tools/bindings_generator.py

@@ -1,832 +0,0 @@
-#!/usr/bin/env python2
-
-'''
-Use CppHeaderParser to parse some C++ headers, and generate binding code for them.
-
-Usage:
-        bindings_generator.py BASENAME HEADER1 HEADER2 ... [-- JSON]
-
-  BASENAME is the name used for output files (with added suffixes).
-  HEADER1 etc. are the C++ headers to parse
-
-We generate the following:
-
-  * BASENAME.c: C bindings file, with generated C wrapper functions. You will
-                need to build this with your project, and make sure it compiles
-                properly by adding the proper #includes etc. You can also just
-                #include this file itself in one of your existing project files.
-
-  * BASENAME.js: JavaScript bindings file, with generated JavaScript wrapper
-                 objects. This is a high-level wrapping, using native JS classes.
-
-  * JSON: An optional JSON object with various optional options:
-
-            ignored: A list of classes and class::methods not to generate code for.
-                     Comma separated.
-            
-            type_processor: Text that is eval()d into a lambda that is run on
-                            all arguments. For example, you can use this to
-                            change all arguments of type float& to float by
-                            "type_processor": "lambda t: t if t != 'float&' else 'float'"
-
-            export: If false, will not export all bindings in the .js file. The
-                    default is to export all bindings, which allows
-                    you to run something like closure compiler advanced opts on
-                    the library+bindings, and the bindings will remain accessible.
-
-          For example, JSON can be { "ignored": "class1,class2::func" }.
-
-The C bindings file is basically a tiny C wrapper around the C++ code.
-It's only purpose is to make it easy to access the C++ code in the JS
-bindings, and to prevent DFE from removing the code we care about. The
-JS bindings do more serious work, creating class structures in JS and
-linking them to the C bindings.
-
-Notes:
- * ammo.js is currently the biggest consumer of this code. For some
-    more docs you can see that project's README,
-
-      https://github.com/kripken/ammo.js
-
-    Another project using these bindings is box2d.js,
-
-      https://github.com/kripken/box2d.js
-
- * Functions implemented inline in classes may not be actually
-    compiled into bitcode, unless they are actually used. That may
-    confuse the bindings generator.
-
- * C strings (char *) passed to functions are treated in a special way.
-    If you pass in a pointer, it is assumed to be a pointer and left as
-    is. Otherwise it must be a JS string, and we convert it to a C
-    string on the *stack*. The C string will live for the current
-    function call. If you need it for longer, you need to create a copy
-    in your C++ code.
-
- * You should compile with -s EXPORT_BINDINGS=1 in order for the
-   autogenerated bindings functions to be exported. This is necessary
-   when compiling in asm.js mode.
-'''
-
-import os, sys, glob, re
-
-__rootpath__ = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-def path_from_root(*pathelems):
-  return os.path.join(__rootpath__, *pathelems)
-sys.path += [path_from_root('')]
-from tools.shared import *
-
-# Find ply and CppHeaderParser
-sys.path = [path_from_root('third_party', 'ply'), path_from_root('third_party', 'CppHeaderParser')] + sys.path
-import CppHeaderParser
-
-#print glob.glob(path_from_root('tests', 'bullet', 'src', 'BulletCollision', 'CollisionDispatch', '*.h'))
-
-basename = sys.argv[1]
-
-ignored = []
-type_processor = lambda t: t
-export = 1
-
-if '--' in sys.argv:
-  index = sys.argv.index('--')
-  json = eval(sys.argv[index+1])
-  sys.argv = sys.argv[:index]
-
-  if json.get('ignored'):
-    ignored = json['ignored'].split(',')
-  if json.get('type_processor'):
-    type_processor = eval(json['type_processor'])
-  if json.get('export'):
-    export = json['export']
-
-  print 'zz ignoring', ignored
-
-# First pass - read everything
-
-classes = {}
-parents = {}
-
-text = ''
-for header in sys.argv[2:]:
-  text += '//// ' + header + '\n'
-  text += open(header, 'r').read()
-all_h_name = basename + '.all.h'
-all_h = open(all_h_name, 'w')
-all_h.write(text)
-all_h.close()
-
-parsed = CppHeaderParser.CppHeader(all_h_name)
-print 'zz dir: ', parsed.__dict__.keys()
-for classname, clazz in parsed.classes.items() + parsed.structs.items():
-  print 'zz see', classname, clazz, type(clazz)
-  classes[classname] = clazz
-  if type(clazz['methods']) == dict:
-    clazz['saved_methods'] = clazz['methods']
-    clazz['methods'] = clazz['methods']['public'] # CppHeaderParser doesn't have 'public' etc. in structs. so equalize to that
-
-  if '::' in classname:
-    assert classname.count('::') == 1
-    parents[classname.split('::')[1]] = classname.split('::')[0]
-
-  if hasattr(clazz, '_public_structs'): # This is a class
-    for sname, struct in clazz._public_structs.iteritems():
-      parents[sname] = classname
-      classes[classname + '::' + sname] = struct
-      struct['name'] = sname # Missing in CppHeaderParser
-      print 'zz seen struct %s in %s' % (sname, classname)
-
-  if 'fields' in clazz: # This is a struct
-    print 'zz add properties!'
-    clazz['properties'] = { 'public': clazz['fields'] }
-    clazz['name'] = classname
-    clazz['inherits'] = []
-print 'zz parents: ', parents
-
-def check_has_constructor(clazz):
-  for method in clazz['methods']:
-    if method['constructor'] and not method['destructor']: return True
-  return False
-
-for classname, clazz in parsed.classes.items() + parsed.structs.items():
-  # Various precalculations
-  print 'zz precalc', classname
-  for method in clazz['methods'][:]:
-    method['constructor'] = method['constructor'] or (method['name'] == classname) # work around cppheaderparser issue
-    print 'z constructorhmm?', method['name'], method['constructor']#, constructor, method['name'], classname
-    args = method['parameters']
-
-    #if method['name'] == 'addWheel': print 'qqqq', classname, method
-
-    # Fill in some missing stuff
-    for i in range(len(args)):
-      if args[i]['pointer'] and '*' not in args[i]['type']:
-        args[i]['type'] += '*'
-      if args[i]['reference'] and '&' not in args[i]['type']:
-        args[i]['type'] += '&'
-      args[i]['type'] = type_processor(args[i]['type'])
-      #raw = args[i]['type'].replace('&', '').replace('*', '')
-      #if raw in classes:
-
-    default_param = len(args)+1
-    for i in range(len(args)):
-      if args[i].get('default'):
-        default_param = i+1
-        break
-
-    method['parameters'] = [args[:i] for i in range(default_param-1, len(args)+1)]
-    print 'zz ', classname, 'has parameters in range', range(default_param-1, len(args)+1)
-
-    method['returns_text'] = method['returns']
-    if method['static']:
-      method['returns_text'] = method['returns_text'].replace('static', '')
-
-    # Implement operators
-    if '__operator__' in method['name']:
-      if 'assignment' in method['name']:
-        method['name'] = 'op_set'
-        method['operator'] = '  return *self = arg0;'
-      elif 'add' in method['name']:
-        method['name'] = 'op_add'
-        method['operator'] = '  return *self += arg0;'
-      elif 'sub' in method['name']:
-        print 'zz subsubsub ', classname, method['name'], method['parameters'][0]
-        method['name'] = 'op_sub'
-        if len(method['parameters'][0]) == 0:
-          method['operator'] = '  static %s ret; ret = -*self; return ret;' % method['returns']
-        else:
-          method['operator'] = '  return *self -= arg0; // %d : %s' % (len(method['parameters'][0]), method['parameters'][0][0]['name'])
-      elif 'imul' in method['name']:
-        method['name'] = 'op_mul'
-        method['operator'] = '  return *self *= arg0;'
-      elif 'mul' in method['name']:
-        method['name'] = 'op_mul'
-        method['operator'] = '  static %s ret; ret = *self * arg0; return ret;' % method['returns']
-      elif 'div' in method['name']:
-        method['name'] = 'op_div'
-        method['operator'] = '  return *self /= arg0;'
-      elif 'getitem' in method['name']:
-        method['name'] = 'op_get'
-        method['operator'] = '  return (*self)[arg0];'
-      elif 'delete' in method['name']:
-        method['ignore'] = True
-      elif 'new' in method['name']:
-        method['ignore'] = True
-      elif 'eq' in method['name']:
-        method['name'] = 'op_comp'
-        method['operator'] = '  return arg0 == arg1;' if len(method['parameters'][0]) == 2 else '  return *self == arg0;'
-      else:
-        print 'zz unknown operator:', method['name'], ', ignoring'
-        method['ignore'] = True
-
-    # Fill in some missing stuff
-    method['returns_text'] = method['returns_text'].replace('&', '').replace('*', '')
-    if method['returns_text'] in parents:
-      method['returns_text'] = parents[method['returns_text']] + '::' + method['returns_text']
-    if method.get('returns_const'): method['returns_text'] = 'const ' + method['returns_text']
-    if method.get('returns_pointer'):
-      while method['returns_text'].count('*') < method['returns_pointer']:
-        method['returns_text'] += '*'
-    if method.get('returns_reference'): method['returns_text'] += '&'
-    method['returns_text'] = type_processor(method['returns_text'])
-
-    #print 'zz %s::%s gets %s and returns %s' % (classname, method['name'], str([arg['type'] for arg in method['parameters']]), method['returns_text'])
-
-    # Add getters/setters for public members
-    for prop in clazz['properties']['public']:
-      if classname + '::' + prop['name'] in ignored: continue
-      if prop.get('array_dimensions'):
-        print 'zz warning: ignoring getter/setter for array', classname + '::' + prop['name']
-        continue
-      type_ = prop['type'].replace('mutable ', '')#.replace(' ', '')
-      if '<' in prop['name'] or '<' in type_:
-        print 'zz warning: ignoring getter/setter for templated class', classname + '::' + prop['name']
-        continue
-      reference = type_ in classes # a raw struct or class as a prop means we need to work with a ref
-      clazz['methods'].append({
-        'getter': True,
-        'name': 'get_' + prop['name'],
-        'constructor': False,
-        'destructor': False,
-        'static': False,
-        'returns': type_.replace(' *', '').replace('*', ''),
-        'returns_text': type_ + ('&' if reference else ''),
-        'returns_reference': reference,
-        'returns_pointer': '*' in type_,
-        'pure_virtual': False,
-        'parameters': [[]],
-      })
-      clazz['methods'].append({
-        'setter': True,
-        'name': 'set_' + prop['name'],
-        'constructor': False,
-        'destructor': False,
-        'static': False,
-        'returns': 'void',
-        'returns_text': 'void',
-        'returns_reference': False,
-        'returns_pointer': False,
-        'pure_virtual': False,
-        'parameters': [[{
-          'type': type_ + ('&' if reference else ''),
-          'name': 'value',
-        }]],
-      })
-
-  print 'zz is effectively abstract?', clazz['name'], classname, '0'
-  if 'saved_methods' in clazz and not check_has_constructor(clazz):
-    print 'zz is effectively abstract?', clazz['name'], '1'
-    # Having a private constructor and no public constructor means you are, in effect, abstract
-    for private_method in clazz['saved_methods']['private']:
-      print 'zz is effectively abstract?', clazz['name'], '2'
-      if private_method['constructor']:
-        print 'zz is effectively abstract?', clazz['name'], '3'
-        clazz['effectively_abstract'] = True
-
-  # Add destroyer
-  if not clazz.get('abstract') and not clazz.get('effectively_abstract'):
-    clazz['methods'].append({
-      'destroyer': True,
-      'name': '__destroy__',
-      'constructor': False,
-      'destructor': False,
-      'static': False,
-      'returns': 'void',
-      'returns_text': 'void',
-      'returns_reference': False,
-      'returns_pointer': False,
-      'pure_virtual': False,
-      'parameters': [[]],
-    })
-
-  clazz['methods'] = filter(lambda method: not method.get('ignore'), clazz['methods'])
-
-# Explore all functions we need to generate, including parent classes, handling of overloading, etc.
-
-def clean_type(t):
-  return t.replace('const ', '').replace('struct ', '').replace('&', '').replace('*', '').replace(' ', '')
-
-def fix_template_value(t): # Not sure why this is needed, might be a bug in CppHeaderParser
-  if t == 'unsignedshortint':
-    return 'unsigned short int'
-  elif t == 'unsignedint':
-    return 'unsigned int'
-  return t
-
-def copy_args(args):
-  ret = []
-  for arg in args:
-    copiedarg = {
-      'type': arg['type'],
-      'name': arg['name'],
-    }
-    ret.append(copiedarg)
-  return ret
-
-for classname, clazz in parsed.classes.items() + parsed.structs.items():
-  clazz['final_methods'] = {}
-
-  def explore(subclass, template_name=None, template_value=None):
-    # Do our functions first, and do not let later classes override
-    for method in subclass['methods']:
-      print classname, 'exploring', subclass['name'], '::', method['name']
-
-      if method['constructor']:
-        if clazz != subclass:
-          print "zz Subclasses cannot directly use their parent's constructors"
-          continue
-      if method['destructor']:
-        print 'zz Nothing to do there'
-        continue
-
-      if method.get('operator') and subclass is not clazz:
-        print 'zz Do not use parent class operators. Cast to that class if you need those operators (castObject)'
-        continue
-
-      if method['name'] not in clazz['final_methods']:
-        copied = clazz['final_methods'][method['name']] = {}
-        for key in ['name', 'constructor', 'static', 'returns', 'returns_text', 'returns_reference', 'returns_pointer', 'destructor', 'pure_virtual',
-                    'getter', 'setter', 'destroyer', 'operator']:
-          copied[key] = method.get(key)
-        copied['origin'] = subclass
-        copied['parameters'] = [];
-        for args in method['parameters']:
-          # Copy the arguments, since templating may cause them to be altered
-          copied['parameters'].append(copy_args(args))
-        if template_name:
-          # Set template values
-          copied['returns'] = copied['returns'].replace(template_name, template_value)
-          copied['returns_text'] = copied['returns_text'].replace(template_name, template_value)
-          for args in copied['parameters']:
-            for arg in args:
-              arg['type'] = arg['type'].replace(template_name, template_value)
-      else:
-        # Merge the new function in the best way we can. Two signatures (args) must differ in their number
-
-        if method.get('operator'): continue # do not merge operators
-
-        curr = clazz['final_methods'][method['name']]
-
-        if curr['origin'] is not subclass: continue # child class functions mask/hide parent functions of the same name in C++
-
-        problem = False
-        for curr_args in curr['parameters']:
-          for method_args in method['parameters']:
-            if len(curr_args) == len(method_args):
-              problem = True
-        if problem:
-          print 'Warning: Cannot mix in overloaded functions', method['name'], 'in class', classname, ', skipping'
-          continue
-        # TODO: Other compatibility checks, if any?
-
-        curr['parameters'] += map(copy_args, method['parameters'])
-
-        print 'zz ', classname, 'has updated parameters of ', curr['parameters']
-
-    # Recurse
-    if subclass.get('inherits'):
-      for parent in subclass['inherits']:
-        parent = parent['class']
-        template_name = None
-        template_value = None
-        if '<' in parent:
-          parent, template = parent.split('<')
-          template_name = classes[parent]['template_typename']
-          template_value = fix_template_value(template.replace('>', ''))
-          print 'template', template_value, 'for', classname, '::', parent, ' | ', template_name
-        if parent not in classes and '::' in classname: # They might both be subclasses in the same parent
-          parent = classname.split('::')[0] + '::' + parent
-        if parent not in classes:
-          print 'Warning: parent class', parent, 'not a known class. Ignoring.'
-          return
-        explore(classes[parent], template_name, template_value)
-
-  explore(clazz)
-
-  for method in clazz['final_methods'].itervalues():
-    method['parameters'].sort(key=len)
-
-# Second pass - generate bindings
-# TODO: Bind virtual functions using dynamic binding in the C binding code
-
-funcs = {} # name -> # of copies in the original, and originalname in a copy
-
-gen_c = open(basename + '.cpp', 'w')
-gen_js = open(basename + '.js', 'w')
-
-gen_c.write('extern "C" {\n')
-
-gen_js.write('''
-// Bindings utilities
-
-var Object__cache = {}; // we do it this way so we do not modify |Object|
-function wrapPointer(ptr, __class__) {
-  var cache = __class__ ? __class__.prototype.__cache__ : Object__cache;
-  var ret = cache[ptr];
-  if (ret) return ret;
-  __class__ = __class__ || Object;
-  ret = Object.create(__class__.prototype);
-  ret.ptr = ptr;
-  ret.__class__ = __class__;
-  return cache[ptr] = ret;
-}
-Module['wrapPointer'] = wrapPointer;
-
-function castObject(obj, __class__) {
-  return wrapPointer(obj.ptr, __class__);
-}
-Module['castObject'] = castObject;
-
-Module['NULL'] = wrapPointer(0);
-
-function destroy(obj) {
-  if (!obj['__destroy__']) throw 'Error: Cannot destroy object. (Did you create it yourself?)';
-  obj['__destroy__']();
-  // Remove from cache, so the object can be GC'd and refs added onto it released
-  if (obj.__class__ !== Object) {
-    delete obj.__class__.prototype.__cache__[obj.ptr];
-  } else {
-    delete Object__cache[obj.ptr];
-  }
-}
-Module['destroy'] = destroy;
-
-function compare(obj1, obj2) {
-  return obj1.ptr === obj2.ptr;
-}
-Module['compare'] = compare;
-
-function getPointer(obj) {
-  return obj.ptr;
-}
-Module['getPointer'] = getPointer;
-
-function getClass(obj) {
-  return obj.__class__;
-}
-Module['getClass'] = getClass;
-
-function customizeVTable(object, replacementPairs) {
-  // Does not handle multiple inheritance
-
-  // Find out vtable size
-  var vTable = getValue(object.ptr, 'void*');
-  // This assumes our modification where we null-terminate vtables
-  var size = 0;
-  while (getValue(vTable + Runtime.QUANTUM_SIZE*size, 'void*')) {
-    size++;
-  }
-
-  // Prepare replacement lookup table and add replacements.
-  // There is actually no good way to do this! So we do the following hack:
-  // We create a fake vtable with canary functions, to detect which actual
-  // function is being called
-  var vTable2 = _malloc(size*Runtime.QUANTUM_SIZE);
-  setValue(object.ptr, vTable2, 'void*');
-  var canaryValue;
-  var tempFuncs = [];
-  for (var i = 0; i < size; i++) {
-    (function(j) {
-      var index = Runtime.addFunction(function() {
-        canaryValue = j;
-      });
-      setValue(vTable2 + Runtime.QUANTUM_SIZE*i, index, 'void*');
-      tempFuncs.push(index);
-    })(i);
-  }
-  var args = [{ptr: 0}];
-  replacementPairs.forEach(function(pair) {
-    // We need the wrapper function that converts arguments to not fail. Keep adding arguments til it works.
-    while(1) {
-      try {
-        pair['original'].apply(object, args);
-        break;
-      } catch(e) {
-        args.push(args[0]);
-      }
-    }
-    pair.originalIndex = getValue(vTable + canaryValue*Runtime.QUANTUM_SIZE, 'void*');
-  });
-  for (var i = 0; i < size; i++) {
-    Runtime.removeFunction(tempFuncs[i]);
-  }
-
-  // Do the replacements
-
-  var replacements = {};
-  replacementPairs.forEach(function(pair) {
-    replacements[pair.originalIndex] = Runtime.addFunction(pair['replacement']);
-  });
-
-  // Copy and modify vtable
-  for (var i = 0; i < size; i++) {
-    var value = getValue(vTable + Runtime.QUANTUM_SIZE*i, 'void*');
-    if (value in replacements) value = replacements[value];
-    setValue(vTable2 + Runtime.QUANTUM_SIZE*i, value, 'void*');
-  }
-  return object;
-}
-Module['customizeVTable'] = customizeVTable;
-
-// Converts a value into a C-style string.
-function ensureString(value) {
-  if (typeof value == 'number') return value;
-  return allocate(intArrayFromString(value), 'i8', ALLOC_STACK);
-}
-''')
-
-def generate_wrapping_code(classname):
-  return '''%(classname)s.prototype.__cache__ = {};
-''' % { 'classname': classname }
-# %(classname)s.prototype['fields'] = Runtime.generateStructInfo(null, '%(classname)s'); - consider adding this
-
-def generate_class(generating_classname, classname, clazz): # TODO: deprecate generating?
-  print 'zz generating:', generating_classname, classname
-  generating_classname_head = generating_classname.split('::')[-1]
-  classname_head = classname.split('::')[-1]
-
-  inherited = generating_classname_head != classname_head
-
-  abstract = clazz['abstract']
-  if abstract:
-    # For abstract base classes, add a function definition on top. There is no constructor
-    gen_js.write('\nfunction ' + generating_classname_head + ('(){ throw "%s is abstract!" }\n' % generating_classname_head) + generate_wrapping_code(generating_classname_head))
-    if export:
-      gen_js.write('''Module['%s'] = %s;
-''' % (generating_classname_head, generating_classname_head))
-
-  print 'zz methods: ', clazz['final_methods'].keys()
-  for method in clazz['final_methods'].itervalues():
-    mname = method['name']
-    if classname_head + '::' + mname in ignored:
-      print 'zz ignoring', mname
-      continue
-
-    params = method['parameters']
-    constructor = method['constructor']
-    destructor = method['destructor']
-    static = method['static']
-
-    print 'zz generating %s::%s' % (generating_classname, method['name'])
-
-    if destructor: continue
-    if constructor and inherited: continue
-    if constructor and clazz['abstract']: continue # do not generate constructors for abstract base classes
-
-    for args in params:
-      for i in range(len(args)):
-        #print 'zz   arggggggg', classname, 'x', mname, 'x', args[i]['name'], 'x', args[i]['type'], 'x', dir(args[i]), 'y', args[i].get('default'), 'z', args[i].get('defaltValue'), args[i].keys()
-
-        if args[i]['name'].replace(' ', '') == '':
-          args[i]['name'] = 'arg' + str(i+1)
-        elif args[i]['name'] == '&':
-          args[i]['name'] = 'arg' + str(i+1)
-          args[i]['type'] += '&'
-
-        #print 'c1', parents.keys()
-        if args[i]['type'][-1] == '&':
-          sname = args[i]['type'][:-1]
-          if sname[-1] == ' ': sname = sname[:-1]
-          if sname in parents:
-            args[i]['type'] = parents[sname] + '::' + sname + '&'
-          elif sname.replace('const ', '') in parents:
-            sname = sname.replace('const ', '')
-            args[i]['type'] = 'const ' + parents[sname] + '::' + sname + '&'
-        #print 'POST arggggggg', classname, 'x', mname, 'x', args[i]['name'], 'x', args[i]['type']
-
-    ret = ((classname + ' *') if constructor else method['returns_text'])#.replace('virtual ', '')
-    has_return = ret.replace(' ', '') != 'void'
-    callprefix = 'new ' if constructor else ('self->' if not static else (classname + '::'))
-
-    '' # mname used in C
-    actualmname = classname if constructor else (method.get('truename') or mname)
-    if method.get('getter') or method.get('setter'):
-      actualmname = actualmname[4:]
-
-    need_self = not constructor and not static
-
-    def typedargs(args):
-      return ([] if not need_self else [classname + ' * self']) + map(lambda i: args[i]['type'] + ' arg' + str(i), range(len(args)))
-    def justargs(args):
-      return map(lambda i: 'arg' + str(i), range(len(args)))
-    def justtypes(args): # note: this ignores 'self'
-      return map(lambda i: args[i]['type'], range(len(args)))
-    def dummyargs(args):
-      return ([] if not need_self else ['(%s*)argv[argc]' % classname]) + map(lambda i: '(%s)argv[argc]' % args[i]['type'], range(len(args)))
-
-    fullname = ('emscripten_bind_' + generating_classname + '__' + mname).replace('::', '__')
-    generating_classname_suffixed = generating_classname
-    mname_suffixed = mname
-    count = funcs.setdefault(fullname, 0)
-    funcs[fullname] += 1
-
-    # handle overloading
-    dupe = False
-    if count > 0:
-      dupe = True
-      suffix = '_' + str(count+1)
-      funcs[fullname + suffix] = 0
-      fullname += suffix
-      mname_suffixed += suffix
-      if constructor:
-        generating_classname_suffixed += suffix
-
-    # C
-
-    for args in params:
-      i = len(args)
-      # If we are returning a *copy* of an object, we return instead to a ref of a static held here. This seems the best compromise
-      staticize = not constructor and ret.replace(' ', '') != 'void' and method['returns'] in classes and (not method['returns_reference'] and not method['returns_pointer'])
-      # Make sure to mark our bindings wrappers in a way that they will not be inlined, eliminated as unneeded, or optimized into other signatures
-      gen_c.write('''
-%s __attribute__((used, noinline)) %s_p%d(%s) {''' % (ret if not staticize else (ret + '&'), fullname, i,
-                    ', '.join(typedargs(args)[:i + (0 if not need_self else 1)])))
-      if not staticize:
-        gen_c.write('\n')
-        if method.get('getter'):
-          gen_c.write('''  return self->%s;''' % actualmname)
-        elif method.get('setter'):
-          gen_c.write('''  self->%s = arg0;''' % actualmname)
-        elif method.get('destroyer'):
-          gen_c.write('''  delete self;''')
-        elif method.get('operator'):
-          gen_c.write(method['operator'])
-        else: # normal method
-          gen_c.write('''  %s%s%s(%s);''' % ('return ' if has_return else '',
-                                             callprefix, actualmname, ', '.join(justargs(args)[:i])))
-        gen_c.write('\n')
-        gen_c.write('}')
-      else:
-        gen_c.write('\n')
-        if method.get('operator'):
-          gen_c.write(method['operator'])
-        else:
-          gen_c.write('''  static %s ret; ret = %s%s(%s);
-  return ret;''' % (method['returns'],
-        callprefix, actualmname,
-        ', '.join(justargs(args)[:i])))
-        gen_c.write('\n}')
-
-    # JS
-
-    #print 'zz types:', map(lambda arg: arg['type'], args)
-
-    has_string_convs = False
-
-    calls = ''
-
-    #print 'js loopin', params, '|', len(args)#, args
-    for args in params:
-      # We can assume that NULL is passed for null pointers, so object arguments can always
-      # have .ptr done on them
-      justargs_fixed = justargs(args)[:]
-      for i in range(len(args)):
-        arg = args[i]
-        clean = clean_type(arg['type'])
-        if clean in classes:
-          justargs_fixed[i] += '.ptr'
-        elif arg['type'].replace(' ', '').endswith('char*'):
-          justargs_fixed[i] = 'ensureString(' + justargs_fixed[i] + ')'
-          has_string_convs = True
-
-      i = len(args)
-      if args != params[0]:
-        calls += '  else '
-      if args != params[-1]:
-        calls += '  if (arg' + str(i) + ' === undefined)'
-      calls += '\n  ' + ('  ' if len(params) > 0 else '')
-      if constructor:
-        if not dupe:
-          calls += '''this.ptr = _%s_p%d(%s);
-''' % (fullname, i, ', '.join(justargs_fixed[:i]))
-        else:
-          calls += '''this.ptr = _%s_p%d(%s);
-''' % (fullname, i, ', '.join(justargs_fixed[:i]))
-      else:
-        return_value = '''_%s_p%d(%s)''' % (fullname, i, ', '.join((['this.ptr'] if need_self else []) + justargs_fixed[:i]))
-        print 'zz making return', classname, method['name'], method['returns'], return_value
-        if method['returns'] in classes:
-          # Generate a wrapper
-          calls += '''return wrapPointer(%s, Module['%s']);''' % (return_value, method['returns'].split('::')[-1])
-        else:
-          # Normal return
-          calls += ('return ' if ret != 'void' else '') + return_value + ';'
-        calls += '\n'
-
-    if has_string_convs:
-      calls = 'var stack = Runtime.stackSave();\ntry {\n' + calls + '} finally { Runtime.stackRestore(stack) }\n';
-
-    print 'Maekin:', classname, generating_classname, mname, mname_suffixed
-    if constructor:
-      calls += '''
-  %s.prototype.__cache__[this.ptr] = this;
-  this.__class__ = %s;''' % (mname_suffixed, mname_suffixed)
-      if not dupe:
-        js_text = '''
-function %s(%s) {
-%s
-}
-%s''' % (mname_suffixed, ', '.join(justargs(args)), calls, generate_wrapping_code(generating_classname_head))
-      else:
-        js_text = '''
-function %s(%s) {
-%s
-}
-%s.prototype = %s.prototype;
-''' % (mname_suffixed, ', '.join(justargs(args)), calls, mname_suffixed, classname)
-
-      if export:
-        js_text += '''
-Module['%s'] = %s;
-''' % (mname_suffixed, mname_suffixed)
-
-    else:
-      js_text = '''
-%s.prototype%s = function(%s) {
-%s
-}
-''' % (generating_classname_head, ('.' + mname_suffixed) if not export else ("['" + mname_suffixed + "']"), ', '.join(justargs(args)), calls)
-
-    js_text = js_text.replace('\n\n', '\n').replace('\n\n', '\n')
-    gen_js.write(js_text)
-
-# Main loop
-
-for classname, clazz in parsed.classes.items() + parsed.structs.items():
-  if any([name in ignored for name in classname.split('::')]):
-    print 'zz ignoring', classname
-    continue
-
-  if clazz.get('template_typename'):
-    print 'zz ignoring templated base class', classname
-    continue
-
-  # Nothing to generate for pure virtual classes XXX actually this is not so. We do need to generate wrappers for returned objects,
-  # they are of a concrete class of course, but an known one, so we create a wrapper for an abstract base class.
-
-  possible_prefix = (classname.split('::')[0] + '::') if '::' in classname else ''
-
-  def check_pure_virtual(clazz, progeny):
-    #if not clazz.get('inherits'): return False # If no inheritance info, not a class, this is a CppHeaderParser struct
-    print 'Checking pure virtual for', clazz['name'], clazz['inherits']
-    # If we do not recognize any of the parent classes, assume this is pure virtual - ignore it
-    parents = [parent['class'] for parent in clazz['inherits']]
-    parents = [parent.split('<')[0] for parent in parents] # remove template stuff
-    parents = [parent if parent in classes else possible_prefix + parent for parent in parents]
-    if any([not parent in classes for parent in parents]):
-      print 'zz Warning: unknown parent class', parents, 'for', classname
-      return True
-    if any([check_pure_virtual(classes[parent], [clazz] + progeny) for parent in parents]): return True
-
-    def dirtied(mname):
-      #print 'zz checking dirtiness for', mname, 'in', progeny
-      for progen in progeny:
-        for method in progen['methods']:
-          if method['name'] == mname and not method['pure_virtual']:
-            #print 'zz dirty'
-            return True
-      #print 'zz not dirtied'
-      return False
-
-    for method in clazz['methods']:
-      if method['pure_virtual'] and not dirtied(method['name']):
-        print 'zz ignoring pure virtual class', classname, 'due to', method['name']
-        return True
-
-  clazz['abstract'] = check_pure_virtual(clazz, []) or clazz.get('effectively_abstract')
-
-  print 'zz', classname, 'is abstract?', clazz['abstract']
-  #if check_pure_virtual(clazz, []):
-  #  continue
-
-  # Add a constructor if none exist
-  has_constructor = check_has_constructor(clazz)
-
-  print 'zz', classname, 'has constructor?', has_constructor
-
-  if not has_constructor:
-    if not clazz['abstract']:
-      print 'zz no constructor for', classname, 'and not abstract, so ignoring'
-      continue
-  
-    #clazz['methods'] = [{
-    #  'name': classname,
-    #  'parameters': [],
-    #  'pure_virtual': False,
-    #  'destructor': False,
-    #}] + clazz['methods']
-
-  generate_class(classname, classname, clazz)
-
-  # TODO: Add a destructor
-
-# Finish up
-
-gen_c.write('''
-
-}
-''')
-
-gen_c.close()
-gen_js.close()
-