__config__ = None

py_list = list

py_str = str

from rpython.rlib.objectmodel import specialize, we_are_translated

def init():

import pixie.vm2.code as code

from pixie.vm2.object import affirm, _type_registry

from rpython.rlib.rarithmetic import r_uint, base_int

from rpython.rlib.rbigint import rbigint

from pixie.vm2.primitives import nil, true, false

from pixie.vm2.string import String

from pixie.vm2.object import Object

def unwrap(fn):

if isinstance(fn, code.Var) and fn.is_defined() and hasattr(fn.deref(), "_returns"):

tp = fn.deref()._returns

if tp is bool:

def wrapper(*args):

ret = fn.invoke(py_list(args))

if ret is nil or ret is false:

return False

return True

return wrapper

elif tp is r_uint:

return lambda *args: fn.invoke(py_list(args)).r_uint_val()

elif tp is unicode:

def wrapper(*args):

ret = fn.invoke(py_list(args))

if ret is nil:

return None

if not isinstance(ret, String):

from pixie.vm2.object import runtime_error

runtime_error(u"Invalid return value, expected String")

return ret._str

return wrapper

else:

assert False, "Don't know how to convert" + str(tp)

return lambda *args: fn.invoke(py_list(args))

if "__inited__" in globals():

return

import sys

#sys.setrecursionlimit(10000) # Yeah we blow the stack sometimes, we promise it's not a bug

import pixie.vm2.code as code

import pixie.vm2.numbers as numbers

import pixie.vm2.files

import pixie.vm2.stdlib

import pixie.vm2.array

import pixie.vm2.arraymap

import pixie.vm2.custom_types

import pixie.vm2.jit_tables

import pixie.vm2.ffi

import pixie.vm2.platform

class FakeSpace(object):

def wrap(self, x):

if isinstance(x, Object):

return x

elif isinstance(x, bool):

return true if x else false

elif isinstance(x, int):

return numbers.Integer(x)

elif isinstance(x, rbigint):

return numbers.BigInteger(x)

elif isinstance(x, float):

return numbers.Float(x)

elif isinstance(x, unicode):

return String(x)

elif isinstance(x, py_str):

return String(unicode(x))

elif isinstance(x, r_uint):

from pixie.vm2.numbers import SizeT

return SizeT(x)

elif x is None:

return nil

else:

from pixie.vm2.object import runtime_error

return runtime_error(u"Bad Wrap")

wrap._annspecialcase_ = 'specialize:argtype(1)'

space = FakeSpace()

@specialize.argtype(0)

def wrap(x):

return space.wrap(x)

globals()["wrap"] = wrap

def int_val(x):

affirm(isinstance(x, numbers.Number), u"Expected number")

return x.int_val()

globals()["int_val"] = int_val

#f = open("pixie/stdlib.pxi")

#data = f.read()

#f.close()

#rdr = reader.MetaDataReader(reader.StringReader(unicode(data)), u"pixie/stdlib.pixie")

#result = nil

#

# @wrap_fn

# def run_load_stdlib():

# with compiler.with_ns(u"pixie.stdlib"):

# while True:

# form = reader.read(rdr, False)

# if form is reader.eof:

# return result

# result = compiler.compile(form).invoke([])

# reinit()

#

# stacklet.with_stacklets(run_load_stdlib)

init_fns = [u"reduce", u"get", u"reset!", u"assoc", u"key", u"val", u"keys", u"vals", u"vec", u"load-file", u"compile-file",

u"load-ns", u"hashmap", u"cons", u"-assoc", u"-val-at"]

for x in init_fns:

globals()[py_str(code.munge(x))] = unwrap(code.intern_var(u"pixie.stdlib", x))

init_vars = [u"load-paths"]

for x in init_vars:

globals()[py_str(code.munge(x))] = code.intern_var(u"pixie.stdlib", x)

#globals()[py_str(code.munge(u"ns"))] = NS_VAR

globals()["__inited__"] = True

globals()["is_true"] = lambda x: False if x is false or x is nil or x is None else True

_type_registry.set_registry(code.ns_registry)

numbers.init()

code.init()

import pixie.vm2.bits

def unwrap_string(x):

from pixie.vm2.string import String

from pixie.vm2.object import affirm

from pixie.vm2.primitives import nil

if x is None or x is nil:

return None

affirm(isinstance(x, String), u"Expected String")

assert isinstance(x, String)

return x._str

def unwrap_keyword(x):

from pixie.vm2.keyword import Keyword

from pixie.vm2.object import affirm

affirm(isinstance(x, Keyword), u"Expected Keyword")

assert isinstance(x, Keyword)

return x._str