def namespace_require_kernel():
namespace_require = get_primitive("namespace-require")
kernel = W_WrappedConsProper.make(W_Symbol.make("quote"),
W_WrappedConsProper.make(W_Symbol.make("#%kernel"), w_null))
namespace_require.call_interpret([kernel])
def namespace_require_kernel():
namespace_require = get_primitive("namespace-require")
kernel = W_WrappedConsProper.make(W_Symbol.make("quote"),
W_WrappedConsProper.make(W_Symbol.make("#%kernel"), w_null))
namespace_require.call_interpret([kernel])
def configure_runtime(m):
dynamic_require = get_primitive("dynamic-require")
module_declared = get_primitive("module-declared?")
join = get_primitive("module-path-index-join")
submod = W_WrappedConsProper.make(W_Symbol.make("submod"),
W_WrappedConsProper.make(W_String.make("."),
W_WrappedConsProper(W_Symbol.make("configure-runtime"), w_null)))
config_m = join.call_interpret([submod, m])
if module_declared.call_interpret([config_m, w_true]) is w_true:
dynamic_require.call_interpret([config_m, w_false])
def configure_runtime(m):
dynamic_require = get_primitive("dynamic-require")
module_declared = get_primitive("module-declared?")
join = get_primitive("module-path-index-join")
submod = W_WrappedConsProper.make(W_Symbol.make("submod"),
W_WrappedConsProper.make(W_String.make("."),
W_WrappedConsProper(W_Symbol.make("configure-runtime"), w_null)))
config_m = join.call_interpret([submod, m])
if module_declared.call_interpret([config_m, w_true]) is w_true:
dynamic_require.call_interpret([config_m, w_false])
def namespace_require_plus(spec):
namespace_require = get_primitive("namespace-require")
dynamic_require = get_primitive("dynamic-require")
module_declared = get_primitive("module-declared?")
join = get_primitive("module-path-index-join")
m = join.call_interpret([spec, w_false])
submod = W_WrappedConsProper.make(W_Symbol.make("submod"),
W_WrappedConsProper.make(W_String.make("."),
W_WrappedConsProper(W_Symbol.make("main"), w_null)))
# FIXME: configure-runtime
if need_runtime_configure[0]:
configure_runtime(m)
need_runtime_configure[0] = False
namespace_require.call_interpret([m])
main = join.call_interpret([submod, m])
if module_declared.call_interpret([main, w_true]) is w_true:
dynamic_require.call_interpret([main, w_false])
def namespace_require_plus(spec):
namespace_require = get_primitive("namespace-require")
dynamic_require = get_primitive("dynamic-require")
module_declared = get_primitive("module-declared?")
join = get_primitive("module-path-index-join")
m = join.call_interpret([spec, w_false])
submod = W_WrappedConsProper.make(W_Symbol.make("submod"),
W_WrappedConsProper.make(W_String.make("."),
W_WrappedConsProper(W_Symbol.make("main"), w_null)))
# FIXME: configure-runtime
if need_runtime_configure[0]:
configure_runtime(m)
need_runtime_configure[0] = False
namespace_require.call_interpret([m])
main = join.call_interpret([submod, m])
if module_declared.call_interpret([main, w_true]) is w_true:
dynamic_require.call_interpret([main, w_false])
def racket_entry(names, config, command_line_arguments):
from pycket.prims.general import executable_yield_handler
from pycket.values import W_Fixnum
if config['make-zos']:
make_bootstrap_zos()
return 0
linklet_perf.init()
loads, startup_options, flags = get_options(names, config)
init_library = startup_options['init_library'][0]
set_run_file = startup_options['set_run_file'][0]
set_collects_dir = startup_options['set_collects_dir'][0]
set_config_dir = startup_options['set_config_dir'][0]
set_addon_dir = startup_options['set_addon_dir'][0]
eval_sexp = startup_options['eval_sexp'][0]
run_as_linklet = startup_options['run_as_linklet'][0]
load_linklets = startup_options['load_linklets']
load_as_linklets = startup_options['load_as_linklets']
is_repl = flags['is_repl']
no_lib = flags['no_lib']
just_kernel = flags['just_kernel']
just_init = flags['just_init']
use_compiled = flags['use_compiled']
debug = flags['debug']
version = flags['version']
c_a = flags['compile_any']
do_load_regexp = flags['do_load_regexp']
dev_mode = flags['dev_mode']
if load_as_linklets:
for rkt in load_as_linklets:
create_linklet_json(rkt)
load_inst_linklet("%s.linklet" % rkt)
return 0
if load_linklets:
load_linklets_at_startup(load_linklets)
return 0
if dev_mode:
dev_mode_entry(dev_mode, eval_sexp, run_as_linklet)
return 0
with PerfRegion("startup"):
initiate_boot_sequence(command_line_arguments,
use_compiled,
debug,
set_run_file,
set_collects_dir,
set_config_dir,
set_addon_dir,
compile_any=c_a,
do_load_regexp=do_load_regexp)
if just_init:
return 0
namespace_require = get_primitive("namespace-require")
load = get_primitive("load")
if just_kernel:
console_log("Running on just the #%kernel")
namespace_require_kernel()
if not no_lib:
with PerfRegion("init-lib"):
init_lib = W_WrappedConsProper.make(W_Symbol.make("lib"),
W_WrappedConsProper.make(W_String.make(init_library), w_null))
console_log("(namespace-require %s) ..." % init_lib.tostring())
namespace_require_plus(init_lib)
console_log("Init lib : %s loaded..." % (init_library))
put_newline = False
if loads:
for rator_str, rand_str in loads:
if rator_str == "load":
# -f
console_log("(load %s)" % (rand_str))
load.call_interpret([W_String.make(rand_str)])
elif rator_str == "file" or rator_str == "lib":
# -t & -l
require_spec = W_WrappedConsProper.make(W_Symbol.make(rator_str),
W_WrappedConsProper.make(W_String.make(rand_str), w_null))
console_log("(namespace-require '(%s %s))" % (rator_str, rand_str))
namespace_require_plus(require_spec)
elif rator_str == "eval":
# -e
console_log("(eval (read (open-input-string %s)))" % rand_str)
read_eval_print_string(rand_str, False, debug)
if version:
from pycket.env import w_version
print("Welcome to Pycket v%s" % w_version.get_version())
if is_repl: # -i
put_newline = True
dynamic_require = get_primitive("dynamic-require")
repl = dynamic_require.call_interpret([W_Symbol.make("racket/repl"),
W_Symbol.make("read-eval-print-loop")])
from pycket.env import w_global_config
w_global_config.set_config_val('repl_loaded', 1)
repl.call_interpret([])
if put_newline:
print
linklet_perf.print_report()
# we just want the global value anyway
eyh = executable_yield_handler.call_interpret([])
eyh.call_interpret([W_Fixnum.ZERO])
exit = get_primitive("exit")
exit.call_interpret([])
return 0
def initiate_boot_sequence(command_line_arguments,
use_compiled=False,
debug=False,
set_run_file="",
set_collects_dir="",
set_config_dir="",
set_addon_dir="",
compile_any=False,
do_load_regexp=False):
from pycket.env import w_version
load_bootstrap_linklets(debug, do_load_regexp=do_load_regexp)
with PerfRegion("set-params"):
# These need to be set before the boot sequence
if set_run_file:
console_log("Setting the 'run-file path to %s" % set_run_file)
set_path("run-file", set_run_file)
if set_collects_dir:
console_log("Setting the 'collects-dir path to %s" % set_collects_dir)
set_path("collects-dir", set_collects_dir)
if set_config_dir:
console_log("Setting the 'config-dir path to %s" % set_config_dir)
set_path("config-dir", set_config_dir)
if set_addon_dir:
console_log("Setting the 'addon-dir path to %s" % set_addon_dir)
set_path("addon-dir", set_addon_dir)
# Set the cmd arguments for racket
ccla = get_primitive("current-command-line-arguments")
ccla.call_interpret([W_Vector.fromelements(command_line_arguments)])
# Run "boot" to set things like (current-module-name-resolver) (o/w it's going to stay as the
# "core-module-name-resolver" which can't recognize modules like 'racket/base (anything other than
# things like '#%kernel really)
console_log("Entering Boot Sequence")
console_log("(boot)")
boot = get_primitive("boot")
boot.call_interpret([])
console_log("(current-library-collection-links (find-library-collection-links))")
flcl = get_primitive("find-library-collection-links")
lib_coll_links = flcl.call_interpret([])
clcl = get_primitive("current-library-collection-links")
clcl.call_interpret([lib_coll_links])
console_log("(current-library-collection-paths (find-library-collection-paths))")
flcp = get_primitive("find-library-collection-paths")
lib_coll_paths = flcp.call_interpret([])
clcp = get_primitive("current-library-collection-paths")
clcp.call_interpret([lib_coll_paths])
console_log("(read-accept-compiled true)")
read_accept_compiled = get_primitive("read-accept-compiled")
read_accept_compiled.call_interpret([w_true])
compiled_file_path = "compiled/pycket"
ucfp = get_primitive("use-compiled-file-paths")
if use_compiled:
console_log("(use-compiled-file-paths %s)" % compiled_file_path)
ucfp.call_interpret([W_WrappedConsProper.make(W_String.make(compiled_file_path), w_null)])
else:
ucfp.call_interpret([w_null])
console_log("(use-compiled-file-paths null)")
cctm = get_primitive("current-compile-target-machine")
if compile_any:
cctm.call_interpret([w_false])
# set the current directory to the current directory
import os
c_dir = os.getcwd()
console_log("(current-directory %s)" % c_dir)
# We can't call the current-directory like a primitive
# because it prints a report to stdout
from pycket.values_parameter import top_level_config
from pycket.prims.general import current_directory_param
c = top_level_config.get(current_directory_param)
assert isinstance(c, W_ThreadCell)
c.set(W_Path(c_dir))
console_log("...Boot Sequence Completed")
from pycket.env import w_global_config as glob
glob.boot_is_completed()
return 0
def racket_entry(names, config, command_line_arguments):
from pycket.prims.general import executable_yield_handler
from pycket.values import W_Fixnum
if config['make-zos']:
make_bootstrap_zos()
return 0
linklet_perf.init()
loads, startup_options, flags = get_options(names, config)
init_library = startup_options['init_library'][0]
set_run_file = startup_options['set_run_file'][0]
set_collects_dir = startup_options['set_collects_dir'][0]
set_config_dir = startup_options['set_config_dir'][0]
set_addon_dir = startup_options['set_addon_dir'][0]
eval_sexp = startup_options['eval_sexp'][0]
run_as_linklet = startup_options['run_as_linklet'][0]
load_linklets = startup_options['load_linklets']
load_as_linklets = startup_options['load_as_linklets']
is_repl = flags['is_repl']
no_lib = flags['no_lib']
just_kernel = flags['just_kernel']
just_init = flags['just_init']
use_compiled = flags['use_compiled']
debug = flags['debug']
version = flags['version']
c_a = flags['compile_any']
do_load_regexp = flags['do_load_regexp']
dev_mode = flags['dev_mode']
if load_as_linklets:
for rkt in load_as_linklets:
create_linklet_json(rkt)
load_inst_linklet("%s.linklet" % rkt)
return 0
if load_linklets:
load_linklets_at_startup(load_linklets)
return 0
if dev_mode:
dev_mode_entry(dev_mode, eval_sexp, run_as_linklet)
return 0
with PerfRegion("startup"):
initiate_boot_sequence(command_line_arguments,
use_compiled,
debug,
set_run_file,
set_collects_dir,
set_config_dir,
set_addon_dir,
compile_any=c_a,
do_load_regexp=do_load_regexp)
if just_init:
return 0
namespace_require = get_primitive("namespace-require")
load = get_primitive("load")
if just_kernel:
console_log("Running on just the #%kernel")
namespace_require_kernel()
if not no_lib:
with PerfRegion("init-lib"):
init_lib = W_WrappedConsProper.make(W_Symbol.make("lib"),
W_WrappedConsProper.make(W_String.make(init_library), w_null))
console_log("(namespace-require %s) ..." % init_lib.tostring())
namespace_require_plus(init_lib)
console_log("Init lib : %s loaded..." % (init_library))
put_newline = False
if loads:
for rator_str, rand_str in loads:
if rator_str == "load":
# -f
console_log("(load %s)" % (rand_str))
load.call_interpret([W_String.make(rand_str)])
elif rator_str == "file" or rator_str == "lib":
# -t & -l
require_spec = W_WrappedConsProper.make(W_Symbol.make(rator_str),
W_WrappedConsProper.make(W_String.make(rand_str), w_null))
console_log("(namespace-require '(%s %s))" % (rator_str, rand_str))
namespace_require_plus(require_spec)
elif rator_str == "eval":
# -e
console_log("(eval (read (open-input-string %s)))" % rand_str)
read_eval_print_string(rand_str, False, debug)
if version:
from pycket.env import w_version
print("Welcome to Pycket v%s" % w_version.get_version())
if is_repl: # -i
put_newline = True
dynamic_require = get_primitive("dynamic-require")
repl = dynamic_require.call_interpret([W_Symbol.make("racket/repl"),
W_Symbol.make("read-eval-print-loop")])
from pycket.env import w_global_config
w_global_config.set_config_val('repl_loaded', 1)
repl.call_interpret([])
if put_newline:
print
linklet_perf.print_report()
# we just want the global value anyway
eyh = executable_yield_handler.call_interpret([])
eyh.call_interpret([W_Fixnum.ZERO])
exit = get_primitive("exit")
exit.call_interpret([])
return 0
def initiate_boot_sequence(command_line_arguments,
use_compiled=False,
debug=False,
set_run_file="",
set_collects_dir="",
set_config_dir="",
set_addon_dir="",
compile_any=False,
do_load_regexp=False):
from pycket.env import w_version
load_bootstrap_linklets(debug, do_load_regexp=do_load_regexp)
with PerfRegion("set-params"):
# These need to be set before the boot sequence
if set_run_file:
console_log("Setting the 'run-file path to %s" % set_run_file)
set_path("run-file", set_run_file)
if set_collects_dir:
console_log("Setting the 'collects-dir path to %s" % set_collects_dir)
set_path("collects-dir", set_collects_dir)
if set_config_dir:
console_log("Setting the 'config-dir path to %s" % set_config_dir)
set_path("config-dir", set_config_dir)
if set_addon_dir:
console_log("Setting the 'addon-dir path to %s" % set_addon_dir)
set_path("addon-dir", set_addon_dir)
# Set the cmd arguments for racket
ccla = get_primitive("current-command-line-arguments")
ccla.call_interpret([W_Vector.fromelements(command_line_arguments)])
# Run "boot" to set things like (current-module-name-resolver) (o/w it's going to stay as the
# "core-module-name-resolver" which can't recognize modules like 'racket/base (anything other than
# things like '#%kernel really)
console_log("Entering Boot Sequence")
console_log("(boot)")
boot = get_primitive("boot")
boot.call_interpret([])
console_log("(current-library-collection-links (find-library-collection-links))")
flcl = get_primitive("find-library-collection-links")
lib_coll_links = flcl.call_interpret([])
clcl = get_primitive("current-library-collection-links")
clcl.call_interpret([lib_coll_links])
console_log("(current-library-collection-paths (find-library-collection-paths))")
flcp = get_primitive("find-library-collection-paths")
lib_coll_paths = flcp.call_interpret([])
clcp = get_primitive("current-library-collection-paths")
clcp.call_interpret([lib_coll_paths])
console_log("(read-accept-compiled true)")
read_accept_compiled = get_primitive("read-accept-compiled")
read_accept_compiled.call_interpret([w_true])
compiled_file_path = "compiled/pycket"
ucfp = get_primitive("use-compiled-file-paths")
if use_compiled:
console_log("(use-compiled-file-paths %s)" % compiled_file_path)
ucfp.call_interpret([W_WrappedConsProper.make(W_String.make(compiled_file_path), w_null)])
else:
ucfp.call_interpret([w_null])
console_log("(use-compiled-file-paths null)")
cctm = get_primitive("current-compile-target-machine")
if compile_any:
cctm.call_interpret([w_false])
# set the current directory to the current directory
import os
c_dir = os.getcwd()
console_log("(current-directory %s)" % c_dir)
# We can't call the current-directory like a primitive
# because it prints a report to stdout
from pycket.values_parameter import top_level_config
from pycket.prims.general import current_directory_param
c = top_level_config.get(current_directory_param)
assert isinstance(c, W_ThreadCell)
c.set(W_Path(c_dir))
console_log("...Boot Sequence Completed")
from pycket.env import w_global_config as glob
glob.boot_is_completed()
return 0