Epy build

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009-2010 Scott Graham
+Copyright (c) 2009-2016 Scott Graham and contributors to the Skulpt Project
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -25,7 +25,7 @@ Portions of the code were written with the benefit of viewing code that's in
 the official "CPython" and "pypy" distribution and/or translated from code that's in the
 official "CPython" and "pypy" distribution. As such, they are:
 
-    Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006 Python Software
+    Copyright (c) 2001 -- 2016 Python Software
     Foundation; All Rights Reserved"
 
 per:

skulpt.py

@@ -69,6 +69,7 @@ def bowerProperty(name):
         ('support/closure-library/closure/goog/debug/error.js',     FILE_TYPE_DIST),
         ('support/closure-library/closure/goog/asserts/asserts.js', FILE_TYPE_DIST),
         ('support/es6-promise-polyfill/promise-1.0.0.hacked.js',    FILE_TYPE_DIST),
+        'support/setImmediate/setImmediate.js',
         'src/env.js',
         'src/type.js',
         'src/abstract.js',
@@ -729,11 +730,19 @@ def dist(options):
     builtinfn = os.path.join(DIST_DIR, OUTFILE_LIB)
     debuggerfn = os.path.join(DIST_DIR, OUTFILE_DEBUGGER)
 
+    ret = test()
+
     # Run tests on uncompressed.
     if options.verbose:
-        print ". Running tests on uncompressed..."
+        print ". Re-Running tests on uncompressed... with debug mode on to find suspension errors."
 
-    ret = test()
+    # turn the tests in debug mode off because they take too long
+    # # Run tests on uncompressed.
+    # if options.verbose:
+    #     print ". Re-Running tests on uncompressed... with debug mode on to find suspension errors."
+    #
+    #
+    # ret = test(debug_mode=True)
 
     # turn the tests in debug mode off because they take too long
     # # Run tests on uncompressed.
@@ -881,7 +890,7 @@ def run_in_browser(fn, options, debug_mode=False):
 
     with open('support/run_template.html') as tpfile:
         page = tpfile.read()
-        page = page % dict(code=prog,scripts=scripts,debug_mode=str(debug_mode).lower())
+        page = page % dict(code=prog,scripts=scripts,debug_mode=str(debug_mode).lower(),root="")
 
     with open("{0}/run.html".format(RUN_DIR),"w") as htmlfile:
         htmlfile.write(page)

src/builtin.js

@@ -245,7 +245,7 @@ Sk.builtin.len = function len (item) {
     var int_ = function(i) { return new Sk.builtin.int_(i); };
 
     if (item.sq$length) {
-        return Sk.misceval.chain(item.sq$length(), int_);
+        return Sk.misceval.chain(item.sq$length(true), int_);
     }
 
     if (item.mp$length) {
@@ -559,7 +559,8 @@ Sk.builtin.dir = function dir (x) {
         var internal = [
             "__bases__", "__mro__", "__class__", "__name__", "GenericGetAttr",
             "GenericSetAttr", "GenericPythonGetAttr", "GenericPythonSetAttr",
-            "pythonFunctions", "HashNotImplemented", "constructor"];
+            "pythonFunctions", "HashNotImplemented", "constructor", "__dict__"
+        ];
         if (internal.indexOf(k) !== -1) {
             return null;
         }
@@ -670,10 +671,13 @@ Sk.builtin.repr = function repr (x) {
 Sk.builtin.open = function open (filename, mode, bufsize) {
     Sk.builtin.pyCheckArgs("open", arguments, 1, 3);
     if (mode === undefined) {
-        mode = new Sk.builtin.str("r");
+        mode = new Sk.builtin.str("r"); 
     }
-
     return new Sk.builtin.file(filename, mode, bufsize);
+
+    /*if (mode.v !== "r" && mode.v !== "b" && !Sk.nonreadopen) {
+        throw new Sk.builtin.ValueError("Hinweis: Bitte verwenden Sie PyCharm für dieses Beispiel. Das Schreiben von Dateien wird derzeit nicht online unterstützt.");
+    }*/
 };
 
 Sk.builtin.isinstance = function isinstance (obj, type) {
@@ -754,11 +758,11 @@ Sk.builtin.hash = function hash (value) {
             value.$savedHash_ = value.tp$hash();
             return value.$savedHash_;
         } else {
-            if (value.__id === undefined) {
+            if (value.__hash === undefined) {
                 Sk.builtin.hashCount += 1;
-                value.__id = Sk.builtin.hashCount;
+                value.__hash = Sk.builtin.hashCount;
             }
-            return new Sk.builtin.int_(value.__id);
+            return new Sk.builtin.int_(value.__hash);
         }
     } else if (typeof value === "number" || value === null ||
         value === true || value === false) {
@@ -788,24 +792,31 @@ Sk.builtin.getattr = function getattr (obj, name, default_) {
 };
 
 Sk.builtin.setattr = function setattr (obj, name, value) {
-
     Sk.builtin.pyCheckArgs("setattr", arguments, 3, 3);
-    if (!Sk.builtin.checkString(name)) {
-        throw new Sk.builtin.TypeError("attribute name must be string");
-    }
-    if (obj.tp$setattr) {
-        obj.tp$setattr(Sk.ffi.remapToJs(name), value);
-    } else {
-        throw new Sk.builtin.AttributeError("object has no attribute " + Sk.ffi.remapToJs(name));
+    // cannot set or del attr from builtin type
+    if (obj === undefined || obj["$r"] === undefined || obj["$r"]().v.slice(1,5) !== "type") {
+        if (!Sk.builtin.checkString(name)) {
+            throw new Sk.builtin.TypeError("attribute name must be string");
+        }
+        if (obj.tp$setattr) {
+            obj.tp$setattr(Sk.ffi.remapToJs(name), value);
+        } else {
+            throw new Sk.builtin.AttributeError("object has no attribute " + Sk.ffi.remapToJs(name));
+        }
+        return Sk.builtin.none.none$;
     }
 
-    return Sk.builtin.none.none$;
+    throw new Sk.builtin.TypeError("can't set attributes of built-in/extension type '" + obj.tp$name + "'");
 };
 
 Sk.builtin.raw_input = function (prompt) {
     var sys = Sk.importModule("sys");
     var lprompt = prompt ? prompt : "";
 
+    if (Sk.inputfunTakesPrompt) {
+        return Sk.misceval.callsimOrSuspend(Sk.builtin.file.$readline, sys["$d"]["stdin"], null, lprompt);
+    }
+
     return Sk.misceval.chain(undefined, function () {
         return Sk.misceval.callsimOrSuspend(sys["$d"]["stdout"]["write"], sys["$d"]["stdout"], new Sk.builtin.str(prompt));
     }, function () {
@@ -994,6 +1005,7 @@ Sk.builtin.filter = function filter (fun, iterable) {
 
 Sk.builtin.hasattr = function hasattr (obj, attr) {
     Sk.builtin.pyCheckArgs("hasattr", arguments, 2, 2);
+    var special, ret;
     if (!Sk.builtin.checkString(attr)) {
         throw new Sk.builtin.TypeError("hasattr(): attribute name must be string");
     }
@@ -1002,14 +1014,32 @@ Sk.builtin.hasattr = function hasattr (obj, attr) {
         if (obj.tp$getattr(attr.v)) {
             return Sk.builtin.bool.true$;
         } else {
-            return Sk.builtin.bool.false$;
+            special = Sk.abstr.lookupSpecial(obj, "__getattr__");
+            if (special) {
+                ret = Sk.misceval.tryCatch(function () {
+                    var val = Sk.misceval.callsim(special, obj, attr);
+                    if (val) {
+                        return Sk.builtin.bool.true$;
+                    } else {
+                        return Sk.builtin.bool.false$;
+                    }
+                }, function(e) {
+                    if (e instanceof Sk.builtin.AttributeError) {
+                        return Sk.builtin.bool.false$;
+                    } else {
+                        throw e;
+                    }
+                });
+                return ret;
+            } else {
+                return Sk.builtin.bool.false$;
+            }
         }
     } else {
         throw new Sk.builtin.AttributeError("Object has no tp$getattr method");
     }
 };
 
-
 Sk.builtin.pow = function pow (a, b, c) {
     var ret;
     var res;
@@ -1207,6 +1237,17 @@ Sk.builtin.reversed = function reversed (seq) {
     }
 };
 
+Sk.builtin.id = function (obj) {
+    Sk.builtin.pyCheckArgs("id", arguments, 1, 1);
+
+    if (obj.__id === undefined) {
+        Sk.builtin.idCount += 1;
+        obj.__id = Sk.builtin.idCount;
+    }
+
+    return new Sk.builtin.int_(obj.__id);
+};
+
 Sk.builtin.bytearray = function bytearray () {
     throw new Sk.builtin.NotImplementedError("bytearray is not yet implemented");
 };
@@ -1221,9 +1262,37 @@ Sk.builtin.callable = function callable (obj) {
     return Sk.builtin.bool.false$;
 };
 
-Sk.builtin.delattr = function delattr () {
-    throw new Sk.builtin.NotImplementedError("delattr is not yet implemented");
+Sk.builtin.delattr = function delattr (obj, attr) {
+    Sk.builtin.pyCheckArgs("delattr", arguments, 2, 2);
+    if (obj["$d"][attr.v] !== undefined) {
+        var ret = Sk.misceval.tryCatch(function() {
+            var try1 = Sk.builtin.setattr(obj, attr, undefined);
+            return try1;
+        }, function(e) {
+            Sk.misceval.tryCatch(function() {
+                var try2 = Sk.builtin.setattr(obj["$d"], attr, undefined);
+
+                return try2;
+            }, function(e) {
+                if (e instanceof Sk.builtin.AttributeError) {
+                    throw new Sk.builtin.AttributeError(Sk.abstr.typeName(obj) + " instance has no attribute '"+ attr.v+ "'");
+                } else {
+                    throw e;
+                }
+            });
+        });
+        return ret;
+    } // cannot set or del attr from builtin type
+    if (obj["$r"]().v.slice(1,5) !== "type") {
+        if (obj.ob$type === Sk.builtin.type && obj[attr.v] !== undefined) {
+            obj[attr.v] = undefined;
+            return Sk.builtin.none.none$;
+        }
+        throw new Sk.builtin.AttributeError(Sk.abstr.typeName(obj) + " instance has no attribute '"+ attr.v+ "'");
+    }
+    throw new Sk.builtin.TypeError("can't set attributes of built-in/extension type '" + obj.tp$name + "'");
 };
+
 Sk.builtin.execfile = function execfile () {
     throw new Sk.builtin.NotImplementedError("execfile is not yet implemented");
 };
@@ -1255,7 +1324,19 @@ Sk.builtin.iter = function iter (obj, sentinel) {
 };
 
 Sk.builtin.locals = function locals () {
-    throw new Sk.builtin.NotImplementedError("locals is not yet implemented");
+    /*global Sk.locals */
+    if (Sk["locals"] != null) {
+        var localsDict = [];
+        for (var prop in Sk["locals"]) {
+            if (Sk["locals"].hasOwnProperty(prop)) {
+                localsDict.push(new Sk.builtin.str(prop));
+                localsDict.push(Sk["locals"][prop]);
+            } 
+        }
+        return new Sk.builtin.dict(localsDict);
+    } else {
+        throw new Sk.builtin.NotImplementedError("locals is not yet implemented");
+    }
 };
 Sk.builtin.memoryview = function memoryview () {
     throw new Sk.builtin.NotImplementedError("memoryview is not yet implemented");
@@ -1298,7 +1379,6 @@ Sk.builtin.intern = function intern () {
     throw new Sk.builtin.NotImplementedError("intern is not yet implemented");
 };
 
-
 /*
  Sk.builtinFiles = {};
  Sk.builtin.read = function read(x) {

src/builtin/sys.js

@@ -64,6 +64,25 @@ var $builtinmodule = function (name) {
         return Sk.builtin.none.none$;
     });
 
+    sys.exit = new Sk.builtin.func(function(arg) {
+        Sk.builtin.pyCheckArgs("exit", arguments, 0, 1);
+        var exit_status;
+        if (arg == null || Sk.builtin.checkNone(arg)) {
+            exit_status = 0
+        } else if (Sk.builtin.checkInt(arg)){
+            exit_status = Sk.ffi.remapToJs(arg);
+        } else {
+            exit_status = 1;
+        }
+
+        if (Sk.builtin.checkString(arg)) {
+            // print arg to console
+            Sk.output(Sk.ffi.remapToJs(arg))
+        }
+
+        throw new Sk.builtin.SystemExit(exit_status);
+    });
+
     sys.__stdout__ = new Sk.builtin.file(new Sk.builtin.str("/dev/stdout"), "w");
     sys.__stdin__ = new Sk.builtin.file(new Sk.builtin.str("/dev/stdin"), "r");
 

src/builtindict.js

@@ -25,6 +25,7 @@ Sk.builtins = {
     "float_$rw$": Sk.builtin.float_,
     "int_$rw$"  : Sk.builtin.int_,
     "hasattr"   : Sk.builtin.hasattr,
+    "id"        : Sk.builtin.id,
 
     "map"   : Sk.builtin.map,
     "filter": Sk.builtin.filter,

src/classmethod.py

@@ -0,0 +1,12 @@
+class classmethod(object):
+    "Emulate PyClassMethod_Type() in Objects/funcobject.c"
+
+    def __init__(self, f):
+        self.f = f
+
+    def __get__(self, obj, klass=None):
+        if klass is None:
+            klass = type(obj)
+        def newfunc(*args):
+            return self.f(klass, *args)
+        return newfunc