1

function pyjs_extend(klass, base) {

     2

    function klass_object_inherit() {}

     3

    klass_object_inherit.prototype = base.prototype;

     4

    klass_object = new klass_object_inherit();

     5

    for (var i in base.prototype.__class__) {

     6

        v = base.prototype.__class__[i];

     7

        if (typeof v == "function" && (v.class_method || v.static_method || v.unbound_method))

     8

        {

     9

            klass_object[i] = v;

    10

        }

    11

    }

    12

    13

    function klass_inherit() {}

    14

    klass_inherit.prototype = klass_object;

    15

    klass.prototype = new klass_inherit();

    16

    klass_object.constructor = klass;

    17

    klass.prototype.__class__ = klass_object;

    18

    19

    for (var i in base.prototype) {

    20

        v = base.prototype[i];

    21

        if (typeof v == "function" && v.instance_method)

    22

        {

    23

            klass.prototype[i] = v;

    24

        }

    25

    }

    26

}

    27

    28

/* creates a class, derived from bases, with methods and variables */

    29

function pyjs_type(clsname, bases, methods)

    30

{

    31

    var fn_cls = function() {};

    32

    fn_cls.__name__ = clsname;

    33

    var fn = function() {

    34

        var instance = new fn_cls();

    35

        if(instance.__init__) instance.__init__.apply(instance, arguments);

    36

        return instance;

    37

    }

    38

    fn_cls.__initialize__ = function() {

    39

        if (fn_cls.__was_initialized__) return;

    40

        fn_cls.__was_initialized__ = true;

    41

        fn_cls.__extend_baseclasses();

    42

        fn_cls.prototype.__class__.__new__ = fn;

    43

        fn_cls.prototype.__class__.__name__ = clsname;

    44

    }

    45

    fn_cls.__extend_baseclasses = function() {

    46

        var bi;

    47

        for (bi in fn_cls.__baseclasses)

    48

        {

    49

            var b = fn_cls.__baseclasses[bi];

    50

            if (b.__was_initialized__)

    51

            {

    52

                continue;

    53

            }

    54

            b.__initialize__();

    55

        }

    56

        for (bi in fn_cls.__baseclasses)

    57

        {

    58

            var b = fn_cls.__baseclasses[bi];

    59

            pyjs_extend(fn_cls, b);

    60

        }

    61

    }

    62

    if (!bases) {

    63

        bases = [pyjslib.__Object];

    64

    }

    65

    fn_cls.__baseclasses = bases;

    66

    67

    fn_cls.__initialize__();

    68

    69

    for (k in methods) {

    70

        var mth = methods[k];

    71

        var mtype = typeof mth;

    72

        if (mtype == "function" ) {

    73

            fn_cls.prototype[k] = mth;

    74

            fn_cls.prototype.__class__[k] = function () {

    75

                return fn_cls.prototype[k].call.apply(

    76

                       fn_cls.prototype[k], arguments);

    77

            };

    78

            fn_cls.prototype.__class__[k].unbound_method = true;

    79

            fn_cls.prototype.instance_method = true;

    80

            fn_cls.prototype.__class__[k].__name__ = k;

    81

            fn_cls.prototype[k].__name__ = k;

    82

        } else {

    83

            fn_cls.prototype.__class__[k] = mth;

    84

        }

    85

    }

    86

    return fn;

    87

}

    88

function pyjs_kwargs_call(obj, func, star_args, args)

    89

{

    90

    var call_args;

    91

    92

    if (star_args)

    93

    {

    94

        if (!pyjslib.isIteratable(star_args))

    95

        {

    96

            throw (pyjslib.TypeError(func.__name__ + "() arguments after * must be a sequence" + pyjslib.repr(star_args)));

    97

        }

    98

        call_args = Array();

    99

        var __i = star_args.__iter__();

   100

        var i = 0;

   101

        try {

   102

            while (true) {

   103

                call_args[i]=__i.next();

   104

                i++;

   105

            }

   106

        } catch (e) {

   107

            if (e != pyjslib.StopIteration) {

   108

                throw e;

   109

            }

   110

        }

   111

   112

        if (args)

   113

        {

   114

            var n = star_args.length;

   115

            for (var i=0; i < args.length; i++) {

   116

                call_args[n+i]=args[i];

   117

            }

   118

        }

   119

    }

   120

    else

   121

    {

   122

        call_args = args;

   123

    }

   124

    return func.apply(obj, call_args);

   125

}

   126

   127

function pyjs_kwargs_function_call(func, star_args, args)

   128

{

   129

    return pyjs_kwargs_call(null, func, star_args, args);

   130

}

   131

   132

function pyjs_kwargs_method_call(obj, method_name, star_args, args)

   133

{

   134

    var method = obj[method_name];

   135

    if (method.parse_kwargs)

   136

    {

   137

        args = method.parse_kwargs.apply(null, args);

   138

    }

   139

    return pyjs_kwargs_call(obj, method, star_args, args);

   140

}

   141

   142

//String.prototype.__getitem__ = String.prototype.charAt;

   143

//String.prototype.upper = String.prototype.toUpperCase;

   144

//String.prototype.lower = String.prototype.toLowerCase;

   145

//String.prototype.find=pyjslib.String_find;

   146

//String.prototype.join=pyjslib.String_join;

   147

//String.prototype.isdigit=pyjslib.String_isdigit;

   148

//String.prototype.__iter__=pyjslib.String___iter__;

   149

//

   150

//String.prototype.__replace=String.prototype.replace;

   151

//String.prototype.replace=pyjslib.String_replace;

   152

//

   153

//String.prototype.split=pyjslib.String_split;

   154

//String.prototype.strip=pyjslib.String_strip;

   155

//String.prototype.lstrip=pyjslib.String_lstrip;

   156

//String.prototype.rstrip=pyjslib.String_rstrip;

   157

//String.prototype.startswith=pyjslib.String_startswith;

   158

   159

var str = String;

   160