def bytes_to_path(b):
return values.W_Path(b.as_str())
def string_to_path(str):
s = str.as_str_utf8()
return values.W_Path(s)
def initialize_paths(self):
from pycket.util import os_get_env_var, os_check_env_var
# FIXME : check absolute/relative paths
# Environment Variables
if not os_check_env_var("PLTHOME") and not os_check_env_var(
"PLTCOLLECTS"):
raise SchemeException(
"In order to locate the Racket installation, Pycket requires a `PLTHOME` environment variable to point to Racket directory. If Racket is installed in Unix-style, then you can just set a `PLTCOLLECTS` variable to point to the Racket `collects`."
)
PLTHOME = os_get_env_var("PLTHOME")
PLTCOLLECTS = os_get_env_var("PLTCOLLECTS")
PLTEXECFILE = os_get_env_var("PLTEXECFILE")
PLTUSERHOME = os_get_env_var("PLTUSERHOME")
HOME = os_get_env_var("HOME")
USER = os_get_env_var("USER")
LOGNAME = os_get_env_var("LOGNAME")
TMPDIR = os_get_env_var("TMPDIR")
PLTCONFIGDIR = os_get_env_var("PLTCONFIGDIR")
PLTADDONDIR = os_get_env_var("PLTADDONDIR")
CURRENT_DIR = os.getcwd()
#############
# HOME
#############
W_PATH_HOME_DIR = ""
if PLTUSERHOME:
W_PATH_HOME_DIR = PLTUSERHOME
elif HOME:
W_PATH_HOME_DIR = HOME
elif USER:
W_PATH_HOME_DIR = USER
elif LOGNAME:
W_PATH_HOME_DIR = LOGNAME
self.paths[path_home_dir] = values.W_Path(W_PATH_HOME_DIR)
#############
# PREF-DIR
#############
W_PATH_PREF_DIR = ""
if W_PATH_HOME_DIR:
W_PATH_PREF_DIR = os.path.join(W_PATH_HOME_DIR, ".racket")
self.paths[path_pref_dir] = values.W_Path(W_PATH_PREF_DIR)
#############
# PREF-FILE
#############
W_PATH_PREF_FILE = ""
if W_PATH_PREF_DIR:
W_PATH_PREF_FILE = os.path.join(W_PATH_PREF_DIR,
"racket-prefs.rktd")
self.paths[path_pref_file] = values.W_Path(W_PATH_PREF_FILE)
#############
# TEMP-DIR
#############
W_PATH_TEMP_DIR = ""
if TMPDIR:
W_PATH_TEMP_DIR = TMPDIR
elif os.path.exists("/var/tmp"):
W_PATH_TEMP_DIR = "/var/tmp"
elif os.path.exists("/usr/tmp"):
W_PATH_TEMP_DIR = "/usr/tmp"
elif os.path.exists("/tmp"):
W_PATH_TEMP_DIR = "/tmp"
self.paths[path_temp_dir] = values.W_Path(W_PATH_TEMP_DIR)
#############
# INIT-DIR
#############
W_PATH_INIT_DIR = W_PATH_HOME_DIR
self.paths[path_init_dir] = values.W_Path(W_PATH_INIT_DIR)
#############
# INIT-FILE -- startup file
#
# Unix and Mac OS: ".racketrc"
# Windows: "racketrc.rktl"
#############
W_PATH_INIT_FILE = ""
if W_PATH_INIT_DIR:
W_PATH_INIT_FILE = os.path.join(W_PATH_INIT_DIR, ".racketrc")
self.paths[path_init_file] = values.W_Path(W_PATH_INIT_FILE)
#############
# CONFIG-DIR
# defaults to an "etc" directory relative to the current executable
# It might not exist
#############
W_PATH_CONFIG_DIR = ""
if PLTCONFIGDIR:
W_PATH_CONFIG_DIR = PLTCONFIGDIR
else:
if PLTHOME:
W_PATH_CONFIG_DIR = os.path.join(PLTHOME,
os.path.join("racket", "etc"))
else:
W_PATH_CONFIG_DIR = os.path.join(CURRENT_DIR, "etc")
if path_config_dir not in self.paths:
self.paths[path_config_dir] = values.W_Path(W_PATH_CONFIG_DIR)
#############
# HOST-CONFIG-DIR
#############
W_PATH_HOST_CONFIG_DIR = W_PATH_CONFIG_DIR
self.paths[path_host_config_dir] = values.W_Path(
W_PATH_HOST_CONFIG_DIR)
#############
# ADDON-DIR
#############
W_PATH_ADDON_DIR = W_PATH_PREF_DIR
if PLTADDONDIR:
W_PATH_ADDON_DIR = PLTADDONDIR
if path_addon_dir not in self.paths:
self.paths[path_addon_dir] = values.W_Path(W_PATH_ADDON_DIR)
#############
# DOC-DIR
#############
W_PATH_DOC_DIR = W_PATH_HOME_DIR
self.paths[path_doc_dir] = values.W_Path(W_PATH_DOC_DIR)
#############
# SYS-DIR
#############
W_PATH_SYS_DIR = "/"
self.paths[path_sys_dir] = values.W_Path(W_PATH_SYS_DIR)
#############
# EXEC-FILE
#############
# FIXME : get argv[0] from target args
if PLTHOME:
# assume the binary is at $PLTHOME/racket/bin/racket
W_PATH_EXEC_FILE = os.path.join(
PLTHOME, os.path.join("racket", os.path.join("bin", "racket")))
elif PLTEXECFILE:
# expect PLTEXECFILE
W_PATH_EXEC_FILE = PLTEXECFILE
else:
# should we error?
# set it to pycket-c for now
W_PATH_EXEC_FILE = os.path.join(CURRENT_DIR, "pycket-c")
self.paths[path_exec_file] = values.W_Path(W_PATH_EXEC_FILE)
#############
# RUN-FILE
#############
W_PATH_RUN_FILE = W_PATH_EXEC_FILE
if path_run_file not in self.paths:
self.paths[path_run_file] = values.W_Path(W_PATH_RUN_FILE)
#############
# COLLECTS-DIR
#############
if PLTHOME:
W_PATH_COLLECTS_DIR = os.path.join(
PLTHOME, os.path.join("racket", "collects"))
else:
W_PATH_COLLECTS_DIR = PLTCOLLECTS
if path_collects_dir not in self.paths:
self.paths[path_collects_dir] = values.W_Path(W_PATH_COLLECTS_DIR)
#############
# HOST-COLLECTS-DIR
#############
W_PATH_HOST_COLLECTS_DIR = W_PATH_COLLECTS_DIR
self.paths[path_host_collects_dir] = values.W_Path(
W_PATH_HOST_COLLECTS_DIR)
#############
# ORIG-DIR
#############
W_PATH_ORIG_DIR = CURRENT_DIR
self.paths[path_orig_dir] = values.W_Path(W_PATH_ORIG_DIR)
self.initialized = True
def cleanse_path(p):
if isinstance(p, values_string.W_String):
return values.W_Path(p.as_str_ascii())
if isinstance(p, values.W_Path):
return p
raise SchemeException("cleanse-path expects string or path")
def fasl_to_sexp_recursive(self, fasl_string, pos):
from pycket import values as v
from pycket.values_string import W_String
from pycket.values_regex import W_Regexp, W_PRegexp, W_ByteRegexp, W_BytePRegexp
from pycket.vector import W_Vector
from pycket.values_struct import W_Struct
from pycket.prims.general import srcloc
from pycket.hash import simple as hash_simple
from pycket.hash.equal import W_EqualHashTable
from pycket.prims.numeric import float_bytes_to_real
from pycket.prims.string import _str2num
from rpython.rlib.rbigint import rbigint
from pycket.prims.input_output import build_path, bytes_to_path_element
from pycket.ast_vs_sexp import to_rpython_list
typ, pos = self.read_byte_no_eof(fasl_string, pos)
if typ == FASL_GRAPH_DEF_TYPE:
position, pos = self.read_fasl_integer(fasl_string, pos)
val, pos = self.fasl_to_sexp_recursive(fasl_string, pos)
if position >= self.GLOBAL_SHARED_COUNT:
raise Exception("fasl: bad graph index")
self.SHARED[position] = val
return val, pos
elif typ == FASL_GRAPH_REF_TYPE:
position, pos = self.read_fasl_integer(fasl_string, pos)
if position >= self.GLOBAL_SHARED_COUNT:
raise Exception("fasl: bad graph index")
return self.SHARED[position], pos
elif typ == FASL_FALSE_TYPE:
return v.w_false, pos
elif typ == FASL_TRUE_TYPE:
return v.w_true, pos
elif typ == FASL_NULL_TYPE:
return v.w_null, pos
elif typ == FASL_VOID_TYPE:
return v.w_void, pos
elif typ == FASL_EOF_TYPE:
return v.eof_object, pos
elif typ == FASL_INTEGER_TYPE:
num, pos = self.read_fasl_integer(fasl_string, pos)
if isinstance(num, rbigint):
return v.W_Bignum(num), pos
return v.W_Fixnum(num), pos
elif typ == FASL_FLONUM_TYPE:
num_str, pos = self.read_bytes_exactly(fasl_string, pos, 8)
return float_bytes_to_real(list(num_str), v.w_false), pos
elif typ == FASL_SINGLE_FLONUM_TYPE:
num_str, pos = self.read_bytes_exactly(fasl_string, pos, 4)
real = float_bytes_to_real(list(num_str), v.w_false)
return real.arith_exact_inexact(), pos
elif typ == FASL_EXTFLONUM_TYPE:
bstr_len, pos = self.read_fasl_integer(fasl_string, pos)
num_str, pos = self.read_bytes_exactly(fasl_string, pos, bstr_len)
return _str2num(W_String.fromstr_utf8(num_str).as_str_utf8(),
10), pos
elif typ == FASL_RATIONAL_TYPE:
num, pos = self.fasl_to_sexp_recursive(fasl_string, pos)
den, pos = self.fasl_to_sexp_recursive(fasl_string, pos)
return v.W_Rational.make(num, den), pos
elif typ == FASL_COMPLEX_TYPE:
re, pos = self.fasl_to_sexp_recursive(fasl_string, pos)
im, pos = self.fasl_to_sexp_recursive(fasl_string, pos)
return v.W_Complex.from_real_pair(re, im), pos
elif typ == FASL_CHAR_TYPE:
_chr, pos = self.read_fasl_integer(fasl_string, pos)
return v.W_Character(unichr(_chr)), pos
elif typ == FASL_SYMBOL_TYPE:
sym_str, pos = self.read_fasl_string(fasl_string, pos)
return v.W_Symbol.make(sym_str), pos
elif typ == FASL_UNREADABLE_SYMBOL_TYPE:
sym_str, pos = self.read_fasl_string(fasl_string, pos)
return v.W_Symbol.make_unreadable(sym_str), pos
elif typ == FASL_UNINTERNED_SYMBOL_TYPE:
sym_str, pos = self.read_fasl_string(fasl_string, pos)
return v.W_Symbol(sym_str), pos
elif typ == FASL_KEYWORD_TYPE:
key_str, pos = self.read_fasl_string(fasl_string, pos)
return v.W_Keyword.make(key_str), pos
elif typ == FASL_STRING_TYPE:
str_str, pos = self.read_fasl_string(fasl_string, pos)
return W_String.make(str_str), pos
elif typ == FASL_IMMUTABLE_STRING_TYPE:
str_str, pos = self.read_fasl_string(fasl_string, pos)
return W_String.make(str_str).make_immutable(), pos
elif typ == FASL_BYTES_TYPE:
byts, pos = self.read_fasl_bytes(fasl_string, pos)
return v.W_Bytes.from_string(byts, immutable=False), pos
elif typ == FASL_IMMUTABLE_BYTES_TYPE:
byts, pos = self.read_fasl_bytes(fasl_string, pos)
return v.W_Bytes.from_string(byts), pos
elif typ == FASL_PATH_TYPE:
byts, pos = self.read_fasl_bytes(fasl_string, pos)
return v.W_Path(byts), pos
elif typ == FASL_RELATIVE_PATH_TYPE:
wrt_dir = self.current_relative_dir
p_w_lst, pos = self.fasl_to_sexp_recursive(fasl_string, pos)
p_r_lst, _ = to_rpython_list(p_w_lst)
rel_elems = [
bytes_to_path_element(p) if isinstance(p, v.W_Bytes) else p
for p in p_r_lst
]
if wrt_dir:
return build_path([wrt_dir] + rel_elems), pos
elif rel_elems == []:
return build_path([v.W_Symbol.make("same")]), pos
else:
return build_path(rel_elems), pos
elif typ == FASL_PREGEXP_TYPE:
str_str, pos = self.read_fasl_string(fasl_string, pos)
return W_PRegexp(str_str), pos
elif typ == FASL_REGEXP_TYPE:
str_str, pos = self.read_fasl_string(fasl_string, pos)
return W_Regexp(str_str), pos
elif typ == FASL_BYTE_PREGEXP:
str_str, pos = self.read_fasl_string(fasl_string, pos)
return W_BytePRegexp(str_str), pos
elif typ == FASL_BYTE_REGEXP_TYPE:
str_str, pos = self.read_fasl_string(fasl_string, pos)
return W_ByteRegexp(str_str), pos
elif typ == FASL_LIST_TYPE:
list_len, pos = self.read_fasl_integer(fasl_string, pos)
lst, pos = self.read_multi_into_rpython_list(
fasl_string, pos, list_len)
return v.to_list(lst), pos
elif typ == FASL_PAIR_TYPE:
car, pos = self.fasl_to_sexp_recursive(fasl_string, pos)
cdr, pos = self.fasl_to_sexp_recursive(fasl_string, pos)
return v.W_Cons.make(car, cdr), pos
elif typ == FASL_LIST_STAR_TYPE:
list_len, pos = self.read_fasl_integer(fasl_string, pos)
# list_len is the length of the proper part
lst, pos = self.read_multi_into_rpython_list(
fasl_string, pos, list_len)
# read the last element
return_list, pos = self.fasl_to_sexp_recursive(fasl_string, pos)
for i in range(list_len - 1, -1, -1):
return_list = v.W_Cons.make(lst[i], return_list)
return return_list, pos
elif typ == FASL_VECTOR_TYPE or typ == FASL_IMMUTABLE_VECTOR_TYPE:
vec_len, pos = self.read_fasl_integer(fasl_string, pos)
storage, pos = self.read_multi_into_rpython_list(
fasl_string, pos, vec_len)
if typ == FASL_IMMUTABLE_VECTOR_TYPE:
return W_Vector.fromelements(storage, immutable=True), pos
return W_Vector.fromelements(storage), pos
elif typ == FASL_BOX_TYPE:
element, pos = self.fasl_to_sexp_recursive(fasl_string, pos)
return v.W_MBox(element), pos
elif typ == FASL_IMMUTABLE_BOX_TYPE:
element, pos = self.fasl_to_sexp_recursive(fasl_string, pos)
return v.W_IBox(element), pos
elif typ == FASL_PREFAB_TYPE:
key, pos = self.fasl_to_sexp_recursive(fasl_string, pos)
length, pos = self.read_fasl_integer(fasl_string, pos)
vals, pos = self.read_multi_into_rpython_list(
fasl_string, pos, length)
return W_Struct.make_prefab(key, vals), pos
elif typ == FASL_HASH_TYPE:
variant, pos = self.read_byte_no_eof(fasl_string, pos)
length, pos = self.read_fasl_integer(fasl_string, pos)
keys, vals, pos = self.read_multi_double_into_rpython_list(
fasl_string, pos, length)
if variant == FASL_HASH_EQ_VARIANT:
return hash_simple.make_simple_mutable_table(
hash_simple.W_EqMutableHashTable, keys, vals), pos
elif variant == FASL_HASH_EQV_VARIANT:
return hash_simple.make_simple_mutable_table(
hash_simple.W_EqvMutableHashTable, keys, vals), pos
else: # variant == FASL_HASH_EQUAL_VARIANT:
return W_EqualHashTable(keys, vals, immutable=False), pos
elif typ == FASL_IMMUTABLE_HASH_TYPE:
variant, pos = self.read_byte_no_eof(fasl_string, pos)
length, pos = self.read_fasl_integer(fasl_string, pos)
keys, vals, pos = self.read_multi_double_into_rpython_list(
fasl_string, pos, length)
if variant == FASL_HASH_EQ_VARIANT:
return hash_simple.make_simple_immutable_table(
hash_simple.W_EqImmutableHashTable, keys, vals), pos
elif variant == FASL_HASH_EQV_VARIANT:
return hash_simple.make_simple_immutable_table(
hash_simple.W_EqvImmutableHashTable, keys, vals), pos
else: # variant == FASL_HASH_EQUAL_VARIANT:
return W_EqualHashTable(keys, vals, immutable=True), pos
elif typ == FASL_SRCLOC:
# difficult to create an instance of srcloc struct so defer that to the runtime
source, pos = self.fasl_to_sexp_recursive(fasl_string, pos)
line, pos = self.fasl_to_sexp_recursive(fasl_string, pos)
column, pos = self.fasl_to_sexp_recursive(fasl_string, pos)
position, pos = self.fasl_to_sexp_recursive(fasl_string, pos)
span, pos = self.fasl_to_sexp_recursive(fasl_string, pos)
return W_Struct.make([source, line, column, position, span],
srcloc), pos
else:
if typ >= FASL_SMALL_INTEGER_START:
return v.W_Fixnum((typ - FASL_SMALL_INTEGER_START) +
FASL_LOWEST_SMALL_INTEGER), pos
else:
raise Exception("unrecognized fasl tag : %s" % typ)
def simplify_path(path, use_filesystem):
path_str = extract_path(path)
return values.W_Path(path_str)
def resolve_path(obj):
if (not isinstance(obj, values_string.W_String)
and not isinstance(obj, values.W_Path)):
raise SchemeException("resolve-path: expected path-string")
str = extract_path(obj)
return values.W_Path(os.path.normpath(str))
def file_exists(w_str):
s = extract_path(w_str)
return values.W_Bool.make(os.path.isfile(s))
@expose("directory-list", [values.W_Object])
def dir_list(w_str):
s = extract_path(w_str)
dir = [values.W_Path(p) for p in os.listdir(s)]
return values.to_list(dir)
UP = values.W_Symbol.make("up")
SAME = values.W_Symbol.make("same")
RELATIVE = values.W_Symbol.make("relative")
ROOT = SEP = values.W_Path(os.sep)
def _explode_element(s):
if not s:
return SEP
if s == ".":
return SAME
if s == "..":
return UP
return values.W_Path(s)
@expose("explode-path", [values.W_Object])
def explode_path(w_path):
sep = os.sep
def dir_list(w_str):
s = extract_path(w_str)
dir = [values.W_Path(p) for p in os.listdir(s)]
return values.to_list(dir)
def varref_rmp(varref):
return values.W_ResolvedModulePath(values.W_Path(varref.varref.path))
def sys_lib_subpath(mode):
return values.W_Path("x86_64-linux") # FIXME
def cur_dir():
return values.W_Path(os.getcwd())
def mpi_resolve(a):
return values.W_ResolvedModulePath(values.W_Path("."))
def to_value(json):
dbgprint("to_value", json)
if json is pycket_json.json_false:
return values.w_false
elif json is pycket_json.json_true:
return values.w_true
if json.is_object:
# The json-object should only contain one element
obj = json.value_object()
if "vector" in obj:
return vector.W_Vector.fromelements([to_value(v) for v in obj["vector"].value_array()], immutable=True)
if "struct" in obj:
key = to_value(obj["prefab-key"])
fields = [to_value(v) for v in obj["struct"].value_array()]
return values_struct.W_Struct.make_prefab(key, fields)
if "box" in obj:
return values.W_IBox(to_value(obj["box"]))
if "number" in obj:
return _to_num(obj["number"])
if "path" in obj:
return values.W_Path(obj["path"].value_string())
if "char" in obj:
return values.W_Character.make(unichr(int(obj["char"].value_string())))
if "hash-keys" in obj and "hash-vals" in obj:
return W_EqualHashTable(
[to_value(i) for i in obj["hash-keys"].value_array()],
[to_value(i) for i in obj["hash-vals"].value_array()],
immutable=True)
if "hasheq-keys" in obj and "hasheq-vals" in obj:
keys = [to_value(i) for i in obj["hasheq-keys"].value_array()]
vals = [to_value(i) for i in obj["hasheq-vals"].value_array()]
return make_simple_immutable_table(W_EqImmutableHashTable, keys, vals)
if "hasheqv-keys" in obj and "hasheqv-vals" in obj:
keys = [to_value(i) for i in obj["hasheqv-keys"].value_array()]
vals = [to_value(i) for i in obj["hasheqv-vals"].value_array()]
return make_simple_immutable_table(W_EqvImmutableHashTable, keys, vals)
if "regexp" in obj:
return values_regex.W_Regexp(obj["regexp"].value_string())
if "byte-regexp" in obj:
arr = decode_byte_array(obj["byte-regexp"])
return values_regex.W_ByteRegexp("".join(arr))
if "pregexp" in obj:
return values_regex.W_PRegexp(obj["pregexp"].value_string())
if "byte-pregexp" in obj:
arr = decode_byte_array(obj["byte-pregexp"])
return values_regex.W_BytePRegexp("".join(arr))
if "bytes" in obj:
arr = decode_byte_array(obj["bytes"])
return values.W_ImmutableBytes(arr)
if "string" in obj:
return values_string.W_String.make(str(obj["string"].value_string()))
if "keyword" in obj:
return values.W_Keyword.make(str(obj["keyword"].value_string()))
if "improper" in obj:
improper = obj["improper"].value_array()
return values.to_improper([to_value(v) for v in improper[0].value_array()], to_value(improper[1]))
if "void" in obj:
return values.w_void
for i in ["lexical", "module", "source-name", "toplevel"]:
if i in obj:
return values.W_Symbol.make(obj[i].value_string())
if json.is_array:
return values.to_list([to_value(j) for j in json.value_array()])
assert 0, "Unexpected json value: %s" % json.tostring()
