3221 lines
138 KiB
Python
3221 lines
138 KiB
Python
#!/usr/bin/env python2
|
|
#
|
|
# Generate initialization data for built-in strings and objects.
|
|
#
|
|
# Supports two different initialization approaches:
|
|
#
|
|
# 1. Bit-packed format for unpacking strings and objects during
|
|
# heap or thread init into RAM-based structures. This is the
|
|
# default behavior.
|
|
#
|
|
# 2. Embedding strings and/or objects into a read-only data section
|
|
# at compile time. This is useful for low memory targets to reduce
|
|
# memory usage. Objects in data section will be immutable.
|
|
#
|
|
# Both of these have practical complications like endianness differences,
|
|
# pointer compression variants, object property table layout variants,
|
|
# and so on. Multiple #if defined()'d initializer sections are emitted
|
|
# to cover all supported alternatives.
|
|
#
|
|
|
|
import logging
|
|
import sys
|
|
logging.basicConfig(level=logging.INFO, stream=sys.stdout, format='%(name)-21s %(levelname)-7s %(message)s')
|
|
logger = logging.getLogger('genbuiltins.py')
|
|
logger.setLevel(logging.INFO)
|
|
|
|
import os
|
|
import re
|
|
import traceback
|
|
import json
|
|
import yaml
|
|
import math
|
|
import struct
|
|
import optparse
|
|
import copy
|
|
import logging
|
|
|
|
import dukutil
|
|
|
|
# Fixed seed for ROM strings, must match src-input/duk_heap_alloc.c.
|
|
DUK__FIXED_HASH_SEED = 0xabcd1234
|
|
|
|
# Base value for compressed ROM pointers, used range is [ROMPTR_FIRST,0xffff].
|
|
# Must match DUK_USE_ROM_PTRCOMP_FIRST (generated header checks).
|
|
ROMPTR_FIRST = 0xf800 # 2048 should be enough; now around ~1000 used
|
|
|
|
# ROM string table size
|
|
ROMSTR_LOOKUP_SIZE = 256
|
|
|
|
#
|
|
# Miscellaneous helpers
|
|
#
|
|
|
|
# Convert Unicode to bytes, identifying Unicode U+0000 to U+00FF as bytes.
|
|
# This representation is used in YAML metadata and allows invalid UTF-8 to
|
|
# be represented exactly (which is necessary).
|
|
def unicode_to_bytes(x):
|
|
if isinstance(x, str):
|
|
return x
|
|
tmp = ''
|
|
for c in x:
|
|
if ord(c) > 0xff:
|
|
raise Exception('invalid codepoint: %r' % x)
|
|
tmp += chr(ord(c))
|
|
assert(isinstance(tmp, str))
|
|
return tmp
|
|
|
|
# Convert bytes to Unicode, identifying bytes as U+0000 to U+00FF.
|
|
def bytes_to_unicode(x):
|
|
if isinstance(x, unicode):
|
|
return x
|
|
tmp = u''
|
|
for c in x:
|
|
tmp += unichr(ord(c))
|
|
assert(isinstance(tmp, unicode))
|
|
return tmp
|
|
|
|
# Convert all strings in an object to bytes recursively. Useful for
|
|
# normalizing all strings in a YAML document.
|
|
def recursive_strings_to_bytes(doc):
|
|
def f(x):
|
|
if isinstance(x, unicode):
|
|
return unicode_to_bytes(x)
|
|
if isinstance(x, dict):
|
|
res = {}
|
|
for k in x.keys():
|
|
res[f(k)] = f(x[k])
|
|
return res
|
|
if isinstance(x, list):
|
|
res = []
|
|
for e in x:
|
|
res.append(f(e))
|
|
return res
|
|
return x
|
|
|
|
return f(doc)
|
|
|
|
# Convert all strings in an object to from bytes to Unicode recursively.
|
|
# Useful for writing back JSON/YAML dumps.
|
|
def recursive_bytes_to_strings(doc):
|
|
def f(x):
|
|
if isinstance(x, str):
|
|
return bytes_to_unicode(x)
|
|
if isinstance(x, dict):
|
|
res = {}
|
|
for k in x.keys():
|
|
res[f(k)] = f(x[k])
|
|
return res
|
|
if isinstance(x, list):
|
|
res = []
|
|
for e in x:
|
|
res.append(f(e))
|
|
return res
|
|
return x
|
|
|
|
return f(doc)
|
|
|
|
# Check if string is an "array index" in ECMAScript terms.
|
|
def string_is_arridx(v):
|
|
is_arridx = False
|
|
try:
|
|
ival = int(v)
|
|
if ival >= 0 and ival <= 0xfffffffe and ('%d' % ival == v):
|
|
is_arridx = True
|
|
except ValueError:
|
|
pass
|
|
|
|
return is_arridx
|
|
|
|
#
|
|
# Metadata loading, merging, and other preprocessing
|
|
#
|
|
# Final metadata object contains merged and normalized objects and strings.
|
|
# Keys added include (see more below):
|
|
#
|
|
# strings_stridx: string objects which have a stridx, matches stridx index order
|
|
# objects_bidx: objects which have a bidx, matches bidx index order
|
|
# objects_ram_toplevel: objects which are top level for RAM init
|
|
#
|
|
# Various helper keys are also added, containing auxiliary object/string
|
|
# lists, lookup maps, etc. See code below for details of these.
|
|
#
|
|
|
|
def metadata_lookup_object(meta, obj_id):
|
|
return meta['_objid_to_object'][obj_id]
|
|
|
|
def metadata_lookup_object_and_index(meta, obj_id):
|
|
for i,t in enumerate(meta['objects']):
|
|
if t['id'] == obj_id:
|
|
return t, i
|
|
return None, None
|
|
|
|
def metadata_lookup_property(obj, key):
|
|
for p in obj['properties']:
|
|
if p['key'] == key:
|
|
return p
|
|
return None
|
|
|
|
def metadata_lookup_property_and_index(obj, key):
|
|
for i,t in enumerate(obj['properties']):
|
|
if t['key'] == key:
|
|
return t, i
|
|
return None, None
|
|
|
|
# Remove disabled objects and properties.
|
|
def metadata_remove_disabled(meta, active_opts):
|
|
objlist = []
|
|
|
|
count_disabled_object = 0
|
|
count_notneeded_object = 0
|
|
count_disabled_property = 0
|
|
count_notneeded_property = 0
|
|
|
|
def present_if_check(v):
|
|
pi = v.get('present_if', None)
|
|
if pi is None:
|
|
return True
|
|
if isinstance(pi, (str, unicode)):
|
|
pi = [ pi ]
|
|
if not isinstance(pi, list):
|
|
raise Exception('invalid present_if syntax: %r' % pi)
|
|
# Present if all listed options are true or unknown.
|
|
# Absent if any option is known to be false.
|
|
for opt in pi:
|
|
if active_opts.get(opt, None) == False:
|
|
return False
|
|
return True
|
|
|
|
for o in meta['objects']:
|
|
if o.get('disable', False):
|
|
logger.debug('Remove disabled object: %s' % o['id'])
|
|
count_disabled_object += 1
|
|
elif not present_if_check(o):
|
|
logger.debug('Removed object not needed in active configuration: %s' % o['id'])
|
|
count_notneeded_object += 1
|
|
else:
|
|
objlist.append(o)
|
|
|
|
props = []
|
|
for p in o['properties']:
|
|
if p.get('disable', False):
|
|
logger.debug('Remove disabled property: %s, object: %s' % (p['key'], o['id']))
|
|
count_disabled_property += 1
|
|
elif not present_if_check(p):
|
|
logger.debug('Removed property not needed in active configuration: %s, object: %s' % (p['key'], o['id']))
|
|
count_notneeded_property += 1
|
|
else:
|
|
props.append(p)
|
|
|
|
o['properties'] = props
|
|
|
|
meta['objects'] = objlist
|
|
|
|
if count_disabled_object + count_notneeded_object + count_disabled_property + count_notneeded_property > 0:
|
|
logger.info('Removed %d objects (%d disabled, %d not needed by config), %d properties (%d disabled, %d not needed by config)' % (count_disabled_object + count_notneeded_object, count_disabled_object, count_notneeded_object, count_disabled_property + count_notneeded_property, count_disabled_property, count_notneeded_property))
|
|
|
|
# Delete dangling references to removed/missing objects.
|
|
def metadata_delete_dangling_references_to_object(meta, obj_id):
|
|
for o in meta['objects']:
|
|
new_p = []
|
|
for p in o['properties']:
|
|
v = p['value']
|
|
ptype = None
|
|
if isinstance(v, dict):
|
|
ptype = p['value']['type']
|
|
delprop = False
|
|
if ptype == 'object' and v['id'] == obj_id:
|
|
delprop = True
|
|
if ptype == 'accessor' and v.get('getter_id') == obj_id:
|
|
p['getter_id'] = None
|
|
if ptype == 'accessor' and v.get('setter_id') == obj_id:
|
|
p['setter_id'] = None
|
|
# XXX: Should empty accessor (= no getter, no setter) be deleted?
|
|
# If so, beware of shorthand.
|
|
if delprop:
|
|
logger.debug('Deleted property %s of object %s, points to deleted object %s' % \
|
|
(p['key'], o['id'], obj_id))
|
|
else:
|
|
new_p.append(p)
|
|
o['properties'] = new_p
|
|
|
|
# Merge a user YAML file into current metadata.
|
|
def metadata_merge_user_objects(meta, user_meta):
|
|
if user_meta.has_key('add_objects'):
|
|
raise Exception('"add_objects" removed, use "objects" with "add: True"')
|
|
if user_meta.has_key('replace_objects'):
|
|
raise Exception('"replace_objects" removed, use "objects" with "replace: True"')
|
|
if user_meta.has_key('modify_objects'):
|
|
raise Exception('"modify_objects" removed, use "objects" with "modify: True"')
|
|
|
|
for o in user_meta.get('objects', []):
|
|
if o.get('disable', False):
|
|
logger.debug('Skip disabled object: %s' % o['id'])
|
|
continue
|
|
targ, targ_idx = metadata_lookup_object_and_index(meta, o['id'])
|
|
|
|
if o.get('delete', False):
|
|
logger.debug('Delete object: %s' % targ['id'])
|
|
if targ is None:
|
|
raise Exception('Cannot delete object %s which doesn\'t exist' % o['id'])
|
|
meta['objects'].pop(targ_idx)
|
|
metadata_delete_dangling_references_to_object(meta, targ['id'])
|
|
continue
|
|
|
|
if o.get('replace', False):
|
|
logger.debug('Replace object %s' % o['id'])
|
|
if targ is None:
|
|
logger.warning('object to be replaced doesn\'t exist, append new object')
|
|
meta['objects'].append(o)
|
|
else:
|
|
meta['objects'][targ_idx] = o
|
|
continue
|
|
|
|
if o.get('add', False) or not o.get('modify', False): # 'add' is the default
|
|
logger.debug('Add object %s' % o['id'])
|
|
if targ is not None:
|
|
raise Exception('Cannot add object %s which already exists' % o['id'])
|
|
meta['objects'].append(o)
|
|
continue
|
|
|
|
assert(o.get('modify', False)) # modify handling
|
|
if targ is None:
|
|
raise Exception('Cannot modify object %s which doesn\'t exist' % o['id'])
|
|
|
|
for k in sorted(o.keys()):
|
|
# Merge top level keys by copying over, except 'properties'
|
|
if k == 'properties':
|
|
continue
|
|
targ[k] = o[k]
|
|
for p in o.get('properties', []):
|
|
if p.get('disable', False):
|
|
logger.debug('Skip disabled property: %s' % p['key'])
|
|
continue
|
|
prop = None
|
|
prop_idx = None
|
|
prop, prop_idx = metadata_lookup_property_and_index(targ, p['key'])
|
|
if prop is not None:
|
|
if p.get('delete', False):
|
|
logger.debug('Delete property %s of %s' % (p['key'], o['id']))
|
|
targ['properties'].pop(prop_idx)
|
|
else:
|
|
logger.debug('Replace property %s of %s' % (p['key'], o['id']))
|
|
targ['properties'][prop_idx] = p
|
|
else:
|
|
if p.get('delete', False):
|
|
logger.debug('Deleting property %s of %s: doesn\'t exist, nop' % (p['key'], o['id']))
|
|
else:
|
|
logger.debug('Add property %s of %s' % (p['key'], o['id']))
|
|
targ['properties'].append(p)
|
|
|
|
# Replace 'symbol' keys and values with encoded strings.
|
|
def format_symbol(sym):
|
|
#print(repr(sym))
|
|
assert(isinstance(sym, dict))
|
|
assert(sym.get('type', None) == 'symbol')
|
|
variant = sym['variant']
|
|
if variant == 'global':
|
|
return '\x80' + sym['string']
|
|
elif variant == 'wellknown':
|
|
# Well known symbols use an empty suffix which never occurs for
|
|
# runtime local symbols.
|
|
return '\x81' + sym['string'] + '\xff'
|
|
elif variant == 'userhidden':
|
|
return '\xff' + sym['string']
|
|
elif variant == 'hidden': # hidden == Duktape hidden Symbol
|
|
return '\x82' + sym['string']
|
|
raise Exception('invalid symbol variant %r' % variant)
|
|
|
|
def metadata_normalize_symbol_strings(meta):
|
|
for o in meta['strings']:
|
|
if isinstance(o['str'], dict) and o['str'].get('type') == 'symbol':
|
|
o['str'] = format_symbol(o['str'])
|
|
#print('normalized symbol as string list element: %r', o)
|
|
|
|
for o in meta['objects']:
|
|
for p in o['properties']:
|
|
if isinstance(p['key'], dict) and p['key'].get('type') == 'symbol':
|
|
p['key'] = format_symbol(p['key'])
|
|
#print('normalized symbol as property key: %r', p)
|
|
if isinstance(p['value'], dict) and p['value'].get('type') == 'symbol':
|
|
p['value'] = format_symbol(p['value'])
|
|
#print('normalized symbol as property value: %r', p)
|
|
|
|
# Normalize nargs for top level functions by defaulting 'nargs' from 'length'.
|
|
def metadata_normalize_nargs_length(meta):
|
|
# Default 'nargs' from 'length' for top level function objects.
|
|
for o in meta['objects']:
|
|
if o.has_key('nargs'):
|
|
continue
|
|
if not o.get('callable', False):
|
|
continue
|
|
for p in o['properties']:
|
|
if p['key'] != 'length':
|
|
continue
|
|
logger.debug('Default nargs for top level: %r' % p)
|
|
assert(isinstance(p['value'], int))
|
|
o['nargs'] = p['value']
|
|
break
|
|
assert(o.has_key('nargs'))
|
|
|
|
# Default 'nargs' from 'length' for function property shorthand.
|
|
for o in meta['objects']:
|
|
for p in o['properties']:
|
|
if not (isinstance(p['value'], dict) and p['value']['type'] == 'function'):
|
|
continue
|
|
pval = p['value']
|
|
if not pval.has_key('length'):
|
|
logger.debug('Default length for function shorthand: %r' % p)
|
|
pval['length'] = 0
|
|
if not pval.has_key('nargs'):
|
|
logger.debug('Default nargs for function shorthand: %r' % p)
|
|
pval['nargs'] = pval['length']
|
|
|
|
# Prepare a list of built-in objects which need a runtime 'bidx'.
|
|
def metadata_prepare_objects_bidx(meta):
|
|
objlist = meta['objects']
|
|
meta['objects'] = []
|
|
meta['objects_bidx'] = []
|
|
|
|
# Objects have a 'bidx: true' if they need a DUK_BIDX_xxx constant
|
|
# and need to be present in thr->builtins[]. The list is already
|
|
# stripped of built-in objects which are not needed based on config.
|
|
# Ideally we'd scan the actually needed indices from the source
|
|
# but since some usage is inside #if defined()s that's not trivial.
|
|
for obj in objlist:
|
|
if obj.get('bidx', False):
|
|
obj['bidx_used'] = True
|
|
meta['objects'].append(obj)
|
|
meta['objects_bidx'].append(obj)
|
|
|
|
# Append remaining objects.
|
|
for obj in objlist:
|
|
if obj.get('bidx_used', False):
|
|
# Already in meta['objects'].
|
|
pass
|
|
else:
|
|
meta['objects'].append(obj)
|
|
|
|
# Normalize metadata property shorthand. For example, if a property value
|
|
# is a shorthand function, create a function object and change the property
|
|
# to point to that function object.
|
|
def metadata_normalize_shorthand(meta):
|
|
# Gather objects through the top level built-ins list.
|
|
objs = []
|
|
subobjs = []
|
|
|
|
def getSubObject():
|
|
obj = {}
|
|
obj['id'] = 'subobj_%d' % len(subobjs) # synthetic ID
|
|
obj['properties'] = []
|
|
obj['auto_generated'] = True # mark as autogenerated (just FYI)
|
|
subobjs.append(obj)
|
|
return obj
|
|
|
|
def decodeFunctionShorthand(funprop):
|
|
# Convert the built-in function property "shorthand" into an actual
|
|
# object for ROM built-ins.
|
|
assert(funprop['value']['type'] == 'function')
|
|
val = funprop['value']
|
|
obj = getSubObject()
|
|
props = obj['properties']
|
|
obj['native'] = val['native']
|
|
obj['nargs'] = val.get('nargs', val['length'])
|
|
obj['varargs'] = val.get('varargs', False)
|
|
obj['magic'] = val.get('magic', 0)
|
|
obj['internal_prototype'] = 'bi_function_prototype'
|
|
obj['class'] = 'Function'
|
|
obj['callable'] = val.get('callable', True)
|
|
obj['constructable'] = val.get('constructable', False)
|
|
obj['special_call'] = val.get('special_call', False)
|
|
fun_name = val.get('name', funprop['key'])
|
|
props.append({ 'key': 'length', 'value': val['length'], 'attributes': 'c' }) # Configurable in ES2015
|
|
props.append({ 'key': 'name', 'value': fun_name, 'attributes': 'c' }) # Configurable in ES2015
|
|
return obj
|
|
|
|
def addAccessor(funprop, magic, nargs, length, name, native_func):
|
|
assert(funprop['value']['type'] == 'accessor')
|
|
obj = getSubObject()
|
|
props = obj['properties']
|
|
obj['native'] = native_func
|
|
obj['nargs'] = nargs
|
|
obj['varargs'] = False
|
|
obj['magic'] = magic
|
|
obj['internal_prototype'] = 'bi_function_prototype'
|
|
obj['class'] = 'Function'
|
|
obj['callable'] = val.get('callable', True)
|
|
obj['constructable'] = val.get('constructable', False)
|
|
assert(obj.get('special_call', False) == False)
|
|
# Shorthand accessors are minimal and have no .length or .name
|
|
# right now. Use longhand if these matter.
|
|
#props.append({ 'key': 'length', 'value': length, 'attributes': 'c' })
|
|
#props.append({ 'key': 'name', 'value': name, 'attributes': 'c' })
|
|
return obj
|
|
|
|
def decodeGetterShorthand(key, funprop):
|
|
assert(funprop['value']['type'] == 'accessor')
|
|
val = funprop['value']
|
|
if not val.has_key('getter'):
|
|
return None
|
|
return addAccessor(funprop,
|
|
val['getter_magic'],
|
|
val['getter_nargs'],
|
|
val.get('getter_length', 0),
|
|
key,
|
|
val['getter'])
|
|
|
|
def decodeSetterShorthand(key, funprop):
|
|
assert(funprop['value']['type'] == 'accessor')
|
|
val = funprop['value']
|
|
if not val.has_key('setter'):
|
|
return None
|
|
return addAccessor(funprop,
|
|
val['setter_magic'],
|
|
val['setter_nargs'],
|
|
val.get('setter_length', 0),
|
|
key,
|
|
val['setter'])
|
|
|
|
def decodeStructuredValue(val):
|
|
logger.debug('Decode structured value: %r' % val)
|
|
if isinstance(val, (int, long, float, str)):
|
|
return val # as is
|
|
elif isinstance(val, (dict)):
|
|
# Object: decode recursively
|
|
obj = decodeStructuredObject(val)
|
|
return { 'type': 'object', 'id': obj['id'] }
|
|
elif isinstance(val, (list)):
|
|
raise Exception('structured shorthand does not yet support array literals')
|
|
else:
|
|
raise Exception('unsupported value in structured shorthand: %r' % v)
|
|
|
|
def decodeStructuredObject(val):
|
|
# XXX: We'd like to preserve dict order from YAML source but
|
|
# Python doesn't do that. Use sorted order to make the result
|
|
# deterministic. User can always use longhand for exact
|
|
# property control.
|
|
|
|
logger.debug('Decode structured object: %r' % val)
|
|
obj = getSubObject()
|
|
obj['class'] = 'Object'
|
|
obj['internal_prototype'] = 'bi_object_prototype'
|
|
|
|
props = obj['properties']
|
|
keys = sorted(val.keys())
|
|
for k in keys:
|
|
logger.debug('Decode property %s' % k)
|
|
prop = { 'key': k, 'value': decodeStructuredValue(val[k]), 'attributes': 'wec' }
|
|
props.append(prop)
|
|
|
|
return obj
|
|
|
|
def decodeStructuredShorthand(structprop):
|
|
assert(structprop['value']['type'] == 'structured')
|
|
val = structprop['value']['value']
|
|
return decodeStructuredValue(val)
|
|
|
|
def clonePropShared(prop):
|
|
res = {}
|
|
for k in [ 'key', 'attributes', 'auto_lightfunc' ]:
|
|
if prop.has_key(k):
|
|
res[k] = prop[k]
|
|
return res
|
|
|
|
for idx,obj in enumerate(meta['objects']):
|
|
props = []
|
|
repl_props = []
|
|
|
|
for val in obj['properties']:
|
|
# Date.prototype.toGMTString must point to the same Function object
|
|
# as Date.prototype.toUTCString, so special case hack it here.
|
|
if obj['id'] == 'bi_date_prototype' and val['key'] == 'toGMTString':
|
|
logger.debug('Skip Date.prototype.toGMTString')
|
|
continue
|
|
|
|
if isinstance(val['value'], dict) and val['value']['type'] == 'function':
|
|
# Function shorthand.
|
|
subfun = decodeFunctionShorthand(val)
|
|
prop = clonePropShared(val)
|
|
prop['value'] = { 'type': 'object', 'id': subfun['id'] }
|
|
repl_props.append(prop)
|
|
elif isinstance(val['value'], dict) and val['value']['type'] == 'accessor' and \
|
|
(val['value'].has_key('getter') or val['value'].has_key('setter')):
|
|
# Accessor normal and shorthand forms both use the type 'accessor',
|
|
# but are differentiated by properties.
|
|
sub_getter = decodeGetterShorthand(val['key'], val)
|
|
sub_setter = decodeSetterShorthand(val['key'], val)
|
|
prop = clonePropShared(val)
|
|
prop['value'] = { 'type': 'accessor' }
|
|
if sub_getter is not None:
|
|
prop['value']['getter_id'] = sub_getter['id']
|
|
if sub_setter is not None:
|
|
prop['value']['setter_id'] = sub_setter['id']
|
|
assert('a' in prop['attributes']) # If missing, weird things happen runtime
|
|
logger.debug('Expand accessor shorthand: %r -> %r' % (val, prop))
|
|
repl_props.append(prop)
|
|
elif isinstance(val['value'], dict) and val['value']['type'] == 'structured':
|
|
# Structured shorthand.
|
|
subval = decodeStructuredShorthand(val)
|
|
prop = clonePropShared(val)
|
|
prop['value'] = subval
|
|
repl_props.append(prop)
|
|
logger.debug('Decoded structured shorthand for object %s, property %s' % (obj['id'], val['key']))
|
|
elif isinstance(val['value'], dict) and val['value']['type'] == 'buffer':
|
|
# Duktape buffer type not yet supported.
|
|
raise Exception('Buffer type not yet supported for builtins: %r' % val)
|
|
elif isinstance(val['value'], dict) and val['value']['type'] == 'pointer':
|
|
# Duktape pointer type not yet supported.
|
|
raise Exception('Pointer type not yet supported for builtins: %r' % val)
|
|
else:
|
|
# Property already in normalized form.
|
|
repl_props.append(val)
|
|
|
|
if obj['id'] == 'bi_date_prototype' and val['key'] == 'toUTCString':
|
|
logger.debug('Clone Date.prototype.toUTCString to Date.prototype.toGMTString')
|
|
prop2 = copy.deepcopy(repl_props[-1])
|
|
prop2['key'] = 'toGMTString'
|
|
repl_props.append(prop2)
|
|
|
|
# Replace properties with a variant where function properties
|
|
# point to built-ins rather than using an inline syntax.
|
|
obj['properties'] = repl_props
|
|
|
|
len_before = len(meta['objects'])
|
|
meta['objects'] += subobjs
|
|
len_after = len(meta['objects'])
|
|
|
|
logger.debug('Normalized metadata shorthand, %d objects -> %d final objects' % (len_before, len_after))
|
|
|
|
# Normalize property attribute order, default attributes, etc.
|
|
def metadata_normalize_property_attributes(meta):
|
|
for o in meta['objects']:
|
|
for p in o['properties']:
|
|
orig_attrs = p.get('attributes', None)
|
|
is_accessor = (isinstance(p['value'], dict) and p['value']['type'] == 'accessor')
|
|
|
|
# If missing, set default attributes.
|
|
attrs = orig_attrs
|
|
if attrs is None:
|
|
if is_accessor:
|
|
attrs = 'ca' # accessor default is configurable
|
|
else:
|
|
attrs = 'wc' # default is writable, configurable
|
|
logger.debug('Defaulted attributes of %s/%s to %s' % (o['id'], p['key'], attrs))
|
|
|
|
# Decode flags to normalize their order in the end.
|
|
writable = 'w' in attrs
|
|
enumerable = 'e' in attrs
|
|
configurable = 'c' in attrs
|
|
accessor = 'a' in attrs
|
|
|
|
# Force 'accessor' attribute for accessors.
|
|
if is_accessor and not accessor:
|
|
logger.debug('Property %s is accessor but has no "a" attribute, add attribute' % p['key'])
|
|
accessor = True
|
|
|
|
# Normalize order and write back.
|
|
attrs = ''
|
|
if writable:
|
|
attrs += 'w'
|
|
if enumerable:
|
|
attrs += 'e'
|
|
if configurable:
|
|
attrs += 'c'
|
|
if accessor:
|
|
attrs += 'a'
|
|
p['attributes'] = attrs
|
|
|
|
if orig_attrs != attrs:
|
|
logger.debug('Updated attributes of %s/%s from %r to %r' % (o['id'], p['key'], orig_attrs, attrs))
|
|
pass
|
|
|
|
# Normalize ROM property attributes.
|
|
def metadata_normalize_rom_property_attributes(meta):
|
|
for o in meta['objects']:
|
|
for p in o['properties']:
|
|
# ROM properties must not be configurable (runtime code
|
|
# depends on this). Writability is kept so that instance
|
|
# objects can override parent properties.
|
|
p['attributes'] = p['attributes'].replace('c', '')
|
|
|
|
# Add a 'name' property for all top level functions; expected by RAM
|
|
# initialization code.
|
|
def metadata_normalize_ram_function_names(meta):
|
|
num_added = 0
|
|
for o in meta['objects']:
|
|
if not o.get('callable', False):
|
|
continue
|
|
name_prop = None
|
|
for p in o['properties']:
|
|
if p['key'] == 'name':
|
|
name_prop = p
|
|
break
|
|
if name_prop is None:
|
|
num_added += 1
|
|
logger.debug('Adding missing "name" property for function %s' % o['id'])
|
|
o['properties'].append({ 'key': 'name', 'value': '', 'attributes': 'c' })
|
|
|
|
if num_added > 0:
|
|
logger.debug('Added missing "name" property for %d functions' % num_added)
|
|
|
|
# Add a built-in objects list for RAM initialization.
|
|
def metadata_add_ram_filtered_object_list(meta):
|
|
# For RAM init data to support user objects, we need to prepare a
|
|
# filtered top level object list, containing only those objects which
|
|
# need a value stack index during duk_hthread_builtins.c init process.
|
|
#
|
|
# Objects in meta['objects'] which are covered by inline property
|
|
# notation in the init data (this includes e.g. member functions like
|
|
# Math.cos) must not be present.
|
|
|
|
objlist = []
|
|
for o in meta['objects']:
|
|
keep = o.get('bidx_used', False)
|
|
if o.has_key('native') and not o.has_key('bidx'):
|
|
# Handled inline by run-time init code
|
|
pass
|
|
else:
|
|
# Top level object
|
|
keep = True
|
|
if keep:
|
|
objlist.append(o)
|
|
|
|
logger.debug('Filtered RAM object list: %d objects with bidx, %d total top level objects' % \
|
|
(len(meta['objects_bidx']), len(objlist)))
|
|
|
|
meta['objects_ram_toplevel'] = objlist
|
|
|
|
# Add missing strings into strings metadata. For example, if an object
|
|
# property key is not part of the strings list, append it there. This
|
|
# is critical for ROM builtins because all property keys etc must also
|
|
# be in ROM.
|
|
def metadata_normalize_missing_strings(meta, user_meta):
|
|
# We just need plain strings here.
|
|
strs_have = {}
|
|
for s in meta['strings']:
|
|
strs_have[s['str']] = True
|
|
|
|
# For ROM builtins all the strings must be in the strings list,
|
|
# so scan objects for any strings not explicitly listed in metadata.
|
|
for idx, obj in enumerate(meta['objects']):
|
|
for prop in obj['properties']:
|
|
key = prop['key']
|
|
if not strs_have.get(key):
|
|
logger.debug('Add missing string: %r' % key)
|
|
meta['strings'].append({ 'str': key, '_auto_add_ref': True })
|
|
strs_have[key] = True
|
|
if prop.has_key('value') and isinstance(prop['value'], (str, unicode)):
|
|
val = unicode_to_bytes(prop['value']) # should already be, just in case
|
|
if not strs_have.get(val):
|
|
logger.debug('Add missing string: %r' % val)
|
|
meta['strings'].append({ 'str': val, '_auto_add_ref': True })
|
|
strs_have[val] = True
|
|
|
|
# Force user strings to be in ROM data.
|
|
for s in user_meta.get('add_forced_strings', []):
|
|
if not strs_have.get(s['str']):
|
|
logger.debug('Add user string: %r' % s['str'])
|
|
s['_auto_add_user'] = True
|
|
meta['strings'].append(s)
|
|
|
|
# Convert built-in function properties into lightfuncs where applicable.
|
|
def metadata_convert_lightfuncs(meta):
|
|
num_converted = 0
|
|
num_skipped = 0
|
|
|
|
for o in meta['objects']:
|
|
for p in o['properties']:
|
|
v = p['value']
|
|
ptype = None
|
|
if isinstance(v, dict):
|
|
ptype = p['value']['type']
|
|
if ptype != 'object':
|
|
continue
|
|
targ, targ_idx = metadata_lookup_object_and_index(meta, p['value']['id'])
|
|
|
|
reasons = []
|
|
if not targ.get('callable', False):
|
|
reasons.append('not-callable')
|
|
#if targ.get('constructable', False):
|
|
# reasons.append('constructable')
|
|
|
|
lf_len = 0
|
|
for p2 in targ['properties']:
|
|
# Don't convert if function has more properties than
|
|
# we're willing to sacrifice.
|
|
logger.debug(' - Check %r . %s' % (o.get('id', None), p2['key']))
|
|
if p2['key'] == 'length' and isinstance(p2['value'], (int, long)):
|
|
lf_len = p2['value']
|
|
if p2['key'] not in [ 'length', 'name' ]:
|
|
reasons.append('nonallowed-property')
|
|
|
|
if not p.get('auto_lightfunc', True):
|
|
logger.debug('Automatic lightfunc conversion rejected for key %s, explicitly requested in metadata' % p['key'])
|
|
reasons.append('no-auto-lightfunc')
|
|
|
|
# lf_len comes from actual property table (after normalization)
|
|
if targ.has_key('magic'):
|
|
try:
|
|
# Magic values which resolve to 'bidx' indices cannot
|
|
# be resolved here yet, because the bidx map is not
|
|
# yet ready. If so, reject the lightfunc conversion
|
|
# for now. In practice this doesn't matter.
|
|
lf_magic = resolve_magic(targ.get('magic'), {}) # empty map is a "fake" bidx map
|
|
logger.debug('resolved magic ok -> %r' % lf_magic)
|
|
except Exception, e:
|
|
logger.debug('Failed to resolve magic for %r: %r' % (p['key'], e))
|
|
reasons.append('magic-resolve-failed')
|
|
lf_magic = 0xffffffff # dummy, will be out of bounds
|
|
else:
|
|
lf_magic = 0
|
|
if targ.get('varargs', True):
|
|
lf_nargs = None
|
|
lf_varargs = True
|
|
else:
|
|
lf_nargs = targ['nargs']
|
|
lf_varargs = False
|
|
|
|
if lf_len < 0 or lf_len > 15:
|
|
logger.debug('lf_len out of bounds: %r' % lf_len)
|
|
reasons.append('len-bounds')
|
|
if lf_magic < -0x80 or lf_magic > 0x7f:
|
|
logger.debug('lf_magic out of bounds: %r' % lf_magic)
|
|
reasons.append('magic-bounds')
|
|
if not lf_varargs and (lf_nargs < 0 or lf_nargs > 14):
|
|
logger.debug('lf_nargs out of bounds: %r' % lf_nargs)
|
|
reasons.append('nargs-bounds')
|
|
|
|
if len(reasons) > 0:
|
|
logger.debug('Don\'t convert to lightfunc: %r %r (%r): %r' % (o.get('id', None), p.get('key', None), p['value']['id'], reasons))
|
|
num_skipped += 1
|
|
continue
|
|
|
|
p_id = p['value']['id']
|
|
p['value'] = {
|
|
'type': 'lightfunc',
|
|
'native': targ['native'],
|
|
'length': lf_len,
|
|
'magic': lf_magic,
|
|
'nargs': lf_nargs,
|
|
'varargs': lf_varargs
|
|
}
|
|
logger.debug(' - Convert to lightfunc: %r %r (%r) -> %r' % (o.get('id', None), p.get('key', None), p_id, p['value']))
|
|
|
|
num_converted += 1
|
|
|
|
logger.debug('Converted %d built-in function properties to lightfuncs, %d skipped as non-eligible' % (num_converted, num_skipped))
|
|
|
|
# Detect objects not reachable from any object with a 'bidx'. This is usually
|
|
# a user error because such objects can't be reached at runtime so they're
|
|
# useless in RAM or ROM init data.
|
|
def metadata_remove_orphan_objects(meta):
|
|
reachable = {}
|
|
|
|
for o in meta['objects']:
|
|
if o.get('bidx_used', False):
|
|
reachable[o['id']] = True
|
|
|
|
while True:
|
|
reachable_count = len(reachable.keys())
|
|
|
|
def _markId(obj_id):
|
|
if obj_id is None:
|
|
return
|
|
reachable[obj_id] = True
|
|
|
|
for o in meta['objects']:
|
|
if not reachable.has_key(o['id']):
|
|
continue
|
|
_markId(o.get('internal_prototype', None))
|
|
for p in o['properties']:
|
|
# Shorthand has been normalized so no need
|
|
# to support it here.
|
|
v = p['value']
|
|
ptype = None
|
|
if isinstance(v, dict):
|
|
ptype = p['value']['type']
|
|
if ptype == 'object':
|
|
_markId(v['id'])
|
|
if ptype == 'accessor':
|
|
_markId(v.get('getter_id'))
|
|
_markId(v.get('setter_id'))
|
|
|
|
logger.debug('Mark reachable: reachable count initially %d, now %d' % \
|
|
(reachable_count, len(reachable.keys())))
|
|
if reachable_count == len(reachable.keys()):
|
|
break
|
|
|
|
num_deleted = 0
|
|
deleted = True
|
|
while deleted:
|
|
deleted = False
|
|
for i,o in enumerate(meta['objects']):
|
|
if not reachable.has_key(o['id']):
|
|
logger.debug('object %s not reachable, dropping' % o['id'])
|
|
meta['objects'].pop(i)
|
|
deleted = True
|
|
num_deleted += 1
|
|
break
|
|
|
|
if num_deleted > 0:
|
|
logger.debug('Deleted %d unreachable objects' % num_deleted)
|
|
|
|
# Add C define names for builtin strings. These defines are added to all
|
|
# strings, even when they won't get a stridx because the define names are
|
|
# used to autodetect referenced strings.
|
|
def metadata_add_string_define_names(strlist, special_defs):
|
|
for s in strlist:
|
|
v = s['str']
|
|
|
|
if special_defs.has_key(v):
|
|
s['define'] = 'DUK_STRIDX_' + special_defs[v]
|
|
continue
|
|
|
|
if len(v) >= 1 and v[0] == '\x82':
|
|
pfx = 'DUK_STRIDX_INT_'
|
|
v = v[1:]
|
|
elif len(v) >= 1 and v[0] == '\x81' and v[-1] == '\xff':
|
|
pfx = 'DUK_STRIDX_WELLKNOWN_'
|
|
v = v[1:-1]
|
|
else:
|
|
pfx = 'DUK_STRIDX_'
|
|
|
|
t = re.sub(r'([a-z0-9])([A-Z])', r'\1_\2', v) # add underscores: aB -> a_B
|
|
t = re.sub(r'\.', '_', t) # replace . with _, e.g. Symbol.iterator
|
|
s['define'] = pfx + t.upper()
|
|
logger.debug('stridx define: ' + s['define'])
|
|
|
|
# Add a 'stridx_used' flag for strings which need a stridx.
|
|
def metadata_add_string_used_stridx(strlist, used_stridx_meta):
|
|
defs_needed = {}
|
|
defs_found = {}
|
|
for s in used_stridx_meta['used_stridx_defines']:
|
|
defs_needed[s] = True
|
|
|
|
# strings whose define is referenced
|
|
for s in strlist:
|
|
if s.has_key('define') and defs_needed.has_key(s['define']):
|
|
s['stridx_used'] = True
|
|
defs_found[s['define']] = True
|
|
|
|
# duk_lexer.h needs all reserved words
|
|
for s in strlist:
|
|
if s.get('reserved_word', False):
|
|
s['stridx_used'] = True
|
|
|
|
# ensure all needed defines are provided
|
|
defs_found['DUK_STRIDX_START_RESERVED'] = True # special defines provided automatically
|
|
defs_found['DUK_STRIDX_START_STRICT_RESERVED'] = True
|
|
defs_found['DUK_STRIDX_END_RESERVED'] = True
|
|
defs_found['DUK_STRIDX_TO_TOK'] = True
|
|
for k in sorted(defs_needed.keys()):
|
|
if not defs_found.has_key(k):
|
|
raise Exception('source code needs define %s not provided by strings' % repr(k))
|
|
|
|
# Merge duplicate strings in string metadata.
|
|
def metadata_merge_string_entries(strlist):
|
|
# The raw string list may contain duplicates so merge entries.
|
|
# The list is processed in reverse because the last entry should
|
|
# "win" and keep its place (this matters for reserved words).
|
|
|
|
strs = []
|
|
str_map = {} # plain string -> object in strs[]
|
|
tmp = copy.deepcopy(strlist)
|
|
tmp.reverse()
|
|
for s in tmp:
|
|
prev = str_map.get(s['str'])
|
|
if prev is not None:
|
|
for k in s.keys():
|
|
if prev.has_key(k) and prev[k] != s[k]:
|
|
raise Exception('fail to merge string entry, conflicting keys: %r <-> %r' % (prev, s))
|
|
prev[k] = s[k]
|
|
else:
|
|
strs.append(s)
|
|
str_map[s['str']] = s
|
|
strs.reverse()
|
|
return strs
|
|
|
|
# Order builtin strings (strings with a stridx) into an order satisfying
|
|
# multiple constraints.
|
|
def metadata_order_builtin_strings(input_strlist, keyword_list, strip_unused_stridx=False):
|
|
# Strings are ordered in the result as follows:
|
|
# 1. Non-reserved words requiring 8-bit indices
|
|
# 2. Non-reserved words not requiring 8-bit indices
|
|
# 3. Reserved words in non-strict mode only
|
|
# 4. Reserved words in strict mode
|
|
#
|
|
# Reserved words must follow an exact order because they are
|
|
# translated to/from token numbers by addition/subtraction.
|
|
# Some strings require an 8-bit index and must be in the
|
|
# beginning.
|
|
|
|
tmp_strs = []
|
|
for s in copy.deepcopy(input_strlist):
|
|
if not s.get('stridx_used', False):
|
|
# Drop strings which are not actually needed by src-input/*.(c|h).
|
|
# Such strings won't be in heap->strs[] or ROM legacy list.
|
|
pass
|
|
else:
|
|
tmp_strs.append(s)
|
|
|
|
# The reserved word list must match token order in duk_lexer.h
|
|
# exactly, so pluck them out first.
|
|
|
|
str_index = {}
|
|
kw_index = {}
|
|
keywords = []
|
|
strs = []
|
|
for idx,s in enumerate(tmp_strs):
|
|
str_index[s['str']] = s
|
|
for idx,s in enumerate(keyword_list):
|
|
keywords.append(str_index[s])
|
|
kw_index[s] = True
|
|
for idx,s in enumerate(tmp_strs):
|
|
if not kw_index.has_key(s['str']):
|
|
strs.append(s)
|
|
|
|
# Sort the strings by category number; within category keep
|
|
# previous order.
|
|
|
|
for idx,s in enumerate(strs):
|
|
s['_idx'] = idx # for ensuring stable sort
|
|
|
|
def req8Bit(s):
|
|
return s.get('class_name', False) # currently just class names
|
|
|
|
def getCat(s):
|
|
req8 = req8Bit(s)
|
|
if s.get('reserved_word', False):
|
|
# XXX: unused path now, because keywords are "plucked out"
|
|
# explicitly.
|
|
assert(not req8)
|
|
if s.get('future_reserved_word_strict', False):
|
|
return 4
|
|
else:
|
|
return 3
|
|
elif req8:
|
|
return 1
|
|
else:
|
|
return 2
|
|
|
|
def sortCmp(a,b):
|
|
return cmp( (getCat(a),a['_idx']), (getCat(b),b['_idx']) )
|
|
|
|
strs.sort(cmp=sortCmp)
|
|
|
|
for idx,s in enumerate(strs):
|
|
# Remove temporary _idx properties
|
|
del s['_idx']
|
|
|
|
for idx,s in enumerate(strs):
|
|
if req8Bit(s) and i >= 256:
|
|
raise Exception('8-bit string index not satisfied: ' + repr(s))
|
|
|
|
return strs + keywords
|
|
|
|
# Dump metadata into a JSON file.
|
|
def dump_metadata(meta, fn):
|
|
tmp = json.dumps(recursive_bytes_to_strings(meta), indent=4)
|
|
with open(fn, 'wb') as f:
|
|
f.write(tmp)
|
|
logger.debug('Wrote metadata dump to %s' % fn)
|
|
|
|
# Main metadata loading function: load metadata from multiple sources,
|
|
# merge and normalize, prepare various indexes etc.
|
|
def load_metadata(opts, rom=False, build_info=None, active_opts=None):
|
|
# Load built-in strings and objects.
|
|
with open(opts.strings_metadata, 'rb') as f:
|
|
strings_metadata = recursive_strings_to_bytes(yaml.load(f))
|
|
with open(opts.objects_metadata, 'rb') as f:
|
|
objects_metadata = recursive_strings_to_bytes(yaml.load(f))
|
|
|
|
# Merge strings and objects metadata as simple top level key merge.
|
|
meta = {}
|
|
for k in objects_metadata.keys():
|
|
meta[k] = objects_metadata[k]
|
|
for k in strings_metadata.keys():
|
|
meta[k] = strings_metadata[k]
|
|
|
|
# Add user objects.
|
|
user_meta = {}
|
|
for fn in opts.builtin_files:
|
|
logger.debug('Merging user builtin metadata file %s' % fn)
|
|
with open(fn, 'rb') as f:
|
|
user_meta = recursive_strings_to_bytes(yaml.load(f))
|
|
metadata_merge_user_objects(meta, user_meta)
|
|
|
|
# Remove disabled objects and properties. Also remove objects and
|
|
# properties which are disabled in (known) active duk_config.h.
|
|
metadata_remove_disabled(meta, active_opts)
|
|
|
|
# Replace Symbol keys and property values with plain (encoded) strings.
|
|
metadata_normalize_symbol_strings(meta)
|
|
|
|
# Normalize 'nargs' and 'length' defaults.
|
|
metadata_normalize_nargs_length(meta)
|
|
|
|
# Normalize property attributes.
|
|
metadata_normalize_property_attributes(meta)
|
|
|
|
# Normalize property shorthand into full objects.
|
|
metadata_normalize_shorthand(meta)
|
|
|
|
# RAM top-level functions must have a 'name'.
|
|
if not rom:
|
|
metadata_normalize_ram_function_names(meta)
|
|
|
|
# Add Duktape.version and (Duktape.env for ROM case).
|
|
for o in meta['objects']:
|
|
if o['id'] == 'bi_duktape':
|
|
o['properties'].insert(0, { 'key': 'version', 'value': int(build_info['duk_version']), 'attributes': '' })
|
|
if rom:
|
|
# Use a fixed (quite dummy for now) Duktape.env
|
|
# when ROM builtins are in use. In the RAM case
|
|
# this is added during global object initialization
|
|
# based on config options in use.
|
|
o['properties'].insert(0, { 'key': 'env', 'value': 'ROM', 'attributes': '' })
|
|
|
|
# Normalize property attributes (just in case shorthand handling
|
|
# didn't add attributes to all properties).
|
|
metadata_normalize_property_attributes(meta)
|
|
|
|
# For ROM objects, mark all properties non-configurable.
|
|
if rom:
|
|
metadata_normalize_rom_property_attributes(meta)
|
|
|
|
# Convert built-in function properties automatically into
|
|
# lightfuncs if requested and function is eligible.
|
|
if rom and opts.rom_auto_lightfunc:
|
|
metadata_convert_lightfuncs(meta)
|
|
|
|
# Create a list of objects needing a 'bidx'. Ensure 'objects' and
|
|
# 'objects_bidx' match in order for shared length.
|
|
metadata_prepare_objects_bidx(meta)
|
|
|
|
# Merge duplicate strings.
|
|
meta['strings'] = metadata_merge_string_entries(meta['strings'])
|
|
|
|
# Prepare an ordered list of strings with 'stridx':
|
|
# - Add a 'stridx_used' flag for strings which need an index in current code base
|
|
# - Add a C define (DUK_STRIDX_xxx) for such strings
|
|
# - Compute a stridx string order satisfying current runtime constraints
|
|
#
|
|
# The meta['strings_stridx'] result will be in proper order and stripped of
|
|
# any strings which don't need a stridx.
|
|
metadata_add_string_define_names(meta['strings'], meta['special_define_names'])
|
|
with open(opts.used_stridx_metadata, 'rb') as f:
|
|
metadata_add_string_used_stridx(meta['strings'], json.loads(f.read()))
|
|
meta['strings_stridx'] = metadata_order_builtin_strings(meta['strings'], meta['reserved_word_token_order'])
|
|
|
|
# For the ROM build: add any strings referenced by built-in objects
|
|
# into the string list (not the 'stridx' list though): all strings
|
|
# referenced by ROM objects must also be in ROM.
|
|
if rom:
|
|
for fn in opts.builtin_files:
|
|
# XXX: awkward second pass
|
|
with open(fn, 'rb') as f:
|
|
user_meta = recursive_strings_to_bytes(yaml.load(f))
|
|
metadata_normalize_missing_strings(meta, user_meta)
|
|
metadata_normalize_missing_strings(meta, {}) # in case no files
|
|
|
|
# Check for orphan objects and remove them.
|
|
metadata_remove_orphan_objects(meta)
|
|
|
|
# Add final stridx and bidx indices to metadata objects and strings.
|
|
idx = 0
|
|
for o in meta['objects']:
|
|
if o.get('bidx_used', False):
|
|
o['bidx'] = idx
|
|
idx += 1
|
|
idx = 0
|
|
for s in meta['strings']:
|
|
if s.get('stridx_used', False):
|
|
s['stridx'] = idx
|
|
idx += 1
|
|
|
|
# Prepare a filtered RAM top level object list, needed for technical
|
|
# reasons during RAM init handling.
|
|
if not rom:
|
|
metadata_add_ram_filtered_object_list(meta)
|
|
|
|
# Sanity check: object index must match 'bidx' for all objects
|
|
# which have a runtime 'bidx'. This is assumed by e.g. RAM
|
|
# thread init.
|
|
for i,o in enumerate(meta['objects']):
|
|
if i < len(meta['objects_bidx']):
|
|
assert(meta['objects_bidx'][i] == meta['objects'][i])
|
|
if o.get('bidx', False):
|
|
assert(o['bidx'] == i)
|
|
|
|
# Create a set of helper lists and maps now that the metadata is
|
|
# in its final form.
|
|
meta['_strings_plain'] = []
|
|
meta['_strings_stridx_plain'] = []
|
|
meta['_stridx_to_string'] = {}
|
|
meta['_idx_to_string'] = {}
|
|
meta['_stridx_to_plain'] = {}
|
|
meta['_idx_to_plain'] = {}
|
|
meta['_string_to_stridx'] = {}
|
|
meta['_plain_to_stridx'] = {}
|
|
meta['_string_to_idx'] = {}
|
|
meta['_plain_to_idx'] = {}
|
|
meta['_define_to_stridx'] = {}
|
|
meta['_stridx_to_define'] = {}
|
|
meta['_is_plain_reserved_word'] = {}
|
|
meta['_is_plain_strict_reserved_word'] = {}
|
|
meta['_objid_to_object'] = {}
|
|
meta['_objid_to_bidx'] = {}
|
|
meta['_objid_to_idx'] = {}
|
|
meta['_objid_to_ramidx'] = {}
|
|
meta['_bidx_to_objid'] = {}
|
|
meta['_idx_to_objid'] = {}
|
|
meta['_bidx_to_object'] = {}
|
|
meta['_idx_to_object'] = {}
|
|
|
|
for i,s in enumerate(meta['strings']):
|
|
assert(s['str'] not in meta['_strings_plain'])
|
|
meta['_strings_plain'].append(s['str'])
|
|
if s.get('reserved_word', False):
|
|
meta['_is_plain_reserved_word'][s['str']] = True # includes also strict reserved words
|
|
if s.get('future_reserved_word_strict', False):
|
|
meta['_is_plain_strict_reserved_word'][s['str']] = True
|
|
meta['_idx_to_string'][i] = s
|
|
meta['_idx_to_plain'][i] = s['str']
|
|
meta['_plain_to_idx'][s['str']] = i
|
|
#meta['_string_to_idx'][s] = i
|
|
for i,s in enumerate(meta['strings_stridx']):
|
|
assert(s.get('stridx_used', False) == True)
|
|
meta['_strings_stridx_plain'].append(s['str'])
|
|
meta['_stridx_to_string'][i] = s
|
|
meta['_stridx_to_plain'][i] = s['str']
|
|
#meta['_string_to_stridx'][s] = i
|
|
meta['_plain_to_stridx'][s['str']] = i
|
|
meta['_define_to_stridx'][s['define']] = i
|
|
meta['_stridx_to_define'][i] = s['define']
|
|
for i,o in enumerate(meta['objects']):
|
|
meta['_objid_to_object'][o['id']] = o
|
|
meta['_objid_to_idx'][o['id']] = i
|
|
meta['_idx_to_objid'][i] = o['id']
|
|
meta['_idx_to_object'][i] = o
|
|
for i,o in enumerate(meta['objects_bidx']):
|
|
assert(o.get('bidx_used', False) == True)
|
|
meta['_objid_to_bidx'][o['id']] = i
|
|
assert(meta['_objid_to_bidx'][o['id']] == meta['_objid_to_idx'][o['id']])
|
|
meta['_bidx_to_objid'][i] = o['id']
|
|
meta['_bidx_to_object'][i] = o
|
|
if meta.has_key('objects_ram_toplevel'):
|
|
for i,o in enumerate(meta['objects_ram_toplevel']):
|
|
meta['_objid_to_ramidx'][o['id']] = i
|
|
|
|
# Dump stats.
|
|
|
|
if rom:
|
|
meta_name = 'ROM'
|
|
else:
|
|
meta_name = 'RAM'
|
|
|
|
count_add_ref = 0
|
|
count_add_user = 0
|
|
for s in meta['strings']:
|
|
if s.get('_auto_add_ref', False):
|
|
count_add_ref += 1
|
|
if s.get('_auto_add_user', False):
|
|
count_add_user += 1
|
|
count_add = count_add_ref + count_add_user
|
|
|
|
logger.debug(('Prepared %s metadata: %d objects, %d objects with bidx, ' + \
|
|
'%d strings, %d strings with stridx, %d strings added ' + \
|
|
'(%d property key references, %d user strings)') % \
|
|
(meta_name, len(meta['objects']), len(meta['objects_bidx']), \
|
|
len(meta['strings']), len(meta['strings_stridx']), \
|
|
count_add, count_add_ref, count_add_user))
|
|
|
|
return meta
|
|
|
|
#
|
|
# Metadata helpers
|
|
#
|
|
|
|
# Magic values for Math built-in.
|
|
math_onearg_magic = {
|
|
'fabs': 0, # BI_MATH_FABS_IDX
|
|
'acos': 1, # BI_MATH_ACOS_IDX
|
|
'asin': 2, # BI_MATH_ASIN_IDX
|
|
'atan': 3, # BI_MATH_ATAN_IDX
|
|
'ceil': 4, # BI_MATH_CEIL_IDX
|
|
'cos': 5, # BI_MATH_COS_IDX
|
|
'exp': 6, # BI_MATH_EXP_IDX
|
|
'floor': 7, # BI_MATH_FLOOR_IDX
|
|
'log': 8, # BI_MATH_LOG_IDX
|
|
'round': 9, # BI_MATH_ROUND_IDX
|
|
'sin': 10, # BI_MATH_SIN_IDX
|
|
'sqrt': 11, # BI_MATH_SQRT_IDX
|
|
'tan': 12, # BI_MATH_TAN_IDX
|
|
'cbrt': 13, # BI_MATH_CBRT_IDX
|
|
'log2': 14, # BI_MATH_LOG2_IDX
|
|
'log10': 15, # BI_MATH_LOG10_IDX
|
|
'trunc': 16, # BI_MATH_TRUNC_IDX
|
|
}
|
|
math_twoarg_magic = {
|
|
'atan2': 0, # BI_MATH_ATAN2_IDX
|
|
'pow': 1 # BI_MATH_POW_IDX
|
|
}
|
|
|
|
# Magic values for Array built-in.
|
|
array_iter_magic = {
|
|
'every': 0, # BI_ARRAY_ITER_EVERY
|
|
'some': 1, # BI_ARRAY_ITER_SOME
|
|
'forEach': 2, # BI_ARRAY_ITER_FOREACH
|
|
'map': 3, # BI_ARRAY_ITER_MAP
|
|
'filter': 4 # BI_ARRAY_ITER_FILTER
|
|
}
|
|
|
|
# Magic value for typedarray/node.js buffer read field operations.
|
|
def magic_readfield(elem, signed=None, bigendian=None, typedarray=None):
|
|
# Must match duk__FLD_xxx in duk_bi_buffer.c
|
|
elemnum = {
|
|
'8bit': 0,
|
|
'16bit': 1,
|
|
'32bit': 2,
|
|
'float': 3,
|
|
'double': 4,
|
|
'varint': 5
|
|
}[elem]
|
|
if signed == True:
|
|
signednum = 1
|
|
elif signed == False:
|
|
signednum = 0
|
|
else:
|
|
raise Exception('missing "signed"')
|
|
if bigendian == True:
|
|
bigendiannum = 1
|
|
elif bigendian == False:
|
|
bigendiannum = 0
|
|
else:
|
|
raise Exception('missing "bigendian"')
|
|
if typedarray == True:
|
|
typedarraynum = 1
|
|
elif typedarray == False:
|
|
typedarraynum = 0
|
|
else:
|
|
raise Exception('missing "typedarray"')
|
|
return elemnum + (signednum << 4) + (bigendiannum << 3) + (typedarraynum << 5)
|
|
|
|
# Magic value for typedarray/node.js buffer write field operations.
|
|
def magic_writefield(elem, signed=None, bigendian=None, typedarray=None):
|
|
return magic_readfield(elem, signed=signed, bigendian=bigendian, typedarray=typedarray)
|
|
|
|
# Magic value for typedarray constructors.
|
|
def magic_typedarray_constructor(elem, shift):
|
|
# Must match duk_hbufobj.h header
|
|
elemnum = {
|
|
'uint8': 0,
|
|
'uint8clamped': 1,
|
|
'int8': 2,
|
|
'uint16': 3,
|
|
'int16': 4,
|
|
'uint32': 5,
|
|
'int32': 6,
|
|
'float32': 7,
|
|
'float64': 8
|
|
}[elem]
|
|
return (elemnum << 2) + shift
|
|
|
|
# Resolve a magic value from a YAML metadata element into an integer.
|
|
def resolve_magic(elem, objid_to_bidx):
|
|
if elem is None:
|
|
return 0
|
|
if isinstance(elem, (int, long)):
|
|
v = int(elem)
|
|
if not (v >= -0x8000 and v <= 0x7fff):
|
|
raise Exception('invalid plain value for magic: %s' % repr(v))
|
|
return v
|
|
if not isinstance(elem, dict):
|
|
raise Exception('invalid magic: %r' % elem)
|
|
|
|
assert(elem.has_key('type'))
|
|
if elem['type'] == 'bidx':
|
|
# Maps to thr->builtins[].
|
|
v = elem['id']
|
|
return objid_to_bidx[v]
|
|
elif elem['type'] == 'plain':
|
|
v = elem['value']
|
|
if not (v >= -0x8000 and v <= 0x7fff):
|
|
raise Exception('invalid plain value for magic: %s' % repr(v))
|
|
return v
|
|
elif elem['type'] == 'math_onearg':
|
|
return math_onearg_magic[elem['funcname']]
|
|
elif elem['type'] == 'math_twoarg':
|
|
return math_twoarg_magic[elem['funcname']]
|
|
elif elem['type'] == 'array_iter':
|
|
return array_iter_magic[elem['funcname']]
|
|
elif elem['type'] == 'typedarray_constructor':
|
|
return magic_typedarray_constructor(elem['elem'], elem['shift'])
|
|
elif elem['type'] == 'buffer_readfield':
|
|
return magic_readfield(elem['elem'], elem['signed'], elem['bigendian'], elem['typedarray'])
|
|
elif elem['type'] == 'buffer_writefield':
|
|
return magic_writefield(elem['elem'], elem['signed'], elem['bigendian'], elem['typedarray'])
|
|
else:
|
|
raise Exception('invalid magic type: %r' % elem)
|
|
|
|
# Helper to find a property from a property list, remove it from the
|
|
# property list, and return the removed property.
|
|
def steal_prop(props, key, allow_accessor=True):
|
|
for idx,prop in enumerate(props):
|
|
if prop['key'] == key:
|
|
if not (isinstance(prop['value'], dict) and prop['value']['type'] == 'accessor') or allow_accessor:
|
|
return props.pop(idx)
|
|
return None
|
|
|
|
#
|
|
# RAM initialization data
|
|
#
|
|
# Init data for built-in strings and objects. The init data for both
|
|
# strings and objects is a bit-packed stream tailored to match the decoders
|
|
# in duk_heap_alloc.c (strings) and duk_hthread_builtins.c (objects).
|
|
# Various bitfield sizes are used to minimize the bitstream size without
|
|
# resorting to actual, expensive compression. The goal is to minimize the
|
|
# overall size of the init code and the init data.
|
|
#
|
|
# The built-in data created here is used to set up initial RAM versions
|
|
# of the strings and objects. References to these objects are tracked in
|
|
# heap->strs[] and thr->builtins[] which allows Duktape internals to refer
|
|
# to built-ins e.g. as thr->builtins[DUK_BIDX_STRING_PROTOTYPE].
|
|
#
|
|
# Not all strings and objects need to be reachable through heap->strs[]
|
|
# or thr->builtins[]: the strings/objects that need to be in these arrays
|
|
# is determined based on metadata and source code scanning.
|
|
#
|
|
|
|
# XXX: Reserved word stridxs could be made to match token numbers
|
|
# directly so that a duk_stridx2token[] would not be needed.
|
|
|
|
# Default property attributes.
|
|
LENGTH_PROPERTY_ATTRIBUTES = 'c'
|
|
ACCESSOR_PROPERTY_ATTRIBUTES = 'c'
|
|
DEFAULT_DATA_PROPERTY_ATTRIBUTES = 'wc'
|
|
DEFAULT_FUNC_PROPERTY_ATTRIBUTES = 'wc'
|
|
|
|
# Encoding constants (must match duk_hthread_builtins.c).
|
|
PROP_FLAGS_BITS = 3
|
|
LENGTH_PROP_BITS = 3
|
|
NARGS_BITS = 3
|
|
PROP_TYPE_BITS = 3
|
|
|
|
NARGS_VARARGS_MARKER = 0x07
|
|
|
|
PROP_TYPE_DOUBLE = 0
|
|
PROP_TYPE_STRING = 1
|
|
PROP_TYPE_STRIDX = 2
|
|
PROP_TYPE_BUILTIN = 3
|
|
PROP_TYPE_UNDEFINED = 4
|
|
PROP_TYPE_BOOLEAN_TRUE = 5
|
|
PROP_TYPE_BOOLEAN_FALSE = 6
|
|
PROP_TYPE_ACCESSOR = 7
|
|
|
|
# must match duk_hobject.h
|
|
PROPDESC_FLAG_WRITABLE = (1 << 0)
|
|
PROPDESC_FLAG_ENUMERABLE = (1 << 1)
|
|
PROPDESC_FLAG_CONFIGURABLE = (1 << 2)
|
|
PROPDESC_FLAG_ACCESSOR = (1 << 3) # unused now
|
|
|
|
# Class names, numeric indices must match duk_hobject.h class numbers.
|
|
class_names = [
|
|
'Unused',
|
|
'Object',
|
|
'Array',
|
|
'Function',
|
|
'Arguments',
|
|
'Boolean',
|
|
'Date',
|
|
'Error',
|
|
'JSON',
|
|
'Math',
|
|
'Number',
|
|
'RegExp',
|
|
'String',
|
|
'global',
|
|
'Symbol',
|
|
'ObjEnv',
|
|
'DecEnv',
|
|
'Pointer',
|
|
'Thread'
|
|
# Remaining class names are not currently needed.
|
|
]
|
|
class2num = {}
|
|
for i,v in enumerate(class_names):
|
|
class2num[v] = i
|
|
|
|
# Map class name to a class number.
|
|
def class_to_number(x):
|
|
return class2num[x]
|
|
|
|
# Bitpack a string into a format shared by heap and thread init data.
|
|
def bitpack_string(be, s, stats=None):
|
|
# Strings are encoded as follows: a string begins in lowercase
|
|
# mode and recognizes the following 5-bit symbols:
|
|
#
|
|
# 0-25 'a' ... 'z' or 'A' ... 'Z' depending on uppercase mode
|
|
# 26-31 special controls, see code below
|
|
|
|
LOOKUP1 = 26
|
|
LOOKUP2 = 27
|
|
SWITCH1 = 28
|
|
SWITCH = 29
|
|
UNUSED1 = 30
|
|
EIGHTBIT = 31
|
|
LOOKUP = '0123456789_ \x82\x80"{' # special characters
|
|
assert(len(LOOKUP) == 16)
|
|
|
|
# support up to 256 byte strings now, cases above ~30 bytes are very
|
|
# rare, so favor short strings in encoding
|
|
if len(s) <= 30:
|
|
be.bits(len(s), 5)
|
|
else:
|
|
be.bits(31, 5)
|
|
be.bits(len(s), 8)
|
|
|
|
# 5-bit character, mode specific
|
|
mode = 'lowercase'
|
|
|
|
for idx, c in enumerate(s):
|
|
# This encoder is not that optimal, but good enough for now.
|
|
|
|
islower = (ord(c) >= ord('a') and ord(c) <= ord('z'))
|
|
isupper = (ord(c) >= ord('A') and ord(c) <= ord('Z'))
|
|
islast = (idx == len(s) - 1)
|
|
isnextlower = False
|
|
isnextupper = False
|
|
if not islast:
|
|
c2 = s[idx+1]
|
|
isnextlower = (ord(c2) >= ord('a') and ord(c2) <= ord('z'))
|
|
isnextupper = (ord(c2) >= ord('A') and ord(c2) <= ord('Z'))
|
|
|
|
# XXX: Add back special handling for hidden or other symbols?
|
|
|
|
if islower and mode == 'lowercase':
|
|
be.bits(ord(c) - ord('a'), 5)
|
|
if stats is not None: stats['n_optimal'] += 1
|
|
elif isupper and mode == 'uppercase':
|
|
be.bits(ord(c) - ord('A'), 5)
|
|
if stats is not None: stats['n_optimal'] += 1
|
|
elif islower and mode == 'uppercase':
|
|
if isnextlower:
|
|
be.bits(SWITCH, 5)
|
|
be.bits(ord(c) - ord('a'), 5)
|
|
mode = 'lowercase'
|
|
if stats is not None: stats['n_switch'] += 1
|
|
else:
|
|
be.bits(SWITCH1, 5)
|
|
be.bits(ord(c) - ord('a'), 5)
|
|
if stats is not None: stats['n_switch1'] += 1
|
|
elif isupper and mode == 'lowercase':
|
|
if isnextupper:
|
|
be.bits(SWITCH, 5)
|
|
be.bits(ord(c) - ord('A'), 5)
|
|
mode = 'uppercase'
|
|
if stats is not None: stats['n_switch'] += 1
|
|
else:
|
|
be.bits(SWITCH1, 5)
|
|
be.bits(ord(c) - ord('A'), 5)
|
|
if stats is not None: stats['n_switch1'] += 1
|
|
elif c in LOOKUP:
|
|
idx = LOOKUP.find(c)
|
|
if idx >= 8:
|
|
be.bits(LOOKUP2, 5)
|
|
be.bits(idx - 8, 3)
|
|
if stats is not None: stats['n_lookup2'] += 1
|
|
else:
|
|
be.bits(LOOKUP1, 5)
|
|
be.bits(idx, 3)
|
|
if stats is not None: stats['n_lookup1'] += 1
|
|
elif ord(c) >= 0 and ord(c) <= 255:
|
|
logger.debug('eightbit encoding for %d (%s)' % (ord(c), c))
|
|
be.bits(EIGHTBIT, 5)
|
|
be.bits(ord(c), 8)
|
|
if stats is not None: stats['n_eightbit'] += 1
|
|
else:
|
|
raise Exception('internal error in bitpacking a string')
|
|
|
|
# Generate bit-packed RAM string init data.
|
|
def gen_ramstr_initdata_bitpacked(meta):
|
|
be = dukutil.BitEncoder()
|
|
|
|
maxlen = 0
|
|
stats = {
|
|
'n_optimal': 0,
|
|
'n_lookup1': 0,
|
|
'n_lookup2': 0,
|
|
'n_switch1': 0,
|
|
'n_switch': 0,
|
|
'n_eightbit': 0
|
|
}
|
|
|
|
for s_obj in meta['strings_stridx']:
|
|
s = s_obj['str']
|
|
if len(s) > maxlen:
|
|
maxlen = len(s)
|
|
bitpack_string(be, s, stats)
|
|
|
|
# end marker not necessary, C code knows length from define
|
|
|
|
if be._varuint_count > 0:
|
|
logger.debug('Varuint distribution:')
|
|
logger.debug(json.dumps(be._varuint_dist[0:1024]))
|
|
logger.debug('Varuint encoding categories: %r' % be._varuint_cats)
|
|
logger.debug('Varuint efficiency: %f bits/value' % (float(be._varuint_bits) / float(be._varuint_count)))
|
|
res = be.getByteString()
|
|
|
|
logger.debug(('%d ram strings, %d bytes of string init data, %d maximum string length, ' + \
|
|
'encoding: optimal=%d,lookup1=%d,lookup2=%d,switch1=%d,switch=%d,eightbit=%d') % \
|
|
(len(meta['strings_stridx']), len(res), maxlen, \
|
|
stats['n_optimal'],
|
|
stats['n_lookup1'], stats['n_lookup2'],
|
|
stats['n_switch1'], stats['n_switch'],
|
|
stats['n_eightbit']))
|
|
|
|
return res, maxlen
|
|
|
|
# Functions to emit string-related source/header parts.
|
|
|
|
def emit_ramstr_source_strinit_data(genc, strdata):
|
|
genc.emitArray(strdata, 'duk_strings_data', visibility='DUK_INTERNAL', typename='duk_uint8_t', intvalues=True, const=True, size=len(strdata))
|
|
|
|
def emit_ramstr_header_strinit_defines(genc, meta, strdata, strmaxlen):
|
|
genc.emitLine('#if !defined(DUK_SINGLE_FILE)')
|
|
genc.emitLine('DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[%d];' % len(strdata))
|
|
genc.emitLine('#endif /* !DUK_SINGLE_FILE */')
|
|
genc.emitDefine('DUK_STRDATA_MAX_STRLEN', strmaxlen)
|
|
genc.emitDefine('DUK_STRDATA_DATA_LENGTH', len(strdata))
|
|
|
|
# This is used for both RAM and ROM strings.
|
|
def emit_header_stridx_defines(genc, meta):
|
|
strlist = meta['strings_stridx']
|
|
|
|
for idx,s in enumerate(strlist):
|
|
genc.emitDefine(s['define'], idx, repr(s['str']))
|
|
defname = s['define'].replace('_STRIDX','_HEAP_STRING')
|
|
genc.emitDefine(defname + '(heap)', 'DUK_HEAP_GET_STRING((heap),%s)' % s['define'])
|
|
defname = s['define'].replace('_STRIDX', '_HTHREAD_STRING')
|
|
genc.emitDefine(defname + '(thr)', 'DUK_HTHREAD_GET_STRING((thr),%s)' % s['define'])
|
|
|
|
idx_start_reserved = None
|
|
idx_start_strict_reserved = None
|
|
for idx,s in enumerate(strlist):
|
|
if idx_start_reserved is None and s.get('reserved_word', False):
|
|
idx_start_reserved = idx
|
|
if idx_start_strict_reserved is None and s.get('future_reserved_word_strict', False):
|
|
idx_start_strict_reserved = idx
|
|
assert(idx_start_reserved is not None)
|
|
assert(idx_start_strict_reserved is not None)
|
|
|
|
genc.emitLine('')
|
|
genc.emitDefine('DUK_HEAP_NUM_STRINGS', len(strlist))
|
|
genc.emitDefine('DUK_STRIDX_START_RESERVED', idx_start_reserved)
|
|
genc.emitDefine('DUK_STRIDX_START_STRICT_RESERVED', idx_start_strict_reserved)
|
|
genc.emitDefine('DUK_STRIDX_END_RESERVED', len(strlist), comment='exclusive endpoint')
|
|
genc.emitLine('')
|
|
genc.emitLine('/* To convert a heap stridx to a token number, subtract')
|
|
genc.emitLine(' * DUK_STRIDX_START_RESERVED and add DUK_TOK_START_RESERVED.')
|
|
genc.emitLine(' */')
|
|
|
|
# Encode property flags for RAM initializers.
|
|
def encode_property_flags(flags):
|
|
# Note: must match duk_hobject.h
|
|
|
|
res = 0
|
|
nflags = 0
|
|
if 'w' in flags:
|
|
nflags += 1
|
|
res = res | PROPDESC_FLAG_WRITABLE
|
|
if 'e' in flags:
|
|
nflags += 1
|
|
res = res | PROPDESC_FLAG_ENUMERABLE
|
|
if 'c' in flags:
|
|
nflags += 1
|
|
res = res | PROPDESC_FLAG_CONFIGURABLE
|
|
if 'a' in flags:
|
|
nflags += 1
|
|
res = res | PROPDESC_FLAG_ACCESSOR
|
|
|
|
if nflags != len(flags):
|
|
raise Exception('unsupported flags: %s' % repr(flags))
|
|
|
|
return res
|
|
|
|
# Generate RAM object initdata for an object (but not its properties).
|
|
def gen_ramobj_initdata_for_object(meta, be, bi, string_to_stridx, natfunc_name_to_natidx, objid_to_bidx):
|
|
def _stridx(strval):
|
|
stridx = string_to_stridx[strval]
|
|
be.varuint(stridx)
|
|
def _stridx_or_string(strval):
|
|
stridx = string_to_stridx.get(strval)
|
|
if stridx is not None:
|
|
be.varuint(stridx + 1)
|
|
else:
|
|
be.varuint(0)
|
|
bitpack_string(be, strval)
|
|
def _natidx(native_name):
|
|
natidx = natfunc_name_to_natidx[native_name]
|
|
be.varuint(natidx)
|
|
|
|
class_num = class_to_number(bi['class'])
|
|
be.varuint(class_num)
|
|
|
|
props = [x for x in bi['properties']] # clone
|
|
|
|
prop_proto = steal_prop(props, 'prototype')
|
|
prop_constr = steal_prop(props, 'constructor')
|
|
prop_name = steal_prop(props, 'name', allow_accessor=False)
|
|
prop_length = steal_prop(props, 'length', allow_accessor=False)
|
|
|
|
length = -1 # default value -1 signifies varargs
|
|
if prop_length is not None:
|
|
assert(isinstance(prop_length['value'], int))
|
|
length = prop_length['value']
|
|
be.bits(1, 1) # flag: have length
|
|
be.bits(length, LENGTH_PROP_BITS)
|
|
else:
|
|
be.bits(0, 1) # flag: no length
|
|
|
|
# The attributes for 'length' are standard ("none") except for
|
|
# Array.prototype.length which must be writable (this is handled
|
|
# separately in duk_hthread_builtins.c).
|
|
|
|
len_attrs = LENGTH_PROPERTY_ATTRIBUTES
|
|
if prop_length is not None:
|
|
len_attrs = prop_length['attributes']
|
|
|
|
if len_attrs != LENGTH_PROPERTY_ATTRIBUTES:
|
|
# Attributes are assumed to be the same, except for Array.prototype.
|
|
if bi['class'] != 'Array': # Array.prototype is the only one with this class
|
|
raise Exception('non-default length attribute for unexpected object')
|
|
|
|
# For 'Function' classed objects, emit the native function stuff.
|
|
# Unfortunately this is more or less a copy of what we do for
|
|
# function properties now. This should be addressed if a rework
|
|
# on the init format is done.
|
|
|
|
if bi['class'] == 'Function':
|
|
_natidx(bi['native'])
|
|
|
|
if bi.get('varargs', False):
|
|
be.bits(1, 1) # flag: non-default nargs
|
|
be.bits(NARGS_VARARGS_MARKER, NARGS_BITS)
|
|
elif bi.has_key('nargs') and bi['nargs'] != length:
|
|
be.bits(1, 1) # flag: non-default nargs
|
|
be.bits(bi['nargs'], NARGS_BITS)
|
|
else:
|
|
assert(length is not None)
|
|
be.bits(0, 1) # flag: default nargs OK
|
|
|
|
# All Function-classed global level objects are callable
|
|
# (have [[Call]]) but not all are constructable (have
|
|
# [[Construct]]). Flag that.
|
|
|
|
assert(bi.has_key('callable'))
|
|
assert(bi['callable'] == True)
|
|
|
|
assert(prop_name is not None)
|
|
assert(isinstance(prop_name['value'], str))
|
|
_stridx_or_string(prop_name['value'])
|
|
|
|
if bi.get('constructable', False):
|
|
be.bits(1, 1) # flag: constructable
|
|
else:
|
|
be.bits(0, 1) # flag: not constructable
|
|
# DUK_HOBJECT_FLAG_SPECIAL_CALL is handled at runtime without init data.
|
|
|
|
# Convert signed magic to 16-bit unsigned for encoding
|
|
magic = resolve_magic(bi.get('magic'), objid_to_bidx) & 0xffff
|
|
assert(magic >= 0)
|
|
assert(magic <= 0xffff)
|
|
be.varuint(magic)
|
|
|
|
# Generate RAM object initdata for an object's properties.
|
|
def gen_ramobj_initdata_for_props(meta, be, bi, string_to_stridx, natfunc_name_to_natidx, objid_to_bidx, double_byte_order):
|
|
count_normal_props = 0
|
|
count_function_props = 0
|
|
|
|
def _bidx(bi_id):
|
|
be.varuint(objid_to_bidx[bi_id])
|
|
def _bidx_or_none(bi_id):
|
|
if bi_id is None:
|
|
be.varuint(0)
|
|
else:
|
|
be.varuint(objid_to_bidx[bi_id] + 1)
|
|
def _stridx(strval):
|
|
stridx = string_to_stridx[strval]
|
|
be.varuint(stridx)
|
|
def _stridx_or_string(strval):
|
|
stridx = string_to_stridx.get(strval)
|
|
if stridx is not None:
|
|
be.varuint(stridx + 1)
|
|
else:
|
|
be.varuint(0)
|
|
bitpack_string(be, strval)
|
|
def _natidx(native_name):
|
|
if native_name is None:
|
|
natidx = 0 # 0 is NULL in the native functions table, denotes missing function
|
|
else:
|
|
natidx = natfunc_name_to_natidx[native_name]
|
|
be.varuint(natidx)
|
|
props = [x for x in bi['properties']] # clone
|
|
|
|
# internal prototype: not an actual property so not in property list
|
|
if bi.has_key('internal_prototype'):
|
|
_bidx_or_none(bi['internal_prototype'])
|
|
else:
|
|
_bidx_or_none(None)
|
|
|
|
# external prototype: encoded specially, steal from property list
|
|
prop_proto = steal_prop(props, 'prototype')
|
|
if prop_proto is not None:
|
|
assert(prop_proto['value']['type'] == 'object')
|
|
assert(prop_proto['attributes'] == '')
|
|
_bidx_or_none(prop_proto['value']['id'])
|
|
else:
|
|
_bidx_or_none(None)
|
|
|
|
# external constructor: encoded specially, steal from property list
|
|
prop_constr = steal_prop(props, 'constructor')
|
|
if prop_constr is not None:
|
|
assert(prop_constr['value']['type'] == 'object')
|
|
assert(prop_constr['attributes'] == 'wc')
|
|
_bidx_or_none(prop_constr['value']['id'])
|
|
else:
|
|
_bidx_or_none(None)
|
|
|
|
# name: encoded specially for function objects, so steal and ignore here
|
|
if bi['class'] == 'Function':
|
|
prop_name = steal_prop(props, 'name', allow_accessor=False)
|
|
assert(prop_name is not None)
|
|
assert(isinstance(prop_name['value'], str))
|
|
assert(prop_name['attributes'] == 'c')
|
|
|
|
# length: encoded specially, so steal and ignore
|
|
prop_proto = steal_prop(props, 'length', allow_accessor=False)
|
|
|
|
# Date.prototype.toGMTString needs special handling and is handled
|
|
# directly in duk_hthread_builtins.c; so steal and ignore here.
|
|
if bi['id'] == 'bi_date_prototype':
|
|
prop_togmtstring = steal_prop(props, 'toGMTString')
|
|
assert(prop_togmtstring is not None)
|
|
logger.debug('Stole Date.prototype.toGMTString')
|
|
|
|
# Split properties into non-builtin functions and other properties.
|
|
# This split is a bit arbitrary, but is used to reduce flag bits in
|
|
# the bit stream.
|
|
values = []
|
|
functions = []
|
|
for prop in props:
|
|
if isinstance(prop['value'], dict) and \
|
|
prop['value']['type'] == 'object' and \
|
|
metadata_lookup_object(meta, prop['value']['id']).has_key('native') and \
|
|
not metadata_lookup_object(meta, prop['value']['id']).has_key('bidx'):
|
|
functions.append(prop)
|
|
else:
|
|
values.append(prop)
|
|
|
|
be.varuint(len(values))
|
|
|
|
for valspec in values:
|
|
count_normal_props += 1
|
|
|
|
val = valspec['value']
|
|
|
|
_stridx_or_string(valspec['key'])
|
|
|
|
# Attribute check doesn't check for accessor flag; that is now
|
|
# automatically set by C code when value is an accessor type.
|
|
# Accessors must not have 'writable', so they'll always have
|
|
# non-default attributes (less footprint than adding a different
|
|
# default).
|
|
default_attrs = DEFAULT_DATA_PROPERTY_ATTRIBUTES
|
|
|
|
attrs = valspec.get('attributes', default_attrs)
|
|
attrs = attrs.replace('a', '') # ram bitstream doesn't encode 'accessor' attribute
|
|
if attrs != default_attrs:
|
|
logger.debug('non-default attributes: %s -> %r (default %r)' % (valspec['key'], attrs, default_attrs))
|
|
be.bits(1, 1) # flag: have custom attributes
|
|
be.bits(encode_property_flags(attrs), PROP_FLAGS_BITS)
|
|
else:
|
|
be.bits(0, 1) # flag: no custom attributes
|
|
|
|
if val is None:
|
|
logger.warning('RAM init data format doesn\'t support "null" now, value replaced with "undefined": %r' % valspec)
|
|
#raise Exception('RAM init format doesn\'t support a "null" value now')
|
|
be.bits(PROP_TYPE_UNDEFINED, PROP_TYPE_BITS)
|
|
elif isinstance(val, bool):
|
|
if val == True:
|
|
be.bits(PROP_TYPE_BOOLEAN_TRUE, PROP_TYPE_BITS)
|
|
else:
|
|
be.bits(PROP_TYPE_BOOLEAN_FALSE, PROP_TYPE_BITS)
|
|
elif isinstance(val, (float, int)) or isinstance(val, dict) and val['type'] == 'double':
|
|
# Avoid converting a manually specified NaN temporarily into
|
|
# a float to avoid risk of e.g. NaN being replaced by another.
|
|
if isinstance(val, dict):
|
|
val = val['bytes'].decode('hex')
|
|
assert(len(val) == 8)
|
|
else:
|
|
val = struct.pack('>d', float(val))
|
|
|
|
be.bits(PROP_TYPE_DOUBLE, PROP_TYPE_BITS)
|
|
|
|
# encoding of double must match target architecture byte order
|
|
indexlist = {
|
|
'big': [ 0, 1, 2, 3, 4, 5, 6, 7 ],
|
|
'little': [ 7, 6, 5, 4, 3, 2, 1, 0 ],
|
|
'mixed': [ 3, 2, 1, 0, 7, 6, 5, 4 ] # some arm platforms
|
|
}[double_byte_order]
|
|
|
|
data = ''.join([ val[indexlist[idx]] for idx in xrange(8) ])
|
|
|
|
logger.debug('DOUBLE: %s -> %s' % (val.encode('hex'), data.encode('hex')))
|
|
|
|
if len(data) != 8:
|
|
raise Exception('internal error')
|
|
be.string(data)
|
|
elif isinstance(val, str) or isinstance(val, unicode):
|
|
if isinstance(val, unicode):
|
|
# Note: non-ASCII characters will not currently work,
|
|
# because bits/char is too low.
|
|
val = val.encode('utf-8')
|
|
|
|
if string_to_stridx.has_key(val):
|
|
# String value is in built-in string table -> encode
|
|
# using a string index. This saves some space,
|
|
# especially for the 'name' property of errors
|
|
# ('EvalError' etc).
|
|
|
|
be.bits(PROP_TYPE_STRIDX, PROP_TYPE_BITS)
|
|
_stridx(val)
|
|
else:
|
|
# Not in string table, bitpack string value as is.
|
|
be.bits(PROP_TYPE_STRING, PROP_TYPE_BITS)
|
|
bitpack_string(be, val)
|
|
elif isinstance(val, dict):
|
|
if val['type'] == 'object':
|
|
be.bits(PROP_TYPE_BUILTIN, PROP_TYPE_BITS)
|
|
_bidx(val['id'])
|
|
elif val['type'] == 'undefined':
|
|
be.bits(PROP_TYPE_UNDEFINED, PROP_TYPE_BITS)
|
|
elif val['type'] == 'accessor':
|
|
be.bits(PROP_TYPE_ACCESSOR, PROP_TYPE_BITS)
|
|
getter_natfun = None
|
|
setter_natfun = None
|
|
getter_magic = 0
|
|
setter_magic = 0
|
|
if val.has_key('getter_id'):
|
|
getter_fn = metadata_lookup_object(meta, val['getter_id'])
|
|
getter_natfun = getter_fn['native']
|
|
assert(getter_fn['nargs'] == 0)
|
|
getter_magic = getter_fn['magic']
|
|
if val.has_key('setter_id'):
|
|
setter_fn = metadata_lookup_object(meta, val['setter_id'])
|
|
setter_natfun = setter_fn['native']
|
|
assert(setter_fn['nargs'] == 1)
|
|
setter_magic = setter_fn['magic']
|
|
if getter_natfun is not None and setter_natfun is not None:
|
|
assert(getter_magic == setter_magic)
|
|
_natidx(getter_natfun)
|
|
_natidx(setter_natfun)
|
|
be.varuint(getter_magic)
|
|
elif val['type'] == 'lightfunc':
|
|
logger.warning('RAM init data format doesn\'t support "lightfunc" now, value replaced with "undefined": %r' % valspec)
|
|
be.bits(PROP_TYPE_UNDEFINED, PROP_TYPE_BITS)
|
|
else:
|
|
raise Exception('unsupported value: %s' % repr(val))
|
|
else:
|
|
raise Exception('unsupported value: %s' % repr(val))
|
|
|
|
be.varuint(len(functions))
|
|
|
|
for funprop in functions:
|
|
count_function_props += 1
|
|
|
|
funobj = metadata_lookup_object(meta, funprop['value']['id'])
|
|
prop_len = metadata_lookup_property(funobj, 'length')
|
|
assert(prop_len is not None)
|
|
assert(isinstance(prop_len['value'], (int)))
|
|
length = prop_len['value']
|
|
|
|
# XXX: this doesn't currently handle a function .name != its key
|
|
# At least warn about it here. Or maybe generate the correct name
|
|
# at run time (it's systematic at the moment, @@toPrimitive has the
|
|
# name "[Symbol.toPrimitive]" which can be computed from the symbol
|
|
# internal representation.
|
|
|
|
_stridx_or_string(funprop['key'])
|
|
_natidx(funobj['native'])
|
|
be.bits(length, LENGTH_PROP_BITS)
|
|
|
|
if funobj.get('varargs', False):
|
|
be.bits(1, 1) # flag: non-default nargs
|
|
be.bits(NARGS_VARARGS_MARKER, NARGS_BITS)
|
|
elif funobj.has_key('nargs') and funobj['nargs'] != length:
|
|
be.bits(1, 1) # flag: non-default nargs
|
|
be.bits(funobj['nargs'], NARGS_BITS)
|
|
else:
|
|
be.bits(0, 1) # flag: default nargs OK
|
|
|
|
# XXX: make this check conditional to minimize bit count
|
|
# (there are quite a lot of function properties)
|
|
# Convert signed magic to 16-bit unsigned for encoding
|
|
magic = resolve_magic(funobj.get('magic'), objid_to_bidx) & 0xffff
|
|
assert(magic >= 0)
|
|
assert(magic <= 0xffff)
|
|
be.varuint(magic)
|
|
|
|
default_attrs = DEFAULT_FUNC_PROPERTY_ATTRIBUTES
|
|
attrs = funprop.get('attributes', default_attrs)
|
|
attrs = attrs.replace('a', '') # ram bitstream doesn't encode 'accessor' attribute
|
|
if attrs != default_attrs:
|
|
logger.debug('non-default attributes: %s -> %r (default %r)' % (funprop['key'], attrs, default_attrs))
|
|
be.bits(1, 1) # flag: have custom attributes
|
|
be.bits(encode_property_flags(attrs), PROP_FLAGS_BITS)
|
|
else:
|
|
be.bits(0, 1) # flag: no custom attributes
|
|
|
|
return count_normal_props, count_function_props
|
|
|
|
# Get helper maps for RAM objects.
|
|
def get_ramobj_native_func_maps(meta):
|
|
# Native function list and index
|
|
native_funcs_found = {}
|
|
native_funcs = []
|
|
natfunc_name_to_natidx = {}
|
|
|
|
native_funcs.append(None) # natidx 0 is reserved for NULL
|
|
|
|
for o in meta['objects']:
|
|
if o.has_key('native'):
|
|
native_funcs_found[o['native']] = True
|
|
for v in o['properties']:
|
|
val = v['value']
|
|
if isinstance(val, dict):
|
|
if val['type'] == 'accessor':
|
|
if val.has_key('getter_id'):
|
|
getter = metadata_lookup_object(meta, val['getter_id'])
|
|
native_funcs_found[getter['native']] = True
|
|
if val.has_key('setter_id'):
|
|
setter = metadata_lookup_object(meta, val['setter_id'])
|
|
native_funcs_found[setter['native']] = True
|
|
if val['type'] == 'object':
|
|
target = metadata_lookup_object(meta, val['id'])
|
|
if target.has_key('native'):
|
|
native_funcs_found[target['native']] = True
|
|
if val['type'] == 'lightfunc':
|
|
# No lightfunc support for RAM initializer now.
|
|
pass
|
|
|
|
for idx,k in enumerate(sorted(native_funcs_found.keys())):
|
|
natfunc_name_to_natidx[k] = len(native_funcs)
|
|
native_funcs.append(k) # native func names
|
|
|
|
return native_funcs, natfunc_name_to_natidx
|
|
|
|
# Generate bit-packed RAM object init data.
|
|
def gen_ramobj_initdata_bitpacked(meta, native_funcs, natfunc_name_to_natidx, double_byte_order):
|
|
# RAM initialization is based on a specially filtered list of top
|
|
# level objects which includes objects with 'bidx' and objects
|
|
# which aren't handled as inline values in the init bitstream.
|
|
objlist = meta['objects_ram_toplevel']
|
|
objid_to_idx = meta['_objid_to_ramidx']
|
|
objid_to_object = meta['_objid_to_object'] # This index is valid even for filtered object list
|
|
string_index = meta['_plain_to_stridx']
|
|
|
|
# Generate bitstream
|
|
be = dukutil.BitEncoder()
|
|
count_builtins = 0
|
|
count_normal_props = 0
|
|
count_function_props = 0
|
|
for o in objlist:
|
|
count_builtins += 1
|
|
gen_ramobj_initdata_for_object(meta, be, o, string_index, natfunc_name_to_natidx, objid_to_idx)
|
|
for o in objlist:
|
|
count_obj_normal, count_obj_func = gen_ramobj_initdata_for_props(meta, be, o, string_index, natfunc_name_to_natidx, objid_to_idx, double_byte_order)
|
|
count_normal_props += count_obj_normal
|
|
count_function_props += count_obj_func
|
|
|
|
if be._varuint_count > 0:
|
|
logger.debug('varuint distribution:')
|
|
logger.debug(json.dumps(be._varuint_dist[0:1024]))
|
|
logger.debug('Varuint encoding categories: %r' % be._varuint_cats)
|
|
logger.debug('Varuint efficiency: %f bits/value' % (float(be._varuint_bits) / float(be._varuint_count)))
|
|
romobj_init_data = be.getByteString()
|
|
#logger.debug(repr(romobj_init_data))
|
|
#logger.debug(len(romobj_init_data))
|
|
|
|
logger.debug('%d ram builtins, %d normal properties, %d function properties, %d bytes of object init data' % \
|
|
(count_builtins, count_normal_props, count_function_props, len(romobj_init_data)))
|
|
|
|
return romobj_init_data
|
|
|
|
# Functions to emit object-related source/header parts.
|
|
|
|
def emit_ramobj_source_nativefunc_array(genc, native_func_list):
|
|
genc.emitLine('/* native functions: %d */' % len(native_func_list))
|
|
genc.emitLine('DUK_INTERNAL const duk_c_function duk_bi_native_functions[%d] = {' % len(native_func_list))
|
|
for i in native_func_list:
|
|
# The function pointer cast here makes BCC complain about
|
|
# "initializer too complicated", so omit the cast.
|
|
#genc.emitLine('\t(duk_c_function) %s,' % i)
|
|
if i is None:
|
|
genc.emitLine('\tNULL,')
|
|
else:
|
|
genc.emitLine('\t%s,' % i)
|
|
genc.emitLine('};')
|
|
|
|
def emit_ramobj_source_objinit_data(genc, init_data):
|
|
genc.emitArray(init_data, 'duk_builtins_data', visibility='DUK_INTERNAL', typename='duk_uint8_t', intvalues=True, const=True, size=len(init_data))
|
|
|
|
def emit_ramobj_header_nativefunc_array(genc, native_func_list):
|
|
genc.emitLine('#if !defined(DUK_SINGLE_FILE)')
|
|
genc.emitLine('DUK_INTERNAL_DECL const duk_c_function duk_bi_native_functions[%d];' % len(native_func_list))
|
|
genc.emitLine('#endif /* !DUK_SINGLE_FILE */')
|
|
|
|
def emit_ramobj_header_objects(genc, meta):
|
|
objlist = meta['objects_bidx']
|
|
for idx,o in enumerate(objlist):
|
|
defname = 'DUK_BIDX_' + '_'.join(o['id'].upper().split('_')[1:]) # bi_foo_bar -> FOO_BAR
|
|
genc.emitDefine(defname, idx)
|
|
genc.emitDefine('DUK_NUM_BUILTINS', len(objlist))
|
|
genc.emitDefine('DUK_NUM_BIDX_BUILTINS', len(objlist)) # Objects with 'bidx'
|
|
genc.emitDefine('DUK_NUM_ALL_BUILTINS', len(meta['objects_ram_toplevel'])) # Objects with 'bidx' + temps needed in init
|
|
|
|
def emit_ramobj_header_initdata(genc, init_data):
|
|
genc.emitLine('#if !defined(DUK_SINGLE_FILE)')
|
|
genc.emitLine('DUK_INTERNAL_DECL const duk_uint8_t duk_builtins_data[%d];' % len(init_data))
|
|
genc.emitLine('#endif /* !DUK_SINGLE_FILE */')
|
|
genc.emitDefine('DUK_BUILTINS_DATA_LENGTH', len(init_data))
|
|
|
|
#
|
|
# ROM init data
|
|
#
|
|
# Compile-time initializers for ROM strings and ROM objects. This involves
|
|
# a lot of small details:
|
|
#
|
|
# - Several variants are needed for different options: unpacked vs.
|
|
# packed duk_tval, endianness, string hash in use, etc).
|
|
#
|
|
# - Static initializers must represent objects of different size. For
|
|
# example, separate structs are needed for property tables of different
|
|
# size or value typing.
|
|
#
|
|
# - Union initializers cannot be used portable because they're only
|
|
# available in C99 and above.
|
|
#
|
|
# - Initializers must use 'const' correctly to ensure that the entire
|
|
# initialization data will go into ROM (read-only data section).
|
|
# Const pointers etc will need to be cast into non-const pointers at
|
|
# some point to properly mix with non-const RAM pointers, so a portable
|
|
# const losing cast is needed.
|
|
#
|
|
# - C++ doesn't allow forward declaration of "static const" structures
|
|
# which is problematic because there are cyclical const structures.
|
|
#
|
|
|
|
# Get string hash initializers; need to compute possible string hash variants
|
|
# which will match runtime values.
|
|
def rom_get_strhash16_macro(val):
|
|
hash16le = dukutil.duk_heap_hashstring_dense(val, DUK__FIXED_HASH_SEED, big_endian=False, strhash16=True)
|
|
hash16be = dukutil.duk_heap_hashstring_dense(val, DUK__FIXED_HASH_SEED, big_endian=True, strhash16=True)
|
|
hash16sparse = dukutil.duk_heap_hashstring_sparse(val, DUK__FIXED_HASH_SEED, strhash16=True)
|
|
return 'DUK__STRHASH16(%dU,%dU,%dU)' % (hash16le, hash16be, hash16sparse)
|
|
def rom_get_strhash32_macro(val):
|
|
hash32le = dukutil.duk_heap_hashstring_dense(val, DUK__FIXED_HASH_SEED, big_endian=False, strhash16=False)
|
|
hash32be = dukutil.duk_heap_hashstring_dense(val, DUK__FIXED_HASH_SEED, big_endian=True, strhash16=False)
|
|
hash32sparse = dukutil.duk_heap_hashstring_sparse(val, DUK__FIXED_HASH_SEED, strhash16=False)
|
|
return 'DUK__STRHASH32(%dUL,%dUL,%dUL)' % (hash32le, hash32be, hash32sparse)
|
|
|
|
# Get string character .length; must match runtime .length computation.
|
|
def rom_charlen(x):
|
|
return dukutil.duk_unicode_unvalidated_utf8_length(x)
|
|
|
|
# Get an initializer type and initializer literal for a specified value
|
|
# (expressed in YAML metadata format). The types and initializers depend
|
|
# on declarations emitted before the initializers, and in several cases
|
|
# use a macro to hide the selection between several initializer variants.
|
|
def rom_get_value_initializer(meta, val, bi_str_map, bi_obj_map):
|
|
def double_bytes_initializer(val):
|
|
# Portable and exact float initializer.
|
|
assert(isinstance(val, str) and len(val) == 16) # hex encoded bytes
|
|
val = val.decode('hex')
|
|
tmp = []
|
|
for i in xrange(8):
|
|
t = ord(val[i])
|
|
if t >= 128:
|
|
tmp.append('%dU' % t)
|
|
else:
|
|
tmp.append('%d' % t)
|
|
return 'DUK__DBLBYTES(' + ','.join(tmp) + ')'
|
|
|
|
def tval_number_initializer(val):
|
|
return 'DUK__TVAL_NUMBER(%s)' % double_bytes_initializer(val)
|
|
|
|
v = val['value']
|
|
if v is None:
|
|
init_type = 'duk_rom_tval_null'
|
|
init_lit = 'DUK__TVAL_NULL()'
|
|
elif isinstance(v, (bool)):
|
|
init_type = 'duk_rom_tval_boolean'
|
|
bval = 0
|
|
if v:
|
|
bval = 1
|
|
init_lit = 'DUK__TVAL_BOOLEAN(%d)' % bval
|
|
elif isinstance(v, (int, float)):
|
|
fval = struct.pack('>d', float(v)).encode('hex')
|
|
init_type = 'duk_rom_tval_number'
|
|
init_lit = tval_number_initializer(fval)
|
|
elif isinstance(v, (str, unicode)):
|
|
init_type = 'duk_rom_tval_string'
|
|
init_lit = 'DUK__TVAL_STRING(&%s)' % bi_str_map[v]
|
|
elif isinstance(v, (dict)):
|
|
if v['type'] == 'double':
|
|
init_type = 'duk_rom_tval_number'
|
|
init_lit = tval_number_initializer(v['bytes'])
|
|
elif v['type'] == 'undefined':
|
|
init_type = 'duk_rom_tval_undefined'
|
|
init_lit = 'DUK__TVAL_UNDEFINED()'
|
|
elif v['type'] == 'null':
|
|
init_type = 'duk_rom_tval_null'
|
|
init_lit = 'DUK__TVAL_UNDEFINED()'
|
|
elif v['type'] == 'object':
|
|
init_type = 'duk_rom_tval_object'
|
|
init_lit = 'DUK__TVAL_OBJECT(&%s)' % bi_obj_map[v['id']]
|
|
elif v['type'] == 'accessor':
|
|
getter_ref = 'NULL'
|
|
setter_ref = 'NULL'
|
|
if v.has_key('getter_id'):
|
|
getter_object = metadata_lookup_object(meta, v['getter_id'])
|
|
getter_ref = '&%s' % bi_obj_map[getter_object['id']]
|
|
if v.has_key('setter_id'):
|
|
setter_object = metadata_lookup_object(meta, v['setter_id'])
|
|
setter_ref = '&%s' % bi_obj_map[setter_object['id']]
|
|
init_type = 'duk_rom_tval_accessor'
|
|
init_lit = 'DUK__TVAL_ACCESSOR(%s, %s)' % (getter_ref, setter_ref)
|
|
elif v['type'] == 'lightfunc':
|
|
# Match DUK_LFUNC_FLAGS_PACK() in duk_tval.h.
|
|
if v.has_key('length'):
|
|
assert(v['length'] >= 0 and v['length'] <= 15)
|
|
lf_length = v['length']
|
|
else:
|
|
lf_length = 0
|
|
if v.get('varargs', True):
|
|
lf_nargs = 15 # varargs marker
|
|
else:
|
|
assert(v['nargs'] >= 0 and v['nargs'] <= 14)
|
|
lf_nargs = v['nargs']
|
|
if v.has_key('magic'):
|
|
assert(v['magic'] >= -0x80 and v['magic'] <= 0x7f)
|
|
lf_magic = v['magic'] & 0xff
|
|
else:
|
|
lf_magic = 0
|
|
lf_flags = (lf_magic << 8) + (lf_length << 4) + lf_nargs
|
|
init_type = 'duk_rom_tval_lightfunc'
|
|
init_lit = 'DUK__TVAL_LIGHTFUNC(%s, %dL)' % (v['native'], lf_flags)
|
|
else:
|
|
raise Exception('unhandled value: %r' % val)
|
|
else:
|
|
raise Exception('internal error: %r' % val)
|
|
return init_type, init_lit
|
|
|
|
# Helpers to get either initializer type or value only (not both).
|
|
def rom_get_value_initializer_type(meta, val, bi_str_map, bi_obj_map):
|
|
init_type, init_lit = rom_get_value_initializer(meta, val, bi_str_map, bi_obj_map)
|
|
return init_type
|
|
def rom_get_value_initializer_literal(meta, val, bi_str_map, bi_obj_map):
|
|
init_type, init_lit = rom_get_value_initializer(meta, val, bi_str_map, bi_obj_map)
|
|
return init_lit
|
|
|
|
# Emit ROM strings source: structs/typedefs and their initializers.
|
|
# Separate initialization structs are needed for strings of different
|
|
# length.
|
|
def rom_emit_strings_source(genc, meta):
|
|
# Write built-in strings as code section initializers.
|
|
|
|
strs = meta['_strings_plain'] # all strings, plain versions
|
|
reserved_words = meta['_is_plain_reserved_word']
|
|
strict_reserved_words = meta['_is_plain_strict_reserved_word']
|
|
strs_needing_stridx = meta['strings_stridx']
|
|
|
|
# Sort used lengths and declare per-length initializers.
|
|
lens = []
|
|
for v in strs:
|
|
strlen = len(v)
|
|
if strlen not in lens:
|
|
lens.append(strlen)
|
|
lens.sort()
|
|
for strlen in lens:
|
|
genc.emitLine('typedef struct duk_romstr_%d duk_romstr_%d; ' % (strlen, strlen) +
|
|
'struct duk_romstr_%d { duk_hstring hdr; duk_uint8_t data[%d]; };' % (strlen, strlen + 1))
|
|
genc.emitLine('')
|
|
|
|
# String hash values depend on endianness and other factors,
|
|
# use an initializer macro to select the appropriate hash.
|
|
genc.emitLine('/* When unaligned access possible, 32-bit values are fetched using host order.')
|
|
genc.emitLine(' * When unaligned access not possible, always simulate little endian order.')
|
|
genc.emitLine(' * See: src-input/duk_util_hashbytes.c:duk_util_hashbytes().')
|
|
genc.emitLine(' */')
|
|
genc.emitLine('#if defined(DUK_USE_STRHASH_DENSE)')
|
|
genc.emitLine('#if defined(DUK_USE_HASHBYTES_UNALIGNED_U32_ACCESS)') # XXX: config option to be reworked
|
|
genc.emitLine('#if defined(DUK_USE_INTEGER_BE)')
|
|
genc.emitLine('#define DUK__STRHASH16(hash16le,hash16be,hash16sparse) (hash16be)')
|
|
genc.emitLine('#define DUK__STRHASH32(hash32le,hash32be,hash32sparse) (hash32be)')
|
|
genc.emitLine('#else')
|
|
genc.emitLine('#define DUK__STRHASH16(hash16le,hash16be,hash16sparse) (hash16le)')
|
|
genc.emitLine('#define DUK__STRHASH32(hash32le,hash32be,hash32sparse) (hash32le)')
|
|
genc.emitLine('#endif')
|
|
genc.emitLine('#else')
|
|
genc.emitLine('#define DUK__STRHASH16(hash16le,hash16be,hash16sparse) (hash16le)')
|
|
genc.emitLine('#define DUK__STRHASH32(hash32le,hash32be,hash32sparse) (hash32le)')
|
|
genc.emitLine('#endif')
|
|
genc.emitLine('#else /* DUK_USE_STRHASH_DENSE */')
|
|
genc.emitLine('#define DUK__STRHASH16(hash16le,hash16be,hash16sparse) (hash16sparse)')
|
|
genc.emitLine('#define DUK__STRHASH32(hash32le,hash32be,hash32sparse) (hash32sparse)')
|
|
genc.emitLine('#endif /* DUK_USE_STRHASH_DENSE */')
|
|
|
|
# String header initializer macro, takes into account lowmem etc.
|
|
genc.emitLine('#if defined(DUK_USE_HEAPPTR16)')
|
|
genc.emitLine('#if !defined(DUK_USE_REFCOUNT16)')
|
|
genc.emitLine('#error currently assumes DUK_USE_HEAPPTR16 and DUK_USE_REFCOUNT16 are both defined')
|
|
genc.emitLine('#endif')
|
|
genc.emitLine('#if defined(DUK_USE_HSTRING_CLEN)')
|
|
genc.emitLine('#define DUK__STRINIT(heaphdr_flags,refcount,hash32,hash16,blen,clen,next) \\')
|
|
genc.emitLine('\t{ { (heaphdr_flags) | ((hash16) << 16), DUK__REFCINIT((refcount)), (blen), (duk_hstring *) DUK_LOSE_CONST((next)) }, (clen) }')
|
|
genc.emitLine('#else /* DUK_USE_HSTRING_CLEN */')
|
|
genc.emitLine('#define DUK__STRINIT(heaphdr_flags,refcount,hash32,hash16,blen,clen,next) \\')
|
|
genc.emitLine('\t{ { (heaphdr_flags) | ((hash16) << 16), DUK__REFCINIT((refcount)), (blen), (duk_hstring *) DUK_LOSE_CONST((next)) } }')
|
|
genc.emitLine('#endif /* DUK_USE_HSTRING_CLEN */')
|
|
genc.emitLine('#else /* DUK_USE_HEAPPTR16 */')
|
|
genc.emitLine('#define DUK__STRINIT(heaphdr_flags,refcount,hash32,hash16,blen,clen,next) \\')
|
|
genc.emitLine('\t{ { (heaphdr_flags), DUK__REFCINIT((refcount)), (duk_hstring *) DUK_LOSE_CONST((next)) }, (hash32), (blen), (clen) }')
|
|
genc.emitLine('#endif /* DUK_USE_HEAPPTR16 */')
|
|
|
|
# Organize ROM strings into a chained ROM string table. The ROM string
|
|
# h_next link pointer is used for chaining just like for RAM strings but
|
|
# in a separate string table.
|
|
#
|
|
# To avoid dealing with the different possible string hash algorithms,
|
|
# use a much more trivial lookup key for ROM strings for now.
|
|
romstr_hash = []
|
|
while len(romstr_hash) < ROMSTR_LOOKUP_SIZE:
|
|
romstr_hash.append([])
|
|
for str_index,v in enumerate(strs):
|
|
if len(v) > 0:
|
|
rom_lookup_hash = ord(v[0]) + (len(v) << 4)
|
|
else:
|
|
rom_lookup_hash = 0 + (len(v) << 4)
|
|
rom_lookup_hash = rom_lookup_hash & 0xff
|
|
romstr_hash[rom_lookup_hash].append(v)
|
|
|
|
romstr_next = {} # string -> the string's 'next' link
|
|
for lst in romstr_hash:
|
|
prev = None
|
|
#print(repr(lst))
|
|
for v in lst:
|
|
if prev is not None:
|
|
romstr_next[prev] = v
|
|
prev = v
|
|
|
|
chain_lens = {}
|
|
for lst in romstr_hash:
|
|
chainlen = len(lst)
|
|
if not chain_lens.has_key(chainlen):
|
|
chain_lens[chainlen] = 0
|
|
chain_lens[chainlen] += 1
|
|
tmp = []
|
|
for k in sorted(chain_lens.keys()):
|
|
tmp.append('%d: %d' % (k, chain_lens[k]))
|
|
logger.info('ROM string table chain lengths: %s' % ', '.join(tmp))
|
|
|
|
bi_str_map = {} # string -> initializer variable name
|
|
for str_index,v in enumerate(strs):
|
|
bi_str_map[v] = 'duk_str_%d' % str_index
|
|
|
|
# Emit string initializers. Emit the strings in an order which avoids
|
|
# forward declarations for the h_next link pointers; const forward
|
|
# declarations are a problem in C++.
|
|
genc.emitLine('')
|
|
for lst in romstr_hash:
|
|
for v in reversed(lst):
|
|
tmp = 'DUK_INTERNAL const duk_romstr_%d %s = {' % (len(v), bi_str_map[v])
|
|
flags = [ 'DUK_HTYPE_STRING',
|
|
'DUK_HEAPHDR_FLAG_READONLY',
|
|
'DUK_HEAPHDR_FLAG_REACHABLE',
|
|
'DUK_HSTRING_FLAG_PINNED_LITERAL' ]
|
|
is_arridx = string_is_arridx(v)
|
|
|
|
blen = len(v)
|
|
clen = rom_charlen(v)
|
|
|
|
if blen == clen:
|
|
flags.append('DUK_HSTRING_FLAG_ASCII')
|
|
if is_arridx:
|
|
flags.append('DUK_HSTRING_FLAG_ARRIDX')
|
|
if len(v) >= 1 and v[0] in [ '\x80', '\x81', '\x82', '\xff' ]:
|
|
flags.append('DUK_HSTRING_FLAG_SYMBOL')
|
|
if len(v) >= 1 and v[0] in [ '\x82', '\xff' ]:
|
|
flags.append('DUK_HSTRING_FLAG_HIDDEN')
|
|
if v in [ 'eval', 'arguments' ]:
|
|
flags.append('DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS')
|
|
if reserved_words.has_key(v):
|
|
flags.append('DUK_HSTRING_FLAG_RESERVED_WORD')
|
|
if strict_reserved_words.has_key(v):
|
|
flags.append('DUK_HSTRING_FLAG_STRICT_RESERVED_WORD')
|
|
|
|
h_next = 'NULL'
|
|
if romstr_next.has_key(v):
|
|
h_next = '&' + bi_str_map[romstr_next[v]]
|
|
|
|
tmp += 'DUK__STRINIT(%s,%d,%s,%s,%d,%d,%s),' % \
|
|
('|'.join(flags), 1, rom_get_strhash32_macro(v), \
|
|
rom_get_strhash16_macro(v), blen, clen, h_next)
|
|
|
|
tmpbytes = []
|
|
for c in v:
|
|
if ord(c) < 128:
|
|
tmpbytes.append('%d' % ord(c))
|
|
else:
|
|
tmpbytes.append('%dU' % ord(c))
|
|
tmpbytes.append('%d' % 0) # NUL term
|
|
tmp += '{' + ','.join(tmpbytes) + '}'
|
|
tmp += '};'
|
|
genc.emitLine(tmp)
|
|
|
|
# Emit the ROM string lookup table used by string interning.
|
|
#
|
|
# cdecl> explain const int * const foo;
|
|
# declare foo as const pointer to const int
|
|
genc.emitLine('')
|
|
genc.emitLine('DUK_INTERNAL const duk_hstring * const duk_rom_strings_lookup[%d] = {'% len(romstr_hash))
|
|
tmp = []
|
|
linecount = 0
|
|
for lst in romstr_hash:
|
|
if len(lst) == 0:
|
|
genc.emitLine('\tNULL,')
|
|
else:
|
|
genc.emitLine('\t(const duk_hstring *) &%s,' % bi_str_map[lst[0]])
|
|
genc.emitLine('};')
|
|
|
|
# Emit an array of duk_hstring pointers indexed using DUK_STRIDX_xxx.
|
|
# This will back e.g. DUK_HTHREAD_STRING_XYZ(thr) directly, without
|
|
# needing an explicit array in thr/heap->strs[].
|
|
#
|
|
# cdecl > explain const int * const foo;
|
|
# declare foo as const pointer to const int
|
|
genc.emitLine('')
|
|
genc.emitLine('DUK_INTERNAL const duk_hstring * const duk_rom_strings_stridx[%d] = {' % len(strs_needing_stridx))
|
|
for s in strs_needing_stridx:
|
|
genc.emitLine('\t(const duk_hstring *) &%s,' % bi_str_map[s['str']]) # strs_needing_stridx is a list of objects, not plain strings
|
|
genc.emitLine('};')
|
|
|
|
return bi_str_map
|
|
|
|
# Emit ROM strings header.
|
|
def rom_emit_strings_header(genc, meta):
|
|
genc.emitLine('#if !defined(DUK_SINGLE_FILE)') # C++ static const workaround
|
|
genc.emitLine('DUK_INTERNAL_DECL const duk_hstring * const duk_rom_strings_lookup[%d];' % ROMSTR_LOOKUP_SIZE)
|
|
genc.emitLine('DUK_INTERNAL_DECL const duk_hstring * const duk_rom_strings_stridx[%d];' % len(meta['strings_stridx']))
|
|
genc.emitLine('#endif')
|
|
|
|
# Emit ROM objects initialized types and macros.
|
|
def rom_emit_object_initializer_types_and_macros(genc):
|
|
# Objects and functions are straightforward because they just use the
|
|
# RAM structure which has no dynamic or variable size parts.
|
|
genc.emitLine('typedef struct duk_romobj duk_romobj; ' + \
|
|
'struct duk_romobj { duk_hobject hdr; };')
|
|
genc.emitLine('typedef struct duk_romarr duk_romarr; ' + \
|
|
'struct duk_romarr { duk_harray hdr; };')
|
|
genc.emitLine('typedef struct duk_romfun duk_romfun; ' + \
|
|
'struct duk_romfun { duk_hnatfunc hdr; };')
|
|
genc.emitLine('typedef struct duk_romobjenv duk_romobjenv; ' + \
|
|
'struct duk_romobjenv { duk_hobjenv hdr; };')
|
|
|
|
# For ROM pointer compression we'd need a -compile time- variant.
|
|
# The current portable solution is to just assign running numbers
|
|
# to ROM compressed pointers, and provide the table for user pointer
|
|
# compression function. Much better solutions would be possible,
|
|
# but such solutions are often compiler/platform specific.
|
|
|
|
# Emit object/function initializer which is aware of options affecting
|
|
# the header. Heap next/prev pointers are always NULL.
|
|
genc.emitLine('#if defined(DUK_USE_HEAPPTR16)')
|
|
genc.emitLine('#if !defined(DUK_USE_REFCOUNT16) || defined(DUK_USE_HOBJECT_HASH_PART)')
|
|
genc.emitLine('#error currently assumes DUK_USE_HEAPPTR16 and DUK_USE_REFCOUNT16 are both defined and DUK_USE_HOBJECT_HASH_PART is undefined')
|
|
genc.emitLine('#endif')
|
|
#genc.emitLine('#if !defined(DUK_USE_HEAPPTR_ENC16_STATIC)')
|
|
#genc.emitLine('#error need DUK_USE_HEAPPTR_ENC16_STATIC which provides compile-time pointer compression')
|
|
#genc.emitLine('#endif')
|
|
genc.emitLine('#define DUK__ROMOBJ_INIT(heaphdr_flags,refcount,props,props_enc16,iproto,iproto_enc16,esize,enext,asize,hsize) \\')
|
|
genc.emitLine('\t{ { { (heaphdr_flags), DUK__REFCINIT((refcount)), 0, 0, (props_enc16) }, (iproto_enc16), (esize), (enext), (asize) } }')
|
|
genc.emitLine('#define DUK__ROMARR_INIT(heaphdr_flags,refcount,props,props_enc16,iproto,iproto_enc16,esize,enext,asize,hsize,length) \\')
|
|
genc.emitLine('\t{ { { { (heaphdr_flags), DUK__REFCINIT((refcount)), 0, 0, (props_enc16) }, (iproto_enc16), (esize), (enext), (asize) }, (length), 0 /*length_nonwritable*/ } }')
|
|
genc.emitLine('#define DUK__ROMFUN_INIT(heaphdr_flags,refcount,props,props_enc16,iproto,iproto_enc16,esize,enext,asize,hsize,nativefunc,nargs,magic) \\')
|
|
genc.emitLine('\t{ { { { (heaphdr_flags), DUK__REFCINIT((refcount)), 0, 0, (props_enc16) }, (iproto_enc16), (esize), (enext), (asize) }, (nativefunc), (duk_int16_t) (nargs), (duk_int16_t) (magic) } }')
|
|
genc.emitLine('#define DUK__ROMOBJENV_INIT(heaphdr_flags,refcount,props,props_enc16,iproto,iproto_enc16,esize,enext,asize,hsize,target,has_this) \\')
|
|
genc.emitLine('\t{ { { { (heaphdr_flags), DUK__REFCINIT((refcount)), 0, 0, (props_enc16) }, (iproto_enc16), (esize), (enext), (asize) }, (duk_hobject *) DUK_LOSE_CONST(target), (has_this) } }')
|
|
genc.emitLine('#else /* DUK_USE_HEAPPTR16 */')
|
|
genc.emitLine('#define DUK__ROMOBJ_INIT(heaphdr_flags,refcount,props,props_enc16,iproto,iproto_enc16,esize,enext,asize,hsize) \\')
|
|
genc.emitLine('\t{ { { (heaphdr_flags), DUK__REFCINIT((refcount)), NULL, NULL }, (duk_uint8_t *) DUK_LOSE_CONST(props), (duk_hobject *) DUK_LOSE_CONST(iproto), (esize), (enext), (asize), (hsize) } }')
|
|
genc.emitLine('#define DUK__ROMARR_INIT(heaphdr_flags,refcount,props,props_enc16,iproto,iproto_enc16,esize,enext,asize,hsize,length) \\')
|
|
genc.emitLine('\t{ { { { (heaphdr_flags), DUK__REFCINIT((refcount)), NULL, NULL }, (duk_uint8_t *) DUK_LOSE_CONST(props), (duk_hobject *) DUK_LOSE_CONST(iproto), (esize), (enext), (asize), (hsize) }, (length), 0 /*length_nonwritable*/ } }')
|
|
genc.emitLine('#define DUK__ROMFUN_INIT(heaphdr_flags,refcount,props,props_enc16,iproto,iproto_enc16,esize,enext,asize,hsize,nativefunc,nargs,magic) \\')
|
|
genc.emitLine('\t{ { { { (heaphdr_flags), DUK__REFCINIT((refcount)), NULL, NULL }, (duk_uint8_t *) DUK_LOSE_CONST(props), (duk_hobject *) DUK_LOSE_CONST(iproto), (esize), (enext), (asize), (hsize) }, (nativefunc), (duk_int16_t) (nargs), (duk_int16_t) (magic) } }')
|
|
genc.emitLine('#define DUK__ROMOBJENV_INIT(heaphdr_flags,refcount,props,props_enc16,iproto,iproto_enc16,esize,enext,asize,hsize,target,has_this) \\')
|
|
genc.emitLine('\t{ { { { (heaphdr_flags), DUK__REFCINIT((refcount)), NULL, NULL }, (duk_uint8_t *) DUK_LOSE_CONST(props), (duk_hobject *) DUK_LOSE_CONST(iproto), (esize), (enext), (asize), (hsize) }, (duk_hobject *) DUK_LOSE_CONST(target), (has_this) } }')
|
|
genc.emitLine('#endif /* DUK_USE_HEAPPTR16 */')
|
|
|
|
# Initializer typedef for a dummy function pointer. ROM support assumes
|
|
# function pointers are 32 bits. Using a dummy function pointer type
|
|
# avoids function pointer to normal pointer cast which emits warnings.
|
|
genc.emitLine('typedef void (*duk_rom_funcptr)(void);')
|
|
|
|
# Emit duk_tval structs. This gets a bit messier with packed/unpacked
|
|
# duk_tval, endianness variants, pointer sizes, etc.
|
|
genc.emitLine('#if defined(DUK_USE_PACKED_TVAL)')
|
|
genc.emitLine('typedef struct duk_rom_tval_undefined duk_rom_tval_undefined;')
|
|
genc.emitLine('typedef struct duk_rom_tval_null duk_rom_tval_null;')
|
|
genc.emitLine('typedef struct duk_rom_tval_lightfunc duk_rom_tval_lightfunc;')
|
|
genc.emitLine('typedef struct duk_rom_tval_boolean duk_rom_tval_boolean;')
|
|
genc.emitLine('typedef struct duk_rom_tval_number duk_rom_tval_number;')
|
|
genc.emitLine('typedef struct duk_rom_tval_object duk_rom_tval_object;')
|
|
genc.emitLine('typedef struct duk_rom_tval_string duk_rom_tval_string;')
|
|
genc.emitLine('typedef struct duk_rom_tval_accessor duk_rom_tval_accessor;')
|
|
genc.emitLine('struct duk_rom_tval_number { duk_uint8_t bytes[8]; };')
|
|
genc.emitLine('struct duk_rom_tval_accessor { const duk_hobject *get; const duk_hobject *set; };')
|
|
genc.emitLine('#if defined(DUK_USE_DOUBLE_LE)')
|
|
genc.emitLine('struct duk_rom_tval_object { const void *ptr; duk_uint32_t hiword; };')
|
|
genc.emitLine('struct duk_rom_tval_string { const void *ptr; duk_uint32_t hiword; };')
|
|
genc.emitLine('struct duk_rom_tval_undefined { const void *ptr; duk_uint32_t hiword; };')
|
|
genc.emitLine('struct duk_rom_tval_null { const void *ptr; duk_uint32_t hiword; };')
|
|
genc.emitLine('struct duk_rom_tval_lightfunc { duk_rom_funcptr ptr; duk_uint32_t hiword; };')
|
|
genc.emitLine('struct duk_rom_tval_boolean { duk_uint32_t dummy; duk_uint32_t hiword; };')
|
|
genc.emitLine('#elif defined(DUK_USE_DOUBLE_BE)')
|
|
genc.emitLine('struct duk_rom_tval_object { duk_uint32_t hiword; const void *ptr; };')
|
|
genc.emitLine('struct duk_rom_tval_string { duk_uint32_t hiword; const void *ptr; };')
|
|
genc.emitLine('struct duk_rom_tval_undefined { duk_uint32_t hiword; const void *ptr; };')
|
|
genc.emitLine('struct duk_rom_tval_null { duk_uint32_t hiword; const void *ptr; };')
|
|
genc.emitLine('struct duk_rom_tval_lightfunc { duk_uint32_t hiword; duk_rom_funcptr ptr; };')
|
|
genc.emitLine('struct duk_rom_tval_boolean { duk_uint32_t hiword; duk_uint32_t dummy; };')
|
|
genc.emitLine('#elif defined(DUK_USE_DOUBLE_ME)')
|
|
genc.emitLine('struct duk_rom_tval_object { duk_uint32_t hiword; const void *ptr; };')
|
|
genc.emitLine('struct duk_rom_tval_string { duk_uint32_t hiword; const void *ptr; };')
|
|
genc.emitLine('struct duk_rom_tval_undefined { duk_uint32_t hiword; const void *ptr; };')
|
|
genc.emitLine('struct duk_rom_tval_null { duk_uint32_t hiword; const void *ptr; };')
|
|
genc.emitLine('struct duk_rom_tval_lightfunc { duk_uint32_t hiword; duk_rom_funcptr ptr; };')
|
|
genc.emitLine('struct duk_rom_tval_boolean { duk_uint32_t hiword; duk_uint32_t dummy; };')
|
|
genc.emitLine('#else')
|
|
genc.emitLine('#error invalid endianness defines')
|
|
genc.emitLine('#endif')
|
|
genc.emitLine('#else /* DUK_USE_PACKED_TVAL */')
|
|
# Unpacked initializers are written assuming normal struct alignment
|
|
# rules so that sizeof(duk_tval) == 16. 32-bit pointers need special
|
|
# handling to ensure the individual initializers pad to 16 bytes as
|
|
# necessary.
|
|
# XXX: 32-bit unpacked duk_tval is not yet supported.
|
|
genc.emitLine('#if defined(DUK_UINTPTR_MAX)')
|
|
genc.emitLine('#if (DUK_UINTPTR_MAX <= 0xffffffffUL)')
|
|
genc.emitLine('#error ROM initializer with unpacked duk_tval does not currently work on 32-bit targets')
|
|
genc.emitLine('#endif')
|
|
genc.emitLine('#endif')
|
|
genc.emitLine('typedef struct duk_rom_tval_undefined duk_rom_tval_undefined;')
|
|
genc.emitLine('struct duk_rom_tval_undefined { duk_small_uint_t tag; duk_small_uint_t extra; duk_uint8_t bytes[8]; };')
|
|
genc.emitLine('typedef struct duk_rom_tval_null duk_rom_tval_null;')
|
|
genc.emitLine('struct duk_rom_tval_null { duk_small_uint_t tag; duk_small_uint_t extra; duk_uint8_t bytes[8]; };')
|
|
genc.emitLine('typedef struct duk_rom_tval_boolean duk_rom_tval_boolean;')
|
|
genc.emitLine('struct duk_rom_tval_boolean { duk_small_uint_t tag; duk_small_uint_t extra; duk_uint32_t val; duk_uint32_t unused; };')
|
|
genc.emitLine('typedef struct duk_rom_tval_number duk_rom_tval_number;')
|
|
genc.emitLine('struct duk_rom_tval_number { duk_small_uint_t tag; duk_small_uint_t extra; duk_uint8_t bytes[8]; };')
|
|
genc.emitLine('typedef struct duk_rom_tval_object duk_rom_tval_object;')
|
|
genc.emitLine('struct duk_rom_tval_object { duk_small_uint_t tag; duk_small_uint_t extra; const duk_heaphdr *val; };')
|
|
genc.emitLine('typedef struct duk_rom_tval_string duk_rom_tval_string;')
|
|
genc.emitLine('struct duk_rom_tval_string { duk_small_uint_t tag; duk_small_uint_t extra; const duk_heaphdr *val; };')
|
|
genc.emitLine('typedef struct duk_rom_tval_lightfunc duk_rom_tval_lightfunc;')
|
|
genc.emitLine('struct duk_rom_tval_lightfunc { duk_small_uint_t tag; duk_small_uint_t extra; duk_rom_funcptr ptr; };')
|
|
genc.emitLine('typedef struct duk_rom_tval_accessor duk_rom_tval_accessor;')
|
|
genc.emitLine('struct duk_rom_tval_accessor { const duk_hobject *get; const duk_hobject *set; };')
|
|
genc.emitLine('#endif /* DUK_USE_PACKED_TVAL */')
|
|
genc.emitLine('')
|
|
|
|
# Double initializer byte shuffle macro to handle byte orders
|
|
# without duplicating the entire initializers.
|
|
genc.emitLine('#if defined(DUK_USE_DOUBLE_LE)')
|
|
genc.emitLine('#define DUK__DBLBYTES(a,b,c,d,e,f,g,h) { (h), (g), (f), (e), (d), (c), (b), (a) }')
|
|
genc.emitLine('#elif defined(DUK_USE_DOUBLE_BE)')
|
|
genc.emitLine('#define DUK__DBLBYTES(a,b,c,d,e,f,g,h) { (a), (b), (c), (d), (e), (f), (g), (h) }')
|
|
genc.emitLine('#elif defined(DUK_USE_DOUBLE_ME)')
|
|
genc.emitLine('#define DUK__DBLBYTES(a,b,c,d,e,f,g,h) { (d), (c), (b), (a), (h), (g), (f), (e) }')
|
|
genc.emitLine('#else')
|
|
genc.emitLine('#error invalid endianness defines')
|
|
genc.emitLine('#endif')
|
|
genc.emitLine('')
|
|
|
|
# Emit duk_tval initializer literal macros.
|
|
genc.emitLine('#if defined(DUK_USE_PACKED_TVAL)')
|
|
genc.emitLine('#define DUK__TVAL_NUMBER(hostbytes) { hostbytes }') # bytes already in host order
|
|
genc.emitLine('#if defined(DUK_USE_DOUBLE_LE)')
|
|
genc.emitLine('#define DUK__TVAL_UNDEFINED() { (const void *) NULL, (DUK_TAG_UNDEFINED << 16) }')
|
|
genc.emitLine('#define DUK__TVAL_NULL() { (const void *) NULL, (DUK_TAG_NULL << 16) }')
|
|
genc.emitLine('#define DUK__TVAL_LIGHTFUNC(func,flags) { (duk_rom_funcptr) (func), (DUK_TAG_LIGHTFUNC << 16) + (flags) }')
|
|
genc.emitLine('#define DUK__TVAL_BOOLEAN(bval) { 0, (DUK_TAG_BOOLEAN << 16) + (bval) }')
|
|
genc.emitLine('#define DUK__TVAL_OBJECT(ptr) { (const void *) (ptr), (DUK_TAG_OBJECT << 16) }')
|
|
genc.emitLine('#define DUK__TVAL_STRING(ptr) { (const void *) (ptr), (DUK_TAG_STRING << 16) }')
|
|
genc.emitLine('#elif defined(DUK_USE_DOUBLE_BE)')
|
|
genc.emitLine('#define DUK__TVAL_UNDEFINED() { (DUK_TAG_UNDEFINED << 16), (const void *) NULL }')
|
|
genc.emitLine('#define DUK__TVAL_NULL() { (DUK_TAG_NULL << 16), (const void *) NULL }')
|
|
genc.emitLine('#define DUK__TVAL_LIGHTFUNC(func,flags) { (DUK_TAG_LIGHTFUNC << 16) + (flags), (duk_rom_funcptr) (func) }')
|
|
genc.emitLine('#define DUK__TVAL_BOOLEAN(bval) { (DUK_TAG_BOOLEAN << 16) + (bval), 0 }')
|
|
genc.emitLine('#define DUK__TVAL_OBJECT(ptr) { (DUK_TAG_OBJECT << 16), (const void *) (ptr) }')
|
|
genc.emitLine('#define DUK__TVAL_STRING(ptr) { (DUK_TAG_STRING << 16), (const void *) (ptr) }')
|
|
genc.emitLine('#elif defined(DUK_USE_DOUBLE_ME)')
|
|
genc.emitLine('#define DUK__TVAL_UNDEFINED() { (DUK_TAG_UNDEFINED << 16), (const void *) NULL }')
|
|
genc.emitLine('#define DUK__TVAL_NULL() { (DUK_TAG_NULL << 16), (const void *) NULL }')
|
|
genc.emitLine('#define DUK__TVAL_LIGHTFUNC(func,flags) { (DUK_TAG_LIGHTFUNC << 16) + (flags), (duk_rom_funcptr) (func) }')
|
|
genc.emitLine('#define DUK__TVAL_BOOLEAN(bval) { (DUK_TAG_BOOLEAN << 16) + (bval), 0 }')
|
|
genc.emitLine('#define DUK__TVAL_OBJECT(ptr) { (DUK_TAG_OBJECT << 16), (const void *) (ptr) }')
|
|
genc.emitLine('#define DUK__TVAL_STRING(ptr) { (DUK_TAG_STRING << 16), (const void *) (ptr) }')
|
|
genc.emitLine('#else')
|
|
genc.emitLine('#error invalid endianness defines')
|
|
genc.emitLine('#endif')
|
|
genc.emitLine('#else /* DUK_USE_PACKED_TVAL */')
|
|
genc.emitLine('#define DUK__TVAL_NUMBER(hostbytes) { DUK_TAG_NUMBER, 0, hostbytes }') # bytes already in host order
|
|
genc.emitLine('#define DUK__TVAL_UNDEFINED() { DUK_TAG_UNDEFINED, 0, {0,0,0,0,0,0,0,0} }')
|
|
genc.emitLine('#define DUK__TVAL_NULL() { DUK_TAG_NULL, 0, {0,0,0,0,0,0,0,0} }')
|
|
genc.emitLine('#define DUK__TVAL_BOOLEAN(bval) { DUK_TAG_BOOLEAN, 0, (bval), 0 }')
|
|
genc.emitLine('#define DUK__TVAL_OBJECT(ptr) { DUK_TAG_OBJECT, 0, (const duk_heaphdr *) (ptr) }')
|
|
genc.emitLine('#define DUK__TVAL_STRING(ptr) { DUK_TAG_STRING, 0, (const duk_heaphdr *) (ptr) }')
|
|
genc.emitLine('#define DUK__TVAL_LIGHTFUNC(func,flags) { DUK_TAG_LIGHTFUNC, (flags), (duk_rom_funcptr) (func) }')
|
|
genc.emitLine('#endif /* DUK_USE_PACKED_TVAL */')
|
|
genc.emitLine('#define DUK__TVAL_ACCESSOR(getter,setter) { (const duk_hobject *) (getter), (const duk_hobject *) (setter) }')
|
|
|
|
# Emit ROM objects source: the object/function headers themselves, property
|
|
# table structs for different property table sizes/types, and property table
|
|
# initializers.
|
|
def rom_emit_objects(genc, meta, bi_str_map):
|
|
objs = meta['objects']
|
|
id_to_bidx = meta['_objid_to_bidx']
|
|
|
|
# Table for compressed ROM pointers; reserve high range of compressed pointer
|
|
# values for this purpose. This must contain all ROM pointers that might be
|
|
# referenced (all objects, strings, and property tables at least).
|
|
romptr_compress_list = []
|
|
def compress_rom_ptr(x):
|
|
if x == 'NULL':
|
|
return 0
|
|
try:
|
|
idx = romptr_compress_list.index(x)
|
|
res = ROMPTR_FIRST + idx
|
|
except ValueError:
|
|
romptr_compress_list.append(x)
|
|
res = ROMPTR_FIRST + len(romptr_compress_list) - 1
|
|
assert(res <= 0xffff)
|
|
return res
|
|
|
|
# Need string and object maps (id -> C symbol name) early.
|
|
bi_obj_map = {} # object id -> initializer variable name
|
|
for idx,obj in enumerate(objs):
|
|
bi_obj_map[obj['id']] = 'duk_obj_%d' % idx
|
|
|
|
# Add built-in strings and objects to compressed ROM pointers first.
|
|
for k in sorted(bi_str_map.keys()):
|
|
compress_rom_ptr('&%s' % bi_str_map[k])
|
|
for k in sorted(bi_obj_map.keys()):
|
|
compress_rom_ptr('&%s' % bi_obj_map[k])
|
|
|
|
# Property attributes lookup, map metadata attribute string into a
|
|
# C initializer.
|
|
attr_lookup = {
|
|
'': 'DUK_PROPDESC_FLAGS_NONE',
|
|
'w': 'DUK_PROPDESC_FLAGS_W',
|
|
'e': 'DUK_PROPDESC_FLAGS_E',
|
|
'c': 'DUK_PROPDESC_FLAGS_C',
|
|
'we': 'DUK_PROPDESC_FLAGS_WE',
|
|
'wc': 'DUK_PROPDESC_FLAGS_WC',
|
|
'ec': 'DUK_PROPDESC_FLAGS_EC',
|
|
'wec': 'DUK_PROPDESC_FLAGS_WEC',
|
|
'a': 'DUK_PROPDESC_FLAGS_NONE|DUK_PROPDESC_FLAG_ACCESSOR',
|
|
'ea': 'DUK_PROPDESC_FLAGS_E|DUK_PROPDESC_FLAG_ACCESSOR',
|
|
'ca': 'DUK_PROPDESC_FLAGS_C|DUK_PROPDESC_FLAG_ACCESSOR',
|
|
'eca': 'DUK_PROPDESC_FLAGS_EC|DUK_PROPDESC_FLAG_ACCESSOR',
|
|
}
|
|
|
|
# Emit property table structs. These are very complex because
|
|
# property count *and* individual property type affect the fields
|
|
# in the initializer, properties can be data properties or accessor
|
|
# properties or different duk_tval types. There are also several
|
|
# property table memory layouts, each with a different ordering of
|
|
# keys, values, etc. Union initializers would make things a bit
|
|
# easier but they're not very portable (being C99).
|
|
#
|
|
# The easy solution is to use a separate initializer type for each
|
|
# property type. Could also cache and reuse identical initializers
|
|
# but there'd be very few of them so it's more straightforward to
|
|
# not reuse the structs.
|
|
#
|
|
# NOTE: naming is a bit inconsistent here, duk_tval is used also
|
|
# to refer to property value initializers like a getter/setter pair.
|
|
|
|
genc.emitLine('#if defined(DUK_USE_HOBJECT_LAYOUT_1)')
|
|
for idx,obj in enumerate(objs):
|
|
numprops = len(obj['properties'])
|
|
if numprops == 0:
|
|
continue
|
|
tmp = 'typedef struct duk_romprops_%d duk_romprops_%d; ' % (idx, idx)
|
|
tmp += 'struct duk_romprops_%d { ' % idx
|
|
for idx,val in enumerate(obj['properties']):
|
|
tmp += 'const duk_hstring *key%d; ' % idx
|
|
for idx,val in enumerate(obj['properties']):
|
|
# XXX: fastint support
|
|
tmp += '%s val%d; ' % (rom_get_value_initializer_type(meta, val, bi_str_map, bi_obj_map), idx)
|
|
for idx,val in enumerate(obj['properties']):
|
|
tmp += 'duk_uint8_t flags%d; ' % idx
|
|
tmp += '};'
|
|
genc.emitLine(tmp)
|
|
genc.emitLine('#elif defined(DUK_USE_HOBJECT_LAYOUT_2)')
|
|
for idx,obj in enumerate(objs):
|
|
numprops = len(obj['properties'])
|
|
if numprops == 0:
|
|
continue
|
|
tmp = 'typedef struct duk_romprops_%d duk_romprops_%d; ' % (idx, idx)
|
|
tmp += 'struct duk_romprops_%d { ' % idx
|
|
for idx,val in enumerate(obj['properties']):
|
|
# XXX: fastint support
|
|
tmp += '%s val%d; ' % (rom_get_value_initializer_type(meta, val, bi_str_map, bi_obj_map), idx)
|
|
for idx,val in enumerate(obj['properties']):
|
|
tmp += 'const duk_hstring *key%d; ' % idx
|
|
for idx,val in enumerate(obj['properties']):
|
|
tmp += 'duk_uint8_t flags%d; ' % idx
|
|
# Padding follows for flags, but we don't need to emit it
|
|
# (at the moment there is never an array or hash part).
|
|
tmp += '};'
|
|
genc.emitLine(tmp)
|
|
genc.emitLine('#elif defined(DUK_USE_HOBJECT_LAYOUT_3)')
|
|
for idx,obj in enumerate(objs):
|
|
numprops = len(obj['properties'])
|
|
if numprops == 0:
|
|
continue
|
|
tmp = 'typedef struct duk_romprops_%d duk_romprops_%d; ' % (idx, idx)
|
|
tmp += 'struct duk_romprops_%d { ' % idx
|
|
for idx,val in enumerate(obj['properties']):
|
|
# XXX: fastint support
|
|
tmp += '%s val%d; ' % (rom_get_value_initializer_type(meta, val, bi_str_map, bi_obj_map), idx)
|
|
# No array values
|
|
for idx,val in enumerate(obj['properties']):
|
|
tmp += 'const duk_hstring *key%d; ' % idx
|
|
# No hash index
|
|
for idx,val in enumerate(obj['properties']):
|
|
tmp += 'duk_uint8_t flags%d; ' % idx
|
|
tmp += '};'
|
|
genc.emitLine(tmp)
|
|
genc.emitLine('#else')
|
|
genc.emitLine('#error invalid object layout')
|
|
genc.emitLine('#endif')
|
|
genc.emitLine('')
|
|
|
|
# Forward declare all property tables so that objects can reference them.
|
|
# Also pointer compress them.
|
|
|
|
for idx,obj in enumerate(objs):
|
|
numprops = len(obj['properties'])
|
|
if numprops == 0:
|
|
continue
|
|
|
|
# We would like to use DUK_INTERNAL_DECL here, but that maps
|
|
# to "static const" in a single file build which has C++
|
|
# portability issues: you can't forward declare a static const.
|
|
# We can't reorder the property tables to avoid this because
|
|
# there are cyclic references. So, as the current workaround,
|
|
# declare as external.
|
|
genc.emitLine('DUK_EXTERNAL_DECL const duk_romprops_%d duk_prop_%d;' % (idx, idx))
|
|
|
|
# Add property tables to ROM compressed pointers too.
|
|
compress_rom_ptr('&duk_prop_%d' % idx)
|
|
genc.emitLine('')
|
|
|
|
# Forward declare all objects so that objects can reference them,
|
|
# e.g. internal prototype reference.
|
|
|
|
for idx,obj in enumerate(objs):
|
|
# Careful with C++: must avoid redefining a non-extern const.
|
|
# See commentary above for duk_prop_%d forward declarations.
|
|
if obj.get('callable', False):
|
|
genc.emitLine('DUK_EXTERNAL_DECL const duk_romfun duk_obj_%d;' % idx)
|
|
elif obj.get('class') == 'Array':
|
|
genc.emitLine('DUK_EXTERNAL_DECL const duk_romarr duk_obj_%d;' % idx)
|
|
elif obj.get('class') == 'ObjEnv':
|
|
genc.emitLine('DUK_EXTERNAL_DECL const duk_romobjenv duk_obj_%d;' % idx)
|
|
else:
|
|
genc.emitLine('DUK_EXTERNAL_DECL const duk_romobj duk_obj_%d;' % idx)
|
|
genc.emitLine('')
|
|
|
|
# Define objects, reference property tables. Objects will be
|
|
# logically non-extensible so also leave their extensible flag
|
|
# cleared despite what metadata requests; the runtime code expects
|
|
# ROM objects to be non-extensible.
|
|
for idx,obj in enumerate(objs):
|
|
numprops = len(obj['properties'])
|
|
|
|
isfunc = obj.get('callable', False)
|
|
|
|
if isfunc:
|
|
tmp = 'DUK_EXTERNAL const duk_romfun duk_obj_%d = ' % idx
|
|
elif obj.get('class') == 'Array':
|
|
tmp = 'DUK_EXTERNAL const duk_romarr duk_obj_%d = ' % idx
|
|
elif obj.get('class') == 'ObjEnv':
|
|
tmp = 'DUK_EXTERNAL const duk_romobjenv duk_obj_%d = ' % idx
|
|
else:
|
|
tmp = 'DUK_EXTERNAL const duk_romobj duk_obj_%d = ' % idx
|
|
|
|
flags = [ 'DUK_HTYPE_OBJECT', 'DUK_HEAPHDR_FLAG_READONLY', 'DUK_HEAPHDR_FLAG_REACHABLE' ]
|
|
if isfunc:
|
|
flags.append('DUK_HOBJECT_FLAG_NATFUNC')
|
|
flags.append('DUK_HOBJECT_FLAG_STRICT')
|
|
flags.append('DUK_HOBJECT_FLAG_NEWENV')
|
|
if obj.get('callable', False):
|
|
flags.append('DUK_HOBJECT_FLAG_CALLABLE')
|
|
if obj.get('constructable', False):
|
|
flags.append('DUK_HOBJECT_FLAG_CONSTRUCTABLE')
|
|
if obj.get('class') == 'Array':
|
|
flags.append('DUK_HOBJECT_FLAG_EXOTIC_ARRAY')
|
|
if obj.get('special_call', False):
|
|
flags.append('DUK_HOBJECT_FLAG_SPECIAL_CALL')
|
|
flags.append('DUK_HOBJECT_CLASS_AS_FLAGS(%d)' % class_to_number(obj['class'])) # XXX: use constant, not number
|
|
|
|
refcount = 1 # refcount is faked to be always 1
|
|
if numprops == 0:
|
|
props = 'NULL'
|
|
else:
|
|
props = '&duk_prop_%d' % idx
|
|
props_enc16 = compress_rom_ptr(props)
|
|
|
|
if obj.has_key('internal_prototype'):
|
|
iproto = '&%s' % bi_obj_map[obj['internal_prototype']]
|
|
else:
|
|
iproto = 'NULL'
|
|
iproto_enc16 = compress_rom_ptr(iproto)
|
|
|
|
e_size = numprops
|
|
e_next = e_size
|
|
a_size = 0 # never an array part for now
|
|
h_size = 0 # never a hash for now; not appropriate for perf relevant builds
|
|
|
|
if isfunc:
|
|
nativefunc = obj['native']
|
|
if obj.get('varargs', False):
|
|
nargs = 'DUK_VARARGS'
|
|
elif obj.has_key('nargs'):
|
|
nargs = '%d' % obj['nargs']
|
|
else:
|
|
assert(False) # 'nargs' should be defaulted from 'length' at metadata load
|
|
magic = '%d' % resolve_magic(obj.get('magic', None), id_to_bidx)
|
|
else:
|
|
nativefunc = 'dummy'
|
|
nargs = '0'
|
|
magic = '0'
|
|
|
|
assert(a_size == 0)
|
|
assert(h_size == 0)
|
|
if isfunc:
|
|
tmp += 'DUK__ROMFUN_INIT(%s,%d,%s,%d,%s,%d,%d,%d,%d,%d,%s,%s,%s);' % \
|
|
('|'.join(flags), refcount, props, props_enc16, \
|
|
iproto, iproto_enc16, e_size, e_next, a_size, h_size, \
|
|
nativefunc, nargs, magic)
|
|
elif obj.get('class') == 'Array':
|
|
arrlen = 0
|
|
tmp += 'DUK__ROMARR_INIT(%s,%d,%s,%d,%s,%d,%d,%d,%d,%d,%d);' % \
|
|
('|'.join(flags), refcount, props, props_enc16, \
|
|
iproto, iproto_enc16, e_size, e_next, a_size, h_size, arrlen)
|
|
elif obj.get('class') == 'ObjEnv':
|
|
objenv_target = '&%s' % bi_obj_map[obj['objenv_target']]
|
|
objenv_has_this = obj['objenv_has_this']
|
|
tmp += 'DUK__ROMOBJENV_INIT(%s,%d,%s,%d,%s,%d,%d,%d,%d,%d,%s,%d);' % \
|
|
('|'.join(flags), refcount, props, props_enc16, \
|
|
iproto, iproto_enc16, e_size, e_next, a_size, h_size, objenv_target, objenv_has_this)
|
|
else:
|
|
tmp += 'DUK__ROMOBJ_INIT(%s,%d,%s,%d,%s,%d,%d,%d,%d,%d);' % \
|
|
('|'.join(flags), refcount, props, props_enc16, \
|
|
iproto, iproto_enc16, e_size, e_next, a_size, h_size)
|
|
|
|
genc.emitLine(tmp)
|
|
|
|
# Property tables. Can reference arbitrary strings and objects as
|
|
# they're defined before them.
|
|
|
|
# Properties will be non-configurable, but must be writable so that
|
|
# standard property semantics allow shadowing properties to be
|
|
# established in inherited objects (e.g. "var obj={}; obj.toString
|
|
# = myToString"). Enumerable can also be kept.
|
|
|
|
def _prepAttrs(val):
|
|
attrs = val['attributes']
|
|
assert('c' not in attrs)
|
|
return attr_lookup[attrs]
|
|
|
|
def _emitPropTableInitializer(idx, obj, layout):
|
|
init_vals = []
|
|
init_keys = []
|
|
init_flags = []
|
|
|
|
numprops = len(obj['properties'])
|
|
for val in obj['properties']:
|
|
init_keys.append('(const duk_hstring *)&%s' % bi_str_map[val['key']])
|
|
for val in obj['properties']:
|
|
# XXX: fastint support
|
|
init_vals.append('%s' % rom_get_value_initializer_literal(meta, val, bi_str_map, bi_obj_map))
|
|
for val in obj['properties']:
|
|
init_flags.append('%s' % _prepAttrs(val))
|
|
|
|
if layout == 1:
|
|
initlist = init_keys + init_vals + init_flags
|
|
elif layout == 2:
|
|
initlist = init_vals + init_keys + init_flags
|
|
elif layout == 3:
|
|
# Same as layout 2 now, no hash/array
|
|
initlist = init_vals + init_keys + init_flags
|
|
|
|
if len(initlist) > 0:
|
|
genc.emitLine('DUK_EXTERNAL const duk_romprops_%d duk_prop_%d = {%s};' % (idx, idx, ','.join(initlist)))
|
|
|
|
genc.emitLine('#if defined(DUK_USE_HOBJECT_LAYOUT_1)')
|
|
for idx,obj in enumerate(objs):
|
|
_emitPropTableInitializer(idx, obj, 1)
|
|
genc.emitLine('#elif defined(DUK_USE_HOBJECT_LAYOUT_2)')
|
|
for idx,obj in enumerate(objs):
|
|
_emitPropTableInitializer(idx, obj, 2)
|
|
genc.emitLine('#elif defined(DUK_USE_HOBJECT_LAYOUT_3)')
|
|
for idx,obj in enumerate(objs):
|
|
_emitPropTableInitializer(idx, obj, 3)
|
|
genc.emitLine('#else')
|
|
genc.emitLine('#error invalid object layout')
|
|
genc.emitLine('#endif')
|
|
genc.emitLine('')
|
|
|
|
# Emit a list of ROM builtins (those objects needing a bidx).
|
|
#
|
|
# cdecl > explain const int * const foo;
|
|
# declare foo as const pointer to const int
|
|
|
|
count_bidx = 0
|
|
for bi in objs:
|
|
if bi.get('bidx_used', False):
|
|
count_bidx += 1
|
|
genc.emitLine('DUK_INTERNAL const duk_hobject * const duk_rom_builtins_bidx[%d] = {' % count_bidx)
|
|
for bi in objs:
|
|
if not bi.get('bidx_used', False):
|
|
continue # for this we want the toplevel objects only
|
|
genc.emitLine('\t(const duk_hobject *) &%s,' % bi_obj_map[bi['id']])
|
|
genc.emitLine('};')
|
|
|
|
# Emit a table of compressed ROM pointers. We must be able to
|
|
# compress ROM pointers at compile time so we assign running
|
|
# indices to them. User pointer compression macros must use this
|
|
# array to encode/decode ROM pointers.
|
|
|
|
genc.emitLine('')
|
|
genc.emitLine('#if defined(DUK_USE_ROM_OBJECTS) && defined(DUK_USE_HEAPPTR16)')
|
|
genc.emitLine('DUK_EXTERNAL const void * const duk_rom_compressed_pointers[%d] = {' % (len(romptr_compress_list) + 1))
|
|
for idx,ptr in enumerate(romptr_compress_list):
|
|
genc.emitLine('\t(const void *) %s, /* 0x%04x */' % (ptr, ROMPTR_FIRST + idx))
|
|
romptr_highest = ROMPTR_FIRST + len(romptr_compress_list) - 1
|
|
genc.emitLine('\tNULL') # for convenience
|
|
genc.emitLine('};')
|
|
genc.emitLine('#endif')
|
|
|
|
logger.debug('%d compressed rom pointers (used range is [0x%04x,0x%04x], %d space left)' % \
|
|
(len(romptr_compress_list), ROMPTR_FIRST, romptr_highest, 0xffff - romptr_highest))
|
|
|
|
# Undefine helpers.
|
|
genc.emitLine('')
|
|
for i in [
|
|
'DUK__STRHASH16',
|
|
'DUK__STRHASH32',
|
|
'DUK__DBLBYTES',
|
|
'DUK__TVAL_NUMBER',
|
|
'DUK__TVAL_UNDEFINED',
|
|
'DUK__TVAL_NULL',
|
|
'DUK__TVAL_BOOLEAN',
|
|
'DUK__TVAL_OBJECT',
|
|
'DUK__TVAL_STRING',
|
|
'DUK__STRINIT',
|
|
'DUK__ROMOBJ_INIT',
|
|
'DUK__ROMFUN_INIT'
|
|
]:
|
|
genc.emitLine('#undef ' + i)
|
|
|
|
return romptr_compress_list
|
|
|
|
# Emit ROM objects header.
|
|
def rom_emit_objects_header(genc, meta):
|
|
bidx = 0
|
|
for bi in meta['objects']:
|
|
if not bi.get('bidx_used', False):
|
|
continue # for this we want the toplevel objects only
|
|
genc.emitDefine('DUK_BIDX_' + '_'.join(bi['id'].upper().split('_')[1:]), bidx) # bi_foo_bar -> FOO_BAR
|
|
bidx += 1
|
|
count_bidx = bidx
|
|
genc.emitDefine('DUK_NUM_BUILTINS', count_bidx)
|
|
genc.emitDefine('DUK_NUM_BIDX_BUILTINS', count_bidx)
|
|
genc.emitDefine('DUK_NUM_ALL_BUILTINS', len(meta['objects']))
|
|
genc.emitLine('')
|
|
genc.emitLine('#if !defined(DUK_SINGLE_FILE)') # C++ static const workaround
|
|
genc.emitLine('DUK_INTERNAL_DECL const duk_hobject * const duk_rom_builtins_bidx[%d];' % count_bidx)
|
|
genc.emitLine('#endif')
|
|
|
|
# XXX: missing declarations here, not an issue for single source build.
|
|
# Add missing declarations.
|
|
# XXX: For example, 'DUK_EXTERNAL_DECL ... duk_rom_compressed_pointers[]' is missing.
|
|
|
|
#
|
|
# Shared for both RAM and ROM
|
|
#
|
|
|
|
def emit_header_native_function_declarations(genc, meta):
|
|
emitted = {} # To suppress duplicates
|
|
funclist = []
|
|
def _emit(fname):
|
|
if not emitted.has_key(fname):
|
|
emitted[fname] = True
|
|
funclist.append(fname)
|
|
|
|
for o in meta['objects']:
|
|
if o.has_key('native'):
|
|
_emit(o['native'])
|
|
|
|
for p in o['properties']:
|
|
v = p['value']
|
|
if isinstance(v, dict) and v['type'] == 'lightfunc':
|
|
assert(v.has_key('native'))
|
|
_emit(v['native'])
|
|
logger.debug('Lightfunc function declaration: %r' % v['native'])
|
|
|
|
for fname in funclist:
|
|
# Visibility depends on whether the function is Duktape internal or user.
|
|
# Use a simple prefix for now.
|
|
if fname[:4] == 'duk_':
|
|
genc.emitLine('DUK_INTERNAL_DECL duk_ret_t %s(duk_context *ctx);' % fname)
|
|
else:
|
|
genc.emitLine('extern duk_ret_t %s(duk_context *ctx);' % fname)
|
|
|
|
#
|
|
# Main
|
|
#
|
|
|
|
def main():
|
|
parser = optparse.OptionParser()
|
|
parser.add_option('--git-commit', dest='git_commit', default=None, help='Git commit hash')
|
|
parser.add_option('--git-describe', dest='git_describe', default=None, help='Git describe')
|
|
parser.add_option('--git-branch', dest='git_branch', default=None, help='Git branch name')
|
|
parser.add_option('--duk-version', dest='duk_version', default=None, help='Duktape version (e.g. 10203)')
|
|
parser.add_option('--quiet', dest='quiet', action='store_true', default=False, help='Suppress info messages (show warnings)')
|
|
parser.add_option('--verbose', dest='verbose', action='store_true', default=False, help='Show verbose debug messages')
|
|
parser.add_option('--used-stridx-metadata', dest='used_stridx_metadata', help='DUK_STRIDX_xxx used by source/headers, JSON format')
|
|
parser.add_option('--strings-metadata', dest='strings_metadata', help='Default built-in strings metadata file, YAML format')
|
|
parser.add_option('--objects-metadata', dest='objects_metadata', help='Default built-in objects metadata file, YAML format')
|
|
parser.add_option('--active-options', dest='active_options', help='Active config options from genconfig.py, JSON format')
|
|
parser.add_option('--user-builtin-metadata', dest='obsolete_builtin_metadata', default=None, help=optparse.SUPPRESS_HELP)
|
|
parser.add_option('--builtin-file', dest='builtin_files', metavar='FILENAME', action='append', default=[], help='Built-in string/object YAML metadata to be applied over default built-ins (multiple files may be given, applied in sequence)')
|
|
parser.add_option('--ram-support', dest='ram_support', action='store_true', default=False, help='Support RAM strings/objects')
|
|
parser.add_option('--rom-support', dest='rom_support', action='store_true', default=False, help='Support ROM strings/objects (increases output size considerably)')
|
|
parser.add_option('--rom-auto-lightfunc', dest='rom_auto_lightfunc', action='store_true', default=False, help='Convert ROM built-in function properties into lightfuncs automatically whenever possible')
|
|
parser.add_option('--out-header', dest='out_header', help='Output header file')
|
|
parser.add_option('--out-source', dest='out_source', help='Output source file')
|
|
parser.add_option('--out-metadata-json', dest='out_metadata_json', help='Output metadata file')
|
|
parser.add_option('--dev-dump-final-ram-metadata', dest='dev_dump_final_ram_metadata', help='Development option')
|
|
parser.add_option('--dev-dump-final-rom-metadata', dest='dev_dump_final_rom_metadata', help='Development option')
|
|
(opts, args) = parser.parse_args()
|
|
|
|
if opts.obsolete_builtin_metadata is not None:
|
|
raise Exception('--user-builtin-metadata has been removed, use --builtin-file instead')
|
|
|
|
# Log level.
|
|
if opts.quiet:
|
|
logger.setLevel(logging.WARNING)
|
|
elif opts.verbose:
|
|
logger.setLevel(logging.DEBUG)
|
|
|
|
# Options processing.
|
|
|
|
build_info = {
|
|
'git_commit': opts.git_commit,
|
|
'git_branch': opts.git_branch,
|
|
'git_describe': opts.git_describe,
|
|
'duk_version': int(opts.duk_version),
|
|
}
|
|
|
|
desc = []
|
|
if opts.ram_support:
|
|
desc += [ 'ram built-in support' ]
|
|
if opts.rom_support:
|
|
desc += [ 'rom built-in support' ]
|
|
if opts.rom_auto_lightfunc:
|
|
desc += [ 'rom auto lightfunc' ]
|
|
logger.info('Creating built-in initialization data: ' + ', '.join(desc))
|
|
|
|
# Read in metadata files, normalizing and merging as necessary.
|
|
|
|
active_opts = {}
|
|
if opts.active_options is not None:
|
|
with open(opts.active_options, 'rb') as f:
|
|
active_opts = json.loads(f.read())
|
|
|
|
ram_meta = load_metadata(opts, rom=False, build_info=build_info, active_opts=active_opts)
|
|
rom_meta = load_metadata(opts, rom=True, build_info=build_info, active_opts=active_opts)
|
|
if opts.dev_dump_final_ram_metadata is not None:
|
|
dump_metadata(ram_meta, opts.dev_dump_final_ram_metadata)
|
|
if opts.dev_dump_final_rom_metadata is not None:
|
|
dump_metadata(rom_meta, opts.dev_dump_final_rom_metadata)
|
|
|
|
# Create RAM init data bitstreams.
|
|
|
|
ramstr_data, ramstr_maxlen = gen_ramstr_initdata_bitpacked(ram_meta)
|
|
ram_native_funcs, ram_natfunc_name_to_natidx = get_ramobj_native_func_maps(ram_meta)
|
|
|
|
if opts.ram_support:
|
|
ramobj_data_le = gen_ramobj_initdata_bitpacked(ram_meta, ram_native_funcs, ram_natfunc_name_to_natidx, 'little')
|
|
ramobj_data_be = gen_ramobj_initdata_bitpacked(ram_meta, ram_native_funcs, ram_natfunc_name_to_natidx, 'big')
|
|
ramobj_data_me = gen_ramobj_initdata_bitpacked(ram_meta, ram_native_funcs, ram_natfunc_name_to_natidx, 'mixed')
|
|
|
|
# Write source and header files.
|
|
|
|
gc_src = dukutil.GenerateC()
|
|
gc_src.emitHeader('genbuiltins.py')
|
|
gc_src.emitLine('#include "duk_internal.h"')
|
|
gc_src.emitLine('')
|
|
gc_src.emitLine('#if defined(DUK_USE_ASSERTIONS)')
|
|
gc_src.emitLine('#define DUK__REFCINIT(refc) 0 /*h_assert_refcount*/, (refc) /*actual*/')
|
|
gc_src.emitLine('#else')
|
|
gc_src.emitLine('#define DUK__REFCINIT(refc) (refc) /*actual*/')
|
|
gc_src.emitLine('#endif')
|
|
gc_src.emitLine('')
|
|
gc_src.emitLine('#if defined(DUK_USE_ROM_STRINGS)')
|
|
if opts.rom_support:
|
|
rom_bi_str_map = rom_emit_strings_source(gc_src, rom_meta)
|
|
rom_emit_object_initializer_types_and_macros(gc_src)
|
|
rom_emit_objects(gc_src, rom_meta, rom_bi_str_map)
|
|
else:
|
|
gc_src.emitLine('#error ROM support not enabled, rerun configure.py with --rom-support')
|
|
gc_src.emitLine('#else /* DUK_USE_ROM_STRINGS */')
|
|
emit_ramstr_source_strinit_data(gc_src, ramstr_data)
|
|
gc_src.emitLine('#endif /* DUK_USE_ROM_STRINGS */')
|
|
gc_src.emitLine('')
|
|
gc_src.emitLine('#if defined(DUK_USE_ROM_OBJECTS)')
|
|
if opts.rom_support:
|
|
gc_src.emitLine('#if !defined(DUK_USE_ROM_STRINGS)')
|
|
gc_src.emitLine('#error DUK_USE_ROM_OBJECTS requires DUK_USE_ROM_STRINGS')
|
|
gc_src.emitLine('#endif')
|
|
gc_src.emitLine('#if defined(DUK_USE_HSTRING_ARRIDX)')
|
|
gc_src.emitLine('#error DUK_USE_HSTRING_ARRIDX is currently incompatible with ROM built-ins')
|
|
gc_src.emitLine('#endif')
|
|
else:
|
|
gc_src.emitLine('#error ROM support not enabled, rerun configure.py with --rom-support')
|
|
gc_src.emitLine('#else /* DUK_USE_ROM_OBJECTS */')
|
|
if opts.ram_support:
|
|
emit_ramobj_source_nativefunc_array(gc_src, ram_native_funcs) # endian independent
|
|
gc_src.emitLine('#if defined(DUK_USE_DOUBLE_LE)')
|
|
emit_ramobj_source_objinit_data(gc_src, ramobj_data_le)
|
|
gc_src.emitLine('#elif defined(DUK_USE_DOUBLE_BE)')
|
|
emit_ramobj_source_objinit_data(gc_src, ramobj_data_be)
|
|
gc_src.emitLine('#elif defined(DUK_USE_DOUBLE_ME)')
|
|
emit_ramobj_source_objinit_data(gc_src, ramobj_data_me)
|
|
gc_src.emitLine('#else')
|
|
gc_src.emitLine('#error invalid endianness defines')
|
|
gc_src.emitLine('#endif')
|
|
else:
|
|
gc_src.emitLine('#error RAM support not enabled, rerun configure.py with --ram-support')
|
|
gc_src.emitLine('#endif /* DUK_USE_ROM_OBJECTS */')
|
|
|
|
gc_hdr = dukutil.GenerateC()
|
|
gc_hdr.emitHeader('genbuiltins.py')
|
|
gc_hdr.emitLine('#if !defined(DUK_BUILTINS_H_INCLUDED)')
|
|
gc_hdr.emitLine('#define DUK_BUILTINS_H_INCLUDED')
|
|
gc_hdr.emitLine('')
|
|
gc_hdr.emitLine('#if defined(DUK_USE_ROM_STRINGS)')
|
|
if opts.rom_support:
|
|
emit_header_stridx_defines(gc_hdr, rom_meta)
|
|
rom_emit_strings_header(gc_hdr, rom_meta)
|
|
else:
|
|
gc_hdr.emitLine('#error ROM support not enabled, rerun configure.py with --rom-support')
|
|
gc_hdr.emitLine('#else /* DUK_USE_ROM_STRINGS */')
|
|
if opts.ram_support:
|
|
emit_header_stridx_defines(gc_hdr, ram_meta)
|
|
emit_ramstr_header_strinit_defines(gc_hdr, ram_meta, ramstr_data, ramstr_maxlen)
|
|
else:
|
|
gc_hdr.emitLine('#error RAM support not enabled, rerun configure.py with --ram-support')
|
|
gc_hdr.emitLine('#endif /* DUK_USE_ROM_STRINGS */')
|
|
gc_hdr.emitLine('')
|
|
gc_hdr.emitLine('#if defined(DUK_USE_ROM_OBJECTS)')
|
|
if opts.rom_support:
|
|
# Currently DUK_USE_ROM_PTRCOMP_FIRST must match our fixed
|
|
# define, and the two must be updated in sync. Catch any
|
|
# mismatch to avoid difficult to diagnose errors.
|
|
gc_hdr.emitLine('#if !defined(DUK_USE_ROM_PTRCOMP_FIRST)')
|
|
gc_hdr.emitLine('#error missing DUK_USE_ROM_PTRCOMP_FIRST define')
|
|
gc_hdr.emitLine('#endif')
|
|
gc_hdr.emitLine('#if (DUK_USE_ROM_PTRCOMP_FIRST != %dL)' % ROMPTR_FIRST)
|
|
gc_hdr.emitLine('#error DUK_USE_ROM_PTRCOMP_FIRST must match ROMPTR_FIRST in genbuiltins.py (%d), update manually and re-dist' % ROMPTR_FIRST)
|
|
gc_hdr.emitLine('#endif')
|
|
emit_header_native_function_declarations(gc_hdr, rom_meta)
|
|
rom_emit_objects_header(gc_hdr, rom_meta)
|
|
else:
|
|
gc_hdr.emitLine('#error RAM support not enabled, rerun configure.py with --ram-support')
|
|
gc_hdr.emitLine('#else /* DUK_USE_ROM_OBJECTS */')
|
|
if opts.ram_support:
|
|
emit_header_native_function_declarations(gc_hdr, ram_meta)
|
|
emit_ramobj_header_nativefunc_array(gc_hdr, ram_native_funcs)
|
|
emit_ramobj_header_objects(gc_hdr, ram_meta)
|
|
gc_hdr.emitLine('#if defined(DUK_USE_DOUBLE_LE)')
|
|
emit_ramobj_header_initdata(gc_hdr, ramobj_data_le)
|
|
gc_hdr.emitLine('#elif defined(DUK_USE_DOUBLE_BE)')
|
|
emit_ramobj_header_initdata(gc_hdr, ramobj_data_be)
|
|
gc_hdr.emitLine('#elif defined(DUK_USE_DOUBLE_ME)')
|
|
emit_ramobj_header_initdata(gc_hdr, ramobj_data_me)
|
|
gc_hdr.emitLine('#else')
|
|
gc_hdr.emitLine('#error invalid endianness defines')
|
|
gc_hdr.emitLine('#endif')
|
|
else:
|
|
gc_hdr.emitLine('#error RAM support not enabled, rerun configure.py with --ram-support')
|
|
gc_hdr.emitLine('#endif /* DUK_USE_ROM_OBJECTS */')
|
|
gc_hdr.emitLine('#endif /* DUK_BUILTINS_H_INCLUDED */')
|
|
|
|
with open(opts.out_source, 'wb') as f:
|
|
f.write(gc_src.getString())
|
|
logger.debug('Wrote built-ins source to ' + opts.out_source)
|
|
|
|
with open(opts.out_header, 'wb') as f:
|
|
f.write(gc_hdr.getString())
|
|
logger.debug('Wrote built-ins header to ' + opts.out_header)
|
|
|
|
# Write a JSON file with build metadata, e.g. built-in strings.
|
|
|
|
ver = long(build_info['duk_version'])
|
|
plain_strs = []
|
|
base64_strs = []
|
|
str_objs = []
|
|
for s in ram_meta['strings_stridx']: # XXX: provide all lists?
|
|
t1 = bytes_to_unicode(s['str'])
|
|
t2 = unicode_to_bytes(s['str']).encode('base64').strip()
|
|
plain_strs.append(t1)
|
|
base64_strs.append(t2)
|
|
str_objs.append({
|
|
'plain': t1, 'base64': t2, 'define': s['define']
|
|
})
|
|
meta = {
|
|
'comment': 'Metadata for Duktape sources',
|
|
'duk_version': ver,
|
|
'duk_version_string': '%d.%d.%d' % (ver / 10000, (ver / 100) % 100, ver % 100),
|
|
'git_commit': build_info['git_commit'],
|
|
'git_branch': build_info['git_branch'],
|
|
'git_describe': build_info['git_describe'],
|
|
'builtin_strings': plain_strs,
|
|
'builtin_strings_base64': base64_strs,
|
|
'builtin_strings_info': str_objs
|
|
}
|
|
|
|
with open(opts.out_metadata_json, 'wb') as f:
|
|
f.write(json.dumps(meta, indent=4, sort_keys=True, ensure_ascii=True))
|
|
logger.debug('Wrote built-ins metadata to ' + opts.out_metadata_json)
|
|
|
|
if __name__ == '__main__':
|
|
main()
|