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 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]
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)
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("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)
