?login_element?

Subversion Repositories NedoOS

Rev

Rev 499 | Blame | Compare with Previous | Last modification | View Log | Download

  1. #include "interpreter.h"
  2. #include "global_mem.h"
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. //#include <time.h>
  6. #include <string>
  7. #include <sstream>
  8.  
  9. #ifdef FOR_DEBUGGER
  10. #include "mainwindow.h"
  11. //#include <QString>
  12. //#include <QMessageBox>
  13.  
  14. uint8_t datastackindex = 0; //растёт вверх
  15. uint8_t callstackindex = 0; //растёт вверх
  16.  
  17. data64bit datastack[STACKSIZE];
  18. uint64_t callstack[STACKSIZE];
  19. data64bit locals[LOCALSSIZE];
  20.  
  21.     uint64_t *pc;
  22.     uint64_t *prog;
  23. #endif //FOR_DEBUGGER
  24.     void myprintstr(uint64_t *prog, uint64_t addr){
  25.         char s[100];
  26.         char *ps=s;
  27.         uint64_t *tmppc=prog+addr;
  28.         while(*tmppc)
  29.             *ps++=static_cast<char>(*tmppc++);
  30.         *ps=0;
  31.         myprint(reinterpret_cast<char *>(s));
  32.     }
  33.  
  34. #ifdef FOR_DEBUGGER
  35.     void pushpar(uint64_t progpar){
  36.         PUSH(progpar);
  37.     }
  38.  
  39.     int interpret() {
  40. #else //FOR_DEBUGGER
  41.     int interpret(uint64_t *prog, uint64_t progpar) {
  42.         uint64_t *pc = prog;
  43. uint8_t datastackindex = 0; //растёт вверх
  44. uint8_t callstackindex = 0; //растёт вверх
  45.  
  46. data64bit datastack[STACKSIZE];
  47. uint64_t callstack[STACKSIZE];
  48. data64bit locals[LOCALSSIZE];
  49.         PUSH(progpar);
  50. #endif //FOR_DEBUGGER
  51.  
  52.     const void *labels[] = {
  53.         &&op_nop, /* !!! НЕ ГЕНЕРИТСЯ !!! */
  54.         &&op_add, /* OK */
  55.         &&op_sub, /* OK */
  56.         &&op_mul, /* OK */
  57.         &&op_div, /* OK */
  58.         &&op_divsigned, /* OK */
  59.         &&op_if0goto, /* OK */
  60.         &&op_goto, /* OK */
  61.         &&op_dup, /* OK */
  62.         &&op_drop, /* !!! НЕ ГЕНЕРИТСЯ !!! */
  63.         &&op_swap, /* OK */
  64.         &&op_readvar, /* OK */
  65.         &&op_writevar, /* OK */
  66.         &&op_const, /* OK */
  67.         &&op_ret, /* OK */
  68.         &&op_call, /* OK */
  69.         &&op_and, /* OK */
  70.         &&op_or, /* OK */
  71.         &&op_xor, /* OK */
  72.         &&op_eq, /* OK */
  73.         &&op_moreeq, /* OK */
  74.         &&op_moreeqsigned, /* OK */
  75.         &&op_inv, /* OK */
  76.         &&op_rst, /* OK */
  77.         &&op_shr, /* OK */
  78.         &&op_shrsigned, /* OK */
  79.         &&op_shl, /* OK */
  80.         &&op_mod, /* !!! НЕ ГЕНЕРИТСЯ !!! */
  81.         &&op_done, /* OK */
  82.         &&op_addfloat, /* OK */
  83.         &&op_subfloat, /* OK */
  84.         &&op_mulfloat, /* OK */
  85.         &&op_divfloat, /* OK */
  86.         &&op_negfloat, /* OK */
  87.         &&op_floattoint, /* OK */
  88.         &&op_inttofloat, /* OK */
  89.         &&op_eqfloat,
  90.         &&op_moreeqfloat, /* OK */
  91.         &&op_readconstvar,
  92.         &&op_writeconstvar,
  93.         &&op_incconstvar,
  94.         &&op_decconstvar
  95.     };
  96.     MAINDISPATCH;/*!*/
  97. op_nop: {
  98.         DISPATCH;
  99.     }
  100. op_add: {
  101.         uint64_t par2 = POP.u;
  102.         TOS.u = (TOS.u+par2);
  103.         DISPATCH;
  104.     }
  105. op_sub: {
  106.         uint64_t par2 = POP.u;
  107.         TOS.u = (TOS.u-par2);
  108.         DISPATCH;
  109.     }
  110. op_mul: {
  111.         uint64_t par2 = POP.u;
  112.         TOS.u = (TOS.u*par2);
  113.         DISPATCH;
  114.     }
  115. op_div: {
  116.         uint64_t par2 = POP.u;
  117.         if (par2)
  118.             TOS.u = (TOS.u/par2);
  119.         DISPATCH;
  120.     }
  121. op_divsigned: {/*!*/
  122.         int64_t par2 = POP.i;
  123.         if (par2)
  124.             TOS.i = TOS.i/par2;
  125.         DISPATCH;
  126.     }
  127. op_mod: {
  128.         uint64_t par2 = POP.u;
  129.         if (par2)
  130.             TOS.u = (TOS.u-((TOS.u/par2)*par2));
  131.         DISPATCH;
  132.     }
  133. op_and: {
  134.         uint64_t par2 = POP.u;
  135.         TOS.u = (TOS.u&par2);
  136.         DISPATCH;
  137.     }
  138. op_or: {
  139.         uint64_t par2 = POP.u;
  140.         TOS.u = (TOS.u|par2);
  141.         DISPATCH;
  142.     }
  143. op_xor: {
  144.         uint64_t par2 = POP.u;
  145.         TOS.u = (TOS.u^par2);
  146.         DISPATCH;
  147.     }
  148. op_inv: {
  149.         TOS.u = ~TOS.u;
  150.         DISPATCH;
  151.     }
  152. op_shr: {
  153.         uint64_t par2 = POP.u;
  154.         TOS.u = (TOS.u>>par2);
  155.         DISPATCH;
  156.     }
  157. op_shrsigned: {
  158.         uint64_t par2 = POP.u;
  159.         TOS.i = (TOS.i>>par2);
  160.         DISPATCH;
  161.     }
  162. op_shl: {
  163.         uint64_t par2 = POP.u;
  164.         TOS.u = (TOS.u<<par2);
  165.         DISPATCH;
  166.     }
  167. op_eq: {
  168.         uint64_t par2 = POP.u;
  169.         TOS.i = (TOS.u==par2)?-1:0;
  170.         DISPATCH;
  171.     }
  172. op_moreeq: {
  173.         uint64_t par2 = POP.u;
  174.         TOS.i = (TOS.u>=par2)?-1:0;
  175.         DISPATCH;
  176.     }
  177. op_moreeqsigned: {
  178.         int64_t par2 = POP.i;
  179.         TOS.i = (TOS.i>=par2)?-1:0;
  180.         DISPATCH;
  181.     }
  182. op_const: {
  183.         PUSH(GETPAR);
  184.         DISPATCH;
  185.     }
  186. op_dup: {
  187.         uint64_t par1 = TOS.u;
  188.         PUSH(par1);
  189.         DISPATCH;
  190.     }
  191. op_drop: {
  192.         POP;
  193.         DISPATCH;
  194.     }
  195. op_swap: {
  196.         uint64_t par2 = POP.u;
  197.         uint64_t par1 = TOS.u;
  198.         TOS.u = par2;
  199.         PUSH(par1);
  200.         DISPATCH;
  201.     }
  202. //pointers:
  203. //0x00000000 - global data segment (VAL)
  204. //0x40000000 - code segment (prog)
  205. //0x80000000 - local data segment (locals)
  206. op_readvar: {
  207.         if (TOS.u < static_cast<uint64_t>(N)) {
  208.             TOS.u = VAL(TOS.u);
  209.         }else if ((TOS.u < 0x80000000)/*&&((TOS.u&0x3fffffff) < progsize)*/) {
  210.             TOS.u = prog[TOS.u&0x3fffffff];
  211.         }else if ((TOS.u&0x3fffffff) < LOCALSSIZE) {
  212.             TOS.u = locals[TOS.u&0x3fffffff].u;
  213.         }
  214.         DISPATCH;
  215.     }
  216. op_writevar: {
  217.         uint64_t vardata = POP.u;
  218.         uint64_t varaddr = POP.u;
  219.         if (varaddr < static_cast<uint64_t>(N)) {
  220.             POKEVAL(varaddr, vardata);
  221.         }else if ((varaddr < 0x80000000)/*&&((varaddr&0x3fffffff) < progsize)*/) {
  222.             prog[varaddr&0x3fffffff] = vardata; //по идее не нужно
  223.         }else if ((varaddr&0x3fffffff) < LOCALSSIZE) {
  224.             locals[varaddr&0x3fffffff].u = vardata;
  225.         }
  226.         DISPATCH;
  227.     }
  228. op_goto: {
  229.         pc = prog+((*pc)&0x3fffffff); //нельзя GETPAR - делает pc++
  230.         DISPATCH;
  231.     }
  232. op_if0goto: {
  233.         if (!POP.u) {
  234.             pc = prog+((*pc)&0x3fffffff); //нельзя GETPAR - делает pc++
  235.         }else {
  236.             pc++;
  237.         }
  238.         DISPATCH;
  239.     }
  240. op_call: {
  241.         uint64_t callpc = GETPAR;
  242.         PUSHCALLSTACK(reinterpret_cast<uint64_t>(pc));
  243.         pc = prog+(callpc&0x3fffffff);
  244.         DISPATCH;
  245.     }
  246. op_ret: {
  247.         pc = reinterpret_cast<uint64_t*>(POPCALLSTACK);
  248.         DISPATCH;
  249.     }
  250. op_addfloat: {
  251.         double par2 = POP.d;
  252.         TOS.d = TOS.d+par2;
  253.         DISPATCH;
  254.     }
  255. op_subfloat: {
  256.         double par2 = POP.d;
  257.         TOS.d = TOS.d - par2;
  258.         DISPATCH;
  259.     }
  260. op_mulfloat: {
  261.         double par2 = POP.d;
  262.         TOS.d = TOS.d * par2;
  263.         DISPATCH;
  264.     }
  265. op_divfloat: {
  266.         double par2 = POP.d;
  267.         TOS.d = TOS.d / par2;
  268.         DISPATCH;
  269.     }
  270. op_negfloat: {
  271.         TOS.d = -TOS.d;
  272.         DISPATCH;
  273.     }
  274. op_floattoint: {
  275.         TOS.i = static_cast<int64_t>(rint(TOS.d));
  276.         DISPATCH;
  277.     }
  278. op_inttofloat: {
  279.         TOS.d = TOS.i;
  280.         DISPATCH;
  281.     }
  282. op_eqfloat: {
  283.         uint64_t par2 = POP.u; //.u - чтобы не получать warning о сравнении 2х double
  284.         TOS.i = (TOS.u==par2)?-1:0;
  285.         DISPATCH;
  286.     }
  287. op_moreeqfloat: {
  288.         double par2 = POP.d;
  289.         TOS.i = (TOS.d>=par2)?-1:0;
  290.         DISPATCH;
  291.     }
  292. op_done: {
  293.         return static_cast<int>(stcSMData[0].current_value.i);
  294.     }
  295. op_readconstvar:{
  296.         uint64_t addr=GETPAR;
  297.         if (addr < static_cast<uint64_t>(N)) {
  298.             PUSH(VAL(addr));
  299.         }else if ((addr < 0x80000000)/*&&((TOS.u&0x3fffffff) < progsize)*/) {
  300.             PUSH(prog[addr]);
  301.         }else if ((addr&0x3fffffff) < LOCALSSIZE) {
  302.             PUSH(locals[addr].u);
  303.         }
  304.         DISPATCH;
  305.     }
  306. op_writeconstvar:{
  307.     uint64_t vardata = POP.u;
  308.     uint64_t varaddr = GETPAR;
  309.     if (varaddr < static_cast<uint64_t>(N)) {
  310.         POKEVAL(varaddr, vardata);
  311.     }else if ((varaddr < 0x80000000)/*&&((varaddr&0x3fffffff) < progsize)*/) {
  312.         prog[varaddr&0x3fffffff] = vardata; //по идее не нужно
  313.     }else if ((varaddr&0x3fffffff) < LOCALSSIZE) {
  314.         locals[varaddr&0x3fffffff].u = vardata;
  315.     }
  316.     DISPATCH;
  317. }
  318. op_incconstvar:{
  319.     uint64_t addr = GETPAR;
  320.     if (addr < static_cast<uint64_t>(N)) {
  321.         POKEVAL(addr, VAL(addr)+1);
  322.     }else if ((addr < 0x80000000)/*&&((varaddr&0x3fffffff) < progsize)*/) {
  323.         prog[addr&0x3fffffff]++; //по идее не нужно
  324.     }else if ((addr&0x3fffffff) < LOCALSSIZE) {
  325.         locals[addr&0x3fffffff].u++;
  326.     }
  327.     DISPATCH;
  328. }
  329. op_decconstvar:{
  330.     uint64_t addr = GETPAR;
  331.     if (addr < static_cast<uint64_t>(N)) {
  332.         POKEVAL(addr, VAL(addr)-1);
  333.     }else if ((addr < 0x80000000)/*&&((varaddr&0x3fffffff) < progsize)*/) {
  334.         prog[addr&0x3fffffff]--; //по идее не нужно
  335.     }else if ((addr&0x3fffffff) < LOCALSSIZE) {
  336.         locals[addr&0x3fffffff].u--;
  337.     }
  338.     DISPATCH;
  339. }
  340. op_rst: {
  341.     uint64_t op = GETPAR;
  342.     double par1;
  343.     uint64_t upar1;
  344.     switch (op) {
  345. //case RST_NOP: //fn_nop:
  346. //        break;
  347. case RST_SIN: //fn_sin:{
  348.         TOS.d=sin(TOS.d);
  349.         break;
  350. case RST_COS: //fn_cos:{
  351.         TOS.d=cos(TOS.d);
  352.         break;
  353. case RST_ATAN: //fn_atan:{
  354.         TOS.d=atan(TOS.d);
  355.         break;
  356. case RST_ATAN2: //fn_atan2:{
  357.         par1 = POP.d;
  358.         TOS.d = atan2(TOS.d,par1);
  359.         break;
  360. case RST_EXP: //fn_exp:{
  361.         TOS.d=exp(TOS.d);
  362.         break;
  363. case RST_LOG: //fn_log:{
  364.         TOS.d=log(TOS.d);
  365.         break;
  366. case RST_SQRT: //fn_sqrt:{
  367.         TOS.d=sqrt(TOS.d);
  368.         break;
  369. case RST_ABS: //fn_abs:{
  370.         TOS.d=abs(TOS.d);
  371.         break;
  372. case RST_ACOS: //fn_acos:{
  373.         TOS.d=acos(TOS.d);
  374.         break;
  375. case RST_ACOSH: //fn_acosh:{
  376.         TOS.d=acosh(TOS.d);
  377.         break;
  378. case RST_ASIN: //fn_asin:{
  379.         TOS.d=asin(TOS.d);
  380.         break;
  381. case RST_ASINH: //fn_asinh:{
  382.         TOS.d=asinh(TOS.d);
  383.         break;
  384. case RST_ATANH: //fn_atanh:{
  385.         TOS.d=atanh(TOS.d);
  386.         break;
  387. case RST_CBRT: //fn_cbrt:{
  388.         TOS.d=cbrt(TOS.d);
  389.         break;
  390. case RST_CEIL: //fn_ceil:{
  391.         TOS.d=ceil(TOS.d);
  392.         break;
  393. case RST_COSH: //fn_cosh:{
  394.         TOS.d=cosh(TOS.d);
  395.         break;
  396. case RST_HYPOT: //fn_hypot:{
  397.         par1 = POP.d;
  398.         TOS.d=hypot(TOS.d,par1);
  399.         break;
  400. case RST_ISFINITE: //fn_isfinite:{
  401.         TOS.i=(isfinite(TOS.d)?-1:0);
  402.         break;
  403. case RST_ISINF: //fn_isinf:{
  404.         TOS.i=(isinf(TOS.d)?-1:0);
  405.         break;
  406. case RST_ISNAN: //fn_isnan:{
  407.         TOS.i=(isnan(TOS.d)?-1:0);
  408.         break;
  409. case RST_J0: //fn_j0:{
  410.         //TOS.d=j0(TOS.d);
  411.         break;
  412. case RST_J1: //fn_j1:{
  413.         //TOS.d=j1(TOS.d);
  414.         break;
  415. case RST_JN: //fn_jn:{
  416.         par1 = POP.d;
  417.         //TOS.d=jn(static_cast<int>(TOS.i),par1);
  418.         break;
  419. case RST_LOG10: //fn_log10:{
  420.         TOS.d=log10(TOS.d);
  421.         break;
  422. case RST_LOG1P: //fn_log1p:{
  423.         TOS.d=log1p(TOS.d);
  424.         break;
  425. case RST_LOGB: //fn_logb:{
  426.         TOS.d=logb(TOS.d);
  427.         break;
  428. case RST_MAX: //fn_max:{
  429.         par1 = POP.d;
  430.         TOS.d=(TOS.d>par1?TOS.d:par1);
  431.         break;
  432. case RST_MIN: //fn_min:{
  433.         par1 = POP.d;
  434.         TOS.d=(TOS.d<par1?TOS.d:par1);
  435.         break;
  436. case RST_RINT: //fn_rint:{
  437.         TOS.d=rint(TOS.d);
  438.         break;
  439. case RST_SINH: //fn_sinh:{
  440.         TOS.d=sinh(TOS.d);
  441.         break;
  442. case RST_TAN: //fn_tan:{
  443.         TOS.d=tan(TOS.d);
  444.         break;
  445. case RST_TANH: //fn_tanh:{
  446.         TOS.d=tanh(TOS.d);
  447.         break;
  448. case RST_Y0: //fn_y0:{
  449.         //TOS.d=y0(TOS.d);
  450.         break;
  451. case RST_Y1: //fn_y1:{
  452.         //TOS.d=y1(TOS.d);
  453.         break;
  454. case RST_YN: //fn_yn:{
  455.         par1 = POP.d;
  456.         //TOS.d=yn(static_cast<int>(TOS.i),par1);
  457.         break;
  458. case RST_POW: //fn_pow:{
  459.         par1 = POP.d;
  460.         TOS.d=pow(TOS.d,par1);
  461.         break;
  462. case RST_PRINT: //fn_print:{
  463.         upar1 = POP.u;
  464.         myprintstr(prog, upar1);
  465.         break;
  466. default: ;
  467. }
  468.         DISPATCH;
  469.     }
  470. }
  471.  
  472. #ifndef FOR_DEBUGGER
  473. uint64_t *loadscript(int state_index, char *waspath) {
  474.     uint64_t *prog;
  475.     FILE *fileProg;
  476.  
  477.     stringstream strToInt;
  478.     string stateIndex;
  479.     string path = waspath;
  480.  
  481.     strToInt << state_index; // перевод из числа в строку
  482.     strToInt >> stateIndex; //
  483.  
  484.     path += stateIndex;
  485.     path += ".bin";
  486.  
  487.     int size;
  488.     fileProg = fopen(path.c_str(), "r");
  489.     if (fileProg) {
  490.         fseek(fileProg,0,SEEK_END);
  491.         size = ftell(fileProg);
  492.         fseek(fileProg,0,SEEK_SET);
  493.         prog = reinterpret_cast<uint64_t*>(malloc(size));
  494.         fread(prog, 1, size, fileProg);
  495.         fclose(fileProg);
  496.  
  497.     } else {
  498.         prog = reinterpret_cast<uint64_t*>(malloc(sizeof(uint64_t)));
  499.         prog[0] = CMD_DONE;
  500.     }
  501.     return prog;
  502. }
  503. #endif //FOR_DEBUGGER
  504.