?login_element?

Subversion Repositories NedoOS

Rev

Rev 497 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

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