def make_fixedtype_cmps(name, methname): methname = "arith_%s_same" % methname @jit.unroll_safe def do(args): idx = 2 truth = True while idx <= len(args): start = idx - 2 assert start >= 0 w_a, w_b = args[start], args[start + 1] nan_a = not isinstance(w_a, values.W_Number) nan_b = not isinstance(w_b, values.W_Number) if nan_a or nan_b: pf = ["st", "nd", "rd"][idx - 1] if idx <= 3 else "th" w = w_a if nan_a else w_b raise SchemeException( "%s expected number as %s%s argument, got : %s" % (name, idx, pf, w.tostring())) idx += 1 truth = truth and getattr(w_a, methname)(w_b) return values.W_Bool.make(truth) do.__name__ = "fl_" + methname expose("fl" + name, simple=True, arity=Arity.geq(2))(do) expose("unsafe-fl" + name, simple=True, arity=Arity.geq(2))(do) # FIXME: get rid of this code duplication @jit.unroll_safe def do(args): idx = 2 truth = True while idx <= len(args): start = idx - 2 assert start >= 0 w_a, w_b = args[start], args[start + 1] nan_a = not isinstance(w_a, values.W_Number) nan_b = not isinstance(w_b, values.W_Number) if nan_a or nan_b: pf = ["st", "nd", "rd"][idx - 1] if idx <= 3 else "th" w = w_a if nan_a else w_b raise SchemeException( "%s expected number as %s%s argument, got : %s" % (name, idx, pf, w.tostring())) idx += 1 truth = truth and getattr(w_a, methname)(w_b) return values.W_Bool.make(truth) do.__name__ = "fx_" + methname expose("fx" + name, simple=True, arity=Arity.geq(2))(do) expose("unsafe-fx" + name, simple=True, arity=Arity.geq(2))(do)
def _make_arg_unwrapper(func, argstypes, funcname, has_self=False, simple=False): argtype_tuples = [] min_arg = 0 isdefault = False for i, typ in enumerate(argstypes): default_value = None if isinstance(typ, default): isdefault = True default_value = typ.default typ = typ.typ else: assert not isdefault, "non-default argument %s after default argument" % typ min_arg += 1 unwrapper, errorname = typ.make_unwrapper() type_errormsg = "expected %s as argument %s to %s, got " % ( errorname, i, funcname) argtype_tuples.append((i, unwrapper, isdefault, default_value, type_errormsg)) unroll_argtypes = unroll.unrolling_iterable(argtype_tuples) max_arity = len(argstypes) if min_arg == max_arity: aritystring = max_arity else: aritystring = "%s to %s" % (min_arg, max_arity) errormsg_arity = "expected %s arguments to %s, got " % ( aritystring, funcname) if min_arg == max_arity and not has_self and min_arg in (1, 2) and simple: func_arg_unwrap, call1, call2 = make_direct_arg_unwrapper( func, min_arg, unroll_argtypes, errormsg_arity) else: func_arg_unwrap = make_list_arg_unwrapper( func, has_self, min_arg, max_arity, unroll_argtypes, errormsg_arity) call1 = call2 = None _arity = Arity(range(min_arg, max_arity+1), -1) return func_arg_unwrap, _arity, call1, call2
def make_cmp(name, op, con): @expose(name, simple=True, arity=Arity.geq(2)) @jit.unroll_safe def do(args): if len(args) < 2: raise SchemeException("number of arguments to %s too small" % name) idx = 2 truth = True while idx <= len(args): start = idx - 2 assert start >= 0 w_a, w_b = args[start], args[start + 1] nan_a = not isinstance(w_a, values.W_Number) nan_b = not isinstance(w_b, values.W_Number) if nan_a or nan_b: pf = ["st", "nd", "rd"][idx - 1] if idx <= 3 else "th" w = w_a if nan_a else w_b raise SchemeException( "%s expected number as %s%s argument, got : %s" % (name, idx, pf, w.tostring())) idx += 1 truth = truth and getattr(w_a, "arith_" + op)(w_b) return con(truth) do.__name__ = op
def _make_arg_unwrapper(func, argstypes, funcname, has_self=False, simple=False): argtype_tuples = [] min_arg = 0 isdefault = False for i, typ in enumerate(argstypes): default_value = None if isinstance(typ, default): isdefault = True default_value = typ.default typ = typ.typ else: assert not isdefault, "non-default argument %s after default argument" % typ min_arg += 1 unwrapper, errorname = typ.make_unwrapper() type_errormsg = "expected %s as argument %s to %s, got " % ( errorname, i, funcname) argtype_tuples.append((i, unwrapper, isdefault, default_value, type_errormsg)) unroll_argtypes = unroll.unrolling_iterable(argtype_tuples) max_arity = len(argstypes) if min_arg == max_arity: aritystring = max_arity else: aritystring = "%s to %s" % (min_arg, max_arity) errormsg_arity = "expected %s arguments to %s, got " % ( aritystring, funcname) if min_arg == max_arity and not has_self and min_arg in (1, 2) and simple: func_arg_unwrap, call1, call2 = make_direct_arg_unwrapper( func, min_arg, unroll_argtypes, errormsg_arity) else: func_arg_unwrap = make_list_arg_unwrapper( func, has_self, min_arg, max_arity, unroll_argtypes, errormsg_arity) call1 = call2 = None _arity = Arity.oneof(*range(min_arg, max_arity+1)) return func_arg_unwrap, _arity, call1, call2
def _generate_methods(self): """ Generate constructor, predicate, mutator, and accessor """ count = self.total_init_field_cnt self.constructor_arity = Arity([count], -1) self.constructor = W_StructConstructor(self) self.predicate = W_StructPredicate(self) self.accessor = W_StructAccessor(self) self.mutator = W_StructMutator(self)
def make_arith(name, neutral_element, methname, supports_zero_args): art = Arity.geq(0) if supports_zero_args else Arity.geq(1) @expose(name, simple=True, arity=art) @jit.unroll_safe def do(args): # XXX so far (+ '()) returns '(). need better type checking here if not args: if not supports_zero_args: raise SchemeException("expected at least 1 argument to %s" % name) return neutral_element if len(args) == 1: if neutral_element is not None: return getattr(neutral_element, methname)(args[0]) return args[0] else: init = args[0] for i in range(1, jit.promote(len(args))): init = getattr(init, methname)(args[i]) return init do.__name__ = methname
def _generate_methods(self, constr_name): """ Generate constructor, predicate, mutator, and accessor """ if isinstance(constr_name, values.W_Symbol): constr_name = constr_name.utf8value else: constr_name = "make-" + self.name.utf8value count = self.total_init_field_cnt self.constructor_arity = Arity([count], -1) self.constructor = W_StructConstructor(self, constr_name) self.predicate = W_StructPredicate(self) self.accessor = W_StructAccessor(self) self.mutator = W_StructMutator(self)
def wrapper(func): from pycket import values names = [n] if isinstance(n, str) else n name = names[0] if argstypes is not None: func_arg_unwrap, _arity, _, _ = _make_arg_unwrapper(func, argstypes, name, simple=simple) if arity is not None: _arity = arity else: func_arg_unwrap = func _arity = arity or Arity.unknown assert isinstance(_arity, Arity) func_result_handling = _make_result_handling_func(func_arg_unwrap, simple) result_arity = Arity.oneof(1) if simple else None return values.W_Prim(name, make_remove_extra_info(func_result_handling), arity=_arity, result_arity=result_arity)
def get_arity(self): if self.iscallable(): typ = self.struct_type() proc = typ.prop_procedure if isinstance(proc, values.W_Fixnum): offset = typ.get_offset(typ.procedure_source) proc = self._ref(proc.value + offset) return proc.get_arity() else: # -1 for the self argument arity = proc.get_arity() ls = [-1] * len(arity.arity_list) for i, val in enumerate(arity.arity_list): ls[i] = val - 1 at_least = arity.at_least if arity.at_least != -1: at_least -= 1 return Arity([val for val in ls if val != -1], at_least) else: raise SchemeException("%s does not have arity" % self.tostring())
class W_BaseParameter(W_Object): errorname = "parameter" _attrs_ = _immutable_fields_ = ["guard", "name"] ARITY = Arity.oneof(0, 1) def __init__(self, guard=None, name=OBJ_NAME): self.name = name self.guard = None if guard is values.w_false else guard def iscallable(self): return True def get_key(self): raise NotImplementedError("abstract base class") def get_arity(self, promote=False): return W_BaseParameter.ARITY def tostring(self): return "#<procedure:%s>" % self.name
def wrapper(func): from pycket import values names = [n] if isinstance(n, str) else n name = names[0] if argstypes is not None: func_arg_unwrap, _arity, _, _ = _make_arg_unwrapper(func, argstypes, name, simple=simple) if arity is not None: _arity = arity else: func_arg_unwrap = func _arity = arity or Arity.unknown assert isinstance(_arity, Arity) func_result_handling = _make_result_handling_func( func_arg_unwrap, simple) result_arity = Arity.oneof(1) if simple else None return values.W_Prim(name, make_remove_extra_info(func_result_handling), arity=_arity, result_arity=result_arity)
def make_cmp(name, op, con): @expose(name, simple=True, arity=Arity.geq(2)) @jit.unroll_safe def do(args): if len(args) < 2: raise SchemeException("number of arguments to %s too small" % name) idx = 2 truth = True while idx <= len(args): start = idx - 2 assert start >= 0 w_a, w_b = args[start], args[start + 1] if not isinstance(w_a, values.W_Number): raise SchemeException("expected number") if not isinstance(w_b, values.W_Number): raise SchemeException("expected number") idx += 1 truth = truth and getattr(w_a, "arith_" + op)(w_b) return con(truth) do.__name__ = op
def make_cmp(name, op, con): @expose(name, simple=True, arity=Arity.geq(2)) @jit.unroll_safe def do(args): if len(args) < 2: raise SchemeException("number of arguments to %s too small" % name) idx = 2 truth = True while idx <= len(args): start = idx - 2 assert start >= 0 w_a, w_b = args[start], args[start + 1] nan_a = not isinstance(w_a, values.W_Number) nan_b = not isinstance(w_b, values.W_Number) if nan_a or nan_b: pf = ["st", "nd", "rd"][idx-1] if idx <= 3 else "th" w = w_a if nan_a else w_b raise SchemeException("%s expected number as %s%s argument, got : %s" % (name, idx, pf, w.tostring())) idx += 1 truth = truth and getattr(w_a, "arith_" + op)(w_b) return con(truth) do.__name__ = op
if not isinstance(field_name, values.W_Symbol): raise SchemeException("make-struct-field-mutator: expected symbol or #f as argument 2") return values_struct.W_StructFieldMutator(mutator, field.value, field_name) @expose("struct->vector", [values_struct.W_RootStruct]) def expose_struct2vector(struct): return values_struct.struct2vector(struct) @expose("prefab-struct-key", [values.W_Object]) def do_prefab_struct_key(v): if not (isinstance(v, values_struct.W_Struct) and v.struct_type().isprefab): return values.w_false prefab_key = values_struct.W_PrefabKey.from_struct_type(v.struct_type()) return prefab_key.short_key() @expose("make-prefab-struct", arity=Arity.geq(1)) def do_make_prefab_struct(args): assert len(args) > 1 key = args[0] vals = args[1:] return values_struct.W_Struct.make_prefab(key, vals) @expose("prefab-key->struct-type", [values.W_Object, values.W_Fixnum]) def expose_prefab_key2struct_type(w_key, field_count): return values_struct.W_StructType.make_prefab( values_struct.W_PrefabKey.from_raw_key(w_key, field_count.value)) @expose("prefab-key?", [values.W_Object]) def do_prefab_key(v): return values_struct.W_PrefabKey.is_prefab_key(v)
[128379, 128419, True], [128421, 128578, True], [128581, 128719, True], [128736, 128748, True], [128752, 128755, True], [128768, 128883, True], [128896, 128980, True], [129024, 129035, True], [129040, 129095, True], [129104, 129113, True], [129120, 129159, True], [129168, 129197, True], [131072, 173782, True], [173824, 177972, True], [177984, 178205, True], [194560, 195101, False], [917505, 917505, True], [917536, 917631, True], [917760, 917999, True], [983040, 1048573, True], [1048576, 1114109, True]] LEN_CHAR_RANGES = len(known_char_ranges) @expose("make-known-char-range-list", arity=Arity.geq(0)) def make_known_char_range_list(args): all_known = [None]*LEN_CHAR_RANGES for i, (start, end, same_props) in enumerate(known_char_ranges): all_known[i] = to_list([W_Fixnum(start), W_Fixnum(end), W_Bool.make(same_props)]) return to_list(all_known)
from pycket.arity import Arity from pycket.base import W_Object from pycket.error import SchemeException from pycket.prims.expose import expose, expose_val, default, procedure @expose("make-parameter", [values.W_Object, default(values.W_Object, values.w_false)]) def make_parameter(init, guard): return values_parameter.W_Parameter(init, guard) @expose("make-derived-parameter", [values_parameter.W_BaseParameter, procedure, procedure]) def make_derived_parameter(param, guard, wrap): return values_parameter.W_DerivedParameter(param, guard, wrap) @expose("extend-parameterization", arity=Arity.geq(1)) def scheme_extend_parameterization(args): if len(args) == 0: raise SchemeException("extend-parameterization: expected 1 or more arguments") config = args[0] argc = len(args) if argc < 2 or not isinstance(config, values_parameter.W_Parameterization) or argc % 2 != 1: return config parser = ArgParser("extend-parameterization", args, start_at=1) while parser.has_more(): param = parser.parameter() key = parser.object() config = config.extend([param], [key])
def do_mcar(a): return a.car() @expose("mcdr", [values.W_MCons]) def do_mcdr(a): return a.cdr() @expose("set-mcar!", [values.W_MCons, values.W_Object]) def do_set_mcar(a, b): a.set_car(b) @expose("set-mcdr!", [values.W_MCons, values.W_Object]) def do_set_mcdr(a, b): a.set_cdr(b) @expose("map", simple=False, arity=Arity.geq(2)) def do_map(args, env, cont): # XXX this is currently not properly jitted if not args: raise SchemeException("map expected at least two argument, got 0") fn, lists = args[0], args[1:] if not fn.iscallable(): raise SchemeException("map expected a procedure, got something else") # FIXME: more errorchecking assert len(args) >= 0 return map_loop(fn, lists, env, cont) @loop_label def map_loop(f, lists, env, cont): from pycket.interpreter import return_value
@expose("reparameterize", [values_parameter.W_Parameterization]) def reparameterize(p): return p @expose("make-parameter", [values.W_Object, default(values.W_Object, values.w_false)]) def make_parameter(init, guard): return values_parameter.W_Parameter(init, guard) @expose("make-derived-parameter", [values_parameter.W_BaseParameter, procedure, procedure]) def make_derived_parameter(param, guard, wrap): return values_parameter.W_DerivedParameter(param, guard, wrap) @expose("extend-parameterization", arity=Arity.geq(1), simple=False) @jit.unroll_safe def scheme_extend_parameterization(args, env, cont): from pycket.interpreter import return_value if len(args) == 0: raise SchemeException("extend-parameterization: expected 1 or more arguments") config = args[0] argc = len(args) if argc < 2 or argc % 2 != 1: # or not isinstance(config, values_parameter.W_Parameterization): return return_value(config, env, cont) parser = ArgParser("extend-parameterization", args, start_at=1) params = [None]*((argc-1)/2)
from rpython.rlib import jit DEBUG = values.W_Symbol.make("debug") w_default_logger = values.W_Logger(values.w_false, values.w_false, values.w_false, []) LOG_LEVEL = ['none', 'fatal', 'error', 'warning', 'info', 'debug'] LOG_LEVEL = map(values.W_Symbol.make, LOG_LEVEL) + [values.w_false] class __extend_parser__(ArgParser): log_level = LOG_LEVEL @expose("make-logger", arity=Arity.geq(0)) @jit.unroll_safe def make_logger(args): parser = ArgParser("make-logger", args) topic = values.w_false parent = values.w_false propagate_level = DEBUG try: topic = parser.symbol_or_false() parent = parser.logger_or_false() propagate_level = parser.log_level() except EndOfInput: pass
@expose("make-parameter", [values.W_Object, default(values.W_Object, values.w_false)]) def make_parameter(init, guard): return values_parameter.W_Parameter(init, guard) @expose("make-derived-parameter", [values_parameter.W_BaseParameter, procedure, procedure]) def make_derived_parameter(param, guard, wrap): return values_parameter.W_DerivedParameter(param, guard, wrap) @expose("extend-parameterization", arity=Arity.geq(1), simple=False) @jit.unroll_safe def scheme_extend_parameterization(args, env, cont): from pycket.interpreter import return_value if len(args) == 0: raise SchemeException( "extend-parameterization: expected 1 or more arguments") config = args[0] argc = len(args) if argc < 2 or argc % 2 != 1: # or not isinstance(config, values_parameter.W_Parameterization): return return_value(config, env, cont) parser = ArgParser("extend-parameterization", args, start_at=1) params = [None] * ((argc - 1) / 2)
expose("abort-current-continuation", simple=False)(abort_current_continuation) @make_procedure("default-error-escape-handler", [], simple=False) def default_error_escape_handler(env, cont): from pycket.prims.general import do_void args = [values.w_default_continuation_prompt_tag, do_void.w_prim] return abort_current_continuation(args, env, cont) expose_val("error-escape-handler", values_parameter.W_Parameter(default_error_escape_handler)) @make_procedure("default-continuation-prompt-handler", [procedure], simple=False) def default_continuation_prompt_handler(proc, env, cont): return proc.call([], env, cont) @expose("call-with-continuation-prompt", simple=False, arity=Arity.geq(1)) def call_with_continuation_prompt(args, env, cont): if not args: raise SchemeException("call-with-continuation-prompt: not given enough values") parser = ArgParser("call-with-continuation-prompt", args) tag = values.w_default_continuation_prompt_tag handler = values.w_false fun = parser.object() try: tag = parser.prompt_tag() handler = parser.object() except EndOfInput: pass args = parser._object()
from pycket.arity import Arity from pycket.parser_definitions import ArgParser, EndOfInput from pycket.prims.expose import default, expose, expose_val from rpython.rlib import jit DEBUG = values.W_Symbol.make("debug") w_default_logger = values.W_Logger(values.w_false, values.w_false, values.w_false, []) LOG_LEVEL = ['none', 'fatal', 'error', 'warning', 'info', 'debug'] LOG_LEVEL = map(values.W_Symbol.make, LOG_LEVEL) + [values.w_false] class __extend_parser__(ArgParser): log_level = LOG_LEVEL @expose("make-logger", arity=Arity.geq(0)) @jit.unroll_safe def make_logger(args): parser = ArgParser("make-logger", args) topic = values.w_false parent = values.w_false propagate_level = DEBUG try: topic = parser.symbol_or_false() parent = parser.logger_or_false() propagate_level = parser.log_level() except EndOfInput: pass
expose_val("uncaught-exception-handler", uncaught_exception_handler_param) @make_procedure("default-continuation-prompt-handler", [procedure], simple=False) def default_continuation_prompt_handler(proc, env, cont): return proc.call([], env, cont) # @expose("call-with-exception-handler", [procedure, procedure], simple=False) # def call_with_exception_handler(f, thunk, env, cont): # #FIXME @expose("call-with-continuation-prompt", simple=False, arity=Arity.geq(1)) def call_with_continuation_prompt(args, env, cont): if not args: raise SchemeException( "call-with-continuation-prompt: not given enough values") parser = ArgParser("call-with-continuation-prompt", args) tag = values.w_default_continuation_prompt_tag handler = values.w_false fun = parser.expect(values.W_Object) try: tag = parser.expect(values.W_ContinuationPromptTag) handler = parser.expect(values.W_Object) except EndOfInput: pass
if not isinstance(hash, W_HashTable): raise SchemeException(name + ": first argument is not a hash") if not ref_proc.iscallable(): raise SchemeException(name + ": ref-proc is not callable") if not set_proc.iscallable(): raise SchemeException(name + ": set-proc is not callable") if not remove_proc.iscallable(): raise SchemeException(name + ": remove-proc is not callable") if not key_proc.iscallable(): raise SchemeException(name + ": key-proc is not callable") if clear_proc is not values.w_false and not clear_proc.iscallable(): raise SchemeException(name + ": clear-proc is not callable") return hash, ref_proc, set_proc, remove_proc, key_proc, clear_proc, prop_keys, prop_vals @expose("impersonate-hash", arity=Arity.geq(5)) def impersonate_hash(args): unpacked = unpack_hash_args(args, "impersonate-hash") if unpacked[0].immutable(): raise SchemeException( "impersonate-hash: cannot impersonate immutable hash") return imp.W_ImpHashTable(*unpacked) @expose("chaperone-hash", arity=Arity.geq(5)) def chaperone_hash(args): unpacked = unpack_hash_args(args, "chaperone-hash") return imp.W_ImpHashTable(*unpacked) @expose("impersonate-procedure", arity=Arity.geq(2))
raise SchemeException(name + ": wrong number of arguments") if not isinstance(hash, W_HashTable): raise SchemeException(name + ": first argument is not a hash") if not ref_proc.iscallable(): raise SchemeException(name + ": ref-proc is not callable") if not set_proc.iscallable(): raise SchemeException(name + ": set-proc is not callable") if not remove_proc.iscallable(): raise SchemeException(name + ": remove-proc is not callable") if not key_proc.iscallable(): raise SchemeException(name + ": key-proc is not callable") if clear_proc is not values.w_false and not clear_proc.iscallable(): raise SchemeException(name + ": clear-proc is not callable") return hash, ref_proc, set_proc, remove_proc, key_proc, clear_proc, prop_keys, prop_vals @expose("impersonate-hash", arity=Arity.geq(5)) def impersonate_hash(args): unpacked = unpack_hash_args(args, "impersonate-hash") if unpacked[0].immutable(): raise SchemeException("impersonate-hash: cannot impersonate immutable hash") return imp.W_ImpHashTable(*unpacked) @expose("chaperone-hash", arity=Arity.geq(5)) def chaperone_hash(args): unpacked = unpack_hash_args(args, "chaperone-hash") return imp.W_ImpHashTable(*unpacked) @expose("impersonate-procedure", arity=Arity.geq(2)) def impersonate_procedure(args): unpacked = unpack_procedure_args(args, "impersonate-procedure") proc, check, keys, _ = unpacked
@expose("make-parameter", [values.W_Object, default(values.W_Object, values.w_false)]) def make_parameter(init, guard): return values_parameter.W_Parameter(init, guard) @expose("make-derived-parameter", [values_parameter.W_BaseParameter, procedure, procedure]) def make_derived_parameter(param, guard, wrap): return values_parameter.W_DerivedParameter(param, guard, wrap) @expose("extend-parameterization", arity=Arity.geq(1)) @jit.unroll_safe def scheme_extend_parameterization(args): if len(args) == 0: raise SchemeException( "extend-parameterization: expected 1 or more arguments") config = args[0] argc = len(args) if argc < 2 or not isinstance( config, values_parameter.W_Parameterization) or argc % 2 != 1: return config parser = ArgParser("extend-parameterization", args, start_at=1) while parser.has_more():
@expose("struct->vector", [values_struct.W_RootStruct]) def expose_struct2vector(struct): return values_struct.struct2vector(struct) @expose("prefab-struct-key", [values.W_Object]) def do_prefab_struct_key(v): if not (isinstance(v, values_struct.W_Struct) and v.struct_type().isprefab): return values.w_false prefab_key = values_struct.W_PrefabKey.from_struct_type(v.struct_type()) return prefab_key.short_key() @expose("make-prefab-struct", arity=Arity.geq(1)) def do_make_prefab_struct(args): key = args[0] vals = args[1:] return values_struct.W_Struct.make_prefab(key, vals) @expose("prefab-key->struct-type", [values.W_Object, values.W_Fixnum]) def expose_prefab_key2struct_type(w_key, field_count): return values_struct.W_StructType.make_prefab( values_struct.W_PrefabKey.from_raw_key(w_key, field_count.value)) @expose("prefab-key?", [values.W_Object]) def do_prefab_key(v): return values_struct.W_PrefabKey.is_prefab_key(v)
[127280, 127339, False], [127344, 127386, False], [127462, 127490, False], [127504, 127546, True], [127552, 127560, True], [127568, 127569, True], [127744, 127788, True], [127792, 127869, True], [127872, 127950, True], [127956, 127991, True], [128000, 128254, True], [128256, 128330, True], [128336, 128377, True], [128379, 128419, True], [128421, 128578, True], [128581, 128719, True], [128736, 128748, True], [128752, 128755, True], [128768, 128883, True], [128896, 128980, True], [129024, 129035, True], [129040, 129095, True], [129104, 129113, True], [129120, 129159, True], [129168, 129197, True], [131072, 173782, True], [173824, 177972, True], [177984, 178205, True], [194560, 195101, False], [917505, 917505, True], [917536, 917631, True], [917760, 917999, True], [983040, 1048573, True], [1048576, 1114109, True]] LEN_CHAR_RANGES = len(known_char_ranges) @expose("make-known-char-range-list", arity=Arity.geq(0)) def make_known_char_range_list(args): all_known = [None] * LEN_CHAR_RANGES for i, (start, end, same_props) in enumerate(known_char_ranges): all_known[i] = to_list( [W_Fixnum(start), W_Fixnum(end), W_Bool.make(same_props)]) return to_list(all_known)