Source: object.js

  1. /**
  2.  * @constructor
  3.  * Sk.builtin.object
  4.  *
  5.  * @description
  6.  * Constructor for Python object. All Python classes (builtin and user-defined)
  7.  * should inherit from this class.
  8.  *
  9.  * @return {Sk.builtin.object} Python object
  10.  */
  11. Sk.builtin.object = function () {
  12.     if (!(this instanceof Sk.builtin.object)) {
  13.         return new Sk.builtin.object();
  14.     }
  16.     return this;
  17. };
  19. Sk.builtin.object.prototype.__init__ = function __init__() {
  20.     return Sk.builtin.none.none$;
  21. };
  22. Sk.builtin.object.prototype.__init__.co_kwargs = 1;
  24. Sk.builtin._tryGetSubscript = function(dict, pyName) {
  25.     try {
  26.         return dict.mp$subscript(pyName);
  27.     } catch (x) {
  28.         return undefined;
  29.     }
  30. };
  31. Sk.exportSymbol("Sk.builtin._tryGetSubscript", Sk.builtin._tryGetSubscript);
  34. /**
  35.  * Get an attribute
  36.  * @param {Object} pyName Python string name of the attribute
  37.  * @param {boolean=} canSuspend Can we return a suspension?
  38.  * @return {undefined}
  39.  */
  40. Sk.builtin.object.prototype.GenericGetAttr = function (pyName, canSuspend) {
  41.     var res;
  42.     var f;
  43.     var descr;
  44.     var tp;
  45.     var dict;
  46.     var getf;
  47.     var jsName = pyName.$jsstr();
  49.     tp = this.ob$type;
  50.     Sk.asserts.assert(tp !== undefined, "object has no ob$type!");
  52.     dict = this["$d"] || this.constructor["$d"];
  53.     //print("getattr", tp.tp$name, name);
  55.     // todo; assert? force?
  56.     if (dict) {
  57.         if (dict.mp$lookup) {
  58.             res = dict.mp$lookup(pyName);
  59.         } else if (dict.mp$subscript) {
  60.             res = Sk.builtin._tryGetSubscript(dict, pyName);
  61.         } else if (typeof dict === "object") {
  62.             res = dict[jsName];
  63.         }
  64.         if (res !== undefined) {
  65.             return res;
  66.         }
  67.     }
  69.     descr = Sk.builtin.type.typeLookup(tp, pyName);
  71.     // otherwise, look in the type for a descr
  72.     if (descr !== undefined && descr !== null) {
  73.         f = descr.tp$descr_get;
  74.         // todo - data descriptors (ie those with tp$descr_set too) get a different lookup priority
  76.         if (f) {
  77.             // non-data descriptor
  78.             return f.call(descr, this, this.ob$type, canSuspend);
  79.         }
  80.     }
  82.     if (descr !== undefined) {
  83.         return descr;
  84.     }
  86.     // OK, try __getattr__
  88.     descr = Sk.builtin.type.typeLookup(tp, Sk.builtin.str.$getattr);
  89.     if (descr !== undefined && descr !== null) {
  90.         f = descr.tp$descr_get;
  91.         if (f) {
  92.             getf = f.call(descr, this, this.ob$type);
  93.         } else {
  94.             getf = descr;
  95.         }
  97.         res = Sk.misceval.tryCatch(function() {
  98.             return Sk.misceval.callsimOrSuspendArray(getf, [pyName]);
  99.         }, function(e) {
  100.             if (e instanceof Sk.builtin.AttributeError) {
  101.                 return undefined;
  102.             } else {
  103.                 throw e;
  104.             }
  105.         });
  106.         return canSuspend ? res : Sk.misceval.retryOptionalSuspensionOrThrow(res);
  107.     }
  110.     return undefined;
  111. };
  112. Sk.exportSymbol("Sk.builtin.object.prototype.GenericGetAttr", Sk.builtin.object.prototype.GenericGetAttr);
  114. Sk.builtin.object.prototype.GenericPythonGetAttr = function(self, pyName) {
  115.     var r = Sk.builtin.object.prototype.GenericGetAttr.call(self, pyName, true);
  116.     if (r === undefined) {
  117.         throw new Sk.builtin.AttributeError(pyName);
  118.     }
  119.     return r;
  120. };
  121. Sk.exportSymbol("Sk.builtin.object.prototype.GenericPythonGetAttr", Sk.builtin.object.prototype.GenericPythonGetAttr);
  123. /**
  124.  * @param {Object} pyName
  125.  * @param {Object} value
  126.  * @param {boolean=} canSuspend
  127.  * @return {undefined}
  128.  */
  129. Sk.builtin.object.prototype.GenericSetAttr = function (pyName, value, canSuspend) {
  130.     var objname = Sk.abstr.typeName(this);
  131.     var jsName = pyName.$jsstr();
  132.     var dict;
  133.     var tp = this.ob$type;
  134.     var descr;
  135.     var f;
  137.     Sk.asserts.assert(tp !== undefined, "object has no ob$type!");
  139.     dict = this["$d"] || this.constructor["$d"];
  141.     if (jsName == "__class__") {
  142.         if (value.tp$mro === undefined || value.tp$name === undefined) {
  143.             throw new Sk.builtin.TypeError(
  144.                 "attempted to assign non-class to __class__");
  145.         }
  146.         this.ob$type = value;
  147.         this.tp$name = value.tp$name;
  148.         return;
  149.     }
  151.     descr = Sk.builtin.type.typeLookup(tp, pyName);
  153.     // otherwise, look in the type for a descr
  154.     if (descr !== undefined && descr !== null) {
  155.         f = descr.tp$descr_set;
  156.         // todo; is this the right lookup priority for data descriptors?
  157.         if (f) {
  158.             return f.call(descr, this, value, canSuspend);
  159.         }
  160.     }
  162.     if (dict.mp$ass_subscript) {
  163.         if (this instanceof Sk.builtin.object && !(this.ob$type.sk$klass) &&
  164.             dict.mp$lookup(pyName) === undefined) {
  165.             // Cannot add new attributes to a builtin object
  166.             throw new Sk.builtin.AttributeError("'" + objname + "' object has no attribute '" + Sk.unfixReserved(jsName) + "'");
  167.         }
  168.         dict.mp$ass_subscript(pyName, value);
  169.     } else if (typeof dict === "object") {
  170.         dict[jsName] = value;
  171.     }
  172. };
  173. Sk.exportSymbol("Sk.builtin.object.prototype.GenericSetAttr", Sk.builtin.object.prototype.GenericSetAttr);
  175. Sk.builtin.object.prototype.GenericPythonSetAttr = function(self, pyName, value) {
  176.     return Sk.builtin.object.prototype.GenericSetAttr.call(self, pyName, value, true);
  177. };
  178. Sk.exportSymbol("Sk.builtin.object.prototype.GenericPythonSetAttr", Sk.builtin.object.prototype.GenericPythonSetAttr);
  180. Sk.builtin.object.prototype.HashNotImplemented = function () {
  181.     throw new Sk.builtin.TypeError("unhashable type: '" + Sk.abstr.typeName(this) + "'");
  182. };
  184. Sk.builtin.object.prototype.tp$getattr = Sk.builtin.object.prototype.GenericGetAttr;
  185. Sk.builtin.object.prototype.tp$setattr = Sk.builtin.object.prototype.GenericSetAttr;
  187. // Although actual attribute-getting happens in pure Javascript via tp$getattr, classes
  188. // overriding __getattribute__ etc need to be able to call object.__getattribute__ etc from Python
  189. Sk.builtin.object.prototype["__getattribute__"] = Sk.builtin.object.prototype.GenericPythonGetAttr;
  190. Sk.builtin.object.prototype["__setattr__"] = Sk.builtin.object.prototype.GenericPythonSetAttr;
  192. /**
  193.  * The name of this class.
  194.  * @type {string}
  195.  */
  196. Sk.builtin.object.prototype.tp$name = "object";
  198. /**
  199.  * The type object of this class.
  200.  * @type {Sk.builtin.type|Object}
  201.  */
  202. Sk.builtin.object.prototype.ob$type = Sk.builtin.type.makeIntoTypeObj("object", Sk.builtin.object);
  203. Sk.builtin.object.prototype.ob$type.sk$klass = undefined;   // Nonsense for closure compiler
  204. Sk.builtin.object.prototype.tp$descr_set = undefined;   // Nonsense for closure compiler
  206. /** Default implementations of dunder methods found in all Python objects */
  207. /**
  208.  * Default implementation of __new__ just calls the class constructor
  209.  * @name  __new__
  210.  * @memberOf Sk.builtin.object.prototype
  211.  * @instance
  212.  */
  213. Sk.builtin.object.prototype["__new__"] = function (cls) {
  214.     Sk.builtin.pyCheckArgsLen("__new__", arguments.length, 1, 1, false, false);
  216.     return new cls([], []);
  217. };
  219. /**
  220.  * Python wrapper for `__repr__` method.
  221.  * @name  __repr__
  222.  * @memberOf Sk.builtin.object.prototype
  223.  * @instance
  224.  */
  225. Sk.builtin.object.prototype["__repr__"] = function (self) {
  226.     Sk.builtin.pyCheckArgsLen("__repr__", arguments.length, 0, 0, false, true);
  228.     return self["$r"]();
  229. };
  232. Sk.builtin.object.prototype["__format__"] = function (self, format_spec) {
  233.     var formatstr;
  234.     Sk.builtin.pyCheckArgsLen("__format__", arguments.length, 2, 2);
  236.     if (!Sk.builtin.checkString(format_spec)) {
  237.         if (Sk.__future__.exceptions) {
  238.             throw new Sk.builtin.TypeError("format() argument 2 must be str, not " + Sk.abstr.typeName(format_spec));
  239.         } else {
  240.             throw new Sk.builtin.TypeError("format expects arg 2 to be string or unicode, not " + Sk.abstr.typeName(format_spec));
  241.         }
  242.     } else {
  243.         formatstr = Sk.ffi.remapToJs(format_spec);
  244.         if (formatstr !== "") {
  245.             throw new Sk.builtin.NotImplementedError("format spec is not yet implemented");
  246.         }
  247.     }
  249.     return new Sk.builtin.str(self);
  250. };
  253. /**
  254.  * Python wrapper for `__str__` method.
  255.  * @name  __str__
  256.  * @memberOf Sk.builtin.object.prototype
  257.  * @instance
  258.  */
  259. Sk.builtin.object.prototype["__str__"] = function (self) {
  260.     Sk.builtin.pyCheckArgsLen("__str__", arguments.length, 0, 0, false, true);
  262.     return self["$r"]();
  263. };
  265. /**
  266.  * Python wrapper for `__hash__` method.
  267.  * @name  __hash__
  268.  * @memberOf Sk.builtin.object.prototype
  269.  * @instance
  270.  */
  271. Sk.builtin.object.prototype["__hash__"] = function (self) {
  272.     Sk.builtin.pyCheckArgsLen("__hash__", arguments.length, 0, 0, false, true);
  274.     return self.tp$hash();
  275. };
  277. /**
  278.  * Python wrapper for `__eq__` method.
  279.  * @name  __eq__
  280.  * @memberOf Sk.builtin.object.prototype
  281.  * @instance
  282.  */
  283. Sk.builtin.object.prototype["__eq__"] = function (self, other) {
  284.     Sk.builtin.pyCheckArgsLen("__eq__", arguments.length, 1, 1, false, true);
  286.     return self.ob$eq(other);
  287. };
  289. /**
  290.  * Python wrapper for `__ne__` method.
  291.  * @name  __ne__
  292.  * @memberOf Sk.builtin.object.prototype
  293.  * @instance
  294.  */
  295. Sk.builtin.object.prototype["__ne__"] = function (self, other) {
  296.     Sk.builtin.pyCheckArgsLen("__ne__", arguments.length, 1, 1, false, true);
  298.     return self.ob$ne(other);
  299. };
  301. /**
  302.  * Python wrapper for `__lt__` method.
  303.  * @name  __lt__
  304.  * @memberOf Sk.builtin.object.prototype
  305.  * @instance
  306.  */
  307. Sk.builtin.object.prototype["__lt__"] = function (self, other) {
  308.     Sk.builtin.pyCheckArgsLen("__lt__", arguments.length, 1, 1, false, true);
  310.     return self.ob$lt(other);
  311. };
  313. /**
  314.  * Python wrapper for `__le__` method.
  315.  * @name  __le__
  316.  * @memberOf Sk.builtin.object.prototype
  317.  * @instance
  318.  */
  319. Sk.builtin.object.prototype["__le__"] = function (self, other) {
  320.     Sk.builtin.pyCheckArgsLen("__le__", arguments.length, 1, 1, false, true);
  322.     return self.ob$le(other);
  323. };
  325. /**
  326.  * Python wrapper for `__gt__` method.
  327.  * @name  __gt__
  328.  * @memberOf Sk.builtin.object.prototype
  329.  * @instance
  330.  */
  331. Sk.builtin.object.prototype["__gt__"] = function (self, other) {
  332.     Sk.builtin.pyCheckArgsLen("__gt__", arguments.length, 1, 1, false, true);
  334.     return self.ob$gt(other);
  335. };
  337. /**
  338.  * Python wrapper for `__ge__` method.
  339.  * @name  __ge__
  340.  * @memberOf Sk.builtin.object.prototype
  341.  * @instance
  342.  */
  343. Sk.builtin.object.prototype["__ge__"] = function (self, other) {
  344.     Sk.builtin.pyCheckArgsLen("__ge__", arguments.length, 1, 1, false, true);
  346.     return self.ob$ge(other);
  347. };
  349. /** Default implementations of Javascript functions used in dunder methods */
  351. /**
  352.  * Return the string representation of this instance.
  353.  *
  354.  * Javascript function, returns Python object.
  355.  *
  356.  * @name  $r
  357.  * @memberOf Sk.builtin.object.prototype
  358.  * @return {Sk.builtin.str} The Python string representation of this instance.
  359.  */
  360. Sk.builtin.object.prototype["$r"] = function () {
  361.     return new Sk.builtin.str("<object>");
  362. };
  364. Sk.builtin.hashCount = 1;
  365. Sk.builtin.idCount = 1;
  367. /**
  368.  * Return the hash value of this instance.
  369.  *
  370.  * Javascript function, returns Python object.
  371.  *
  372.  * @return {Sk.builtin.int_} The hash value
  373.  */
  374. Sk.builtin.object.prototype.tp$hash = function () {
  375.     if (!this.$savedHash_) {
  376.         this.$savedHash_ = new Sk.builtin.int_(Sk.builtin.hashCount++);
  377.     }
  379.     return this.$savedHash_;
  380. };
  382. /**
  383.  * Perform equality check between this instance and a Python object (i.e. this == other).
  384.  *
  385.  * Implements `__eq__` dunder method.
  386.  *
  387.  * Javascript function, returns Python object.
  388.  *
  389.  * @param  {Object} other The Python object to check for equality.
  390.  * @return {(Sk.builtin.bool|Sk.builtin.NotImplemented)} true if equal, false otherwise
  391.  */
  392. Sk.builtin.object.prototype.ob$eq = function (other) {
  393.     if (this === other) {
  394.         return Sk.builtin.bool.true$;
  395.     }
  397.     return Sk.builtin.NotImplemented.NotImplemented$;
  398. };
  400. /**
  401.  * Perform non-equality check between this instance and a Python object (i.e. this != other).
  402.  *
  403.  * Implements `__ne__` dunder method.
  404.  *
  405.  * Javascript function, returns Python object.
  406.  *
  407.  * @param  {Object} other The Python object to check for non-equality.
  408.  * @return {(Sk.builtin.bool|Sk.builtin.NotImplemented)} true if not equal, false otherwise
  409.  */
  410. Sk.builtin.object.prototype.ob$ne = function (other) {
  411.     if (this === other) {
  412.         return Sk.builtin.bool.false$;
  413.     }
  415.     return Sk.builtin.NotImplemented.NotImplemented$;
  416. };
  418. /**
  419.  * Determine if this instance is less than a Python object (i.e. this < other).
  420.  *
  421.  * Implements `__lt__` dunder method.
  422.  *
  423.  * Javascript function, returns Python object.
  424.  *
  425.  * @param  {Object} other The Python object to compare.
  426.  * @return {(Sk.builtin.bool|Sk.builtin.NotImplemented)} true if this < other, false otherwise
  427.  */
  428. Sk.builtin.object.prototype.ob$lt = function (other) {
  429.     return Sk.builtin.NotImplemented.NotImplemented$;
  430. };
  432. /**
  433.  * Determine if this instance is less than or equal to a Python object (i.e. this <= other).
  434.  *
  435.  * Implements `__le__` dunder method.
  436.  *
  437.  * Javascript function, returns Python object.
  438.  *
  439.  * @param  {Object} other The Python object to compare.
  440.  * @return {(Sk.builtin.bool|Sk.builtin.NotImplemented)} true if this <= other, false otherwise
  441.  */
  442. Sk.builtin.object.prototype.ob$le = function (other) {
  443.     return Sk.builtin.NotImplemented.NotImplemented$;
  444. };
  446. /**
  447.  * Determine if this instance is greater than a Python object (i.e. this > other).
  448.  *
  449.  * Implements `__gt__` dunder method.
  450.  *
  451.  * Javascript function, returns Python object.
  452.  *
  453.  * @param  {Object} other The Python object to compare.
  454.  * @return {(Sk.builtin.bool|Sk.builtin.NotImplemented)} true if this > other, false otherwise
  455.  */
  456. Sk.builtin.object.prototype.ob$gt = function (other) {
  457.     return Sk.builtin.NotImplemented.NotImplemented$;
  458. };
  460. /**
  461.  * Determine if this instance is greater than or equal to a Python object (i.e. this >= other).
  462.  *
  463.  * Implements `__ge__` dunder method.
  464.  *
  465.  * Javascript function, returns Python object.
  466.  *
  467.  * @param  {Object} other The Python object to compare.
  468.  * @return {(Sk.builtin.bool|Sk.builtin.NotImplemented)} true if this >= other, false otherwise
  469.  */
  470. Sk.builtin.object.prototype.ob$ge = function (other) {
  471.     return Sk.builtin.NotImplemented.NotImplemented$;
  472. };
  474. // Wrap the following functions in Sk.builtin.func once that class is initialized
  475. /**
  476.  * Array of all the Python functions which are methods of this class.
  477.  * @type {Array}
  478.  */
  479. Sk.builtin.object.pythonFunctions = [
  480.     "__repr__", "__str__", "__hash__",
  481.     "__eq__", "__ne__", "__lt__", "__le__",
  482.     "__gt__", "__ge__", "__getattribute__",
  483.     "__setattr__", "__format__"
  484. ];
  486. /**
  487.  * @constructor
  488.  * Sk.builtin.none
  489.  *
  490.  * @extends {Sk.builtin.object}
  491.  */
  492. Sk.builtin.none = function () {
  493.     this.v = null;
  494. };
  495. Sk.abstr.setUpInheritance("NoneType", Sk.builtin.none, Sk.builtin.object);
  497. /** @override */
  498. Sk.builtin.none.prototype["$r"] = function () { return new Sk.builtin.str("None"); };
  500. /** @override */
  501. Sk.builtin.none.prototype.tp$hash = function () {
  502.     return new Sk.builtin.int_(0);
  503. };
  505. /**
  506.  * Python None constant.
  507.  * @type {Sk.builtin.none}
  508.  */
  509. Sk.builtin.none.none$ = new Sk.builtin.none();
  511. /**
  512.  * @constructor
  513.  * Sk.builtin.NotImplemented
  514.  *
  515.  * @extends {Sk.builtin.object}
  516.  */
  517. Sk.builtin.NotImplemented = function() { };
  518. Sk.abstr.setUpInheritance("NotImplementedType", Sk.builtin.NotImplemented, Sk.builtin.object);
  520. /** @override */
  521. Sk.builtin.NotImplemented.prototype["$r"] = function () { return new Sk.builtin.str("NotImplemented"); };
  523. /**
  524.  * Python NotImplemented constant.
  525.  * @type {Sk.builtin.NotImplemented}
  526.  */
  527. Sk.builtin.NotImplemented.NotImplemented$ = new Sk.builtin.NotImplemented();
  529. Sk.exportSymbol("Sk.builtin.none", Sk.builtin.none);
  530. Sk.exportSymbol("Sk.builtin.NotImplemented", Sk.builtin.NotImplemented);