@continuation
def force_exit_cont(v, env, cont, _vals):
return _force_exit(v)
@make_procedure("initial-exit-handler", [values.W_Object],
arity=Arity.ZERO,
simple=False)
def initial_exit_handler(v, env, cont):
from pycket.prims.plumber import do_plumber_flush_all
root_plumber = current_plumber_param.get(cont) ## ??
return do_plumber_flush_all(root_plumber, env,
force_exit_cont(v, env, cont))
exit_handler_param = values_parameter.W_Parameter(initial_exit_handler)
expose_val("exit-handler", exit_handler_param)
@continuation
def exit_cont(env, cont, _vals):
from pycket.interpreter import return_value
return return_value(values.w_void, env, cont)
@expose("exit", [default(values.W_Object, values.w_true)], simple=False)
def exit(v, env, cont):
exit_handler = exit_handler_param.get(cont)
return exit_handler.call([v], env, exit_cont(env, cont))
def set_callback(self, h, proc):
self.callbacks[h] = proc
def set_weak_callback(self, h, proc):
self.weak_callbacks[h] = proc
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)
from pycket.values import parameterization_key
paramz = cont.get_mark_first(parameterization_key)
assert isinstance(paramz, values_parameter.W_Parameterization)
return paramz.extend(keys, vals, env,
call_with_paramz_cont(f, args, env, cont))
@make_procedure("eval-jit-enabled-guard", [values.W_Object], simple=False)
def eval_jit_enabled_guard(arg, env, cont):
from pycket.interpreter import return_value
# never disable the jit
return return_value(values.w_void, env, cont)
expose_val("compile-enforce-module-constants",
values_parameter.W_Parameter(values.w_true))
# compilation should avoid function-call inlining and other optimizations that may cause information to be lost from stack traces
expose_val("compile-context-preservation-enabled",
values_parameter.W_Parameter(values.w_true))
expose_val("compile-allow-set!-undefined",
values_parameter.W_Parameter(values.w_false))
current_cmd_args_param = values_parameter.W_Parameter(
vector.W_Vector.fromelements([]))
expose_val("current-command-line-arguments", current_cmd_args_param)
expose_val("eval-jit-enabled",
values_parameter.W_Parameter(values.w_true, eval_jit_enabled_guard))
expose_val("exnh", values_parameter.W_Parameter(values.w_false))
expose_val("load-on-demand-enabled",
def make_parameter(init, guard):
return values_parameter.W_Parameter(init, guard)
return unwind_frames(frames, env, cont)
return handler.call(args, env, cont)
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
def call_with_parameterization(f, args, paramz, env, cont):
cont.update_cm(values.parameterization_key, paramz)
return f.call(args, env, cont)
@expose("call-with-parameterization",
[values.W_Object, values_parameter.W_Parameterization],
simple=False)
def call_w_paramz(f, paramz, env, cont):
return call_with_parameterization(f, [], paramz, env, cont)
def call_with_extended_paramz(f, args, keys, vals, env, cont):
from pycket.values import parameterization_key
# XXX seems untested?
paramz = cont.get_mark_first(parameterization_key)
assert isinstance(
paramz,
values_parameter.W_Parameterization) # XXX is this always right?
paramz_new = paramz.extend(keys, vals)
return call_with_parameterization(f, args, paramz_new, env, cont)
expose_val("parameterization-key", values.parameterization_key)
expose_val("print-mpair-curly-braces",
values_parameter.W_Parameter(values.w_false))
expose_val("print-pair-curly-braces",
values_parameter.W_Parameter(values.w_false))
return return_value(values.W_Fixnum(n), env, cont)
# FIXME:
@expose("custom-write?", [values.W_Object])
def do_has_custom_write(v):
return values.w_false
def shutdown(env):
# called before the interpreter exits
stdout_port.flush()
############################ Values and Parameters
expose_val("eof", values.eof_object)
current_print_param = values_parameter.W_Parameter(standard_printer)
expose_val("current-print", current_print_param)
# line buffer stdout
stdout_port = values.W_FileOutputPort(sio.fdopen_as_stream(1, "w", buffering=1))
stderr_port = values.W_FileOutputPort(sio.fdopen_as_stream(2, "w", buffering=1))
stdin_port = values.W_FileInputPort(sio.fdopen_as_stream(0, "r"))
current_out_param = values_parameter.W_Parameter(stdout_port)
current_error_param = values_parameter.W_Parameter(stderr_port)
current_in_param = values_parameter.W_Parameter(stdin_port)
expose_val("current-output-port", current_out_param)
expose_val("current-error-port", current_error_param)
expose_val("current-input-port", current_in_param)
print_graph_param = values_parameter.W_Parameter(values.w_false)
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)
assert isinstance(
paramz,
values_parameter.W_Parameterization) # XXX is this always right?
paramz_new = paramz.extend(keys, vals)
return call_with_parameterization(f, args, paramz_new, env, cont)
@make_procedure("eval-jit-enabled-guard", [values.W_Object], simple=False)
def eval_jit_enabled_guard(arg, env, cont):
from pycket.interpreter import return_value
# never disable the jit
return return_value(values.w_void, env, cont)
expose_val("compile-enforce-module-constants",
values_parameter.W_Parameter(values.w_true))
# compilation should avoid function-call inlining and other optimizations that may cause information to be lost from stack traces
expose_val("compile-context-preservation-enabled",
values_parameter.W_Parameter(values.w_true))
expose_val("compile-allow-set!-undefined",
values_parameter.W_Parameter(values.w_false))
expose_val("current-command-line-arguments",
values_parameter.W_Parameter(values.w_false))
expose_val("eval-jit-enabled",
values_parameter.W_Parameter(values.w_true, eval_jit_enabled_guard))
expose_val("exnh", values_parameter.W_Parameter(values.w_false))
expose_val("load-on-demand-enabled",
values_parameter.W_Parameter(values.w_true))
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()
def call_with_extended_paramz(f, args, keys, vals, env, cont):
from pycket.values import parameterization_key
# XXX seems untested?
paramz = cont.get_mark_first(parameterization_key)
assert isinstance(
paramz,
values_parameter.W_Parameterization) # XXX is this always right?
paramz_new = paramz.extend(keys, vals)
return call_with_parameterization(f, args, paramz_new, env, cont)
expose_val("parameterization-key", values.parameterization_key)
expose_val("print-mpair-curly-braces",
values_parameter.W_Parameter(values.w_false))
expose_val("print-pair-curly-braces",
values_parameter.W_Parameter(values.w_false))
READ_PARAMS = """
read-square-bracket-as-paren
read-curly-brace-as-paren
read-square-bracket-with-tag
read-curly-brace-with-tag
read-accept-box
read-accept-compiled
read-accept-bar-quote
read-accept-graph
read-decimal-as-inexact
read-accept-dot
read-accept-infix-dot
# message : string?
message = parser.expect(values_string.W_String)
# data : any/c
data = parser.expect(values.W_Object)
try:
# prefix-message? : any/c = #t
prefix_message_huh = parser.expect(values.W_Object, values.w_true)
except EndOfInput:
prefix_message_huh = values.w_true
print_str = message.tostring()
if (prefix_message_huh is not values.w_false) and (topic
is not values.w_false):
print_str = "%s: %s" % (topic.tostring(), print_str)
print(print_str)
return values.w_void
@expose("logger-name", [values.W_Logger])
def logger_name(logger):
return logger.topic
w_current_logger = values_parameter.W_Parameter(w_main_logger)
expose_val("current-logger", w_current_logger)
def make_parameter(init, guard, name):
return values_parameter.W_Parameter(init, guard, name.tostring())
