[pypy-svn] r15056 - pypy/dist/pypy/lib

[tismer at codespeak.net]

Author: tismer
Date: Mon Jul 25 18:58:18 2005
New Revision: 15056

Modified:
   pypy/dist/pypy/lib/marshal.py
Log:
made marshal CPython 2.5 compatible.

next step is to geninterp it, to have something
to bootstrap compiled code.

Modified: pypy/dist/pypy/lib/marshal.py
==============================================================================
--- pypy/dist/pypy/lib/marshal.py	(original)
+++ pypy/dist/pypy/lib/marshal.py	Mon Jul 25 18:58:18 2005
@@ -15,6 +15,9 @@
 
 TYPE_NULL     = '0'
 TYPE_NONE     = 'N'
+TYPE_FALSE    = 'F'
+TYPE_TRUE     = 'T'
+TYPE_STOPITER = 'S'
 TYPE_ELLIPSIS = '.'
 TYPE_INT      = 'i'
 TYPE_INT64    = 'I'
@@ -22,13 +25,17 @@
 TYPE_COMPLEX  = 'x'
 TYPE_LONG     = 'l'
 TYPE_STRING   = 's'
+TYPE_INTERNED = 't'
+TYPE_STRINGREF= 'R'
 TYPE_TUPLE    = '('
 TYPE_LIST     = '['
 TYPE_DICT     = '{'
 TYPE_CODE     = 'c'
 TYPE_UNKNOWN  = '?'
-FALSE_CODE    = 'F'
-TRUE_CODE     = 'T'
+TYPE_UNICODE  = 'u'
+TYPE_UNKNOWN  = '?'
+TYPE_SET      = '<'
+TYPE_FROZENSET= '>'
 
 class Marshaller:
 
@@ -62,11 +69,16 @@
 
     def dump_bool(self, x):
         if x:
-            self.f.write(TRUE_CODE)
+            self.f.write(TYPE_TRUE)
         else:
-            self.f.write(FALSE_CODE)
+            self.f.write(TYPE_FALSE)
     dispatch[bool] = dump_bool
 
+    def dump_stopiter(self, x):
+        assert x is StopIteration
+        self.f.write(TYPE_STOPITER)
+    dispatch[type(StopIteration)] = dump_stopiter
+
     def dump_ellipsis(self, x):
         self.f.write(TYPE_ELLIPSIS)
     
@@ -123,11 +135,20 @@
         pass
 
     def dump_string(self, x):
+        # XXX we can't check for interned strings, yet,
+        # so we (for now) never create TYPE_INTERNED or TYPE_STRINGREF
         self.f.write(TYPE_STRING)
         self.w_long(len(x))
         self.f.write(x)
     dispatch[StringType] = dump_string
 
+    def dump_unicode(self, x):
+        self.f.write(TYPE_UNICODE)
+        s = x.encode('utf8')
+        self.w_long(len(s))
+        self.f.write(s)
+    dispatch[UnicodeType] = dump_unicode
+
     def dump_tuple(self, x):
         self.f.write(TYPE_TUPLE)
         self.w_long(len(x))
@@ -152,17 +173,19 @@
 
     def dump_code(self, x):
         self.f.write(TYPE_CODE)
-        self.w_short(x.co_argcount)
-        self.w_short(x.co_nlocals)
-        self.w_short(x.co_stacksize)
-        self.w_short(x.co_flags)
+        self.w_long(x.co_argcount)
+        self.w_long(x.co_nlocals)
+        self.w_long(x.co_stacksize)
+        self.w_long(x.co_flags)
         self.dump(x.co_code)
         self.dump(x.co_consts)
         self.dump(x.co_names)
         self.dump(x.co_varnames)
+        self.dump(x.co_freevars)
+        self.dump(x.co_cellvars)
         self.dump(x.co_filename)
         self.dump(x.co_name)
-        self.w_short(x.co_firstlineno)
+        self.w_long(x.co_firstlineno)
         self.dump(x.co_lnotab)
     try:
         dispatch[CodeType] = dump_code
@@ -179,6 +202,7 @@
 
     def __init__(self, f):
         self.f = f
+        self._stringtable = []
 
     def load(self):
         c = self.f.read(1)
@@ -232,14 +256,18 @@
 
     def load_true(self):
         return True
-    dispatch[TRUE_CODE] = load_true
+    dispatch[TYPE_TRUE] = load_true
 
     def load_false(self):
         return False
-    dispatch[FALSE_CODE] = load_false
+    dispatch[TYPE_FALSE] = load_false
+
+    def load_stopiter(self):
+        return StopIteration
+    dispatch[TYPE_STOPITER] = load_stopiter
 
     def load_ellipsis(self):
-        return EllipsisType
+        return Ellipsis
     dispatch[TYPE_ELLIPSIS] = load_ellipsis
 
     def load_int(self):
@@ -284,6 +312,25 @@
         return self.f.read(n)
     dispatch[TYPE_STRING] = load_string
 
+    def load_interned(self):
+        n = self.r_long()
+        ret = intern(self.f.read(n))
+        self._stringtable.append(ret)
+        return ret
+    dispatch[TYPE_INTERNED] = load_interned
+
+    def load_stringref(self):
+        n = self.r_long()
+        return self._stringtable[n]
+    dispatch[TYPE_STRINGREF] = load_stringref
+
+    def load_unicode(self):
+        n = self.r_long()
+        s = self.f.read(n)
+        ret = s.decode('utf8')
+        return ret
+    dispatch[TYPE_UNICODE] = load_unicode
+
     def load_tuple(self):
         return tuple(self.load_list())
     dispatch[TYPE_TUPLE] = load_tuple
@@ -308,22 +355,25 @@
     dispatch[TYPE_DICT] = load_dict
 
     def load_code(self):
-        argcount = self.r_short()
-        nlocals = self.r_short()
-        stacksize = self.r_short()
-        flags = self.r_short()
+        argcount = self.r_long()
+        nlocals = self.r_long()
+        stacksize = self.r_long()
+        flags = self.r_long()
         code = self.load()
         consts = self.load()
         names = self.load()
         varnames = self.load()
+        freevars = self.load()
+        cellvars = self.load()
         filename = self.load()
         name = self.load()
-        firstlineno = self.r_short()
+        firstlineno = self.r_long()
         lnotab = self.load()
         if not new:
             raise RuntimeError, "can't unmarshal code objects; no 'new' module"
         return new.code(argcount, nlocals, stacksize, flags, code, consts,
-                        names, varnames, filename, name, firstlineno, lnotab)
+                        names, varnames, filename, name, firstlineno, lnotab,
+                        freevars, cellvars)
     dispatch[TYPE_CODE] = load_code