| # Copyright 2014 The Emscripten Authors. All rights reserved. |
| # Emscripten is available under two separate licenses, the MIT license and the |
| # University of Illinois/NCSA Open Source License. Both these licenses can be |
| # found in the LICENSE file. |
| |
| ''' |
| WebIDL binder |
| |
| http://kripken.github.io/emscripten-site/docs/porting/connecting_cpp_and_javascript/WebIDL-Binder.html |
| ''' |
| |
| from __future__ import print_function |
| import os, sys |
| |
| sys.path.insert(1, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) |
| |
| from tools import shared |
| |
| sys.path.append(shared.path_from_root('third_party')) |
| sys.path.append(shared.path_from_root('third_party', 'ply')) |
| |
| import WebIDL |
| |
| # CHECKS='FAST' will skip most argument type checks in the wrapper methods for |
| # performance (~3x faster than default). |
| # CHECKS='ALL' will do extensive argument type checking (~5x slower than default). |
| # This will catch invalid numbers, invalid pointers, invalid strings, etc. |
| # Anything else defaults to legacy mode for backward compatibility. |
| CHECKS = os.environ.get('IDL_CHECKS') or 'DEFAULT' |
| # DEBUG=1 will print debug info in render_function |
| DEBUG = os.environ.get('IDL_VERBOSE') is '1' |
| |
| if DEBUG: print("Debug print ON, CHECKS=%s" % CHECKS) |
| |
| # We need to avoid some closure errors on the constructors we define here. |
| CONSTRUCTOR_CLOSURE_SUPPRESSIONS = '/** @suppress {undefinedVars, duplicate} */' |
| |
| class Dummy(object): |
| def __init__(self, init): |
| for k, v in init.items(): |
| self.__dict__[k] = v |
| |
| def getExtendedAttribute(self, name): |
| return None |
| |
| input_file = sys.argv[1] |
| output_base = sys.argv[2] |
| |
| shared.try_delete(output_base + '.cpp') |
| shared.try_delete(output_base + '.js') |
| |
| p = WebIDL.Parser() |
| p.parse(r''' |
| interface VoidPtr { |
| }; |
| ''' + open(input_file).read()) |
| data = p.finish() |
| |
| interfaces = {} |
| implements = {} |
| enums = {} |
| |
| for thing in data: |
| if isinstance(thing, WebIDL.IDLInterface): |
| interfaces[thing.identifier.name] = thing |
| elif isinstance(thing, WebIDL.IDLImplementsStatement): |
| implements.setdefault(thing.implementor.identifier.name, []).append(thing.implementee.identifier.name) |
| elif isinstance(thing, WebIDL.IDLEnum): |
| enums[thing.identifier.name] = thing |
| |
| #print interfaces |
| #print implements |
| |
| pre_c = [] |
| mid_c = [] |
| mid_js = [] |
| |
| pre_c += [r''' |
| #include <emscripten.h> |
| '''] |
| |
| mid_c += [r''' |
| extern "C" { |
| '''] |
| |
| def build_constructor(name): |
| implementing_name = implements[name][0] if implements.get(name) else 'WrapperObject' |
| return [r'''{name}.prototype = Object.create({implementing}.prototype); |
| {name}.prototype.constructor = {name}; |
| {name}.prototype.__class__ = {name}; |
| {name}.__cache__ = {{}}; |
| Module['{name}'] = {name}; |
| '''.format(name=name, implementing=implementing_name)] |
| |
| |
| mid_js += [''' |
| // Bindings utilities |
| |
| function WrapperObject() { |
| } |
| '''] |
| |
| mid_js += build_constructor('WrapperObject') |
| |
| mid_js += [''' |
| function getCache(__class__) { |
| return (__class__ || WrapperObject).__cache__; |
| } |
| Module['getCache'] = getCache; |
| |
| function wrapPointer(ptr, __class__) { |
| var cache = getCache(__class__); |
| var ret = cache[ptr]; |
| if (ret) return ret; |
| ret = Object.create((__class__ || WrapperObject).prototype); |
| ret.ptr = ptr; |
| 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 |
| delete getCache(obj.__class__)[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; |
| |
| // Converts big (string or array) values into a C-style storage, in temporary space |
| |
| var ensureCache = { |
| buffer: 0, // the main buffer of temporary storage |
| size: 0, // the size of buffer |
| pos: 0, // the next free offset in buffer |
| temps: [], // extra allocations |
| needed: 0, // the total size we need next time |
| |
| prepare: function() { |
| if (ensureCache.needed) { |
| // clear the temps |
| for (var i = 0; i < ensureCache.temps.length; i++) { |
| Module['_free'](ensureCache.temps[i]); |
| } |
| ensureCache.temps.length = 0; |
| // prepare to allocate a bigger buffer |
| Module['_free'](ensureCache.buffer); |
| ensureCache.buffer = 0; |
| ensureCache.size += ensureCache.needed; |
| // clean up |
| ensureCache.needed = 0; |
| } |
| if (!ensureCache.buffer) { // happens first time, or when we need to grow |
| ensureCache.size += 128; // heuristic, avoid many small grow events |
| ensureCache.buffer = Module['_malloc'](ensureCache.size); |
| assert(ensureCache.buffer); |
| } |
| ensureCache.pos = 0; |
| }, |
| alloc: function(array, view) { |
| assert(ensureCache.buffer); |
| var bytes = view.BYTES_PER_ELEMENT; |
| var len = array.length * bytes; |
| len = (len + 7) & -8; // keep things aligned to 8 byte boundaries |
| var ret; |
| if (ensureCache.pos + len >= ensureCache.size) { |
| // we failed to allocate in the buffer, ensureCache time around :( |
| assert(len > 0); // null terminator, at least |
| ensureCache.needed += len; |
| ret = Module['_malloc'](len); |
| ensureCache.temps.push(ret); |
| } else { |
| // we can allocate in the buffer |
| ret = ensureCache.buffer + ensureCache.pos; |
| ensureCache.pos += len; |
| } |
| return ret; |
| }, |
| copy: function(array, view, offset) { |
| var offsetShifted = offset; |
| var bytes = view.BYTES_PER_ELEMENT; |
| switch (bytes) { |
| case 2: offsetShifted >>= 1; break; |
| case 4: offsetShifted >>= 2; break; |
| case 8: offsetShifted >>= 3; break; |
| } |
| for (var i = 0; i < array.length; i++) { |
| view[offsetShifted + i] = array[i]; |
| } |
| }, |
| }; |
| |
| function ensureString(value) { |
| if (typeof value === 'string') { |
| var intArray = intArrayFromString(value); |
| var offset = ensureCache.alloc(intArray, HEAP8); |
| ensureCache.copy(intArray, HEAP8, offset); |
| return offset; |
| } |
| return value; |
| } |
| function ensureInt8(value) { |
| if (typeof value === 'object') { |
| var offset = ensureCache.alloc(value, HEAP8); |
| ensureCache.copy(value, HEAP8, offset); |
| return offset; |
| } |
| return value; |
| } |
| function ensureInt16(value) { |
| if (typeof value === 'object') { |
| var offset = ensureCache.alloc(value, HEAP16); |
| ensureCache.copy(value, HEAP16, offset); |
| return offset; |
| } |
| return value; |
| } |
| function ensureInt32(value) { |
| if (typeof value === 'object') { |
| var offset = ensureCache.alloc(value, HEAP32); |
| ensureCache.copy(value, HEAP32, offset); |
| return offset; |
| } |
| return value; |
| } |
| function ensureFloat32(value) { |
| if (typeof value === 'object') { |
| var offset = ensureCache.alloc(value, HEAPF32); |
| ensureCache.copy(value, HEAPF32, offset); |
| return offset; |
| } |
| return value; |
| } |
| function ensureFloat64(value) { |
| if (typeof value === 'object') { |
| var offset = ensureCache.alloc(value, HEAPF64); |
| ensureCache.copy(value, HEAPF64, offset); |
| return offset; |
| } |
| return value; |
| } |
| |
| '''] |
| |
| mid_c += [''' |
| // Not using size_t for array indices as the values used by the javascript code are signed. |
| void array_bounds_check(const int array_size, const int array_idx) { |
| if (array_idx < 0 || array_idx >= array_size) { |
| EM_ASM({ |
| throw 'Array index ' + $0 + ' out of bounds: [0,' + $1 + ')'; |
| }, array_idx, array_size); |
| } |
| } |
| '''] |
| |
| C_FLOATS = ['float', 'double'] |
| |
| def full_typename(arg): |
| return ('const ' if arg.getExtendedAttribute('Const') else '') + arg.type.name + ('[]' if arg.type.isArray() else '') |
| |
| def type_to_c(t, non_pointing=False): |
| #print 'to c ', t |
| def base_type_to_c(t): |
| if t == 'Long': |
| ret = 'int' |
| elif t == 'UnsignedLong': |
| ret = 'unsigned int' |
| elif t == 'Short': |
| ret = 'short' |
| elif t == 'UnsignedShort': |
| ret = 'unsigned short' |
| elif t == 'Byte': |
| ret = 'char' |
| elif t == 'Octet': |
| ret = 'unsigned char' |
| elif t == 'Void': |
| ret = 'void' |
| elif t == 'String': |
| ret = 'char*' |
| elif t == 'Float': |
| ret = 'float' |
| elif t == 'Double': |
| ret = 'double' |
| elif t == 'Boolean': |
| ret = 'bool' |
| elif t == 'Any' or t == 'VoidPtr': |
| ret = 'void*' |
| elif t in interfaces: |
| ret = (interfaces[t].getExtendedAttribute('Prefix') or [''])[0] + t + ('' if non_pointing else '*') |
| else: |
| ret = t |
| return ret |
| |
| t = t.replace(' (Wrapper)', '') |
| |
| prefix = '' |
| suffix = '' |
| if '[]' in t: |
| t = t.replace('[]', '') |
| suffix = '*' |
| if 'const ' in t: |
| t = t.replace('const ', '') |
| prefix = 'const ' |
| return prefix + base_type_to_c(t) + suffix |
| |
| def take_addr_if_nonpointer(m): |
| if m.getExtendedAttribute('Ref') or m.getExtendedAttribute('Value'): |
| return '&' |
| return '' |
| |
| def deref_if_nonpointer(m): |
| if m.getExtendedAttribute('Ref') or m.getExtendedAttribute('Value'): |
| return '*' |
| return '' |
| |
| def type_to_cdec(raw): |
| name = ret = type_to_c(raw.type.name, non_pointing=True) |
| if raw.getExtendedAttribute('Const'): ret = 'const ' + ret |
| if name not in interfaces: return ret |
| if raw.getExtendedAttribute('Ref'): |
| return ret + '&' |
| if raw.getExtendedAttribute('Value'): |
| return ret |
| return ret + '*' |
| |
| def render_function(class_name, func_name, sigs, return_type, non_pointer, copy, operator, constructor, func_scope, call_content=None, const=False, array_attribute=False): |
| global mid_c, mid_js, js_impl_methods |
| |
| legacy_mode = CHECKS not in ['ALL', 'FAST'] |
| all_checks = CHECKS == 'ALL' |
| |
| bindings_name = class_name + '_' + func_name |
| min_args = min(sigs.keys()) |
| max_args = max(sigs.keys()) |
| |
| all_args = sigs.get(max_args) |
| |
| if DEBUG: |
| print('renderfunc', class_name, func_name, list(sigs.keys()), return_type, constructor) |
| for i in range(max_args): |
| a = all_args[i] |
| if isinstance(a, WebIDL.IDLArgument): |
| print((" arg%d" % i), a.identifier, a.type, a.optional) |
| else: |
| print(" arg%d" % i) |
| |
| # JS |
| |
| cache = ('getCache(%s)[this.ptr] = this;' % class_name) if constructor else '' |
| call_prefix = '' if not constructor else 'this.ptr = ' |
| call_postfix = '' |
| if return_type != 'Void' and not constructor: call_prefix = 'return ' |
| if not constructor: |
| if return_type in interfaces: |
| call_prefix += 'wrapPointer(' |
| call_postfix += ', ' + return_type + ')' |
| elif return_type == 'String': |
| call_prefix += 'Pointer_stringify(' |
| call_postfix += ')' |
| elif return_type == 'Boolean': |
| call_prefix += '!!(' |
| call_postfix += ')' |
| |
| args = ['arg%d' % i for i in range(max_args)] |
| if not constructor: |
| body = ' var self = this.ptr;\n' |
| pre_arg = ['self'] |
| else: |
| body = '' |
| pre_arg = [] |
| |
| if any(arg.type.isString() or arg.type.isArray() for arg in all_args): |
| body += ' ensureCache.prepare();\n' |
| |
| full_name = "%s::%s" % (class_name, func_name) |
| |
| for i, (js_arg, arg) in enumerate(zip(args, all_args)): |
| if i >= min_args: |
| optional = True |
| else: |
| optional = False |
| do_default = False |
| # Filter out arguments we don't know how to parse. Fast casing only common cases. |
| compatible_arg = isinstance(arg, Dummy) or (isinstance(arg, WebIDL.IDLArgument) and arg.optional is False) |
| # note: null has typeof object, but is ok to leave as is, since we are calling into asm code where null|0 = 0 |
| if not legacy_mode and compatible_arg: |
| if isinstance(arg, WebIDL.IDLArgument): |
| arg_name = arg.identifier.name |
| else: |
| arg_name = '' |
| # Format assert fail message |
| check_msg = "[CHECK FAILED] %s(%s:%s): " % (full_name, js_arg, arg_name) |
| if isinstance(arg.type, WebIDL.IDLWrapperType): |
| inner = arg.type.inner |
| else: |
| inner = "" |
| |
| # Print type info in comments. |
| body += " /* %s <%s> [%s] */\n" % (js_arg, arg.type.name, inner) |
| |
| # Wrap asserts with existence check when argument is optional. |
| if all_checks and optional: body += "if(typeof {0} !== 'undefined' && {0} !== null) {{\n".format(js_arg) |
| # Special case argument types. |
| if arg.type.isNumeric(): |
| if arg.type.isInteger(): |
| if all_checks: body += " assert(typeof {0} === 'number' && !isNaN({0}), '{1}Expecting <integer>');\n".format(js_arg, check_msg) |
| else: |
| if all_checks: body += " assert(typeof {0} === 'number', '{1}Expecting <number>');\n".format(js_arg, check_msg) |
| # No transform needed for numbers |
| elif arg.type.isBoolean(): |
| if all_checks: body += " assert(typeof {0} === 'boolean' || (typeof {0} === 'number' && !isNaN({0})), '{1}Expecting <boolean>');\n".format(js_arg, check_msg) |
| # No transform needed for booleans |
| elif arg.type.isString(): |
| # Strings can be DOM strings or pointers. |
| if all_checks: body += " assert(typeof {0} === 'string' || ({0} && typeof {0} === 'object' && typeof {0}.ptr === 'number'), '{1}Expecting <string>');\n".format(js_arg, check_msg) |
| do_default = True # legacy path is fast enough for strings. |
| elif arg.type.isInterface(): |
| if all_checks: body += " assert(typeof {0} === 'object' && typeof {0}.ptr === 'number', '{1}Expecting <pointer>');\n".format(js_arg, check_msg) |
| if optional: |
| body += " if(typeof {0} !== 'undefined' && {0} !== null) {{ {0} = {0}.ptr }};\n".format(js_arg) |
| else: |
| # No checks in fast mode when the arg is required |
| body += " {0} = {0}.ptr;\n".format(js_arg) |
| else: |
| do_default = True |
| |
| if all_checks and optional: body += "}\n" |
| else: |
| do_default = True |
| |
| if do_default: |
| if not (arg.type.isArray() and not array_attribute): |
| body += " if ({0} && typeof {0} === 'object') {0} = {0}.ptr;\n".format(js_arg) |
| if arg.type.isString(): |
| body += " else {0} = ensureString({0});\n".format(js_arg) |
| else: |
| # an array can be received here |
| arg_type = arg.type.name |
| if arg_type in ['Byte', 'Octet']: |
| body += " if (typeof {0} == 'object') {{ {0} = ensureInt8({0}); }}\n".format(js_arg) |
| elif arg_type in ['Short', 'UnsignedShort']: |
| body += " if (typeof {0} == 'object') {{ {0} = ensureInt16({0}); }}\n".format(js_arg) |
| elif arg_type in ['Long', 'UnsignedLong']: |
| body += " if (typeof {0} == 'object') {{ {0} = ensureInt32({0}); }}\n".format(js_arg) |
| elif arg_type == 'Float': |
| body += " if (typeof {0} == 'object') {{ {0} = ensureFloat32({0}); }}\n".format(js_arg) |
| elif arg_type == 'Double': |
| body += " if (typeof {0} == 'object') {{ {0} = ensureFloat64({0}); }}\n".format(js_arg) |
| |
| c_names = {} |
| for i in range(min_args, max_args): |
| c_names[i] = 'emscripten_bind_%s_%d' % (bindings_name, i) |
| body += ' if (%s === undefined) { %s%s(%s)%s%s }\n' % (args[i], call_prefix, '_' + c_names[i], ', '.join(pre_arg + args[:i]), call_postfix, '' if 'return ' in call_prefix else '; ' + (cache or ' ') + 'return') |
| c_names[max_args] = 'emscripten_bind_%s_%d' % (bindings_name, max_args) |
| body += ' %s%s(%s)%s;\n' % (call_prefix, '_' + c_names[max_args], ', '.join(pre_arg + args), call_postfix) |
| if cache: |
| body += ' ' + cache + '\n' |
| mid_js += [r'''%sfunction%s(%s) { |
| %s |
| };''' % (CONSTRUCTOR_CLOSURE_SUPPRESSIONS, (' ' + func_name) if constructor else '', ', '.join(args), body[:-1])] |
| |
| # C |
| |
| for i in range(min_args, max_args+1): |
| raw = sigs.get(i) |
| if raw is None: continue |
| sig = list(map(full_typename, raw)) |
| if array_attribute: |
| sig = [x.replace('[]', '') for x in sig] # for arrays, ignore that this is an array - our get/set methods operate on the elements |
| |
| c_arg_types = list(map(type_to_c, sig)) |
| |
| normal_args = ', '.join(['%s %s' % (c_arg_types[j], args[j]) for j in range(i)]) |
| if constructor: |
| full_args = normal_args |
| else: |
| full_args = type_to_c(class_name, non_pointing=True) + '* self' + ('' if not normal_args else ', ' + normal_args) |
| call_args = ', '.join(['%s%s' % ('*' if raw[j].getExtendedAttribute('Ref') else '', args[j]) for j in range(i)]) |
| if constructor: |
| call = 'new ' + type_to_c(class_name, non_pointing=True) |
| call += '(' + call_args + ')' |
| elif call_content is not None: |
| call = call_content |
| else: |
| call = 'self->' + func_name |
| call += '(' + call_args + ')' |
| |
| if operator: |
| cast_self = 'self' |
| if class_name != func_scope: |
| # this function comes from an ancestor class; for operators, we must cast it |
| cast_self = 'dynamic_cast<' + type_to_c(func_scope) + '>(' + cast_self + ')' |
| maybe_deref = deref_if_nonpointer(raw[0]) |
| if '=' in operator: |
| call = '(*%s %s %s%s)' % (cast_self, operator, maybe_deref, args[0]) |
| elif operator == '[]': |
| call = '((*%s)[%s%s])' % (cast_self, maybe_deref, args[0]) |
| else: |
| raise Exception('unfamiliar operator ' + operator) |
| |
| pre = '' |
| |
| basic_return = 'return ' if constructor or return_type is not 'Void' else '' |
| return_prefix = basic_return |
| return_postfix = '' |
| if non_pointer: |
| return_prefix += '&'; |
| if copy: |
| pre += ' static %s temp;\n' % type_to_c(return_type, non_pointing=True) |
| return_prefix += '(temp = ' |
| return_postfix += ', &temp)' |
| |
| c_return_type = type_to_c(return_type) |
| maybe_const = 'const ' if const else '' |
| mid_c += [r''' |
| %s%s EMSCRIPTEN_KEEPALIVE %s(%s) { |
| %s %s%s%s; |
| } |
| ''' % (maybe_const, type_to_c(class_name) if constructor else c_return_type, c_names[i], full_args, pre, return_prefix, call, return_postfix)] |
| |
| if not constructor: |
| if i == max_args: |
| dec_args = ', '.join([type_to_cdec(raw[j]) + ' ' + args[j] for j in range(i)]) |
| js_call_args = ', '.join(['%s%s' % (('(int)' if sig[j] in interfaces else '') + take_addr_if_nonpointer(raw[j]), args[j]) for j in range(i)]) |
| |
| js_impl_methods += [r''' %s %s(%s) %s { |
| %sEM_ASM_%s({ |
| var self = Module['getCache'](Module['%s'])[$0]; |
| if (!self.hasOwnProperty('%s')) throw 'a JSImplementation must implement all functions, you forgot %s::%s.'; |
| %sself['%s'](%s)%s; |
| }, (int)this%s); |
| }''' % (c_return_type, func_name, dec_args, maybe_const, |
| basic_return, 'INT' if c_return_type not in C_FLOATS else 'DOUBLE', |
| class_name, |
| func_name, class_name, func_name, |
| return_prefix, |
| func_name, |
| ','.join(['$%d' % i for i in range(1, max_args + 1)]), |
| return_postfix, |
| (', ' if js_call_args else '') + js_call_args)] |
| |
| |
| for name, interface in interfaces.items(): |
| js_impl = interface.getExtendedAttribute('JSImplementation') |
| if not js_impl: continue |
| implements[name] = [js_impl[0]] |
| |
| # Compute the height in the inheritance tree of each node. Note that the order of interation |
| # of `implements` is irrelevant. |
| # |
| # After one iteration of the loop, all ancestors of child are guaranteed to have a a larger |
| # height number than the child, and this is recursively true for each ancestor. If the height |
| # of child is later increased, all its ancestors will be readjusted at that time to maintain |
| # that invariant. Further, the height of a node never decreases. Therefore, when the loop |
| # finishes, all ancestors of a given node should have a larger height number than that node. |
| nodeHeight = {} |
| for child, parent in implements.items(): |
| parent = parent[0] |
| while parent: |
| nodeHeight[parent] = max(nodeHeight.get(parent, 0), nodeHeight.get(child, 0) + 1) |
| grandParent = implements.get(parent) |
| if grandParent: |
| child = parent |
| parent = grandParent[0] |
| else: |
| parent = None |
| |
| names = sorted(interfaces.keys(), key=lambda x: nodeHeight.get(x, 0), reverse=True) |
| |
| for name in names: |
| interface = interfaces[name] |
| |
| mid_js += ['\n// ' + name + '\n'] |
| mid_c += ['\n// ' + name + '\n'] |
| |
| global js_impl_methods |
| js_impl_methods = [] |
| |
| cons = interface.getExtendedAttribute('Constructor') |
| if type(cons) == list: raise Exception('do not use "Constructor", instead create methods with the name of the interface') |
| |
| js_impl = interface.getExtendedAttribute('JSImplementation') |
| if js_impl: |
| js_impl = js_impl[0] |
| |
| # Methods |
| |
| # Ensure a constructor even if one is not specified. |
| if not any(m.identifier.name == name for m in interface.members): |
| mid_js += ['%sfunction %s() { throw "cannot construct a %s, no constructor in IDL" }\n' % (CONSTRUCTOR_CLOSURE_SUPPRESSIONS, name, name)] |
| mid_js += build_constructor(name) |
| |
| for m in interface.members: |
| if not m.isMethod(): continue |
| constructor = m.identifier.name == name |
| if not constructor: |
| parent_constructor = False |
| temp = m.parentScope |
| while temp.parentScope: |
| if temp.identifier.name == m.identifier.name: |
| parent_constructor = True |
| temp = temp.parentScope |
| if parent_constructor: |
| continue |
| if not constructor: |
| mid_js += [r''' |
| %s.prototype['%s'] = %s.prototype.%s = ''' % (name, m.identifier.name, name, m.identifier.name)] |
| sigs = {} |
| return_type = None |
| for ret, args in m.signatures(): |
| if return_type is None: |
| return_type = ret.name |
| else: |
| assert return_type == ret.name, 'overloads must have the same return type' |
| for i in range(len(args)+1): |
| if i == len(args) or args[i].optional: |
| assert i not in sigs, 'overloading must differentiate by # of arguments (cannot have two signatures that differ by types but not by length)' |
| sigs[i] = args[:i] |
| render_function(name, |
| m.identifier.name, sigs, return_type, |
| m.getExtendedAttribute('Ref'), |
| m.getExtendedAttribute('Value'), |
| (m.getExtendedAttribute('Operator') or [None])[0], |
| constructor, |
| func_scope=m.parentScope.identifier.name, |
| const=m.getExtendedAttribute('Const')) |
| mid_js += [';\n'] |
| if constructor: |
| mid_js += build_constructor(name) |
| |
| for m in interface.members: |
| if not m.isAttr(): continue |
| attr = m.identifier.name |
| |
| if m.type.isArray(): |
| get_sigs = { 1: [Dummy({ 'type': WebIDL.BuiltinTypes[WebIDL.IDLBuiltinType.Types.long] })] } |
| set_sigs = { 2: [Dummy({ 'type': WebIDL.BuiltinTypes[WebIDL.IDLBuiltinType.Types.long] }), |
| Dummy({ 'type': m.type })] } |
| get_call_content = take_addr_if_nonpointer(m) + 'self->' + attr + '[arg0]' |
| set_call_content = 'self->' + attr + '[arg0] = ' + deref_if_nonpointer(m) + 'arg1' |
| if m.getExtendedAttribute('BoundsChecked'): |
| bounds_check = "array_bounds_check(sizeof(self->%s) / sizeof(self->%s[0]), arg0)" % (attr, attr) |
| get_call_content = "(%s, %s)" % (bounds_check, get_call_content) |
| set_call_content = "(%s, %s)" % (bounds_check, set_call_content) |
| else: |
| get_sigs = { 0: [] } |
| set_sigs = { 1: [Dummy({ 'type': m.type })] } |
| get_call_content = take_addr_if_nonpointer(m) + 'self->' + attr |
| set_call_content = 'self->' + attr + ' = ' + deref_if_nonpointer(m) + 'arg0' |
| |
| get_name = 'get_' + attr |
| mid_js += [r''' |
| %s.prototype['%s'] = %s.prototype.%s = ''' % (name, get_name, name, get_name)] |
| render_function(name, |
| get_name, get_sigs, m.type.name, |
| None, |
| None, |
| None, |
| False, |
| func_scope=interface, |
| call_content=get_call_content, |
| const=m.getExtendedAttribute('Const'), |
| array_attribute=m.type.isArray()) |
| |
| if m.readonly: |
| mid_js += [r''' |
| Object.defineProperty(%s.prototype, '%s', { get: %s.prototype.%s }) ''' % (name, attr, name, get_name)] |
| else: |
| set_name = 'set_' + attr |
| mid_js += [r''' |
| %s.prototype['%s'] = %s.prototype.%s = ''' % (name, set_name, name, set_name)] |
| render_function(name, |
| set_name, set_sigs, 'Void', |
| None, |
| None, |
| None, |
| False, |
| func_scope=interface, |
| call_content=set_call_content, |
| const=m.getExtendedAttribute('Const'), |
| array_attribute=m.type.isArray()) |
| mid_js += [r''' |
| Object.defineProperty(%s.prototype, '%s', { get: %s.prototype.%s, set: %s.prototype.%s }) ''' % (name, attr, name, get_name, name, set_name)] |
| |
| |
| if not interface.getExtendedAttribute('NoDelete'): |
| mid_js += [r''' |
| %s.prototype['__destroy__'] = %s.prototype.__destroy__ = ''' % (name, name)] |
| render_function(name, |
| '__destroy__', { 0: [] }, 'Void', |
| None, |
| None, |
| None, |
| False, |
| func_scope=interface, |
| call_content='delete self') |
| |
| # Emit C++ class implementation that calls into JS implementation |
| |
| if js_impl: |
| pre_c += [r''' |
| class %s : public %s { |
| public: |
| %s |
| }; |
| ''' % (name, type_to_c(js_impl, non_pointing=True), '\n'.join(js_impl_methods))] |
| |
| deferred_js = [] |
| |
| for name, enum in enums.items(): |
| mid_c += ['\n// ' + name + '\n'] |
| deferred_js += ['\n', '// ' + name + '\n'] |
| for value in enum.values(): |
| function_id = "%s_%s" % (name, value.split('::')[-1]) |
| function_id = 'emscripten_enum_%s' % function_id |
| mid_c += [r'''%s EMSCRIPTEN_KEEPALIVE %s() { |
| return %s; |
| } |
| ''' % (name, function_id, value)] |
| symbols = value.split('::') |
| if len(symbols) == 1: |
| identifier = symbols[0] |
| deferred_js += ["Module['%s'] = _%s();\n" % (identifier, function_id)] |
| elif len(symbols) == 2: |
| [namespace, identifier] = symbols |
| if namespace in interfaces: |
| # namespace is a class |
| deferred_js += ["Module['%s']['%s'] = _%s();\n" % \ |
| (namespace, identifier, function_id)] |
| else: |
| # namespace is a namespace, so the enums get collapsed into the top level namespace. |
| deferred_js += ["Module['%s'] = _%s();\n" % (identifier, function_id)] |
| else: |
| raise Exception("Illegal enum value %s" % value) |
| |
| mid_c += ['\n}\n\n'] |
| mid_js += [''' |
| (function() { |
| function setupEnums() { |
| %s |
| } |
| if (Module['calledRun']) setupEnums(); |
| else addOnPreMain(setupEnums); |
| })(); |
| ''' % '\n '.join(deferred_js)] |
| |
| # Write |
| |
| with open(output_base + '.cpp', 'w') as c: |
| for x in pre_c: c.write(x) |
| for x in mid_c: c.write(x) |
| |
| with open(output_base + '.js', 'w') as js: |
| for x in mid_js: js.write(x) |
| |
