svgui/pyjs/lib/_pyjs.js
author Andrey Skvortsov <andrej.skvortzov@gmail.com>
Mon, 18 Apr 2016 18:56:51 +0300
changeset 1478 69fe0b81e951
parent 728 e0424e96e3fd
permissions -rw-r--r--
make attribute CFLAGS and LDFLAGS optional and add default empty value

Actually CFLAGS and LDFLAGS are not required and can be empty.
Without default empty value if target platform in project settings was
set to "Linux" CFLAGS and LDFLAGS was initialized with NoneType.
The result was broken build and it wasn't to save/load project with
such settings.

Traceback (most recent call last):
File "/home/developer/WorkData/PLC/beremiz/beremiz/ProjectController.py", line 956, in _Build
if not builder.build() :
File "/home/developer/WorkData/PLC/beremiz/beremiz/targets/toolchain_gcc.py", line 96, in build
Builder_CFLAGS = ' '.join(self.getBuilderCFLAGS())
TypeError: sequence item 0: expected string, NoneType found
function pyjs_extend(klass, base) {
    function klass_object_inherit() {}
    klass_object_inherit.prototype = base.prototype;
    klass_object = new klass_object_inherit();
    for (var i in base.prototype.__class__) {
        v = base.prototype.__class__[i];
        if (typeof v == "function" && (v.class_method || v.static_method || v.unbound_method))
        {
            klass_object[i] = v;
        }
    }

    function klass_inherit() {}
    klass_inherit.prototype = klass_object;
    klass.prototype = new klass_inherit();
    klass_object.constructor = klass;
    klass.prototype.__class__ = klass_object;

    for (var i in base.prototype) {
        v = base.prototype[i];
        if (typeof v == "function" && v.instance_method)
        {
            klass.prototype[i] = v;
        }
    }
}

/* creates a class, derived from bases, with methods and variables */
function pyjs_type(clsname, bases, methods)
{
    var fn_cls = function() {};
    fn_cls.__name__ = clsname;
    var fn = function() {
        var instance = new fn_cls();
        if(instance.__init__) instance.__init__.apply(instance, arguments);
        return instance;
    }
    fn_cls.__initialize__ = function() {
        if (fn_cls.__was_initialized__) return;
        fn_cls.__was_initialized__ = true;
        fn_cls.__extend_baseclasses();
        fn_cls.prototype.__class__.__new__ = fn;
        fn_cls.prototype.__class__.__name__ = clsname;
    }
    fn_cls.__extend_baseclasses = function() {
        var bi;
        for (bi in fn_cls.__baseclasses)
        {
            var b = fn_cls.__baseclasses[bi];
            if (b.__was_initialized__)
            {
                continue;
            }
            b.__initialize__();
        }
        for (bi in fn_cls.__baseclasses)
        {
            var b = fn_cls.__baseclasses[bi];
            pyjs_extend(fn_cls, b);
        }
    }
    if (!bases) {
        bases = [pyjslib.__Object];
    }
    fn_cls.__baseclasses = bases;

    fn_cls.__initialize__();

    for (k in methods) {
        var mth = methods[k];
        var mtype = typeof mth;
        if (mtype == "function" ) {
            fn_cls.prototype[k] = mth;
            fn_cls.prototype.__class__[k] = function () {
                return fn_cls.prototype[k].call.apply(
                       fn_cls.prototype[k], arguments);
            };
            fn_cls.prototype.__class__[k].unbound_method = true;
            fn_cls.prototype.instance_method = true;
            fn_cls.prototype.__class__[k].__name__ = k;
            fn_cls.prototype[k].__name__ = k;
        } else {
            fn_cls.prototype.__class__[k] = mth;
        }
    }
    return fn;
}
function pyjs_kwargs_call(obj, func, star_args, args)
{
    var call_args;

    if (star_args)
    {
        if (!pyjslib.isIteratable(star_args))
        {
            throw (pyjslib.TypeError(func.__name__ + "() arguments after * must be a sequence" + pyjslib.repr(star_args)));
        }
        call_args = Array();
        var __i = star_args.__iter__();
        var i = 0;
        try {
            while (true) {
                call_args[i]=__i.next();
                i++;
            }
        } catch (e) {
            if (e != pyjslib.StopIteration) {
                throw e;
            }
        }

        if (args)
        {
            var n = star_args.length;
            for (var i=0; i < args.length; i++) {
                call_args[n+i]=args[i];
            }
        }
    }
    else
    {
        call_args = args;
    }
    return func.apply(obj, call_args);
}

function pyjs_kwargs_function_call(func, star_args, args)
{
    return pyjs_kwargs_call(null, func, star_args, args);
}

function pyjs_kwargs_method_call(obj, method_name, star_args, args)
{
    var method = obj[method_name];
    if (method.parse_kwargs)
    {
        args = method.parse_kwargs.apply(null, args);
    }
    return pyjs_kwargs_call(obj, method, star_args, args);
}

//String.prototype.__getitem__ = String.prototype.charAt;
//String.prototype.upper = String.prototype.toUpperCase;
//String.prototype.lower = String.prototype.toLowerCase;
//String.prototype.find=pyjslib.String_find;
//String.prototype.join=pyjslib.String_join;
//String.prototype.isdigit=pyjslib.String_isdigit;
//String.prototype.__iter__=pyjslib.String___iter__;
//
//String.prototype.__replace=String.prototype.replace;
//String.prototype.replace=pyjslib.String_replace;
//
//String.prototype.split=pyjslib.String_split;
//String.prototype.strip=pyjslib.String_strip;
//String.prototype.lstrip=pyjslib.String_lstrip;
//String.prototype.rstrip=pyjslib.String_rstrip;
//String.prototype.startswith=pyjslib.String_startswith;

var str = String;