@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())