class W_StructPropertyAccessor(values.W_Procedure):
errorname = "struct-property-accessor"
_immutable_fields_ = ["property"]
import_from_mixin(SingleResultMixin)
def __init__(self, prop):
self.property = prop
def get_arity(self):
return Arity.ONE
@make_call_method(
[values.W_Object, default(values.W_Object, None)], simple=False)
def call_with_extra_info(self, arg, fail, env, cont, app):
from pycket.interpreter import return_value
if isinstance(arg, W_StructType):
w_val = arg.read_prop_precise(self.property)
if w_val is not None:
return return_value(w_val, env, cont)
elif isinstance(arg, W_RootStruct):
return arg.get_prop(self.property, env, cont)
elif fail is not None:
if fail.iscallable():
return fail.call_with_extra_info([], env, cont, app)
return return_value(fail, env, cont)
raise SchemeException(
"%s-accessor: expected %s? but got %s" %
(self.property.name, self.property.name, arg.tostring()))
class W_ImpPropertyAccessor(W_ImpPropertyFunction):
errorname = "impersonator-property-accessor"
@make_call_method([values.W_Object, default(values.W_Object)]) # FIXME: handle second argument as proc
def call(self, obj, fail):
v = lookup_property(obj, self.descriptor)
if v:
return v
if v:
return v
if fail:
return fail
raise SchemeException("missing impersonator property")
return linkl, config
"""
(define-values (1/read-compiled-linklet) (hash-ref linklet-primitive-table 'read-compiled-linklet #f))
(define-values (1/instance-unset-variable!) (hash-ref linklet-primitive-table 'instance-unset-variable! #f))
(define-values (1/variable-reference?) (hash-ref linklet-primitive-table 'variable-reference? #f))
(define-values (1/variable-reference-constant?) (hash-ref linklet-primitive-table 'variable-reference-constant? #f))
"""
make_pred("linklet?", W_Linklet)
make_pred("instance?", W_LinkletInstance)
@expose("compile-linklet", [W_Object, default(W_Object, w_false), default(W_Object, w_false), default(W_Object, w_false), default(W_Object, w_false)], simple=False)
def compile_linklet(form, name, import_keys, get_import, options, env, cont):
from pycket.util import console_log
console_log("compiling linklet : %s %s\n import_keys : %s -- get_import : %s" % (name.tostring(), form.tostring(), import_keys.tostring(), get_import.tostring()), 5)
with PerfRegionCPS("compile-linklet"):
cont_ = finish_perf_region_cont("compile-linklet", env, cont)
return do_compile_linklet(form, name, import_keys, get_import, options, env, cont_)
def do_compile_linklet(form, name, import_keys, get_import, options, env, cont):
from pycket.util import console_log
if isinstance(form, W_WrappedConsProper): # s-expr
# read it and create an AST, put it in a W_Linklet and return
if not isinstance(form.car(), W_Symbol) or "linklet" != form.car().tostring():
raise SchemeException("Malformed s-expr. Expected a linklet, got %s" % form.tostring())
else:
w_name = W_Symbol.make("ad-hoc") if name is w_false else name
raise SchemeException("make-ctype: expected (or/c #f procedure) in argument 2 got %s" %
ctr.tostring())
return W_DerivedCType(ctype, rtc, ctr)
def validate_alignment(ctx, arg, align):
if align is values.w_false:
return -1
if isinstance(align, values.W_Fixnum) and align.value in (1, 2, 4, 8, 16):
return align.value
msg = ("%s: expected (or/c #f 1 2 4 8 16) in argument %d got %s" %
(ctx, arg, align.tostring()))
raise SchemeException(msg)
@expose("make-cstruct-type",
[values.W_List,
default(values.W_Object, values.w_false),
default(values.W_Object, values.w_false)])
def make_cstruct_type(types, abi, _alignment):
alignment = validate_alignment("make-cstruct-type", 2, _alignment)
if types.is_proper_list():
types_list = []
for ctype in values.from_list_iter(types):
if not isinstance(ctype, W_CType):
break
types_list.append(ctype)
else:
return W_CStructType(types_list[:], abi, alignment)
msg = "make-cstruct-type: expected (listof ctype?) in argument 0 got %s" % types.tostring()
raise SchemeException(msg)
from pycket.prims.expose import unsafe, default, expose, subclass_unsafe
@expose("vector")
def vector(args):
return values_vector.W_Vector.fromelements(args)
@expose("flvector")
def flvector(args):
return values_vector.W_FlVector.fromelements(args)
# FIXME: immutable
@expose("vector-immutable")
def vector_immutable(args):
return values_vector.W_Vector.fromelements(args, immutable=True)
@expose("make-vector", [values.W_Fixnum, default(values.W_Object, values.W_Fixnum(0))])
def make_vector(w_size, w_val):
size = w_size.value
if size < 0:
raise SchemeException("make-vector: expected a positive fixnum")
return values_vector.W_Vector.fromelement(w_val, size)
@expose("make-flvector", [values.W_Fixnum, default(values.W_Flonum, values.W_Flonum(0.0))])
def make_vector(w_size, w_val):
size = w_size.value
if size < 0:
raise SchemeException("make-flvector: expected a positive fixnum")
return values_vector.W_FlVector.fromelement(w_val, size)
@expose("vector-length", [values_vector.W_MVector])
def vector_length(v):
if c2 == "t":
return BooleanToken(values.w_true)
if c2 == "f":
return BooleanToken(values.w_false)
if c2 in ["(", "[", "{"]:
return LParenToken("#" + c2)
if c2 == "\\":
s = f.read(1)
if not s:
raise SchemeException("unexpected end of file")
c = ord(s[0]) # XXX deal with unicode
return CharToken(values.W_Character.make(unichr(c)))
raise SchemeException("bad token in read: %s" % c2)
raise SchemeException("bad token in read: %s" % c)
@expose("read", [default(values.W_InputPort, None)], simple=False)
def read(port, env, cont):
from pycket.interpreter import return_value
if port is None:
port = current_in_param.get(cont)
v = read_stream(port)
return return_value(v, env, cont)
def read_stream(stream):
next_token = read_token(stream)
if isinstance(next_token, SpecialToken):
v = read_stream(stream)
return next_token.finish(v)
if isinstance(next_token, DelimToken):
if not isinstance(next_token, LParenToken):
raise SchemeException("read: unexpected %s"%next_token.str)
("=", "eq"),
]:
make_fixedtype_cmps(*args)
@expose("unsafe-flsqrt", [unsafe(values.W_Flonum)])
def flsqrt(f):
return f.arith_sqrt()
@expose("add1", [values.W_Number])
def add1(v):
return v.arith_add(values.W_Fixnum.ONE)
@expose("atan", [values.W_Number, default(values.W_Number, None)])
def atan(y, x):
if x is not None:
# FIXME: signs determine the quadrant of the result
# and care about NaNs and precision
if x.arith_zerop() is values.w_false:
z = y.arith_div(x)
else:
# we should raise exn_fail_contract_divide_by_zero
raise SchemeException("zero_divisor")
else:
z = y
return getattr(z, "arith_atan")()
def make_unary_arith(name,
#! /usr/bin/env python
# -*- coding: utf-8 -*-
from pycket import impersonators as imp
from pycket import values
from pycket import vector
from pycket.cont import call_cont, Cont
from pycket.error import SchemeException
from pycket.prims.expose import default, expose, make_callable_label, procedure
# Can use this to promote a get_cmk operation to a callable function.
CMKSetToListHandler = make_callable_label([values.W_Object])
@expose("current-continuation-marks",
[default(values.W_ContinuationPromptTag, values.w_default_continuation_prompt_tag)],
simple=False)
def current_cont_marks(prompt_tag, env, cont):
from pycket.interpreter import return_value
return return_value(values.W_ContinuationMarkSet(cont, prompt_tag), env, cont)
@expose("continuation-marks",
[values.W_Continuation,
default(values.W_ContinuationPromptTag, values.w_default_continuation_prompt_tag)])
def continuation_marks(cont, prompt_tag):
# TODO Prompt tag
return values.W_ContinuationMarkSet(cont.cont, prompt_tag)
@expose("continuation-mark-set->list",
[values.W_ContinuationMarkSet, values.W_Object,
default(values.W_ContinuationPromptTag, None)],
simple=False)
def remove_handle(self, handle):
if handle in self.callbacks:
del(self.callbacks[handle])
if handle in self.weak_callbacks:
del(self.weak_callbacks[handle])
current_plumber_param = values_parameter.W_Parameter(W_Plumber())
expose_val("current-plumber", current_plumber_param)
@expose("make-plumber", [])
def make_plumber():
return W_Plumber()
@expose("plumber-add-flush!", [W_Plumber, procedure, default(values.W_Bool, values.w_false)])
def plumber_add_flush_bang(p, proc, is_weak):
# create a new handle
h = W_PlumberFlushHandle(p)
# put the new handle into p's callbacks with the given proc
if is_weak is values.w_true:
p.set_weak_callback(h, proc)
else:
p.set_callback(h, proc)
return h
@continuation
def plumber_flush_loop_cont(handlers_callbacks, index, env, cont, _vals):
@expose("syntax-tainted?", [values.W_Syntax])
def syntax_tainted(v):
return values.w_false
@expose("syntax->datum", [values.W_Syntax])
def syntax_to_datum(stx):
return stx.val
# FIXME: not implemented
@expose("datum->syntax", [
values.W_Object, values.W_Object,
default(values.W_Object, None),
default(values.W_Object, None),
default(values.W_Object, None)
])
def datum_to_syntax(ctxt, v, srcloc, prop, ignored):
print "NOT YET IMPLEMENTED: datum->syntax"
assert isinstance(ctxt, values.W_Syntax) or ctxt is values.w_false
return values.W_Syntax(v)
@expose("syntax-source", [values.W_Syntax])
def syntax_source(stx):
# XXX Obviously not correct
return values.w_false
("<=", "le"),
(">", "gt"),
(">=", "ge"),
("=", "eq"),
]:
make_fixedtype_cmps(*args)
@expose("unsafe-flsqrt", [unsafe(values.W_Flonum)])
def flsqrt(f):
return f.arith_sqrt()
@expose("add1", [values.W_Number])
def add1(v):
return v.arith_add(values.W_Fixnum.ONE)
@expose("atan", [values.W_Number, default(values.W_Number, None)])
def atan(y, x):
if x is not None:
# FIXME: signs determine the quadrant of the result
# and care about NaNs and precision
if x.arith_zerop() is values.w_false:
z = y.arith_div(x)
else:
# we should raise exn_fail_contract_divide_by_zero
raise SchemeException("zero_divisor")
else:
z = y
return getattr(z, "arith_atan")()
def make_unary_arith(name, methname, flversion=False, fxversion=False,
return W_DerivedCType(ctype, rtc, ctr)
def validate_alignment(ctx, arg, align):
if align is values.w_false:
return -1
if isinstance(align, values.W_Fixnum) and align.value in (1, 2, 4, 8, 16):
return align.value
msg = ("%s: expected (or/c #f 1 2 4 8 16) in argument %d got %s" %
(ctx, arg, align.tostring()))
raise SchemeException(msg)
@expose("make-cstruct-type", [
values.W_List,
default(values.W_Object, values.w_false),
default(values.W_Object, values.w_false)
])
def make_cstruct_type(types, abi, _alignment):
alignment = validate_alignment("make-cstruct-type", 2, _alignment)
if types.is_proper_list():
types_list = []
for ctype in values.from_list_iter(types):
if not isinstance(ctype, W_CType):
break
types_list.append(ctype)
else:
return W_CStructType(types_list[:], abi, alignment)
msg = "make-cstruct-type: expected (listof ctype?) in argument 0 got %s" % types.tostring(
return values_vector.W_Vector.fromelements(args)
@expose("flvector")
def flvector(args):
return values_vector.W_FlVector.fromelements(args)
@expose("extflvector?", [values.W_Object])
def extflvector(obj):
return values.w_false
# FIXME: immutable
@expose("vector-immutable")
def vector_immutable(args):
return values_vector.W_Vector.fromelements(args, immutable=True)
@expose("make-vector", [values.W_Fixnum, default(values.W_Object, values.W_Fixnum.ZERO)])
def make_vector(w_size, w_val):
size = w_size.value
if size < 0:
raise SchemeException("make-vector: expected a positive fixnum")
return values_vector.W_Vector.fromelement(w_val, size)
@expose("make-flvector", [values.W_Fixnum, default(values.W_Flonum, values.W_Flonum.ZERO)])
def make_vector(w_size, w_val):
size = w_size.value
if size < 0:
raise SchemeException("make-flvector: expected a positive fixnum")
return values_vector.W_FlVector.fromelement(w_val, size)
@expose("vector-length", [values_vector.W_MVector])
def vector_length(v):
for start, end in reversed(lst):
s = values.W_Fixnum(start)
e = values.W_Fixnum(end)
elem = values.W_Cons.make(s, e)
acc = values.W_Cons.make(elem, acc)
return acc, end
EMPTY_BYTES = values.W_Bytes.from_string("")
NO_MATCH = values.Values.make([values.w_false, values.w_false])
ZERO = values.W_Fixnum.make(0)
ONE = values.W_Fixnum.make(1)
RMP_ARGS = [
values.W_Object,
values.W_Object,
default(values.W_Fixnum, ZERO),
default(values.W_Object, values.w_false),
default(values.W_Object, values.w_false),
default(values.W_Bytes, EMPTY_BYTES)]
@expose("regexp-match-positions", RMP_ARGS)
@jit.unroll_safe
def rmp(pat, input, inp_start, inp_end, output_port, prefix):
start = inp_start.value
if inp_end is values.w_false:
end = sys.maxint
elif isinstance(inp_end, values.W_Fixnum):
end = inp_end.value
else:
raise SchemeException("regexp-match-positions: expected fixnum or #f for argument 3")
assert output_port is values.w_false, "output port not supported yet"
return values_regex.W_PRegexp(w_str.as_str_utf8())
@expose("byte-regexp", [values.W_Bytes])
def byte_regrexp(w_str):
return values_regex.W_ByteRegexp(w_str.as_str())
@expose("byte-pregexp", [values.W_Bytes])
def byte_pregrexp(w_str):
return values_regex.W_BytePRegexp(w_str.as_str())
EMPTY_BYTES = values.W_Bytes.from_string("")
NO_MATCH = values.Values.make([values.w_false, values.w_false])
RM_ARGS = [
values.W_Object, values.W_Object,
default(values.W_Fixnum, values.W_Fixnum.ZERO),
default(values.W_Object, values.w_false),
default(values.W_Object, values.w_false),
default(values.W_Bytes, EMPTY_BYTES)
]
@expose("regexp-match", RM_ARGS)
@jit.unroll_safe
def regexp_match(w_re, w_str, inp_start, inp_end, output_port, prefix):
start = inp_start.value
if inp_end is values.w_false:
end = sys.maxint
elif isinstance(inp_end, values.W_Fixnum):
end = inp_end.value
else:
raise SchemeException("regexp-match: expected fixnum or #f for argument 3")
# [core:correlated->datum syntax->datum]
@expose("syntax->datum", [W_Object])
def correlated_to_datum(e):
return correlated_to_datum_inner(e)
@continuation
def datum_to_corr_cont(datum, env, cont, _vals):
srcloc_object = check_one_val(_vals)
return return_value(W_Correlated(datum, srcloc_object, {}), env, cont)
# [core:datum->correlated datum->syntax]
@expose("datum->syntax",
[W_Object, W_Object, default(W_Object, w_false)],
simple=False)
def datum_to_correlated(ignored, datum, _srcloc, env, cont):
if isinstance(datum, W_Correlated):
return return_value(datum, env, cont)
else:
from pycket.prims.general import srcloc
srcloc_const = srcloc.constructor
if isinstance(_srcloc, W_Vector):
#unerase = _srcloc.get_strategy().unerase
#vector_contents = unerase(_srcloc.storage)
v_ref = _srcloc.get_strategy().ref
return srcloc_const.call([
v_ref(_srcloc, 0),
v_ref(_srcloc, 1),
("<=", "le"),
(">", "gt"),
(">=", "ge"),
("=", "eq"),
]:
make_fixedtype_cmps(*args)
@expose("unsafe-flsqrt", [unsafe(values.W_Flonum)])
def flsqrt(f):
return f.arith_sqrt()
@expose("add1", [values.W_Number])
def add1(v):
return v.arith_add(values.W_Fixnum(1))
@expose("atan", [values.W_Number, default(values.W_Number, None)])
def atan(y, x):
if x is not None:
# FIXME: signs determine the quadrant of the result
# and care about NaNs and precision
if x.arith_zerop() is values.w_false:
z = y.arith_div(x)
else:
# we should raise exn_fail_contract_divide_by_zero
raise SchemeException("zero_divisor")
else:
z = y
return getattr(z, "arith_atan")()
def make_unary_arith(name, methname, flversion=False, fxversion=False, unwrap_type=values.W_Number):
s = w_s.as_str_utf8()
try:
if "." in s:
return values.W_Flonum(rfloat.string_to_float(s))
else:
try:
return values.W_Fixnum(rarithmetic.string_to_int(s, base=10))
except ParseStringOverflowError:
return values.W_Bignum(rbigint.rbigint.fromstr(s))
except ParseStringError as e:
return values.w_false
@expose("number->string",
[values.W_Number,
default(values.W_Fixnum, values.W_Fixnum.make(10))])
def num2str(a, radix):
from rpython.rlib.rbigint import BASE8, BASE16
if radix.value == 10:
return W_String.fromascii(a.tostring())
else:
if isinstance(a, values.W_Fixnum):
if radix.value == 16:
res = hex(a.value)
if a.value >= 0:
res = res[2:]
else:
res = "-" + res[3:]
return W_String.fromascii(res)
#elif radix.value == 8:
# return W_String.fromascii(oct(a.value))
else:
return e
# [core:correlated->datum syntax->datum]
@expose("syntax->datum", [W_Object])
def correlated_to_datum(e):
return correlated_to_datum_inner(e)
@continuation
def datum_to_corr_cont(datum, env, cont, _vals):
srcloc_object = check_one_val(_vals)
return return_value(W_Correlated(datum, srcloc_object, {}), env, cont)
# [core:datum->correlated datum->syntax]
@expose("datum->syntax", [W_Object, W_Object, default(W_Object, w_false)], simple=False)
def datum_to_correlated(ignored, datum, _srcloc, env, cont):
if isinstance(datum, W_Correlated):
return return_value(datum, env, cont)
else:
from pycket.prims.general import srcloc
srcloc_const = srcloc.constructor
if isinstance(_srcloc, W_Vector):
#unerase = _srcloc.get_strategy().unerase
#vector_contents = unerase(_srcloc.storage)
v_ref = _srcloc.get_strategy().ref
return srcloc_const.call([v_ref(_srcloc, 0),
v_ref(_srcloc, 1),
v_ref(_srcloc, 2),
v_ref(_srcloc, 3),
receive_first_field(proc, v, v1, v2, env, cont))
return proc.call([v, v1, v2], env, cont)
################################################################
# printing
@expose("current-logger", [])
def current_logger():
return values.current_logger
@expose("make-logger", [values.W_Symbol, values.W_Logger])
def make_logger(name, parent):
return values.W_Logger()
@expose("make-parameter",
[values.W_Object, default(values.W_Object, values.w_false)])
def make_parameter(init, guard):
return values.W_Parameter(init, guard)
@expose("system-library-subpath", [default(values.W_Object, values.w_false)])
def sys_lib_subpath(mode):
return values.W_Path("x86_64-linux") # FIXME
@expose("primitive-closure?", [values.W_Object])
def prim_clos(v):
return values.w_false
################################################################
# built-in struct types
def define_struct(name, super=values.w_null, fields=[]):
def syntax_tainted(v):
return values.w_false
@expose("syntax->datum", [values.W_Syntax])
def syntax_to_datum(stx):
return stx.val
@expose("syntax-e", [values.W_Syntax])
def syntax_e(stx):
# XXX Obviously not correct
print "NOT YET IMPLEMENTED: syntax-e"
return stx.val
# FIXME: not implemented
@expose("datum->syntax", [values.W_Object, values.W_Object,
default(values.W_Object, None), default(values.W_Object, None),
default(values.W_Object, None)])
def datum_to_syntax(ctxt, v, srcloc, prop, ignored):
print "NOT YET IMPLEMENTED: datum->syntax"
assert isinstance(ctxt, values.W_Syntax) or ctxt is values.w_false
return values.W_Syntax(v)
@expose("syntax-source", [values.W_Syntax])
def syntax_source(stx):
# XXX Obviously not correct
return values.w_false
@expose("syntax-source-module", [values.W_Syntax, default(values.W_Object, values.w_false)])
def syntax_source_module(stx, src):
# XXX Obviously not correct
return values.W_ResolvedModulePath(values.W_Symbol.make("fake symbol"))
from pycket import values
from pycket import values_parameter
from pycket.argument_parser import ArgParser, EndOfInput
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)
@expose(["flrandom", "unsafe-flrandom"], [values.W_PseudoRandomGenerator])
def flrandom(gen):
return values.W_Flonum(rng.random())
@expose("random-seed", [values.W_Fixnum])
def random_seed(seed):
key = [rarithmetic.r_uint(seed.value)]
rng.init_by_array(key)
return values.w_void
@expose("make-pseudo-random-generator", [])
def make_pseudo_random_generator():
return values.W_PseudoRandomGenerator()
current_pseudo_random_generator = values_parameter.W_Parameter(values.W_PseudoRandomGenerator())
expose_val("current-pseudo-random-generator", current_pseudo_random_generator)
@expose("pseudo-random-generator->vector", [values.W_PseudoRandomGenerator])
def pseudo_random_generator_to_vector(gen):
return values_vector.W_Vector.fromelements([])
@expose("vector->pseudo-random-generator", [values.W_PseudoRandomGenerator, default(values.W_MVector, None)])
def vector_to_pseudo_random_generator(gen, vec):
return values.W_PseudoRandomGenerator()
@expose("pseudo-random-generator-vector?", [values.W_Object])
def pseudo_random_generator_vector_huh(vec):
return values.W_Bool.make(isinstance(vec, values.W_MVector) and vec.length() == 0)
@continuation
def rewind_next_frame_cont(frames, index, final_cont, env, cont, _vals):
return do_rewind_frames(frames, index - 1, env, final_cont)
def unwind_frames(frames, env, final_cont):
return do_unwind_frames(frames, 0, env, final_cont)
def rewind_frames(frames, env, final_cont):
return do_rewind_frames(frames, len(frames) - 1, env, final_cont)
@expose("continuation-prompt-available?",
[values.W_ContinuationPromptTag,
default(values.W_Continuation, None)],
simple=False)
def cont_prompt_avail(tag, continuation, env, cont):
from pycket.interpreter import return_value
if continuation is not None:
cont = continuation.cont
prompt = find_continuation_prompt(tag, cont)
available = values.W_Bool.make(prompt is not None)
return return_value(available, env, cont)
@continuation
def dynamic_wind_pre_cont(value, pre, post, env, cont, _vals):
cont = DynamicWindValueCont(pre, post, env, cont)
return value.call([], env, cont)
rng.init_by_array(key)
return values.w_void
@expose("make-pseudo-random-generator", [])
def make_pseudo_random_generator():
return values.W_PseudoRandomGenerator()
current_pseudo_random_generator = values_parameter.W_Parameter(
values.W_PseudoRandomGenerator())
expose_val("current-pseudo-random-generator", current_pseudo_random_generator)
@expose("pseudo-random-generator->vector", [values.W_PseudoRandomGenerator])
def pseudo_random_generator_to_vector(gen):
return values_vector.W_Vector.fromelements([])
@expose("vector->pseudo-random-generator",
[values.W_PseudoRandomGenerator,
default(values.W_MVector, None)])
def vector_to_pseudo_random_generator(gen, vec):
return values.W_PseudoRandomGenerator()
@expose("pseudo-random-generator-vector?", [values.W_Object])
def pseudo_random_generator_vector_huh(vec):
return values.W_Bool.make(
isinstance(vec, values.W_MVector) and vec.length() == 0)
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
# Any remaining arguments are propagate topics
propagate_topic = parser._symbol_or_false()
return values.W_Logger(topic, parent, propagate_level, propagate_topic)
@expose("log-level?", [values.W_Object, values.W_Object, default(values.W_Object, values.w_false)])
def log_level(logger, level, topic):
# TODO: Actual implementation
return values.w_false
@expose("log-message", arity=Arity.oneof(4, 5, 6))
def log_message(args):
# TODO: Actual implementation
return
w_current_logger = values_parameter.W_Parameter(w_default_logger)
expose_val("current-logger", w_current_logger)
return BooleanToken(values.w_true)
if c2 == "f":
return BooleanToken(values.w_false)
if c2 in ["(", "[", "{"]:
return LParenToken("#" + c2)
if c2 == "\\":
s = f.read(1)
if not s:
raise SchemeException("unexpected end of file")
c = ord(s[0]) # XXX deal with unicode
return CharToken(values.W_Character.make(unichr(c)))
raise SchemeException("bad token in read: %s" % c2)
raise SchemeException("bad token in read: %s" % c)
@expose("read", [default(values.W_Object, None)], simple=False)
def read(port, env, cont):
from pycket.interpreter import return_value
cont = read_stream_cont(env, cont)
return get_input_port(port, env, cont)
def get_input_port(port, env, cont):
from pycket.interpreter import return_value
if port is None:
port = current_in_param.get(cont)
return return_value(port, env, cont)
else:
return get_port(port, values_struct.w_prop_input_port,
values.W_InputPort, env, cont)
values.w_default_continuation_prompt_tag)
cont = post_build_exception(env, cont)
return exn_fail.constructor.call([message, marks], env, cont)
def find_continuation_prompt(tag, cont):
while cont is not None:
if isinstance(cont, Prompt) and cont.tag is tag:
return cont
cont = cont.get_previous_continuation()
return None
@expose("continuation-prompt-available?",
[values.W_ContinuationPromptTag,
default(values.W_Continuation, None)],
simple=False)
def cont_prompt_avail(tag, continuation, env, cont):
from pycket.interpreter import return_value
if continuation is not None:
cont = continuation.cont
prompt = find_continuation_prompt(tag, cont)
available = values.W_Bool.make(prompt is not None)
return return_value(available, env, cont)
@continuation
def dynamic_wind_pre_cont(value, post, env, cont, _vals):
return value.call([], env, dynamic_wind_value_cont(post, env, cont))
def symbol_to_string_impl(v):
asciivalue = v.asciivalue()
if asciivalue is not None:
return W_String.fromascii(asciivalue)
return W_String.fromunicode(v.unicodevalue())
@expose("string->symbol", [W_String])
def string_to_symbol(v):
return values.W_Symbol.make(v.as_str_utf8())
@expose("string->number", [
W_String,
default(values.W_Integer, values.W_Fixnum(10)),
default(values.W_Symbol, values.W_Symbol.make("number-or-false")),
default(values.W_Symbol, values.W_Symbol.make("decimal-as-exact"))
])
def str2num(w_s, radix, convert_mode, decimal_mode):
from rpython.rlib import rarithmetic, rfloat, rbigint
from rpython.rlib.rstring import ParseStringError, ParseStringOverflowError
from rpython.rlib.rsre import rsre_re as re
import math
s = w_s.as_str_utf8()
try:
if re.match("[+-]?([\d]+)?.?\d+[tT]\d", s):
# it's an extflonum
return values.W_ExtFlonum(s)
#! /usr/bin/env python
# -*- coding: utf-8 -*-
from pycket import impersonators as imp
from pycket import values
from pycket import values_parameter, values_struct
from pycket.arity import Arity
from pycket.error import SchemeException
from pycket.prims.expose import unsafe, default, expose, expose_val
expose_val("current-inspector", values_struct.current_inspector_param)
expose_val("current-code-inspector", values_struct.current_inspector_param)
@expose("make-inspector", [default(values_struct.W_StructInspector, None)],
simple=False)
def do_make_instpector(inspector, env, cont):
from pycket.interpreter import return_value
if inspector is None:
inspector = values_struct.current_inspector_param.get(cont)
new_inspector = values_struct.W_StructInspector.make(inspector)
return return_value(new_inspector, env, cont)
@expose("make-sibling-inspector",
[default(values_struct.W_StructInspector, None)],
simple=False)
def do_make_sibling_instpector(inspector, env, cont):
from pycket.interpreter import return_value
if inspector is None:
inspector = values_struct.current_inspector_param.get(cont)
@expose("flvector")
def flvector(args):
return values_vector.W_FlVector.fromelements(args)
# FIXME: immutable
@expose("vector-immutable")
def vector_immutable(args):
return values_vector.W_Vector.fromelements(args, immutable=True)
@expose("make-vector",
[values.W_Fixnum,
default(values.W_Object, values.W_Fixnum(0))])
def make_vector(w_size, w_val):
size = w_size.value
if size < 0:
raise SchemeException("make-vector: expected a positive fixnum")
return values_vector.W_Vector.fromelement(w_val, size)
@expose("make-flvector",
[values.W_Fixnum,
default(values.W_Flonum, values.W_Flonum(0.0))])
def make_vector(w_size, w_val):
size = w_size.value
if size < 0:
raise SchemeException("make-flvector: expected a positive fixnum")
return values_vector.W_FlVector.fromelement(w_val, size)
#! /usr/bin/env python
# -*- coding: utf-8 -*-
from pycket import impersonators as imp
from pycket import values
from pycket import vector
from pycket.cont import call_cont
from pycket.error import SchemeException
from pycket.prims.expose import default, expose, make_callable_label, procedure
# Can use this to promote a get_cmk operation to a callable function.
CMKSetToListHandler = make_callable_label([values.W_Object])
@expose("current-continuation-marks", [
default(values.W_ContinuationPromptTag,
values.w_default_continuation_prompt_tag)
],
simple=False)
def current_cont_marks(prompt_tag, env, cont):
from pycket.interpreter import return_value
return return_value(values.W_ContinuationMarkSet(cont, prompt_tag), env,
cont)
@expose("continuation-marks", [
values.W_Continuation,
default(values.W_ContinuationPromptTag,
values.w_default_continuation_prompt_tag)
])
def continuation_marks(cont, prompt_tag):
# TODO Prompt tag
val, assocs = assocs.car(), assocs.cdr()
if not isinstance(val, values.W_Cons):
raise SchemeException("%s: expected list of pairs" % fname)
keys.append(val.car())
vals.append(val.cdr())
return keys[:], vals[:]
@expose("make-weak-hasheq", [])
def make_weak_hasheq():
# FIXME: not actually weak
return make_simple_mutable_table(W_EqvMutableHashTable, None, None)
@expose(["make-weak-hash", "make-late-weak-hasheq"],
[default(values.W_List, None)])
def make_weak_hash(assocs):
if assocs is None:
return W_EqualHashTable([], [], immutable=False)
return W_EqualHashTable(*from_assocs(assocs, "make-weak-hash"),
immutable=False)
@expose("make-immutable-hash", [default(values.W_List, values.w_null)])
def make_immutable_hash(assocs):
keys, vals = from_assocs(assocs, "make-immutable-hash")
return W_EqualHashTable(keys, vals, immutable=True)
@expose("make-immutable-hasheq", [default(values.W_List, values.w_null)])
def make_immutable_hasheq(assocs):
@expose("extflvector?", [values.W_Object])
def extflvector(obj):
return values.w_false
# FIXME: immutable
@expose("vector-immutable")
def vector_immutable(args):
return values_vector.W_Vector.fromelements(args, immutable=True)
@expose(["make-vector", "make-fxvector"],
[values.W_Fixnum,
default(values.W_Object, values.W_Fixnum.ZERO)])
def make_vector(w_size, w_val):
size = w_size.value
if size < 0:
raise SchemeException("make-vector: expected a positive fixnum")
return values_vector.W_Vector.fromelement(w_val, size)
@expose("make-flvector",
[values.W_Fixnum,
default(values.W_Flonum, values.W_Flonum.ZERO)])
def make_flvector(w_size, w_val):
size = w_size.value
if size < 0:
raise SchemeException("make-flvector: expected a positive fixnum")
return values_vector.W_FlVector.fromelement(w_val, size)
if c2 == "t":
return BooleanToken(values.w_true)
if c2 == "f":
return BooleanToken(values.w_false)
if c2 in ["(", "[", "{"]:
return LParenToken("#" + c2)
if c2 == "\\":
s = f.read(1)
if not s:
raise SchemeException("unexpected end of file")
c = ord(s[0]) # XXX deal with unicode
return CharToken(values.W_Character.make(unichr(c)))
raise SchemeException("bad token in read: %s" % c2)
raise SchemeException("bad token in read: %s" % c)
@expose("read", [default(values.W_InputPort, None)], simple=False)
def read(port, env, cont):
from pycket.interpreter import return_value
if port is None:
port = current_in_param.get(cont)
v = read_stream(port)
return return_value(v, env, cont)
def read_stream(stream):
next_token = read_token(stream)
if isinstance(next_token, SpecialToken):
v = read_stream(stream)
return next_token.finish(v)
if isinstance(next_token, DelimToken):
if not isinstance(next_token, LParenToken):
raise SchemeException("read: unexpected %s"%next_token.str)
pass
else:
raise SchemeException("regexp-match: unknown kind of regexp")
if isinstance(w_str, values_string.W_String):
s = w_str.as_str_ascii() # XXX for now
result = w_re.match_string(s)
return result
if isinstance(w_str, values.W_Bytes):
result = w_re.match_string(w_str.as_str())
return result
if isinstance(w_str, values.W_InputPort):
result = w_re.match_port(w_str)
return result
raise SchemeException("regexp-match: can't deal with this type")
@expose("regexp-match?", [values.W_Object, values.W_Object])
def regexp_matchp(w_r, w_o):
result = match(w_r, w_o)
if result:
return values.w_true
else:
return values.w_false
# FIXME: implementation
define_nyi("regexp-replace", [values.W_Object, values.W_Object, values.W_Object,
default(values.W_Bytes, None)])
# def regexp_replace(pattern, input, insert, input_prefix):
# raise NotImplementedError()
# return input
@expose("unsafe-unbox", [subclass_unsafe(values.W_Box)], simple=False)
def unsafe_unbox(b, env, cont):
return b.unbox(env, cont)
@expose("set-box!", [values.W_Box, values.W_Object], simple=False)
def set_box(box, v, env, cont):
return box.set_box(v, env, cont)
@expose("unsafe-set-box!", [subclass_unsafe(values.W_Box), values.W_Object], simple=False)
def unsafe_set_box(box, v, env, cont):
return box.set_box(v, env, cont)
# This implementation makes no guarantees about atomicity
@expose("box-cas!", [values.W_MBox, values.W_Object, values.W_Object])
def box_cas(box, old, new):
if eq_prims.eqp_logic(box.value, old):
box.value = new
return values.w_true
return values.w_false
@expose("make-weak-box", [values.W_Object])
def make_weak_box(val):
return values.W_WeakBox(val)
@expose("weak-box-value",
[values.W_WeakBox, default(values.W_Object, values.w_false)])
def weak_box_value(wb, default):
v = wb.get()
return v if v is not None else default
"""
(define-values (1/read-compiled-linklet) (hash-ref linklet-primitive-table 'read-compiled-linklet #f))
(define-values (1/instance-unset-variable!) (hash-ref linklet-primitive-table 'instance-unset-variable! #f))
(define-values (1/variable-reference?) (hash-ref linklet-primitive-table 'variable-reference? #f))
(define-values (1/variable-reference-constant?) (hash-ref linklet-primitive-table 'variable-reference-constant? #f))
"""
make_pred("linklet?", W_Linklet)
make_pred("instance?", W_LinkletInstance)
@expose("compile-linklet", [
W_Object,
default(W_Object, w_false),
default(W_Object, w_false),
default(W_Object, w_false),
default(W_Object, w_false)
],
simple=False)
def compile_linklet(form, name, import_keys, get_import, options, env, cont):
from pycket.util import console_log
console_log(
"compiling linklet : %s %s\n import_keys : %s -- get_import : %s" %
(name.tostring(), form.tostring(), import_keys.tostring(),
get_import.tostring()), 5)
with PerfRegionCPS("compile-linklet"):
cont_ = finish_perf_region_cont("compile-linklet", env, cont)
return do_compile_linklet(form, name, import_keys, get_import, options,
env, cont_)
from pycket import values
from pycket import values_parameter
from pycket.argument_parser import ArgParser, EndOfInput
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
from rpython.rlib import jit
@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
("<=", "le"),
(">", "gt"),
(">=", "ge"),
("=", "eq"),
]:
make_fixedtype_cmps(*args)
@expose("unsafe-flsqrt", [unsafe(values.W_Flonum)])
def flsqrt(f):
return f.arith_sqrt()
@expose("add1", [values.W_Number])
def add1(v):
return v.arith_add(values.W_Fixnum.ONE)
@expose("atan", [values.W_Number, default(values.W_Number, None)])
def atan(y, x):
if x is not None:
# FIXME: signs determine the quadrant of the result
# and care about NaNs and precision
if x.arith_zerop() is values.w_false:
z = y.arith_div(x)
else:
# we should raise exn_fail_contract_divide_by_zero
raise SchemeException("zero_divisor")
else:
z = y
return getattr(z, "arith_atan")()
def make_unary_arith(name, methname, flversion=False, fxversion=False,
from rpython.rlib.rstring import ParseStringError, ParseStringOverflowError
try:
s = w_s.as_str_utf8()
if "." in s:
return values.W_Flonum(rfloat.string_to_float(s))
else:
try:
return values.W_Fixnum(rarithmetic.string_to_int(s, base=0))
except ParseStringOverflowError:
return values.W_Bignum(rbigint.rbigint.fromstr(s))
except ParseStringError as e:
return values.w_false
@expose("number->string",
[values.W_Number, default(values.W_Fixnum, values.W_Fixnum(10))])
def num2str(a, radix):
from rpython.rlib.rbigint import BASE8, BASE16
if radix.value == 10:
return W_String.fromascii(a.tostring())
else:
if isinstance(a, values.W_Fixnum):
if radix.value == 16:
res = hex(a.value)
if a.value >= 0:
res = res[2:]
else:
res = "-" + res[3:]
return W_String.fromascii(res)
#elif radix.value == 8:
# return W_String.fromascii(oct(a.value))
def set_box(box, v, env, cont):
return box.set_box(v, env, cont)
@expose("unsafe-set-box!", [subclass_unsafe(values.W_Box), values.W_Object],
simple=False)
def unsafe_set_box(box, v, env, cont):
return box.set_box(v, env, cont)
# This implementation makes no guarantees about atomicity
@expose("box-cas!", [values.W_MBox, values.W_Object, values.W_Object])
def box_cas(box, old, new):
if eq_prims.eqp_logic(box.value, old):
box.value = new
return values.w_true
return values.w_false
@expose("make-weak-box", [values.W_Object])
def make_weak_box(val):
return values.W_WeakBox(val)
@expose("weak-box-value",
[values.W_WeakBox,
default(values.W_Object, values.w_false)])
def weak_box_value(wb, default):
v = wb.get()
return v if v is not None else default
@expose("symbol->string", [values.W_Symbol])
def symbol_to_string(v):
return symbol_to_string_impl(v)
def symbol_to_string_impl(v):
asciivalue = v.asciivalue()
if asciivalue is not None:
return W_String.fromascii(asciivalue)
return W_String.fromunicode(v.unicodevalue())
@expose("string->symbol", [W_String])
def string_to_symbol(v):
return values.W_Symbol.make(v.as_str_utf8())
@expose("string->number", [W_String,
default(values.W_Integer, values.W_Fixnum(10)),
default(values.W_Symbol, values.W_Symbol.make("number-or-false")),
default(values.W_Symbol, values.W_Symbol.make("decimal-as-exact"))])
def str2num(w_s, radix, convert_mode, decimal_mode):
from rpython.rlib import rarithmetic, rfloat, rbigint
from rpython.rlib.rstring import ParseStringError, ParseStringOverflowError
from rpython.rlib.rsre import rsre_re as re
import math
radix = radix.toint()
s = w_s.as_str_utf8()
try:
if ((radix == 16 and re.match("^[0-9A-Fa-f]+$", s)) or
(radix == 8 and re.match("^[0-7]+$", s)) or
(radix == 10 and re.match("^[0-9]+$", s))):
try:
return values.W_Fixnum(rarithmetic.string_to_int(s, base=radix))
#! /usr/bin/env python
# -*- coding: utf-8 -*-
from pycket import impersonators as imp
from pycket import values
from pycket import values_struct
from pycket.error import SchemeException
from pycket.prims.expose import unsafe, default, expose
@expose("make-inspector", [default(values_struct.W_StructInspector,
values_struct.current_inspector)])
def do_make_instpector(inspector):
return values_struct.W_StructInspector.make(inspector)
@expose("make-sibling-inspector", [default(values_struct.W_StructInspector,
values_struct.current_inspector)])
def do_make_sibling_instpector(inspector):
return values_struct.W_StructInspector.make(inspector, True)
@expose("current-inspector")
def do_current_instpector(args):
return values_struct.current_inspector
@expose("struct?", [values.W_Object])
def do_is_struct(v):
return values.W_Bool.make(isinstance(v, values_struct.W_RootStruct) and
values_struct.current_inspector.has_control(v.struct_type()))
@expose("struct-info", [values.W_Object])
def do_struct_info(v):
if (isinstance(v, values_struct.W_RootStruct) and
values_struct.current_inspector.has_control(v.struct_type())):
xs.append(values.W_Cons.make(s, e))
return values.to_list(xs)
@expose("regexp-match?", [values.W_Object, values.W_Object])
def regexp_matchp(w_r, w_o):
result = match(w_r, w_o)
if result:
return values.w_true
else:
return values.w_false
@expose("regexp-max-lookbehind", [values.W_Object])
def regexp_max_lookbehind(obj):
if not isinstance(obj, values_regex.W_Regexp) and not isinstance(
obj, values_regex.W_ByteRegexp):
raise SchemeException(
"regexp-max-lookbehind: expected regexp or bytes-regexp")
return values.W_Fixnum(1000)
# FIXME: implementation
define_nyi("regexp-replace", [
values.W_Object, values.W_Object, values.W_Object,
default(values.W_Bytes, None)
])
# def regexp_replace(pattern, input, insert, input_prefix):
# raise NotImplementedError()
# return input
@continuation
def unwind_next_frame_cont(frames, index, final_cont, env, cont, _vals):
return do_unwind_frames(frames, index + 1, env, final_cont)
@continuation
def rewind_next_frame_cont(frames, index, final_cont, env, cont, _vals):
return do_rewind_frames(frames, index - 1, env, final_cont)
def unwind_frames(frames, env, final_cont):
return do_unwind_frames(frames, 0, env, final_cont)
def rewind_frames(frames, env, final_cont):
return do_rewind_frames(frames, len(frames) - 1, env, final_cont)
@expose("continuation-prompt-available?", [values.W_ContinuationPromptTag, default(values.W_Continuation, None)], simple=False)
def cont_prompt_avail(tag, continuation, env, cont):
from pycket.interpreter import return_value
if continuation is not None:
cont = continuation.cont
prompt = find_continuation_prompt(tag, cont)
available = values.W_Bool.make(prompt is not None)
return return_value(available, env, cont)
@continuation
def dynamic_wind_pre_cont(value, pre, post, env, cont, _vals):
cont = DynamicWindValueCont(pre, post, env, cont)
return value.call([], env, cont)
@continuation
def dynamic_wind_value_cont(post, env, cont, _vals):
expose_val("_int16" , values.W_Fixnum.make(1))
expose_val("_int32" , values.W_Fixnum.make(2))
expose_val("_int64" , values.W_Fixnum.make(3))
expose_val("_uint8" , values.W_Fixnum.make(4))
expose_val("_uint16" , values.W_Fixnum.make(5))
expose_val("_uint32" , values.W_Fixnum.make(6))
expose_val("_uint64" , values.W_Fixnum.make(7))
expose_val("_bytes" , values.W_Fixnum.make(8))
expose_val("_path" , values.W_Fixnum.make(9))
expose_val("_void" , values.W_Fixnum.make(10))
expose_val("_pointer" , values.W_Fixnum.make(11))
expose_val("_fpointer" , values.W_Fixnum.make(12))
ctype = values.W_Fixnum
@expose("make-ctype", [ctype, default(values.W_Object, values.w_false), default(values.W_Object, values.w_false)])
def make_c_type(typ, rtc, ctr):
return values.W_Fixnum(0)
@expose("compiler-sizeof", [values.W_Object])
def compiler_sizeof(sym):
return values.W_Fixnum(8)
@expose("make-stubborn-will-executor", [])
def make_stub_will_executor():
return values.w_false
@expose("ctype-sizeof", [ctype])
def ctype_sizeof(c):
return values.W_Fixnum(8)
keys = []
vals = []
while isinstance(assocs, values.W_Cons):
val, assocs = assocs.car(), assocs.cdr()
if not isinstance(val, values.W_Cons):
raise SchemeException("%s: expected list of pairs" % fname)
keys.append(val.car())
vals.append(val.cdr())
return keys[:], vals[:]
@expose("make-weak-hasheq", [])
def make_weak_hasheq():
# FIXME: not actually weak
return make_simple_mutable_table(W_EqvMutableHashTable, None, None)
@expose("make-weak-hash", [default(values.W_List, None)])
def make_weak_hash(assocs):
if assocs is None:
return W_EqualHashTable([], [], immutable=False)
return W_EqualHashTable(*from_assocs(assocs, "make-weak-hash"), immutable=False)
@expose("make-immutable-hash", [default(values.W_List, values.w_null)])
def make_immutable_hash(assocs):
keys, vals = from_assocs(assocs, "make-immutable-hash")
return W_EqualHashTable(keys, vals, immutable=True)
@expose("make-immutable-hasheq", [default(values.W_List, values.w_null)])
def make_immutable_hasheq(assocs):
return make_simple_immutable_table_assocs(W_EqImmutableHashTable, assocs, "make-immutable-hasheq")
@expose("make-immutable-hasheqv", [default(values.W_List, values.w_null)])
("<=", "le"),
(">", "gt"),
(">=", "ge"),
("=", "eq"),
]:
make_fixedtype_cmps(*args)
@expose("unsafe-flsqrt", [unsafe(values.W_Flonum)])
def flsqrt(f):
return f.arith_sqrt()
@expose("add1", [values.W_Number])
def add1(v):
return v.arith_add(values.W_Fixnum.ONE)
@expose("atan", [values.W_Number, default(values.W_Number, None)])
def atan(y, x):
if x is not None:
# FIXME: signs determine the quadrant of the result
# and care about NaNs and precision
if x.arith_zerop() is values.w_false:
z = y.arith_div(x)
else:
# we should raise exn_fail_contract_divide_by_zero
raise SchemeException("zero_divisor")
else:
z = y
return getattr(z, "arith_atan")()
def make_unary_arith(name, methname, flversion=False, fxversion=False,
if handle in self.weak_callbacks:
del (self.weak_callbacks[handle])
current_plumber_param = values_parameter.W_Parameter(W_Plumber())
expose_val("current-plumber", current_plumber_param)
@expose("make-plumber", [])
def make_plumber():
return W_Plumber()
@expose("plumber-add-flush!",
[W_Plumber, procedure,
default(values.W_Bool, values.w_false)])
def plumber_add_flush_bang(p, proc, is_weak):
# create a new handle
h = W_PlumberFlushHandle(p)
# put the new handle into p's callbacks with the given proc
if is_weak is values.w_true:
p.set_weak_callback(h, proc)
else:
p.set_callback(h, proc)
return h
@continuation
@expose(prefix_hash_names("hash-iterate-value"),
[W_HashTable, values.W_Fixnum], simple=False)
def hash_iterate_value(ht, pos, env, cont):
return hash_iter_ref(ht, pos.value, env, cont, returns=_VALUE)
@expose(prefix_hash_names("hash-iterate-key+value"),
[W_HashTable, values.W_Fixnum], simple=False)
def hash_iterate_key_value(ht, pos, env, cont):
return hash_iter_ref(ht, pos.value, env, cont, returns=_KEY_AND_VALUE)
@expose(prefix_hash_names("hash-iterate-pair"),
[W_HashTable, values.W_Fixnum], simple=False)
def hash_iterate_pair(ht, pos, env, cont):
return hash_iter_ref(ht, pos.value, env, cont, returns=_PAIR)
@expose("hash-for-each", [W_HashTable, procedure, default(values.W_Object, values.w_false)], simple=False)
def hash_for_each(ht, f, try_order, env, cont):
# FIXME: implmeent try-order? -- see hash-map
return hash_for_each_loop(ht, f, 0, env, cont)
@loop_label
def hash_for_each_loop(ht, f, index, env, cont):
from pycket.interpreter import return_value
try:
w_key, w_value = ht.get_item(index)
except KeyError:
return hash_for_each_loop(ht, f, index + 1, env, cont)
except IndexError:
return return_value(values.w_void, env, cont)
return f.call([w_key, w_value], env,
hash_for_each_cont(ht, f, index, env, cont))
#! /usr/bin/env python
# -*- coding: utf-8 -*-
from pycket import impersonators as imp
from pycket import values
from pycket import values_struct
from pycket.error import SchemeException
from pycket.prims.expose import unsafe, default, expose, procedure
from rpython.rlib import jit
@expose("make-inspector", [default(values_struct.W_StructInspector, None)])
def do_make_instpector(inspector):
return values_struct.W_StructInspector.make(inspector)
@expose("make-sibling-inspector", [default(values_struct.W_StructInspector, None)])
def do_make_sibling_instpector(inspector):
return values_struct.W_StructInspector.make(inspector, True)
@expose("current-inspector")
def do_current_instpector(args):
return values_struct.current_inspector
@expose("struct?", [values.W_Object])
def do_is_struct(v):
return values.W_Bool.make(isinstance(v, values_struct.W_RootStruct) and
not v.struct_type().isopaque)
def is_struct_info(v):
if isinstance(v, values.W_Cons):
struct_info = values.from_list(v)
if len(struct_info) == 6:
if not isinstance(struct_info[0], values_struct.W_StructType) and\
return values_regex.W_PRegexp(w_str.as_str_utf8())
@expose("byte-regexp", [values.W_Bytes])
def byte_regrexp(w_str):
return values_regex.W_ByteRegexp(w_str.as_str())
@expose("byte-pregexp", [values.W_Bytes])
def byte_pregrexp(w_str):
return values_regex.W_BytePRegexp(w_str.as_str())
EMPTY_BYTES = values.W_Bytes.from_string("")
NO_MATCH = values.Values.make([values.w_false, values.w_false])
RM_ARGS = [
values.W_Object, values.W_Object,
default(values.W_Fixnum, values.W_Fixnum.ZERO),
default(values.W_Object, values.w_false),
default(values.W_Object, values.w_false),
default(values.W_Bytes, EMPTY_BYTES)
]
@expose("regexp-match", RM_ARGS)
@jit.unroll_safe
def regexp_match(w_re, w_str, inp_start, inp_end, output_port, prefix):
start = inp_start.value
if inp_end is values.w_false:
end = sys.maxint
elif isinstance(inp_end, values.W_Fixnum):
end = inp_end.value
else:
raise SchemeException("regexp-match: expected fixnum or #f for argument 3")
# -*- coding: utf-8 -*-
from pycket import impersonators as imp
from pycket import values
from pycket.cont import call_cont
from pycket.error import SchemeException
from pycket.prims.expose import default, expose, make_callable_label, procedure
# Can use this to promote a get_cmk operation to a callable function.
CMKSetToListHandler = make_callable_label([values.W_Object])
#@expose("continuation-marks",
#[values.W_Continuation, default(values.W_ContinuationPromptTag, None)])
#def continuation_marks(cont, prompt_tag):
#return values.W_ContinuationPromptTag(cont.cont)
@expose("current-continuation-marks", [default(values.W_ContinuationPromptTag, None)], simple=False)
def current_cont_marks(prompt_tag, env, cont):
from pycket.interpreter import return_value
return return_value(values.W_ContinuationMarkSet(cont), env, cont)
@expose("continuation-mark-set->list",
[values.W_ContinuationMarkSet, values.W_Object], simple=False)
def cms_list(cms, mark, env, cont):
from pycket.interpreter import return_value
from pycket.prims.general import map_loop
if isinstance(mark, values.W_ContinuationMarkKey):
func = CMKSetToListHandler(mark.get_cmk)
marks = cms.cont.get_marks(imp.get_base_object(mark))
return map_loop(func, [marks], env, cont)
marks = cms.cont.get_marks(mark)
return return_value(marks, env, cont)
@expose("symbol->string", [values.W_Symbol])
def symbol_to_string(v):
return symbol_to_string_impl(v)
def symbol_to_string_impl(v):
asciivalue = v.asciivalue()
if asciivalue is not None:
return W_String.fromascii(asciivalue)
return W_String.fromunicode(v.unicodevalue())
@expose("string->symbol", [W_String])
def string_to_symbol(v):
return values.W_Symbol.make(v.as_str_utf8())
@expose("string->number", [W_String,
default(values.W_Integer, values.W_Fixnum(10)),
default(values.W_Symbol, values.W_Symbol.make("number-or-false")),
default(values.W_Symbol, values.W_Symbol.make("decimal-as-exact"))])
def str2num(w_s, radix, convert_mode, decimal_mode):
radix = radix.toint()
s = w_s.as_str_utf8()
return _str2num(s, radix)
def _str2num(s, radix):
from rpython.rlib import rarithmetic, rfloat, rbigint
from rpython.rlib.rstring import ParseStringError, ParseStringOverflowError
from rpython.rlib.rsre import rsre_re as re
import math
try:
if ((radix == 16 and re.match("^[0-9A-Fa-f]+$", s)) or
(radix == 8 and re.match("^[0-7]+$", s)) or