def test_write_compiled_module(self):
        space = self.space
        pathname = _testfilesource()
        os.chmod(pathname, 0777)
        stream = streamio.open_file_as_stream(pathname, "r")
        try:
            w_ret = importing.parse_source_module(space,
                                                  pathname,
                                                  stream.readall())
        finally:
            stream.close()
        pycode = space.interpclass_w(w_ret)
        assert type(pycode) is pypy.interpreter.pycode.PyCode

        cpathname = str(udir.join('cpathname.pyc'))
        mode = 0777
        mtime = 12345
        importing.write_compiled_module(space,
                                        pycode,
                                        cpathname,
                                        mode,
                                        mtime)

        # check
        ret = importing.check_compiled_module(space,
                                              cpathname,
                                              mtime)
        assert ret is not None
        ret.close()

        # Check that the executable bit was removed
        assert os.stat(cpathname).st_mode & 0111 == 0

        # read compiled module
        stream = streamio.open_file_as_stream(cpathname, "rb")
        try:
            stream.seek(8, 0)
            w_code = importing.read_compiled_module(space, cpathname,
                                                    stream.readall())
            pycode = space.interpclass_w(w_code)
        finally:
            stream.close()

        # check value of load
        w_dic = space.newdict()
        pycode.exec_code(space, w_dic, w_dic)
        w_ret = space.getitem(w_dic, space.wrap('x'))
        ret = space.int_w(w_ret)
        assert ret == 42

 def direct___init__(self, w_name, mode='r', buffering=-1):
     name = self.space.str_w(w_name)
     self.direct_close()
     self.check_mode_ok(mode)
     stream = streamio.open_file_as_stream(name, mode, buffering)
     fd = stream.try_to_find_file_descriptor()
     self.fdopenstream(stream, fd, mode, w_name)

 def test_load_compiled_module(self):
     space = self.space
     pathname = "whatever"
     mtime = 12345
     co = compile('x = 42', '?', 'exec')
     cpathname = _testfile(importing.get_pyc_magic(space), mtime, co)
     w_modulename = space.wrap('somemodule')
     stream = streamio.open_file_as_stream(cpathname, "r")
     try:
         w_mod = space.wrap(Module(space, w_modulename))
         magic = importing._r_long(stream)
         timestamp = importing._r_long(stream)
         w_ret = importing.load_compiled_module(space,
                                                w_modulename,
                                                w_mod,
                                                cpathname,
                                                magic,
                                                timestamp,
                                                stream.readall())
     finally:
         stream.close()
     assert w_mod is w_ret
     w_ret = space.getattr(w_mod, space.wrap('x'))
     ret = space.int_w(w_ret)
     assert ret == 42

def entry_point(argv):
    if len(argv) == 2:
        code = open_file_as_stream(argv[1]).readall()
        try:
            t = parse(code)
        except BacktrackException:
            #(line, col) = e.error.get_line_column(code)
            #expected = " ".join(e.error.expected)
            print "parse error"
            return 1

        #this should not be necessary here
        assert isinstance(t, list)
        ctx = ExecutionContext()
        try:
            for sexpr in t:
                try:
                    w_retval = sexpr.eval(ctx)
                    print w_retval.to_string()
                except ContinuationReturn, e:
                    print e.result.to_string()

        except SchemeQuit, e:
            return 0

        return 0

 def load(self, cartridge_path):
     cartridge_path               = str(cartridge_path)
     self.cartridge_file_path     = cartridge_path
     self.cartridge_stream        = open_file_as_stream(cartridge_path)
     self.cartridge_file_contents = map_to_byte(
                                             self.cartridge_stream.readall())
     self.load_battery(cartridge_path)

 def test_pyc_magic_changes(self):
     # test that the pyc files produced by a space are not reimportable
     # from another, if they differ in what opcodes they support
     allspaces = [self.space]
     for opcodename in self.space.config.objspace.opcodes.getpaths():
         key = 'objspace.opcodes.' + opcodename
         space2 = gettestobjspace(**{key: True})
         allspaces.append(space2)
     for space1 in allspaces:
         for space2 in allspaces:
             if space1 is space2:
                 continue
             pathname = "whatever"
             mtime = 12345
             co = compile('x = 42', '?', 'exec')
             cpathname = _testfile(importing.get_pyc_magic(space1),
                                   mtime, co)
             w_modulename = space2.wrap('somemodule')
             stream = streamio.open_file_as_stream(cpathname, "rb")
             try:
                 w_mod = space2.wrap(Module(space2, w_modulename))
                 magic = importing._r_long(stream)
                 timestamp = importing._r_long(stream)
                 space2.raises_w(space2.w_ImportError,
                                 importing.load_compiled_module,
                                 space2,
                                 w_modulename,
                                 w_mod,
                                 cpathname,
                                 magic,
                                 timestamp,
                                 stream.readall())
             finally:
                 stream.close()

def load_bytecode(filename):
    from pypy.rlib.streamio import open_file_as_stream

    f = open_file_as_stream(filename)
    bytecode = f.readall()
    f.close()
    return bytecode

def check_compiled_module(space, pathname, mtime, cpathname):
    """
    Given a pathname for a Python source file, its time of last
    modification, and a pathname for a compiled file, check whether the
    compiled file represents the same version of the source.  If so,
    return a FILE pointer for the compiled file, positioned just after
    the header; if not, return NULL.
    Doesn't set an exception.
    """
    w_marshal = space.getbuiltinmodule('marshal')
    stream = streamio.open_file_as_stream(cpathname, "rb")
    magic = _r_long(stream)
    try:
        if magic != get_pyc_magic(space):
            # XXX what to do about Py_VerboseFlag ?
            # PySys_WriteStderr("# %s has bad magic\n", cpathname);
            return -1
        pyc_mtime = _r_long(stream)
        if pyc_mtime != mtime:
            # PySys_WriteStderr("# %s has bad mtime\n", cpathname);
            return 0
        # if (Py_VerboseFlag)
           # PySys_WriteStderr("# %s matches %s\n", cpathname, pathname);
    finally:
        stream.close()
    return 1

def run_file(filename):
    fp = open_file_as_stream(filename)
    source = fp.readall()
    toplevel_env = get_report_env()
    try:
        exprs_w = parse_string(source)
    except BacktrackException as e:
        print e.error.nice_error_message('<file %s>' % filename, source)
        return 1
    try:
        nodelist = Builder(exprs_w).getast()
    except OperationError as e:
        print e.unwrap().to_string()
        return 1
    cpsform = Rewriter(nodelist, toplevel=True).run()
    try:
        w_maincont, proto_w = compile_all(cpsform, toplevel_env)
    except OperationError as e:
        print e.unwrap().to_string()
        return 1
    #print 'ast:', map(lambda o: o.to_string(), nodelist)
    #print cpsform.to_string()
    #print w_maincont, 'dis:'
    #print dis_proto(w_maincont.w_proto)
    #for w_proto in proto_w:
    #    print w_proto, 'dis:'
    #    print dis_proto(w_proto)
    #return 0
    frame = Frame(w_maincont, proto_w)
    frame.run()
    return 0

def compile_file(filename, outfname):
    """maybe rpython..."""
    w_skel = compile_list_of_expr(filename_to_expr_list(filename))

    outf = open_file_as_stream(outfname, 'w')
    chunkio.dump(w_skel, outf)
    outf.close()

def find_module(space, modulename, w_modulename, partname, w_path,
                use_loader=True):
    # Examin importhooks (PEP302) before doing the import
    if use_loader:
        w_loader  = find_in_meta_path(space, w_modulename, w_path)
        if w_loader:
            return FindInfo.fromLoader(w_loader)

    # XXX Check for frozen modules?
    #     when w_path is a string

    if w_path is None:
        # check the builtin modules
        if modulename in space.builtin_modules:
            return FindInfo(C_BUILTIN, modulename, None)
        w_path = space.sys.get('path')

    # XXX check frozen modules?
    #     when w_path is null

    if w_path is not None:
        for w_pathitem in space.unpackiterable(w_path):
            # sys.path_hooks import hook
            if use_loader:
                w_loader = find_in_path_hooks(space, w_modulename, w_pathitem)
                if w_loader:
                    return FindInfo.fromLoader(w_loader)

            path = space.str_w(w_pathitem)
            filepart = os.path.join(path, partname)
            if os.path.isdir(filepart) and case_ok(filepart):
                initfile = os.path.join(filepart, '__init__')
                modtype, _, _ = find_modtype(space, initfile)
                if modtype in (PY_SOURCE, PY_COMPILED):
                    return FindInfo(PKG_DIRECTORY, filepart, None)
                else:
                    msg = "Not importing directory " +\
                            "'%s' missing __init__.py" % (filepart,)
                    space.warn(msg, space.w_ImportWarning)
            modtype, suffix, filemode = find_modtype(space, filepart)
            try:
                if modtype in (PY_SOURCE, PY_COMPILED):
                    assert suffix is not None
                    filename = filepart + suffix
                    stream = streamio.open_file_as_stream(filename, filemode)
                    try:
                        return FindInfo(modtype, filename, stream, suffix, filemode)
                    except:
                        stream.close()
                        raise
                if modtype == C_EXTENSION:
                    filename = filepart + suffix
                    return FindInfo(modtype, filename, None, suffix, filemode)
            except StreamErrors:
                pass   # XXX! must not eat all exceptions, e.g.
                       # Out of file descriptors.

    # not found
    return None

def load_compiled_chunk(filename):
    vm = VM()
    open_lib(vm)
    stream = open_file_as_stream(filename, 'r')
    w_skel = chunkio.load(stream)
    stream.close()
    vm.bootstrap(w_skel)
    vm.run()

def main(argv):
    if not len(argv) == 2:
        print __doc__
        return 1
    f = open_file_as_stream(argv[1])
    data = f.readall()
    f.close()
    interpret(data)
    return 0

def get_file(space, w_file, filename, filemode):
    if w_file is None or space.is_w(w_file, space.w_None):
        try:
            return streamio.open_file_as_stream(filename, filemode)
        except StreamErrors, e:
            # XXX this is not quite the correct place, but it will do for now.
            # XXX see the issue which I'm sure exists already but whose number
            # XXX I cannot find any more...
            raise wrap_streamerror(space, e)

 def load(self, cartridge_path):
     if cartridge_path is None:
         raise Exception("cartridge_path cannot be None!")
     cartridge_path = str(cartridge_path)
     self.cartridge_file_path = cartridge_path
     self.cartridge_stream = open_file_as_stream(cartridge_path)
     self.cartridge_file_contents = map_to_byte( \
                                             self.cartridge_stream.readall())
     self.load_battery(cartridge_path)

    def test_write_compiled_module(self):
        space = self.space
        pathname = _testfilesource()
        stream = streamio.open_file_as_stream(pathname, "r")
        try:
            w_ret = importing.parse_source_module(space,
                                                  pathname,
                                                  stream.readall())
        finally:
            stream.close()
        pycode = space.interpclass_w(w_ret)
        assert type(pycode) is pypy.interpreter.pycode.PyCode

        cpathname = str(udir.join('cpathname.pyc'))
        mtime = 12345
        importing.write_compiled_module(space,
                                        pycode,
                                        cpathname,
                                        mtime)

        # check
        pathname = str(udir.join('cpathname.py'))
        ret = importing.check_compiled_module(space,
                                              pathname,
                                              mtime,
                                              cpathname)
        assert ret == 1

        # read compile module
        stream = streamio.open_file_as_stream(cpathname, "r")
        try:
            stream.seek(8, 0)
            w_code = importing.read_compiled_module(space, cpathname,
                                                    stream.readall())
            pycode = space.interpclass_w(w_code)
        finally:
            stream.close()

        # check value of load
        w_dic = space.newdict()
        pycode.exec_code(space, w_dic, w_dic)
        w_ret = space.getitem(w_dic, space.wrap('x'))
        ret = space.int_w(w_ret)
        assert ret == 42

def main(fname, argv):
    f = open_file_as_stream(fname, "r")
    input = f.readall()
    f.close()
    code = compile(input)
    mainframe = Frame(code)
    for i in range(len(argv)):
        mainframe.registers[i] = Int(int(argv[i]))
    res = mainframe.interpret()
    print "Result:", res.repr()

def parse(code):
    GFILE = open_file_as_stream(abspath(join(dirname(__file__), "grammar.txt")))

    t = None
    try:
        t = GFILE.read()
        regexs, rules, ToAST = parse_ebnf(t)
    except ParseError,e:
        print e.nice_error_message(filename=str(GFILE),source=t)
        raise

	def __init__( self, program=None, filename=None, argv=[] ):
		self.program = program
		if filename:
			f = open_file_as_stream(filename)
			self.program = f.readall()
			f.close()

		self.space = Space2D( self.program )
		self.stacks = StackStack()
		self.argv = argv

def entry_point(argv):
    if len(argv) < 2:
        print __doc__
        os._exit(1)
    args = argv[2:]
    stream = open_file_as_stream(argv[1])
    co = serializer.deserialize(stream.readall())
    w_args = [unwrap_arg(args[i]) for i in range(len(args))]
    execution.run(co, w_args)
    return 0