Subversion Repositories Kolibri OS

    int i;

    tp_vm *tp = (tp_vm*)tp_malloc(sizeof(tp_vm));

    tp->cur = 0;

    tp->jmp = 0;

    tp->ex = tp_None;

    tp->root = tp_list(0);

    for (i=0; i<256; i++) { tp->chars[i][0]=i; }

    tp_gc_init(tp);

    tp->_regs = tp_list(tp);

    for (i=0; i_regs,tp_None,tp_None); }

    tp->builtins = tp_dict(tp);

    tp->modules = tp_dict(tp);

    tp->_params = tp_list(tp);

    for (i=0; i_params,tp_None,tp_list(tp)); }

    tp_set(tp,tp->root,tp_None,tp->builtins);

    tp_set(tp,tp->root,tp_None,tp->modules);

    tp_set(tp,tp->root,tp_None,tp->_regs);

    tp_set(tp,tp->root,tp_None,tp->_params);

    tp_set(tp,tp->builtins,tp_string("MODULES"),tp->modules);

    tp_set(tp,tp->modules,tp_string("BUILTINS"),tp->builtins);

    tp_set(tp,tp->builtins,tp_string("BUILTINS"),tp->builtins);

    tp->regs = tp->_regs.list.val->items;

    tp_full(tp);

    return tp;

}

    while (tp->root.list.val->len) {

        _tp_list_pop(tp,tp->root.list.val,0,"tp_deinit");

    }

    tp_full(tp); tp_full(tp);

    tp_delete(tp,tp->root);

    tp_gc_deinit(tp);

    tp_free(tp);

}

void tp_frame(TP,tp_obj globals,tp_code *codes,tp_obj *ret_dest) {

    tp_frame_ f;

    f.globals = globals;

    f.codes = codes;

    f.cur = f.codes;

    f.jmp = 0;

/*     fprintf(stderr,"tp->cur: %d\n",tp->cur);*/

    f.regs = (tp->cur <= 0?tp->regs:tp->frames[tp->cur].regs+tp->frames[tp->cur].cregs);

    f.ret_dest = ret_dest;

    f.lineno = 0;

    f.line = tp_string("");

    f.name = tp_string("?");

    f.fname = tp_string("?");

    f.cregs = 0;

/*     return f;*/

    if (f.regs+256 >= tp->regs+TP_REGS || tp->cur >= TP_FRAMES-1) { tp_raise(,"tp_frame: stack overflow %d",tp->cur); }

    tp->cur += 1;

    tp->frames[tp->cur] = f;

}

    if (!tp || !tp->jmp) {

        con_printf("\nException:\n%s\n",TP_CSTR(e));

        exit(-1);

        return;

    }

    if (e.type != TP_NONE) { tp->ex = e; }

    tp_grey(tp,e);

    longjmp(tp->buf,1);

}

    int i;

    con_printf("\n");

    for (i=0; i<=tp->cur; i++) {

        if (!tp->frames[i].lineno) { continue; }

        con_printf("File \"%s\", line %d, in %s\n  %s\n",

            TP_CSTR(tp->frames[i].fname),tp->frames[i].lineno,

            TP_CSTR(tp->frames[i].name),TP_CSTR(tp->frames[i].line));

    }

    con_printf("\nException:\n%s\n",TP_CSTR(tp->ex));

}

    int i;

    for (i=tp->cur; i>=0; i--) {

        if (tp->frames[i].jmp) { break; }

    }

    if (i >= 0) {

        tp->cur = i;

        tp->frames[i].cur = tp->frames[i].jmp;

        tp->frames[i].jmp = 0;

        return;

    }

    tp_print_stack(tp);

    exit(-1);

}

    /*con_printf("_tp_call %s %s\n",TP_CSTR(fnc), TP_CSTR(params));*/

    if (fnc.type == TP_DICT) {

        _tp_call(tp,dest,tp_get(tp,fnc,tp_string("__call__")),params);

        return;

    }

    if (fnc.type == TP_FNC && !(fnc.fnc.ftype&1)) {

        *dest = _tp_tcall(tp,fnc);

        tp_grey(tp,*dest);

        return;

    }

    if (fnc.type == TP_FNC) {

        tp_frame(tp,fnc.fnc.info->globals,(tp_code*)fnc.fnc.val,dest);

        if ((fnc.fnc.ftype&2)) {

            tp->frames[tp->cur].regs[0] = params;

            _tp_list_insert(tp,params.list.val,0,fnc.fnc.info->self);

        } else {

            tp->frames[tp->cur].regs[0] = params;

        }

        return;

    }

    tp_params_v(tp,1,fnc); tp_print(tp);

    tp_raise(,"tp_call: %s is not callable",TP_CSTR(fnc));

}

    tp_obj *dest = tp->frames[tp->cur].ret_dest;

    if (dest) { *dest = v; tp_grey(tp,v); }

/*     memset(tp->frames[tp->cur].regs,0,TP_REGS_PER_FRAME*sizeof(tp_obj));

       fprintf(stderr,"regs:%d\n",(tp->frames[tp->cur].cregs+1));*/

    memset(tp->frames[tp->cur].regs,0,tp->frames[tp->cur].cregs*sizeof(tp_obj));

    tp->cur -= 1;

}

    TP_IEOF,TP_IADD,TP_ISUB,TP_IMUL,TP_IDIV,TP_IPOW,TP_IAND,TP_IOR,TP_ICMP,TP_IGET,TP_ISET,

    TP_INUMBER,TP_ISTRING,TP_IGGET,TP_IGSET,TP_IMOVE,TP_IDEF,TP_IPASS,TP_IJUMP,TP_ICALL,

    TP_IRETURN,TP_IIF,TP_IDEBUG,TP_IEQ,TP_ILE,TP_ILT,TP_IDICT,TP_ILIST,TP_INONE,TP_ILEN,

    TP_ILINE,TP_IPARAMS,TP_IIGET,TP_IFILE,TP_INAME,TP_INE,TP_IHAS,TP_IRAISE,TP_ISETJMP,

    TP_IMOD,TP_ILSH,TP_IRSH,TP_IITER,TP_IDEL,TP_IREGS,

    TP_ITOTAL

};

       "EOF","ADD","SUB","MUL","DIV","POW","AND","OR","CMP","GET","SET","NUM",

       "STR","GGET","GSET","MOVE","DEF","PASS","JUMP","CALL","RETURN","IF","DEBUG",

       "EQ","LE","LT","DICT","LIST","NONE","LEN","LINE","PARAMS","IGET","FILE",

       "NAME","NE","HAS","RAISE","SETJMP","MOD","LSH","RSH","ITER","DEL","REGS",

   };*/

#define VB ((int)e.regs.b)

#define VC ((int)e.regs.c)

#define RA regs[e.regs.a]

#define RB regs[e.regs.b]

#define RC regs[e.regs.c]

#define UVBC (unsigned short)(((VB<<8)+VC))

#define SVBC (short)(((VB<<8)+VC))

#define GA tp_grey(tp,RA)

#define SR(v) f->cur = cur; return(v);

    tp_frame_ *f = &tp->frames[tp->cur];

    tp_obj *regs = f->regs;

    tp_code *cur = f->cur;

    while(1) {

    tp_code e = *cur;

/*     fprintf(stderr,"%2d.%4d: %-6s %3d %3d %3d\n",tp->cur,cur-f->codes,tp_strings[e.i],VA,VB,VC);

       int i; for(i=0;i<16;i++) { fprintf(stderr,"%d: %s\n",i,TP_CSTR(regs[i])); }*/

    switch (e.i) {

        case TP_IEOF: tp_return(tp,tp_None); SR(0); break;

        case TP_IADD: RA = tp_add(tp,RB,RC); break;

        case TP_ISUB: RA = tp_sub(tp,RB,RC); break;

        case TP_IMUL: RA = tp_mul(tp,RB,RC); break;

        case TP_IDIV: RA = tp_div(tp,RB,RC); break;

        case TP_IPOW: RA = tp_pow(tp,RB,RC); break;

        case TP_IAND: RA = tp_and(tp,RB,RC); break;

        case TP_IOR:  RA = tp_or(tp,RB,RC); break;

        case TP_IMOD:  RA = tp_mod(tp,RB,RC); break;

        case TP_ILSH:  RA = tp_lsh(tp,RB,RC); break;

        case TP_IRSH:  RA = tp_rsh(tp,RB,RC); break;

        case TP_ICMP: RA = tp_number(tp_cmp(tp,RB,RC)); break;

        case TP_INE: RA = tp_number(tp_cmp(tp,RB,RC)!=0); break;

        case TP_IEQ: RA = tp_number(tp_cmp(tp,RB,RC)==0); break;

        case TP_ILE: RA = tp_number(tp_cmp(tp,RB,RC)<=0); break;

        case TP_ILT: RA = tp_number(tp_cmp(tp,RB,RC)<0); break;

        case TP_IPASS: break;

        case TP_IIF: if (tp_bool(tp,RA)) { cur += 1; } break;

        case TP_IGET: RA = tp_get(tp,RB,RC); GA; break;

        case TP_IITER:

            if (RC.number.val < tp_len(tp,RB).number.val) {

                RA = tp_iter(tp,RB,RC); GA;

                RC.number.val += 1;

                cur += 1;

            }

            break;

        case TP_IHAS: RA = tp_has(tp,RB,RC); break;

        case TP_IIGET: tp_iget(tp,&RA,RB,RC); break;

        case TP_ISET: tp_set(tp,RA,RB,RC); break;

        case TP_IDEL: tp_del(tp,RA,RB); break;

        case TP_IMOVE: RA = RB; break;

        case TP_INUMBER:

            RA = tp_number(*(tp_num*)(*++cur).string.val);

            cur += sizeof(tp_num)/4;

            continue;

        case TP_ISTRING:

            RA = tp_string_n((*(cur+1)).string.val,UVBC);

            cur += (UVBC/4)+1;

            break;

        case TP_IDICT: RA = tp_dict_n(tp,VC/2,&RB); break;

        case TP_ILIST: RA = tp_list_n(tp,VC,&RB); break;

        case TP_IPARAMS: RA = tp_params_n(tp,VC,&RB); break;

        case TP_ILEN: RA = tp_len(tp,RB); break;

        case TP_IJUMP: cur += SVBC; continue; break;

        case TP_ISETJMP: f->jmp = cur+SVBC; break;

        case TP_ICALL: _tp_call(tp,&RA,RB,RC); cur++; SR(0); break;

        case TP_IGGET:

            if (!tp_iget(tp,&RA,f->globals,RB)) {

                RA = tp_get(tp,tp->builtins,RB); GA;

            }

            break;

        case TP_IGSET: tp_set(tp,f->globals,RA,RB); break;

        case TP_IDEF:

            RA = tp_def(tp,(*(cur+1)).string.val,f->globals);

            cur += SVBC; continue;

            break;

        case TP_IRETURN: tp_return(tp,RA); SR(0); break;

        case TP_IRAISE: _tp_raise(tp,RA); SR(0); break;

        case TP_IDEBUG:

            tp_params_v(tp,3,tp_string("DEBUG:"),tp_number(VA),RA); tp_print(tp);

            break;

        case TP_INONE: RA = tp_None; break;

        case TP_ILINE:

            f->line = tp_string_n((*(cur+1)).string.val,VA*4-1);

/*             fprintf(stderr,"%7d: %s\n",UVBC,f->line.string.val);*/

            cur += VA; f->lineno = UVBC;

            break;

        case TP_IFILE: f->fname = RA; break;

        case TP_INAME: f->name = RA; break;

        case TP_IREGS: f->cregs = VA; break;

        default: tp_raise(0,"tp_step: invalid instruction %d",e.i); break;

    }

    cur += 1;

    }

    SR(0);

}

    if (tp->jmp) {

      tp_raise(,"tp_run(%d) called recusively",cur);

    }

    tp->jmp = 1;

    if (setjmp(tp->buf))

    {

      tp_handle(tp);

    }

    while (tp->cur >= cur && tp_step(tp) != -1);

    tp->cur = cur-1;

    tp->jmp = 0;

}

    tp_obj tmp;

    tp_obj r = tp_None;

    tmp = tp_get(tp,tp->modules,tp_string(mod));

    tmp = tp_get(tp,tmp,tp_string(fnc));

    _tp_call(tp,&r,tmp,params);

    tp_run(tp,tp->cur);

    return r;

}

    tp_obj code = tp_None;

    tp_obj g;

    if (!((fname && strstr(fname,".tpc")) || codes)) {

        return tp_call(tp,"py2bc","import_fname",tp_params_v(tp,2,tp_string(fname),tp_string(name)));

    }

    if (!codes) {

        tp_params_v(tp,1,tp_string(fname));

        code = tp_load(tp);

        /* We cast away the constness. */

        codes = (void *)code.string.val;

    } else {

        code = tp_data(tp,0,codes);

    }

    tp_set(tp,g,tp_string("__name__"),tp_string(name));

    tp_set(tp,g,tp_string("__code__"),code);

    tp_set(tp,g,tp_string("__dict__"),g);

    tp_frame(tp,g,(tp_code*)codes,0);

    tp_set(tp,tp->modules,tp_string(name),g);

    if (!tp->jmp) {

      tp_run(tp,tp->cur);

    }

}

    tp_obj code = TP_OBJ();

    tp_obj globals = TP_OBJ();

    tp_frame(tp,globals,(tp_code*)code.string.val,0);

    return tp_None;

}

    tp_obj mod = TP_OBJ();

    char const *s;

    tp_obj r;

        return tp_get(tp,tp->modules,mod);

    }

    r = tp_import(tp,TP_CSTR(tp_add(tp,mod,tp_string(".tpc"))),s,0);

    return r;

}

    struct {const char *s;void *f;} b[] = {

    {"print",tp_print}, {"range",tp_range}, {"raw_input", tp_raw_input},

    {"min",tp_min}, {"max",tp_max}, {"bind",tp_bind}, {"copy",tp_copy},

    {"import",tp_import_}, {"len",tp_len_}, {"assert",tp_assert},

    {"str",tp_str2}, {"float",tp_float}, {"system",tp_system},

    {"istype",tp_istype}, {"chr",tp_chr}, {"save",tp_save},

    {"load",tp_load}, {"fpack",tp_fpack}, {"abs",tp_abs},

    {"int",tp_int}, {"exec",tp_exec_}, {"exists",tp_exists},

    {"mtime",tp_mtime}, {"number",tp_float}, {"round",tp_round},

    {"ord",tp_ord}, {"merge",tp_merge}, {"syscall", tp_syscall}, {0,0},

    };

    int i; for(i=0; b[i].s; i++) {

        tp_set(tp,tp->builtins,tp_string(b[i].s),tp_fnc(tp,(tp_obj (*)(tp_vm *))b[i].f));

    }

}

    tp_obj self = tp_list(tp);

    int i;

    for (i=1; i

    tp_set(tp,tp->builtins,tp_string("ARGV"),self);

}

    return tp_import(tp,fname,"__main__",code);

}

tp_obj tp_compile(TP, tp_obj text, tp_obj fname) {

    return tp_call(tp,"BUILTINS","compile",tp_params_v(tp,2,text,fname));

}

    tp_obj r=tp_None;

    tp_frame(tp,globals,(tp_code*)code.string.val,&r);

    tp_run(tp,tp->cur);

    return r;

}

    tp_obj code = tp_compile(tp,tp_string(text),tp_string(""));

    return tp_exec(tp,code,globals);

}

    tp_vm *tp = _tp_init();

    tp_builtins(tp);

    tp_args(tp,argc,argv);

    tp_compiler(tp);

    return tp;

}

#define>