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