Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. #define buffer 1024
  2.  
  3. :struct VAR
  4. {
  5.         dword   data;
  6.         byte   type;
  7.         dword   length;
  8.                 dword stack;
  9. };
  10.  
  11.  
  12. :dword build_map(dword count)
  13. {
  14.         dword o = 0;
  15.         dword a1 = 0;
  16.         dword a2 = 0;
  17.         IF(count>8) o = arrayInit(count);
  18.         ELSE o = arrayInit(8);
  19.         WHILE(count)
  20.         {
  21.                 a1 = popStack();
  22.                 a2 = popStack();
  23.                 SWITCH(DSBYTE[a2+4])
  24.                 {
  25.                         CASE PY_STR:
  26.                                 dictSet(#o,DSDWORD[a2],a1);
  27.                         BREAK;
  28.                         CASE PY_INT:
  29.                                 arraySet(#o,1,a1);
  30.                         BREAK;
  31.                 }
  32.                 count--;
  33.         }
  34.         load_const(o,PY_DCT,0);
  35. }
  36.  
  37. :void load_const(dword data,type,length)
  38. {
  39.         DSDWORD[#RDATA] = data;
  40.         DSBYTE[#RDATA+4] = type;
  41.         DSDWORD[#RDATA+5] = length;
  42.         DSDWORD[#RDATA+9] = 0;
  43.        
  44.         pushStack(#RDATA);
  45. }
  46.  
  47. :void compare_op(byte cmd)
  48. {
  49.         dword n = 0;
  50.         dword y = popStack();
  51.         dword x = popStack();
  52.         dword dx = 0;
  53.         dword dy = 0;
  54.         dword i = 0;
  55.        
  56.         checkType(x,y);
  57.        
  58.         IF(DSBYTE[x+4] == PY_STR)
  59.         {
  60.                 IF(DSDWORD[x+5] == DSDWORD[y+5])
  61.                 {
  62.                         dx = DSDWORD[x];
  63.                         dy = DSDWORD[y];
  64.                        
  65.                         i = DSDWORD[x+5];
  66.                        
  67.                         WHILE(i)
  68.                         {
  69.                                 IF(DSBYTE[dx]!=DSBYTE[dy]) BREAK;
  70.                                 dx++;
  71.                                 dy++;
  72.                                 i--;
  73.                         }
  74.                         IF(!i) load_const(1,PY_BOOL,0);
  75.                         ELSE load_const(0,PY_BOOL,0);
  76.                 }
  77.                 return;
  78.         }
  79.        
  80.         IF(!cmd)IF(DSDWORD[x] == DSDWORD[y])
  81.         {
  82.                 load_const(1,PY_BOOL,0);
  83.                 return;
  84.         }
  85.         IF(cmd==1)IF(DSDWORD[x] != DSDWORD[y])
  86.         {
  87.                 load_const(1,PY_BOOL,0);
  88.                 return;
  89.         }
  90.         IF(cmd==2)IF(DSDWORD[x] >= DSDWORD[y])
  91.         {
  92.                 load_const(1,PY_BOOL,0);
  93.                 return;
  94.         }
  95.         IF(cmd==3)IF(DSDWORD[x] <= DSDWORD[y])
  96.         {
  97.                 load_const(1,PY_BOOL,0);
  98.                 return;
  99.         }
  100.         IF(cmd==4)IF(DSDWORD[x] > DSDWORD[y])
  101.         {
  102.                 load_const(1,PY_BOOL,0);
  103.                 return;
  104.         }
  105.         IF(cmd==5)IF(DSDWORD[x] < DSDWORD[y])
  106.         {
  107.                 load_const(1,PY_BOOL,0);
  108.                 return;
  109.         }
  110.         load_const(0,PY_BOOL,0);
  111. }
  112. :byte pop_jump_if(byte cmd)
  113. {
  114.         dword x = 0;
  115.  
  116.         x = popStack();
  117.         //test(DSDWORD[x+4],1);
  118.         SWITCH(DSBYTE[x+4])
  119.         {
  120.                 CASE PY_INT:
  121.                 CASE PY_BOOL:
  122.                         IF(cmd){ IF (DSDWORD[x]) RETURN 1;}
  123.                         IF(!cmd){ IF (!DSDWORD[x]) RETURN 1;}
  124.                 BREAK;
  125.                 CASE PY_STR:
  126.                         IF(cmd){ IF (DSDWORD[x+5]) RETURN 1;}
  127.                         IF(!cmd){ IF (!DSDWORD[x+5]) RETURN 1;}
  128.                 BREAK;
  129.         }
  130.         RETURN 0;
  131. }
  132. :void pop_block()
  133. {
  134.         stackLoop-=4;
  135. }
  136. :void unary_invert()
  137. {
  138.         dword x = 0;
  139.         x = DSDWORD[stack-4];
  140.         EAX = DSDWORD[x];
  141.         $not eax;
  142.         DSDWORD[x] = EAX;
  143. }
  144. :void inplace(byte cmd)
  145. {
  146.         dword buffer = 0;
  147.         dword length = 0;
  148.        
  149.         Y = popStack();
  150.         X = DSDWORD[stack-4];
  151.        
  152.         IF(cmd==PY_ADD) checkType(X,Y);
  153.        
  154.         E = DSBYTE[X+4];
  155.        
  156.         if(E==PY_STR)
  157.         {
  158.                
  159.                 A = DSDWORD[X+5];
  160.                
  161.                 IF(cmd==PY_ADD) B = DSDWORD[Y+5];
  162.                 ELSE
  163.                 {
  164.                         C = DSDWORD[Y];
  165.                         B = C*A;
  166.                 }
  167.                
  168.                 length = A+B;
  169.                
  170.                 buffer = length+MEMBUF;
  171.                
  172.                 D = malloc(buffer);
  173.  
  174.                 IF(cmd==PY_ADD)
  175.                 {
  176.                        
  177.                         memcpy(D,DSDWORD[X],A);
  178.                         memcpy(D+A,DSDWORD[Y],B);
  179.                 }
  180.                 ELSE IF(cmd==PY_MUL)
  181.                 {
  182.                         B = D;
  183.                         E = DSDWORD[X];
  184.                         WHILE(C)
  185.                         {
  186.                                 memcpy(B,E,A);
  187.                                 B+=4;
  188.                                 C--;
  189.                         }
  190.                 }
  191.  
  192.                 DSDWORD[#RDATA] = D;
  193.                 DSBYTE[#RDATA+4] = PY_STR;
  194.                 DSDWORD[#RDATA+5] = length;
  195.                 DSDWORD[#RDATA+9] = buffer;
  196.                
  197.                 pushStack(#RDATA);
  198.                
  199.                 return;
  200.         }
  201.         if(E==PY_INT)
  202.         {
  203.                 switch(cmd)
  204.                 {
  205.                         case PY_ADD:
  206.                                 DSDWORD[X] += DSDWORD[Y];
  207.                         break;
  208.                         case PY_POW:
  209.                                 length = DSDWORD[Y];
  210.                                 D = DSDWORD[X];
  211.                                 DSDWORD[X] = 1;
  212.                                 WHILE(length) {DSDWORD[X]*=D; length--;}
  213.                         break;
  214.                         case PY_SUB:
  215.                                 DSDWORD[X] -= DSDWORD[Y];
  216.                         break;
  217.                         case PY_MUL:
  218.                                 DSDWORD[X] *= DSDWORD[Y];
  219.                         break;
  220.                         case PY_MOD:
  221.                                 DSDWORD[X] = DSDWORD[X]%DSDWORD[Y];
  222.                         break;
  223.                         case PY_XOR:
  224.                                 DSDWORD[X] ^= DSDWORD[Y];
  225.                         break;
  226.                         case PY_AND:
  227.                                 DSDWORD[X] &= DSDWORD[Y];
  228.                         break;
  229.                         case PY__OR:
  230.                                 DSDWORD[X] |= DSDWORD[Y];
  231.                         break;
  232.                         case PY_LSH:
  233.                                 DSDWORD[X] <<= DSDWORD[Y];
  234.                         break;
  235.                         case PY_RSH:
  236.                                 DSDWORD[X] >>= DSDWORD[Y];
  237.                         break;
  238.                         case PY_FDV:
  239.                                 DSDWORD[X] /= DSDWORD[Y];
  240.                         break;
  241.                         case PY_TDV:
  242.                                 DSDWORD[X] /= DSDWORD[Y];
  243.                         break;
  244.                 }
  245.         }
  246. }
  247. :void binary(byte cmd)
  248. {
  249.         dword buffer = 0;
  250.         dword length = 0;
  251.        
  252.         Y = popStack();
  253.         X = popStack();
  254.        
  255.         IF(cmd==PY_ADD) checkType(X,Y);
  256.        
  257.         E = DSBYTE[X+4];
  258.        
  259.         if(E==PY_STR)
  260.         {
  261.                
  262.                 A = DSDWORD[X+5];
  263.                
  264.                 IF(cmd==PY_ADD) B = DSDWORD[Y+5];
  265.                 ELSE
  266.                 {
  267.                         C = DSDWORD[Y];
  268.                         B = C*A;
  269.                 }
  270.                
  271.                 length = A+B;
  272.                
  273.                 buffer = length+MEMBUF;
  274.                
  275.                 D = malloc(buffer);
  276.  
  277.                 IF(cmd==PY_ADD)
  278.                 {
  279.                        
  280.                         memcpy(D,DSDWORD[X],A);
  281.                         memcpy(D+A,DSDWORD[Y],B);
  282.                 }
  283.                 ELSE IF(cmd==PY_MUL)
  284.                 {
  285.                         B = D;
  286.                         E = DSDWORD[X];
  287.                         WHILE(C)
  288.                         {
  289.                                 memcpy(B,E,A);
  290.                                 B+=4;
  291.                                 C--;
  292.                         }
  293.                 }
  294.  
  295.                 DSDWORD[#RDATA] = D;
  296.                 DSBYTE[#RDATA+4] = PY_STR;
  297.                 DSDWORD[#RDATA+5] = length;
  298.                 DSDWORD[#RDATA+9] = buffer;
  299.                
  300.                 pushStack(#RDATA);
  301.                
  302.                 return;
  303.         }
  304.         if(E==PY_INT)
  305.         {
  306.                 switch(cmd)
  307.                 {
  308.                         case PY_ADD:
  309.                                 A = DSDWORD[X] + DSDWORD[Y];
  310.                         break;
  311.                         case PY_POW:
  312.                                 length = DSDWORD[Y];
  313.                                 D = DSDWORD[X];
  314.                                 DSDWORD[Z] = 1;
  315.                                 WHILE(length) {A*=D; length--;}
  316.                         break;
  317.                         case PY_SUB:
  318.                                 A = DSDWORD[X] - DSDWORD[Y];
  319.                         break;
  320.                         case PY_MUL:
  321.                                 A = DSDWORD[X] * DSDWORD[Y];
  322.                         break;
  323.                         case PY_MOD:
  324.                                 A = DSDWORD[X] % DSDWORD[Y];
  325.                         break;
  326.                         case PY_XOR:
  327.                                 A = DSDWORD[X] ^ DSDWORD[Y];
  328.                         break;
  329.                         case PY_AND:
  330.                                 A = DSDWORD[X] & DSDWORD[Y];
  331.                         break;
  332.                         case PY__OR:
  333.                                 A = DSDWORD[X] | DSDWORD[Y];
  334.                         break;
  335.                         case PY_LSH:
  336.                                 A = DSDWORD[X] << DSDWORD[Y];
  337.                         break;
  338.                         case PY_RSH:
  339.                                 A = DSDWORD[X] >> DSDWORD[Y];
  340.                         break;
  341.                         case PY_FDV:
  342.                                 A = DSDWORD[X] / DSDWORD[Y];
  343.                         break;
  344.                         case PY_TDV:
  345.                                 A = DSDWORD[X] / DSDWORD[Y];
  346.                         break;
  347.                 }
  348.                 load_const(A,PY_INT,0);
  349.         }
  350. }
  351.  
  352. :byte del(dword v)
  353. {
  354.         dword x = 0;
  355.         x = DSDWORD[v];
  356.         IF(x)
  357.         {
  358.                 IF(DSDWORD[x+9]) free(DSDWORD[x]);
  359.                 free(x);
  360.                 DSDWORD[v] = 0;
  361.                 RETURN 1;
  362.         }
  363.         RETURN 0;
  364. }
  365. :void build_class(dword count)
  366. {
  367.         dword name = 0;
  368.         dword func = 0;
  369.         func = popFast();
  370.         name = popFast();
  371.         load_const(func,PY_CLS,0);
  372. }
  373. :void load_build_class()
  374. {
  375.         load_const(#build_class,PY_FNC,0);
  376. }
  377. :void make_function()
  378. {
  379.         stack-=4;
  380. }
  381. :void store_name(dword x)
  382. {
  383.         dword tmp = 0;
  384.         dword stk = 0;
  385.         stk = popStack();
  386.         IF(!DSDWORD[x])
  387.         {
  388.                 tmp = malloc(30);
  389.                 memcpy(tmp,stk,30);
  390.                 DSDWORD[x] = tmp;
  391.                 return;
  392.         }
  393.         memcpy(DSDWORD[x],stk,30);
  394. }
  395. :void rot(dword x,y)
  396. {
  397.         EAX = DSDWORD[stack-8];
  398.         DSDWORD[stack-8] = DSDWORD[stack-4];
  399.         DSDWORD[stack-4] = EAX;
  400. }
  401. :void build_tuple(dword len)
  402. {
  403.         dword tuple = 0;
  404.         dword buf = 0;
  405.         dword l = 0;
  406.         l = len;
  407.         tuple = malloc(4*len+MEMBUF);
  408.         buf = tuple;
  409.         WHILE(len)
  410.         {
  411.                 DSDWORD[buf] = popStack();
  412.                 buf+=4;
  413.                 len--;
  414.         }
  415.         load_const(tuple,PY_TPL,l);
  416. }
  417. :void unpack_sequence(dword len)
  418. {
  419.         dword tuple = 0;
  420.         dword x = 0;
  421.         popStack();
  422.         tuple = DSDWORD[EAX];
  423.  
  424.         WHILE(len)
  425.         {
  426.                 pushStack(DSDWORD[tuple]);
  427.                 tuple+=4;
  428.                 len--;
  429.         }
  430. }
  431. :void rot_two()
  432. {
  433.         rot(DSDWORD[stack-8],DSDWORD[stack-4]);
  434. }
  435. :void rot_three()
  436. {
  437.         rot(DSDWORD[stack-12],DSDWORD[stack-4]);
  438.         rot(DSDWORD[stack-8],DSDWORD[stack-4]);
  439. }
  440. :void load_name(dword addr)
  441. {
  442.         pushStack(addr);
  443. }
  444. :void load_global(dword addr)
  445. {
  446.         pushStack(addr);
  447. }
  448. :dword strlen(dword txt)
  449. {
  450.         dword i = 0;
  451.         i = txt;
  452.         WHILE(DSBYTE[i]) i++;
  453.         RETURN i - txt;
  454. }
  455. :dword hashString(dword x)
  456. {
  457.         dword l = 0;
  458.         dword h = 0;
  459.         l = x;
  460.         WHILE(DSBYTE[x])
  461.         {
  462.                 h+=DSBYTE[x];
  463.                 h<<=1;
  464.                 x++;
  465.                 h/=x-l;
  466.         }
  467.         return h;
  468. }
  469.  
  470.  
  471. :void pop_top()
  472. {
  473.         stack-=4;
  474. }
  475. :void load_fast(dword addr)
  476. {
  477.         dword x = 0;
  478.         IF(!DSDWORD[addr])
  479.         {
  480.                 x = popFast();
  481.                 DSDWORD[addr] = x;
  482.         }
  483.         ELSE x = DSDWORD[addr];
  484.         pushStack(x);
  485. }
  486. :void call_function(dword arg)
  487. {
  488.         dword count = 0;
  489.         dword func = 0;
  490.         byte type = 0;
  491.         dword stackRet = 0;
  492.         count = arg;
  493.        
  494.         WHILE(count)
  495.         {
  496.                 pushFast(popStack());
  497.                 count--;
  498.         }
  499.        
  500.         func = popStack();
  501.        
  502.         //IF(DSBYTE[Z+4]!=PY_FNC) test("No function!",0);
  503.         type = DSBYTE[func+4];
  504.        
  505.         func = DSDWORD[func];
  506.         IF(!func)
  507.         {
  508.                 test1("Null function!",0);
  509.                 pushStack(0);
  510.                 return;
  511.         }
  512.         IF(type==PY_FNC)
  513.         {
  514.                 stackRet = stack;
  515.                 func(arg);
  516.                 IF(stackRet == stack) load_const(0,PY_NONE,0);
  517.         }
  518.         ELSE IF(type==PY_CLS)
  519.         {
  520.                 stackRet = stack;
  521.                 func(arg);
  522.                 IF(stackRet == stack) load_const(0,PY_NONE,0);
  523.         }
  524.         stackFast = beginStackFast;
  525. }
  526. :void call_method(dword arg)
  527. {
  528.         dword count = 0;
  529.         dword func = 0;
  530.         byte type = 0;
  531.         dword stackRet = 0;
  532.         count = arg;
  533.        
  534.         WHILE(count)
  535.         {
  536.                 pushFast(popStack());
  537.                 count--;
  538.         }
  539.        
  540.         func = popStack();
  541.        
  542.         //IF(DSBYTE[Z+4]!=PY_FNC) test("No function!",0);
  543.         type = DSBYTE[func+4];
  544.        
  545.         func = DSDWORD[func];
  546.         IF(!func)
  547.         {
  548.                 test1("Null function!",0);
  549.                 pushStack(0);
  550.                 return;
  551.         }
  552.         IF(type==PY_FNC)
  553.         {
  554.                 stackRet = stack;
  555.                 func(arg);
  556.                 IF(stackRet == stack) load_const(0,PY_NONE,0);
  557.         }
  558.         ELSE IF(type==PY_CLS)
  559.         {
  560.                 func(arg);
  561.                 pushStack(EAX);
  562.         }
  563.         stackFast = beginStackFast;
  564. }
  565. :void load_method(dword name)
  566. {
  567.         dword x = 0;
  568.         dword data = 0;
  569.         dword get = 0;
  570.         x = popStack();
  571.         data = DSDWORD[x];
  572.         get = dictGet(DSDWORD[data],name);
  573.         pushStack(get);
  574. }
  575. :void append(dword count)
  576. {
  577.         dword x = 0;
  578.         dword y = 0;
  579.         x = popFast();
  580.         y = popFast();
  581.         test1(DSBYTE[x+4],1);
  582. }
  583. :void build_list(dword count)
  584. {
  585.         dword n = 0;
  586.         dword mem = 0;
  587.         dword i = 0;
  588.         dword tmp = 0;
  589.         dword method = 0;
  590.  
  591.         mem = malloc(count*4+MEMBUF);
  592.         i = count;
  593.         n = i*4+mem+4;
  594.        
  595.         load_const(#append,PY_FNC,0);
  596.         dictSet(#method,"append",popStack());
  597.        
  598.         DSDWORD[mem] = method;
  599.         WHILE(i)
  600.         {
  601.                 n-=4;
  602.                 tmp = malloc(30);
  603.                 memcpy(tmp,popStack(),30);
  604.                 DSDWORD[n] = tmp;
  605.                 i--;
  606.         }
  607.         load_const(mem,PY_LST,count);
  608. }
  609. :dword store_fast()
  610. {
  611.         return popStack();
  612. }
  613.  
  614. :void binary_subscr()
  615. {
  616.         dword x = 0;
  617.         dword y = 0;
  618.         dword l1 = 0;
  619.         dword l2 = 0;
  620.         dword tmp = 0;
  621.         dword ret = 0;
  622.         byte t = 0;
  623.        
  624.         x = popStack();
  625.         y = popStack();
  626.        
  627.         //IF(DSBYTE[x+4]!=PY_INT) error type;
  628.  
  629.         l1 = DSDWORD[y+5];
  630.        
  631.         t = DSBYTE[y+4];
  632.         IF(t==PY_LST)
  633.         {
  634.                 IF(l1<=x) test1("error max list",0);
  635.                 IF(0>l1) test1("error min list",0);
  636.                
  637.                 y = DSDWORD[y];
  638.                 pushStack(DSDWORD[x*4+y]);
  639.                 return;
  640.         }
  641.         IF(t==PY_DCT)
  642.         {
  643.                 y = DSDWORD[y]; // data object
  644.                 SWITCH(DSBYTE[x+4])
  645.                 {
  646.                         CASE PY_INT:
  647.                                
  648.                                 test1(DSDWORD[y],1);
  649.                                 x = arrayGet(DSDWORD[y],DSDWORD[x]);
  650.                         BREAK;
  651.                         CASE PY_STR:
  652.                                 x = dictGet(DSDWORD[y],DSDWORD[x]);
  653.                         BREAK;
  654.                 }
  655.                 pushStack(x);
  656.                 //test1(DSBYTE[x+4],1);
  657.                 return;
  658.         }
  659.         IF(t==PY_STR)
  660.         {
  661.                 x = DSDWORD[x];
  662.                 IF (l1<=x)||(l1<0) test1("IndexError: string index out of range",0);
  663.                 y = DSDWORD[y];
  664.                 tmp = malloc(MEMBUF);
  665.                 ret = malloc(30);
  666.                 DSBYTE[tmp] = DSBYTE[x+y];
  667.                 DSDWORD[ret] = tmp;
  668.                 DSBYTE[ret+4] = PY_STR;
  669.                 DSDWORD[ret+5] = 1;
  670.                 DSDWORD[ret+9] = MEMBUF;
  671.                 pushStack(ret);
  672.  
  673.                 return;
  674.         }
  675. }
  676. :void build_slice(dword count)
  677. {
  678.        
  679. }
  680. /*
  681.  
  682. :void call_function(dword arg)
  683. {
  684.         dword x = 0;
  685.  
  686.         dword c = arg;
  687.         dword o = 0;
  688.        
  689.         dword v = 0;
  690.        
  691.         WHILE(c)
  692.         {
  693.                 o+=4;
  694.                 popStack();
  695.                 $push eax
  696.                 c--;
  697.         }
  698.         $push arg
  699.        
  700.         v = popStack();
  701.        
  702.         IF(DSBYTE[v+4]!=PY_FNC) test("No function!",0);
  703.        
  704.         v = DSDWORD[v];
  705.         IF(!v)
  706.         {
  707.                 test(1,1);
  708.                 pushStack(0);
  709.                 return;
  710.         }
  711.        
  712.         $call v
  713.         ESP+=o;
  714.        
  715.         pushStack(EAX);
  716. }
  717. */