?login_element?

Subversion Repositories NedoOS

Rev

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

  1. //// imported
  2. //тхчфх, уфх эєцхэ ёЄЁюъют√щ ярЁрьхЄЁ, шёяюы№чєхЄё  _joined (ъЁюьх call - Єрь _callee)
  3. #include "../_sdk/typecode.h"
  4. #include "../_sdk/str.h"
  5. #include "../_sdk/emit.h"
  6.  
  7. #ifdef TARGET_THUMB
  8. #include "sizesarm.h"
  9. #else
  10. #ifdef TARGET_SCRIPT
  11. #include "sizesspt.h"
  12. #else
  13. #include "sizesz80.h"
  14. #endif
  15. #endif
  16.  
  17. CONST BYTE _typeshift[32]; //log ЁрчьхЁ Єшяр (n фы  2^n срщЄ)
  18. CONST BYTE _typesz[32];
  19.  
  20. CONST BYTE _RMAIN; //ЁхушёЄЁ Ёхчєы№ЄрЄр ш 1-ую ярЁрьхЄЁр ёЄрэфрЁЄэ√ї ЇєэъЎшщ
  21. //#endif
  22.  
  23. EXPORT VAR TYPE _t; //Єхъє∙шщ Єшя (фы  cmds)
  24. EXPORT VAR BOOL _isloc; //ыюъры№эр  ыш яЁюўшЄрээр  яхЁхьхээр 
  25.  
  26. //EXTERN PCHAR _tword; //Єхъє∙хх ёыютю
  27. //EXTERN UINT _lentword;
  28. EXPORT VAR PCHAR _name; //ьхЄър схч яЁхЇшъёр (фы  ЄрсышЎ√ ьхЄюъ)
  29. EXPORT VAR UINT  _lenname;
  30. EXPORT VAR PCHAR _joined; //ртЄюьхЄър
  31. EXPORT VAR UINT  _lenjoined;
  32.  
  33. #ifdef TARGET_THUMB
  34. #include "codearm.c"
  35. #else
  36. #ifdef TARGET_SCRIPT
  37. #include "codespt.c"
  38. #else
  39. #include "codez80.c"
  40. #endif
  41. #endif
  42.  
  43. #include "regs.c"
  44.  
  45. ////
  46.  
  47. VAR PCHAR _const; //ёЄрЁр  ъюэёЄрэЄр
  48. VAR UINT  _lenconst;
  49. //VAR PCHAR _wastword; //ёЄрЁр  ъюэёЄрэЄр
  50. //VAR UINT  _lenwastword;
  51. VAR BOOL _wasconst;
  52. VAR CHAR  _sc[_STRLEN]; //ёЄрЁр  ъюэёЄрэЄр
  53. //VAR CHAR  _sw[_STRLEN]; //ёЄрЁ√щ tword
  54. VAR TYPE _wast;
  55.  
  56. VAR BYTE _sz; //тЁхьхээю ЁрчьхЁ Єшяр - шёяюы№чєхЄё  т Ёрчэ√ї яЁюЎхфєЁрї
  57.  
  58. #define _STRSTKMAX 256
  59. VAR CHAR _strstk[_STRSTKMAX]; //str1+<len>+str2+<len>...+strN+<len> //с√ыю ' '+str1+' '+str2+...+' '+strN
  60. EXPORT VAR UINT _lenstrstk;
  61.  
  62. #ifdef BIGMEM
  63. #define _LBLBUFSZ 0xffff
  64. #else
  65. #define _LBLBUFSZ 0x2300 /**0x2100*/
  66. #endif
  67. VAR UINT _lblbuffreeidx; //[1];
  68. VAR UINT _oldlblbuffreeidx; //[1];
  69. CONST UINT _LBLBUFEOF = 0xffff;
  70. #define _LBLBUFMAXSHIFT (UINT)(_LBLBUFSZ-_STRLEN-20)
  71. //todo фшэрьшўхёъш т√фхышЄ№
  72. VAR UINT _lblshift[0x100];
  73. VAR UINT _oldlblshift[0x100];
  74. VAR BYTE _lbls[_LBLBUFSZ];
  75. VAR BYTE _lblhash;
  76.  
  77. EXPORT VAR UINT _typeaddr;
  78. EXPORT VAR UINT _varszaddr;
  79. EXPORT VAR UINT _varsz;
  80.  
  81. PROC cmdshl1 FORWARD();
  82.  
  83. PROC errtype(PCHAR msg, TYPE t)
  84. {
  85.   errstr("operation "); errstr(msg); errstr(" bad type="); erruint(+(UINT)t); enderr();
  86. }
  87.  
  88. EXPORT PROC strpush(PCHAR s, UINT len) //joined шыш callee
  89. { //str1+<len>+str2+<len>...+strN+<len> (ё ЄхЁьшэрЄюЁрьш)
  90.   IF ((_lenstrstk+len+2) > _STRSTKMAX) {
  91.     errstr("STRING STACK OVERFLOW"); enderr();
  92.   }ELSE {
  93.     strcopy(s, len, &_strstk[_lenstrstk]);
  94.     _lenstrstk = _lenstrstk + len + 1;
  95.     _strstk[_lenstrstk] = +(CHAR)(+(BYTE)len);
  96.     INC _lenstrstk;
  97.   };
  98. }
  99.  
  100. EXPORT FUNC UINT strpop(PCHAR s)
  101. { //str1+<len>+str2+<len>...+strN+<len> (ё ЄхЁьшэрЄюЁрьш)
  102. VAR UINT len;
  103.   DEC _lenstrstk;
  104.   len = +(UINT)(+(BYTE)(_strstk[_lenstrstk]));
  105.   _lenstrstk = _lenstrstk - len - 1;
  106.   strcopy((PCHAR)(&_strstk[_lenstrstk]), len, s);
  107. RETURN len;
  108. }
  109.  
  110. EXPORT PROC initlblbuf()
  111. {
  112.   _lblhash = 0x00;
  113.   REPEAT {
  114.     _lblshift[_lblhash] = _LBLBUFEOF;
  115.     INC _lblhash;
  116.   }UNTIL (_lblhash == 0x00);
  117.   _lblbuffreeidx = 0;
  118. };
  119.  
  120. EXPORT FUNC UINT gettypename(PCHAR s) //тч Є№ эрчтрэшх Єшяр ёЄЁєъЄєЁ√ т joined (ёЁрчє яюёых lbltype)
  121. {
  122. RETURN strcopy((PCHAR)&_lbls[_typeaddr], (UINT)*(PBYTE)&_lbls[_typeaddr-1], s);
  123. }
  124.  
  125. EXPORT PROC setvarsz(UINT addr, UINT shift)
  126. {
  127.   POKE *(PUINT)(&_lbls[addr]) = shift;
  128. }
  129.  
  130. EXPORT FUNC TYPE lbltype() //тхЁэєЄ№ Єшя ьхЄъш _name ш _typeaddr
  131. {
  132. VAR PBYTE plbl; //ьхЄър т ЄрсышЎх чрърэўштрхЄё  эєы╕ь
  133. VAR TYPE t;
  134. VAR UINT plbl_idx;
  135.   t = _T_UNKNOWN;
  136.   _lblhash = +(BYTE)hash((PBYTE)_name);
  137.   plbl_idx = _lblshift[_lblhash];
  138.   WHILE (plbl_idx != _LBLBUFEOF) { //яюър Ўхяюўър ьхЄюъ эх чръюэўшырё№
  139.     plbl = &_lbls[plbl_idx];
  140.     plbl_idx = *(PUINT)(plbl);
  141.     plbl = &plbl[+sizeof(UINT)+1]; //skip string size
  142.     IF (strcp((PCHAR)_name, (PCHAR)plbl)) { //ьхЄър эрщфхэр
  143.       _typeaddr = (UINT)(plbl - _lbls); //фы  чряюьшэрэш  Єшяр т сєфє∙хщ яхЁхьхээющ
  144.       plbl = &plbl[_lenname+1];
  145.       t = *(TYPE*)(plbl);
  146.       plbl = &plbl[+sizeof(TYPE)]; //INC plbl;
  147.       _isloc = (BOOL)*(PBYTE)(plbl);
  148.       INC plbl;
  149.       IF ((t&_T_TYPE)==(TYPE)0x00) _typeaddr = *(PUINT)(plbl); //тёяюьшэрхь рфЁхё Єшяр, хёыш ¤Єю яхЁхьхээр , р эх юс· тыхэшх Єшяр
  150.       plbl = &plbl[+sizeof(UINT)];
  151.       _varsz = *(PUINT)(plbl);
  152.       break;
  153.     };
  154.   };
  155. RETURN t;
  156. }
  157.  
  158. EXPORT PROC dellbl() //фы  undef
  159. {
  160. VAR PBYTE plbl; //ьхЄър т ЄрсышЎх чрърэўштрхЄё  эєы╕ь
  161. VAR UINT plbl_idx;
  162.   _lblhash = +(BYTE)hash((PBYTE)_name);
  163.   plbl_idx = _lblshift[_lblhash];
  164.   WHILE (plbl_idx != _LBLBUFEOF) { //яюър Ўхяюўър ьхЄюъ эх чръюэўшырё№
  165.     plbl = &_lbls[plbl_idx];
  166.     plbl_idx = *(PUINT)(plbl);
  167.     plbl = &plbl[+sizeof(UINT)+1]; //skip string size
  168.     IF (strcp((PCHAR)_name, (PCHAR)plbl)) { //ьхЄър эрщфхэр
  169.       POKE *(PCHAR)(plbl) = '\0';
  170.       break;
  171.     };
  172.   };
  173. }
  174.  
  175. EXPORT PROC addlbl(TYPE t, BOOL isloc, UINT varsz/**, PCHAR size, UINT lensize*/) //(_name)
  176. {
  177. VAR PBYTE plbl;
  178. VAR UINT freeidx;
  179. VAR TYPE oldt;
  180.   oldt = lbltype(); //(_name) //єёЄрэртыштрхЄ _isloc (хёыш эрщфхэр) ш _typeaddr (рфЁхё, хёыш эрщфхэр)
  181.   IF ((oldt == _T_UNKNOWN)||isloc/**(isloc&&!_isloc)*/) { //хёыш эх с√ыю ьхЄъш шыш ыюъры№эр  яютхЁї уыюсры№эющ шыш фЁєующ ыюъры№эющ (ярЁрьхЄЁр)
  182.     //ьхЄъш эхЄ: яш°хь т эрўрыю Ўхяюўъш рфЁхё ъюэЎр ёЄЁрэшЎ√ ш ёючфр╕ь ьхЄъє Єрь ёю ёё√ыъющ эр ёЄрЁюх эрўрыю Ўхяюўъш
  183.     freeidx = _lblbuffreeidx; //[0] //эрўрыю ётюсюфэюую ьхёЄр
  184.     IF (freeidx < _LBLBUFMAXSHIFT) { //хёЄ№ ьхёЄю яюф ьхЄъє
  185.       plbl = &_lbls[freeidx]; //єърчрЄхы№ эр эрўрыю ёючфртрхьющ ьхЄъш
  186.       //яш°хь ьхЄъє
  187.       POKE *(PUINT)(plbl) = _lblshift[_lblhash]; //ёЄрЁ√щ єърчрЄхы№ эр эрўрыю Ўхяюўъш
  188.       plbl = &plbl[+sizeof(UINT)];
  189.       POKE *(PBYTE)(plbl) = (BYTE)_lenname;
  190.       INC plbl;
  191.       strcopy(_name, _lenname, (PCHAR)plbl);
  192.       plbl = &plbl[_lenname+1];
  193.       POKE *(TYPE*)(plbl) = t;
  194.       plbl = &plbl[+sizeof(TYPE)]; //INC plbl;
  195.       POKE *(PBYTE)(plbl) = (BYTE)isloc;
  196.       INC plbl;
  197.       POKE *(PUINT)(plbl) = _typeaddr; //ёё√ыър эр эрчтрэшх Єшяр (фы  ёЄЁєъЄєЁ√)
  198.       plbl = &plbl[+sizeof(UINT)];
  199.       _varszaddr = (UINT)(plbl - _lbls); //ўЄюс√ яюЄюь ьюцэю с√ыю ьхэ Є№
  200.       POKE *(PUINT)(plbl) = varsz;
  201.       _lblbuffreeidx = +(UINT)(plbl - _lbls) + +sizeof(UINT); //єърчрЄхы№ ъюэхЎ ёючфртрхьющ ьхЄъш
  202.       _lblshift[_lblhash] = freeidx; //эют√щ єърчрЄхы№ эр эрўрыю Ўхяюўъш
  203.     }ELSE {errstr("nomem"); enderr();
  204.     };
  205.   }ELSE IF (oldt != t) {
  206.     errstr("addvar type doesn't match previous declaration:"); errstr(_name); enderr();
  207.   };
  208. }
  209.  
  210. //#define _LBLBUFSZ (UINT)(+sizeof(UINT)*0x100) /**эхы№ч  sizeof т рёьх*/
  211. EXPORT PROC keepvars() //яхЁхф эрўрыюь ыюъры№э√ї ьхЄюъ
  212. {
  213.   memcopy((PBYTE)_lblshift, +sizeof(UINT)*0x100 /**todo const*/, (PBYTE)_oldlblshift);
  214.   _oldlblbuffreeidx = _lblbuffreeidx;
  215. }
  216.  
  217. EXPORT PROC undovars() //яюёых ыюъры№э√ї ьхЄюъ (чрс√Є№ шї)
  218. {
  219.   memcopy((PBYTE)_oldlblshift, +sizeof(UINT)*0x100 /**todo const*/, (PBYTE)_lblshift);
  220.   _lblbuffreeidx = _oldlblbuffreeidx;
  221. }
  222.  
  223. //////////////////////////////// MATH ///////////////////////////////////////
  224. //яЁюЎхфєЁ√ эх чэр■Є ш эх ЄЁюур■Є Ёхцшь√ ЁхушёЄЁют
  225.  
  226. EXPORT PROC var_alignwsz_label(TYPE t)
  227. {
  228.   IF (_typesz[t&_TYPEMASK]!=_SZ_BYTE) {
  229.     var_alignwsz();
  230.   };
  231.   emitvarlabel(_joined);
  232. }
  233.  
  234. EXPORT PROC var_def(TYPE t, PCHAR s) //фюёЄєяэю шч compile!
  235. {
  236. VAR BYTE sz = _typesz[t];
  237.   IF (sz==_SZ_REG/**(tmasked==_T_INT)||(tmasked==_T_UINT)*/) {
  238.     var_dw(); varstr(s); endvar(); //°шЁшэр DW Ёртэр uint
  239.   }ELSE IF (sz==_SZ_BYTE/**(tmasked==_T_BYTE)||(tmasked==_T_CHAR)||(tmasked==_T_BOOL)*/) {
  240.     var_db(); varstr(s); endvar();
  241.   }ELSE IF (sz==_SZ_LONG/**tmasked==_T_LONG*/) {
  242.     var_dl(); varstr(s); endvar();
  243.   }ELSE { errstr( "const bad type " ); erruint(+(UINT)t); enderr(); };
  244. }
  245.  
  246. PROC pushconst() //ёюїЁрэ хЄ ўшёыю, ъюЄюЁюх эх ёюїЁрэшыш яЁш pushnum
  247. { //эхы№ч  чрЄшЁрЄ№ joined
  248. #ifdef USE_COMMENTS
  249. ;;  cmtstr( ";PUSHCONST " ); cmtstr( _const ); endcmt();
  250. #endif
  251.   //_lenwastword = strcopy(_joined, _lenjoined, _wastword);
  252.   //_lenjoined = strcopy(_const, _lenconst, _joined);
  253.   _sz = _typesz[_wast];
  254.   IF (_sz==_SZ_BYTE) { //(_wast==_T_BYTE)||(_wast==_T_CHAR)||(_wast==_T_BOOL)
  255.     getrfree(); //_rnew
  256.     emitloadb();
  257.   }ELSE IF (_sz==_SZ_REG) { //(_wast==_T_INT)||(_wast==_T_UINT)||(_wast>=_T_POI)
  258.     getrfree(); //_rnew
  259.     emitloadrg(+FALSE);
  260.   }ELSE IF (_sz==_SZ_LONG) { //_wast==_T_LONG
  261.     getrfree(); //_rnew
  262.     emitloadrg(+TRUE); //high
  263.     getrfree(); //_rnew
  264.     emitloadrg(+FALSE); //low
  265.   }ELSE errtype("pushconst",_wast);
  266.   //_lenjoined = strcopy(_wastword, _lenwastword, _joined);
  267.   _wasconst = +FALSE;
  268. }
  269.  
  270. EXPORT PROC cmdpushnum()
  271. {
  272. #ifdef USE_COMMENTS
  273. ;;  cmtstr(";PUSHNUM "); cmtstr(_joined); endcmt();
  274. #endif
  275.   IF (_wasconst) pushconst();
  276.   _lenconst = strcopy(_joined, _lenjoined, _const);
  277.   _wast = _t;
  278.   _wasconst = +TRUE;
  279. }
  280.  
  281. EXPORT PROC cmdpushvar()
  282. {
  283. #ifdef USE_COMMENTS
  284. ;;  cmtstr(";PUSHVAR "); cmtstr(_joined); endcmt();
  285. #endif
  286.   IF (_wasconst) pushconst();
  287.   _sz = _typesz[_t];
  288.   IF (_sz==_SZ_BYTE/**(_t==_T_BYTE)||(_t==_T_CHAR)||(_t==_T_BOOL)*/) {
  289.     getrfree(); //_rnew
  290.     emitgetb();
  291.   }ELSE IF (_sz==_SZ_REG/**(_t==_T_INT)||(_t==_T_UINT)||(_t>=_T_POI)*/) {
  292.     getrfree(); //_rnew
  293.     emitgetrg(+FALSE);
  294.   }ELSE IF (_sz==_SZ_LONG/**_t==_T_LONG*/) {
  295.     getrfree(); //_rnew
  296.     emitgetrg(+TRUE); //high
  297.     getrfree(); //_rnew
  298.     emitgetrg(+FALSE); //low
  299.   }ELSE errtype("pushvar",_t);
  300. }
  301.  
  302. EXPORT PROC cmdpopvar()
  303. {
  304. #ifdef USE_COMMENTS
  305. ;;  cmtstr(";POPVAR "); cmtstr(_joined); endcmt();
  306. #endif
  307.   IF (_wasconst) pushconst();
  308.   _sz = _typesz[_t];
  309.   IF (_sz==_SZ_BYTE/**(_t==_T_BYTE)||(_t==_T_CHAR)||(_t==_T_BOOL)*/) {
  310.     getrnew();
  311.     emitputb();
  312.     freernew();
  313.   }ELSE IF (_sz==_SZ_REG/**(_t==_T_INT)||(_t==_T_UINT)||(_t>=_T_POI)*/) {
  314.     getrnew();
  315.     emitputrg(+FALSE);
  316.     freernew();
  317.   }ELSE IF (_sz==_SZ_LONG/**_t==_T_LONG*/) {
  318.     getrnew();
  319.     emitputrg(+FALSE); //low
  320.     freernew();
  321.     getrnew();
  322.     emitputrg(+TRUE); //high
  323.     freernew();
  324.   }ELSE errtype("popvar",_t);
  325. }
  326.  
  327. EXPORT PROC cmdcastto(TYPE t2)
  328. {
  329. VAR BYTE tsz;
  330. VAR BYTE t2sz;
  331. #ifdef USE_COMMENTS
  332. ;;  cmtstr(";OPERATION cast "); cmtuint(+(UINT)_t); cmt('>'); cmtuint(+(UINT)t2); endcmt();
  333. #endif
  334.   tsz = _typesz[_t];
  335.   t2sz = _typesz[t2];
  336. #ifdef TARGET_SCRIPT
  337.   IF (_t == t2) {
  338.   }ELSE IF (t2==_T_FLOAT) {
  339.     IF (_wasconst) pushconst(); //эх яюЁЄшь ъюэёЄрэЄє яЁш BYTE<=>CHAR
  340.     IF (_t==_T_INT) {emitinttofloat(); //(FLOAT)intval - эхёютьхёЄшью ё C!
  341.     }ELSE {goto bad;
  342.     };
  343.   }ELSE IF (_t==_T_FLOAT) {
  344.     IF (_wasconst) pushconst(); //эх яюЁЄшь ъюэёЄрэЄє яЁш BYTE<=>CHAR
  345.     IF (t2==_T_INT) {emitfloattoint(); //(INT)floatval - эхёютьхёЄшью ё C!
  346.     }ELSE {goto bad;
  347.     };
  348.   }ELSE
  349. #endif
  350.   IF (tsz==t2sz/**_t == t2*/) { //Єшя√ юфэюую ЁрчьхЁр - эх яюЁЄшь ъюэёЄрэЄє
  351.     //todo badcast LONG<=>FLOAT
  352.   }ELSE {
  353.     IF (_wasconst) pushconst(); //эх яюЁЄшь ъюэёЄрэЄє яЁш BYTE<=>CHAR
  354.     IF (tsz==_SZ_BYTE/**_t==_T_BYTE*/) { //BYTE =>
  355.       IF (t2sz==_SZ_REG/**(t2==_T_INT)||(t2==_T_UINT)*/) { //BYTE => INT|UINT
  356.         getrnew();
  357.         emitbtorg();
  358.       }ELSE /**IF (t2sz==_SZ_LONG)*/ { //BYTE => LONG
  359.         getrnew();
  360.         emitbtorg();
  361.         getrfree(); //_rnew
  362.         emitloadrg0(); //ЄхяхЁ№ old = rg, new = 0
  363.         swaptop(); //ЄхяхЁ№ old = 0, new = rg
  364.       //}ELSE IF (t2==_T_CHAR) { //BYTE => CHAR
  365.       //}ELSE IF (t2==_T_BOOL) { //BYTE => BOOL (for serialization)
  366.       };//ELSE goto bad;
  367.     }ELSE IF (tsz==_SZ_REG/**(_t==_T_INT)||(_t==_T_UINT)*/) {
  368.       IF (t2sz==_SZ_BYTE/**t2==_T_BYTE*/) { //INT|UINT => BYTE
  369.         getrnew();
  370.         emitrgtob();
  371.       }ELSE /**IF (t2sz==_SZ_LONG)*/ { //INT|UINT => LONG
  372.         getrfree(); //_rnew
  373.         //IF (_t==_T_UINT) { //UINT => LONG
  374.           emitloadrg0(); //ЄхяхЁ№ old = rg, new = 0
  375.         //}ELSE IF (_t==_T_UINT) { //INT => LONG
  376.         //};
  377.         swaptop(); //ЄхяхЁ№ old = 0, new = rg
  378.       //}ELSE IF (t2>=_T_POI) { //UINT => POINTER (INT possible but not desirable)
  379.       };//ELSE goto bad;
  380.     }ELSE IF (tsz==_SZ_LONG) { //LONG =>
  381.       IF (t2sz==_SZ_REG/**(t2==_T_INT)||(t2==_T_UINT)*/) { //LONG => INT|UINT
  382.         swaptop(); //ЄхяхЁ№ old = low, new = high
  383.         freernew(); //high
  384.       }ELSE /**IF (t2sz==_SZ_BYTE)*/ { //LONG => BYTE
  385.         swaptop(); //ЄхяхЁ№ old = low, new = high
  386.         freernew(); //high
  387.         getrnew();
  388.         emitrgtob();
  389. /**      }ELSE { //LONG<=>FLOAT
  390.         goto bad;
  391.         errstr("bad cast: "); erruint(+(UINT)_t); err('>'); erruint(+(UINT)t2); enderr();*/
  392.       };
  393.     //}ELSE IF ( (_t==_T_CHAR) && (t2==_T_BYTE) ) { //CHAR => BYTE
  394.     //}ELSE IF ( (_t==_T_BOOL) && (t2==_T_BYTE) ) { //BOOL => BYTE (for serialization)
  395.     //}ELSE IF ( (_t>=_T_POI) && ((t2==_T_UINT)||(t2>=_T_POI)) ) { //POINTER => UINT|POINTER (conversion between pointers)
  396.     //}ELSE IF ((t2&_T_POI)!=0x00) { // anything (i.e. array) => POINTER
  397.     }ELSE { //яю шфхх эшъюуфр эх яЁюшчющф╕Є
  398.       bad:
  399.       errstr("bad cast: "); erruint(+(UINT)_t); err('>'); erruint(+(UINT)t2); enderr();
  400.     };
  401.   };
  402.   _t = t2;
  403. }
  404.  
  405. EXPORT PROC cmdadd()
  406. {
  407. #ifdef USE_COMMENTS
  408. ;;  cmtstr(";OPERATION +"); endcmt();
  409. #endif
  410.   IF (_t==_T_BYTE) {
  411.     IF (_wasconst) {
  412.       getrnew();
  413.       emitaddbconst();
  414.       _wasconst = +FALSE;
  415.     }ELSE {
  416.       getrnew();
  417.       getrold();
  418.       emitaddb();
  419.       freernew();
  420.     };
  421.   }ELSE {
  422.     IF (_wasconst) pushconst();
  423. #ifdef TARGET_SCRIPT
  424.     IF (_t==_T_FLOAT) {emitaddfloat();
  425.     }ELSE
  426. #endif
  427.     IF (_typesz[_t]==_SZ_REG/**(_t==_T_INT)||(_t==_T_UINT)||(_t>=_T_POI)*/) {
  428.       getrold(); //схЁ╕ь Ёрэ№°х, ўЄюс√ яюыєўшЄ№ с√ёЄЁ√щ ЁхушёЄЁ
  429.       getrnew();
  430.       emitaddrg(); //rold+rnew => rold
  431.       freernew();
  432.     }ELSE IF (_t==_T_LONG) { //эх float
  433.       getrold2(); //oldlow //схЁ╕ь Ёрэ№°х, ўЄюс√ яюыєўшЄ№ с√ёЄЁ√щ ЁхушёЄЁ
  434.       getrnew(); //newlow
  435.       emitaddrg(); //old2+new => old2
  436.       freernew();
  437.       //ЄхяхЁ№ new=newhigh, old=(oldlow+newlow)
  438.       getrold2(); //oldhigh шч ёЄхър //схЁ╕ь Ёрэ№°х, ўЄюс√ яюыєўшЄ№ с√ёЄЁ√щ ЁхушёЄЁ
  439.       getrnew(); //newhigh
  440.       emitadcrg(); //old2+new+CY => old2
  441.       freernew();
  442.       //ЄхяхЁ№ new=(oldlow+newlow), old=(oldhigh+newhigh+CY)
  443.     }ELSE errtype("+",_t);
  444.   };
  445. }
  446.  
  447. EXPORT PROC cmdsub() //шч ёЄрЁюую т√ўхёЄ№ эютюх!
  448. {
  449. #ifdef USE_COMMENTS
  450. ;;  cmtstr( ";OPERATION -" ); endcmt();
  451. #endif
  452.   IF (_t==_T_BYTE) {
  453.     IF (_wasconst) {
  454.       getrnew();
  455.       emitsubbconst();
  456.       _wasconst = +FALSE;
  457.     }ELSE {
  458.       getrnew();
  459.       getrold();
  460.       emitsubb();
  461.       freernew();
  462.     };
  463.   }ELSE {
  464.     IF (_wasconst) pushconst();
  465. #ifdef TARGET_SCRIPT
  466.     IF (_t==_T_FLOAT) {emitsubfloat();
  467.     }ELSE
  468. #endif
  469.     IF (_typesz[_t]==_SZ_REG/**(_t==_T_INT)||(_t==_T_UINT)||(_t>=_T_POI)*/) {
  470.       getrold(); //схЁ╕ь Ёрэ№°х, ўЄюс√ яюыєўшЄ№ с√ёЄЁ√щ ЁхушёЄЁ
  471.       getrnew();
  472.       emitsubrg(); //rold-rnew => rold
  473.       freernew();
  474.       //IF(_t>=_T_POI) {t = _T_INT;};
  475.     }ELSE IF (_t==_T_LONG) { //эх float
  476.       getrold2(); //oldlow //схЁ╕ь Ёрэ№°х, ўЄюс√ яюыєўшЄ№ с√ёЄЁ√щ ЁхушёЄЁ
  477.       getrnew(); //newlow
  478.       emitsubrg(); //old2-new => old2
  479.       freernew();
  480.       //ЄхяхЁ№ new=newhigh, old=(oldlow-newlow)
  481.       getrold2(); //oldhigh шч ёЄхър //схЁ╕ь Ёрэ№°х, ўЄюс√ яюыєўшЄ№ с√ёЄЁ√щ ЁхушёЄЁ
  482.       getrnew(); //newhigh
  483.       emitsbcrg(); //old2-new-CY => old2
  484.       freernew();
  485.       //ЄхяхЁ№ new=(oldlow-newlow), old=(oldhigh-newhigh-CY)
  486.     }ELSE errtype("-",_t);
  487.   };
  488. }
  489.  
  490. EXPORT PROC cmdaddpoi() //_t ёюфхЁцшЄ Єшя  ўхщъш ьрёёштр
  491. {
  492. VAR BYTE i;
  493. #ifdef USE_COMMENTS
  494. ;;  cmtstr(";OPERATION +poi"); endcmt();
  495. #endif
  496.   IF (_wasconst) pushconst();
  497. /**  i = _typeshift[_t&_TYPEMASK];
  498.   WHILE (i != 0x00) {
  499.     _t = _T_INT;
  500.     cmdshl1();
  501.     DEC i;
  502.   };*/
  503.   getrold(); //схЁ╕ь Ёрэ№°х, ўЄюс√ яюыєўшЄ№ с√ёЄЁ√щ ЁхушёЄЁ
  504.   getrnew();
  505.   i = _typesz[_t&_TYPEMASK];
  506.   WHILE (i != 0x00) {
  507.     emitaddrg(); //rold+rnew => rold
  508.     DEC i;
  509.   };
  510.   freernew();
  511. }
  512.  
  513. EXPORT PROC cmdmul()
  514. {
  515. #ifdef USE_COMMENTS
  516. ;;  cmtstr( ";OPERATION *" ); endcmt();
  517. #endif
  518.   IF (_wasconst) pushconst();
  519. #ifdef TARGET_SCRIPT
  520.   IF (_t==_T_BYTE) {emitmulbyte();
  521.   }ELSE IF ( (_t==_T_UINT)||(_t==_T_INT) ) {emitmuluint();
  522.   }ELSE IF (_t==_T_LONG) {emitmullong();
  523.   }ELSE IF (_t==_T_FLOAT) {emitmulfloat();
  524. #else
  525.   IF (_t==_T_BYTE) {emitcall2rgs("_MULB.");
  526.   }ELSE IF (_t==_T_UINT) {emitcall2rgs("_MUL.");
  527.   }ELSE IF (_t==_T_INT) {emitcall2rgs("_MULSIGNED.");
  528.   }ELSE IF (_t==_T_LONG) {emitcall4rgs("_MULLONG.");
  529. #endif
  530.   }ELSE errtype("*",_t);
  531. }
  532.  
  533. EXPORT PROC cmddiv() //ёЄрЁюх ЁрчфхышЄ№ эр эютюх!
  534. {
  535. #ifdef USE_COMMENTS
  536. ;;  cmtstr(";OPERATION /"); endcmt();
  537. #endif
  538.   IF (_wasconst) pushconst();
  539. #ifdef TARGET_SCRIPT
  540.   IF (_t==_T_BYTE) {emitdivbyte();
  541.   }ELSE IF (_t==_T_UINT) {emitdivuint();
  542.   }ELSE IF (_t==_T_INT) {emitdivint();
  543.   }ELSE IF (_t==_T_LONG) {emitdivlong();
  544.   }ELSE IF (_t==_T_FLOAT) {emitdivfloat();
  545. #else
  546.   IF (_t==_T_BYTE) {emitcall2rgs("_DIVB.");
  547.   }ELSE IF (_t==_T_UINT) {emitcall2rgs("_DIV.");
  548.   }ELSE IF (_t==_T_INT) {emitcall2rgs("_DIVSIGNED.");
  549.   }ELSE IF (_t==_T_LONG) {emitcall4rgs("_DIVLONG.");
  550. #endif
  551.   }ELSE errtype("/",_t);
  552. }
  553.  
  554. EXPORT PROC cmdshl() //ёЄрЁюх ёфтшэєЄ№ ёЄюы№ъю Ёрч, ёъюы№ъю уырёшЄ эютюх!
  555. {
  556. #ifdef USE_COMMENTS
  557. ;;  cmtstr( ";OPERATION shl" ); endcmt();
  558. #endif
  559.   IF (_wasconst) pushconst();
  560. #ifdef TARGET_SCRIPT
  561.   IF (_t==_T_BYTE) {emitshlbyte();
  562.   }ELSE IF ( (_t==_T_UINT)||(_t==_T_INT) ) {emitshluint();
  563.   }ELSE IF (_t==_T_LONG) {emitshllong();
  564. #else
  565.   IF (_t==_T_BYTE) {emitcall2rgs("_SHLB.");
  566.   }ELSE IF ( (_t==_T_INT)||(_t==_T_UINT) ) {emitcall2rgs("_SHL.");
  567.   }ELSE IF (_t==_T_LONG) {emitcall4rgs("_SHLLONG.");
  568. #endif
  569.   }ELSE errtype("<<",_t);
  570. }
  571.  
  572. EXPORT PROC cmdshr() //ёЄрЁюх ёфтшэєЄ№ ёЄюы№ъю Ёрч, ёъюы№ъю уырёшЄ эютюх!
  573. {
  574. #ifdef USE_COMMENTS
  575. ;;  cmtstr( ";OPERATION shr" ); endcmt();
  576. #endif
  577.   IF (_wasconst) pushconst();
  578. #ifdef TARGET_SCRIPT
  579.   IF (_t==_T_BYTE) {emitshrbyte();
  580.   }ELSE IF (_t==_T_UINT) {emitshruint();
  581.   }ELSE IF (_t==_T_INT) {emitshrint();
  582.   }ELSE IF (_t==_T_LONG) {emitshrlong();
  583. #else
  584.   IF (_t==_T_BYTE) {emitcall2rgs("_SHRB.");
  585.   }ELSE IF (_t==_T_UINT) {emitcall2rgs("_SHR.");
  586.   }ELSE IF (_t==_T_INT) {emitcall2rgs("_SHRSIGNED.");
  587.   }ELSE IF (_t==_T_LONG) {emitcall4rgs("_SHRLONG.");
  588. #endif
  589.   }ELSE errtype(">>",_t);
  590. }
  591.  
  592. EXPORT PROC cmdshl1()
  593. {
  594. #ifdef USE_COMMENTS
  595. ;;  cmtstr( ";SHL1" ); endcmt();
  596. #endif
  597.   IF (_wasconst) pushconst();
  598.   IF (_t==_T_BYTE) {
  599.     getrnew();
  600.     emitshl1b();
  601.   }ELSE IF ( (_t==_T_INT)||(_t==_T_UINT) ) {
  602.     getrnew();
  603.     emitshl1rg();
  604.   //}ELSE IF (_t==_T_LONG) { //todo
  605.   }ELSE errtype("shl1",_t);
  606. }
  607. /**
  608. EXPORT PROC cmdshr1()
  609. {
  610. #ifdef USE_COMMENTS
  611. ;;  cmtstr( ";SHR1" ); endcmt();
  612. #endif
  613.   IF (_wasconst) pushconst();
  614.   IF ( (_t==_T_BYTE)||(_t==_T_CHAR) ) {emitshr1rgb(getrnew());
  615.   }ELSE IF (_t==_T_INT) {emitshr1signedrg(getrnew());
  616.   }ELSE IF (_t==_T_UINT) {emitshr1rg(getrnew());
  617.   }ELSE errtype("shr1",_t);
  618. }
  619. */
  620. EXPORT PROC cmdand()
  621. {
  622. #ifdef USE_COMMENTS
  623. ;;  cmtstr( ";OPERATION &" ); endcmt();
  624. #endif
  625.   IF (_wasconst) pushconst();
  626.   _sz = _typesz[_t];
  627.   IF (_sz==_SZ_BYTE) {
  628.     getrnew();
  629.     getrold();
  630.     getandb();
  631.     freernew();
  632.   }ELSE IF (_sz==_SZ_REG) {
  633.     getrnew();
  634.     getrold();
  635.     emitandrg();
  636.     freernew();
  637.   }ELSE /**IF (_sz==_SZ_LONG)*/ {
  638.     getrnew();
  639.     getrold2();
  640.     emitandrg(); //low
  641.     freernew();
  642.     getrnew();
  643.     getrold2();
  644.     emitandrg(); //high
  645.     freernew();
  646.   };//ELSE errtype("&",_t);
  647. }
  648.  
  649. EXPORT PROC cmdor()
  650. {
  651. #ifdef USE_COMMENTS
  652. ;;  cmtstr( ";OPERATION |" ); endcmt();
  653. #endif
  654.   IF (_wasconst) pushconst();
  655.   _sz = _typesz[_t];
  656.   IF (_sz==_SZ_BYTE) {
  657.     getrnew();
  658.     getrold();
  659.     getorb();
  660.     freernew();
  661.   }ELSE IF (_sz==_SZ_REG) {
  662.     getrnew();
  663.     getrold();
  664.     emitorrg();
  665.     freernew();
  666.   }ELSE /**IF (_sz==_SZ_LONG)*/ {
  667.     getrnew();
  668.     getrold2();
  669.     emitorrg(); //low
  670.     freernew();
  671.     getrnew();
  672.     getrold2();
  673.     emitorrg(); //high
  674.     freernew();
  675.   };//ELSE errtype("|",_t);
  676. }
  677.  
  678. EXPORT PROC cmdxor()
  679. {
  680. #ifdef USE_COMMENTS
  681. ;;  cmtstr( ";OPERATION ^" ); endcmt();
  682. #endif
  683.   IF (_wasconst) pushconst();
  684.   _sz = _typesz[_t];
  685.   IF (_sz==_SZ_BYTE) {
  686.     getrnew();
  687.     getrold();
  688.     getxorb();
  689.     freernew();
  690.   }ELSE IF (_sz==_SZ_REG) {
  691.     getrnew();
  692.     getrold();
  693.     emitxorrg();
  694.     freernew();
  695.   }ELSE /**IF (_sz==_SZ_LONG)*/ {
  696.     getrnew();
  697.     getrold2();
  698.     emitxorrg(); //low
  699.     freernew();
  700.     getrnew();
  701.     getrold2();
  702.     emitxorrg(); //high
  703.     freernew();
  704.   };//ELSE errtype("^",_t);
  705. }
  706.  
  707. EXPORT PROC cmdpoke() //эютюх чряшё√трхь т ёЄрЁє■ ыюърЎш■ ярь Єш
  708. { //_t = Єшя фрээ√ї яюф єърчрЄхыхь
  709. #ifdef USE_COMMENTS
  710. ;;  cmtstr(";POKE"); endcmt();
  711. #endif
  712.   IF (_wasconst) pushconst();
  713.   _sz = _typesz[_t];
  714.   IF (_sz==_SZ_BYTE/**(_t==_T_BYTE)||(_t==_T_CHAR)||(_t==_T_BOOL)*/) {
  715.     getrnew();
  716.     getrold();
  717.     emitpokeb();
  718.     freernew();
  719.     freernew();
  720.   }ELSE IF (_sz==_SZ_REG/**(_t==_T_INT)||(_t==_T_UINT)||(_t>=_T_POI)*/) {
  721.     getrnew();
  722.     getrold();
  723.     emitpokerg();
  724.     freernew();
  725.     freernew();
  726.   }ELSE /**IF (_sz==_SZ_LONG)*/ {
  727.     getrnew();
  728.     getrold2(); _rold2 = _rold;
  729.     getrold();
  730.     emitpokelong();
  731.     freernew();
  732.     freernew();
  733.     freernew();
  734.   };//ELSE errtype("poke",_t); //яю шфхх эшъюуфр
  735. }
  736.  
  737. EXPORT PROC cmdpeek() //_t = Єшя фрээ√ї яюф єърчрЄхыхь, эх const
  738. {
  739. #ifdef USE_COMMENTS
  740. ;;  cmtstr( ";PEEK" ); endcmt();
  741. #endif
  742.   IF (_wasconst) pushconst();
  743.   _sz = _typesz[_t];
  744.   IF (_sz==_SZ_BYTE/**(_t==_T_BYTE)||(_t==_T_CHAR)||(_t==_T_BOOL)*/) {
  745.     getrnew();
  746.     emitpeekb();
  747.   }ELSE IF (_sz==_SZ_REG/**(_t==_T_INT)||(_t==_T_UINT)||(_t>=_T_POI)*/) {
  748.     getrnew();
  749.     emitpeekrg();
  750.   }ELSE /**IF (_sz==_SZ_LONG)*/ {
  751.     getrfree(); //_rnew
  752.     getrnew();
  753.     getrold();
  754.     emitpeeklong();
  755.   };//ELSE errtype("peek",_t); //яю шфхх эшъюуфр
  756. }
  757.  
  758. EXPORT PROC cmdneg()
  759. {
  760. #ifdef USE_COMMENTS
  761. ;;  cmtstr( ";NEG" ); endcmt();
  762. #endif
  763.   IF (_wasconst) pushconst();
  764.   IF ( (_t==_T_INT)||(_t==_T_UINT) ) {
  765.     getrnew();
  766.     emitnegrg();
  767. #ifdef TARGET_SCRIPT
  768.   }ELSE IF (_t==_T_FLOAT) { emitnegfloat();
  769. #endif
  770.   }ELSE errtype("neg",_t);
  771. }
  772.  
  773. EXPORT PROC cmdinv()
  774. {
  775. #ifdef USE_COMMENTS
  776. ;;  cmtstr( ";INV" ); endcmt();
  777. #endif
  778.   IF (_wasconst) pushconst();
  779.   _sz = _typesz[_t];
  780.   IF (_sz==_SZ_BYTE) {
  781.     getrnew();
  782.     emitinvb();
  783.   }ELSE IF (_sz == _SZ_REG) {
  784.     getrnew();
  785.     emitinvrg();
  786.   }ELSE /**IF (_t==_T_LONG)*/ {
  787.     getrnew();
  788.     emitinvrg();
  789.     getrold(); _rnew = _rold;
  790.     emitinvrg();
  791.   };//ELSE errtype("inv",_t);
  792. }
  793.  
  794. EXPORT PROC cmdinc() //no float
  795. {
  796. #ifdef USE_COMMENTS
  797. ;;  cmtstr(";OPERATION ++"); endcmt();
  798. #endif
  799.   IF (_wasconst) pushconst();
  800.   IF (_t==_T_BYTE) {
  801.     prefernoregs(); //Єюы№ъю [hl]
  802.     _t = _T_POI|_T_BYTE; cmdpushnum();
  803.     IF (_wasconst) pushconst();
  804.     getrnew();
  805.     emitincb_bypoi();
  806.     freernew();
  807.   }ELSE IF (_typesz[_t]==_SZ_REG/**(_t==_T_INT)||(_t==_T_UINT)||(_t>=_T_POI)*/) {
  808.     getrfree(); //_rnew
  809.     //emitgetrg(+FALSE);
  810.     emitincrg_byname();
  811.     //emitputrg(+FALSE);
  812.     freernew();
  813. /**  }ELSE IF (_t==_T_LONG) {
  814.     emitinclong();
  815. */
  816.   }ELSE errtype("inc",_t);
  817. }
  818.  
  819. EXPORT PROC cmddec() //no float
  820. {
  821. #ifdef USE_COMMENTS
  822. ;;  cmtstr( ";OPERATION --" ); endcmt();
  823. #endif
  824.   IF (_wasconst) pushconst();
  825.   IF (_t==_T_BYTE) {
  826.     prefernoregs(); //Єюы№ъю [hl]
  827.     _t = _T_POI|_T_BYTE; cmdpushnum();
  828.     IF (_wasconst) pushconst();
  829.     getrnew();
  830.     emitdecb_bypoi();
  831.     freernew();
  832.   }ELSE IF (_typesz[_t]==_SZ_REG/**(_t==_T_INT)||(_t==_T_UINT)||(_t>=_T_POI)*/) {
  833.     getrfree(); //_rnew
  834.     //emitgetrg(+FALSE);
  835.     emitdecrg_byname();
  836.     //emitputrg(+FALSE);
  837.     freernew();
  838. /**  }ELSE IF (_t==_T_LONG) {
  839.     emitdeclong();
  840. */
  841.   }ELSE errtype("dec",_t);
  842. }
  843.  
  844. EXPORT PROC cmdincbyaddr() //no float
  845. {
  846. #ifdef USE_COMMENTS
  847. ;;  cmtstr(";OPERATION ++byaddr"); endcmt();
  848. #endif
  849.   IF (_wasconst) pushconst();
  850.   getrnew();
  851.   IF (_t==_T_BYTE) {
  852.     emitincb_bypoi(); //[new]
  853.   }ELSE IF (_typesz[_t]==_SZ_REG/**(_t==_T_INT)||(_t==_T_UINT)||(_t>=_T_POI)*/) {
  854.     getrfree();
  855.     getrold();
  856.     emitincrg_bypoi(); //[old]
  857.     freernew();
  858. /**  }ELSE IF (_t==_T_LONG) {
  859.     emitinclong();
  860. */
  861.   }ELSE errtype("incbypoi",_t);
  862.   freernew();
  863. }
  864.  
  865. EXPORT PROC cmddecbyaddr() //no float
  866. {
  867. #ifdef USE_COMMENTS
  868. ;;  cmtstr(";OPERATION --byaddr"); endcmt();
  869. #endif
  870.   IF (_wasconst) pushconst();
  871.   getrnew();
  872.   IF (_t==_T_BYTE) {
  873.     emitdecb_bypoi(); //[new]
  874.   }ELSE IF (_typesz[_t]==_SZ_REG/**(_t==_T_INT)||(_t==_T_UINT)||(_t>=_T_POI)*/) {
  875.     getrfree();
  876.     getrold();
  877.     emitdecrg_bypoi(); //[old]
  878.     freernew();
  879. /**  }ELSE IF (_t==_T_LONG) {
  880.     emitdeclong();
  881. */
  882.   }ELSE errtype("decbypoi",_t);
  883.   freernew();
  884. }
  885.  
  886. //////////////////////////////////
  887. //ёЁртэхэш 
  888.  
  889. EXPORT PROC cmdless() //ёЄрЁюх ьхэ№°х эютюую
  890. {
  891. #ifdef USE_COMMENTS
  892. ;;  cmtstr( ";OPERATION <" ); endcmt();
  893. #endif
  894.   IF (_wasconst) pushconst();
  895. #ifdef TARGET_SCRIPT
  896.   IF (_t==_T_FLOAT) {
  897.     emitlessfloat();
  898.   }ELSE IF (_t==_T_BYTE) {
  899.     emitlessb();
  900.   }ELSE IF (_t==_T_UINT) {
  901.     emitless();
  902.   }ELSE IF (_t==_T_INT) {
  903.     emitlesssigned();
  904. #else
  905.   IF (_t==_T_BYTE) {
  906.     getrnew();
  907.     getrold();
  908.     emitsubbflags(_rnew, _rold); //old-new
  909.     freernew();
  910.     freernew();
  911.     getrfree(); //_rnew
  912.     emitcytob();
  913.   }ELSE IF (_t==_T_UINT) {
  914.     getrnew();
  915.     getrold();
  916.     emitsubflags(_rnew, _rold); //old-new
  917.     freernew();
  918.     freernew();
  919.     getrfree(); //_rnew
  920.     emitcytob();
  921.   }ELSE IF (_t==_T_INT) {
  922.     getrnew();
  923.     getrold();
  924.     emitsubflags(_rnew, _rold); //old-new
  925.     freernew();
  926.     freernew();
  927.     getrfree(); //_rnew
  928.     emitSxorVtob(); //S xor overflow
  929.   //}ELSE IF (_t==_T_LONG) {
  930. #endif
  931.   }ELSE errtype("<",_t);
  932.   _t = _T_BOOL;
  933. }
  934.  
  935. EXPORT PROC cmdmore() //ёЄрЁюх сюы№°х эютюую
  936. {
  937. #ifdef USE_COMMENTS
  938. ;;  cmtstr( ";OPERATION >" ); endcmt();
  939. #endif
  940.   IF (_wasconst) pushconst();
  941. #ifdef TARGET_SCRIPT
  942.   IF (_t==_T_FLOAT) {
  943.     emitmorefloat();
  944.   }ELSE IF (_t==_T_BYTE) {
  945.     emitmoreb();
  946.   }ELSE IF (_t==_T_UINT) {
  947.     emitmore();
  948.   }ELSE IF (_t==_T_INT) {
  949.     emitmoresigned();
  950. #else
  951.   IF (_t==_T_BYTE) {
  952.     getrold();
  953.     getrnew();
  954.     emitsubbflags(_rold, _rnew); //new-old
  955.     freernew();
  956.     freernew();
  957.     getrfree(); //_rnew
  958.     emitcytob();
  959.   }ELSE IF (_t==_T_UINT) {
  960.     getrold();
  961.     getrnew();
  962.     emitsubflags(_rold, _rnew); //new-old
  963.     freernew();
  964.     freernew();
  965.     getrfree(); //_rnew
  966.     emitcytob();
  967.   }ELSE IF (_t==_T_INT) {
  968.     getrold();
  969.     getrnew();
  970.     emitsubflags(_rold, _rnew); //new-old
  971.     freernew();
  972.     freernew();
  973.     getrfree(); //_rnew
  974.     emitSxorVtob(); //S xor overflow
  975.   //}ELSE IF (_t==_T_LONG) {
  976. #endif
  977.   }ELSE errtype(">",_t);
  978.   _t = _T_BOOL;
  979. }
  980.  
  981. EXPORT PROC cmdlesseq() //ёЄрЁюх <= эютюую
  982. {
  983. #ifdef USE_COMMENTS
  984. ;;  cmtstr( ";OPERATION <=" ); endcmt();
  985. #endif
  986.   IF (_wasconst) pushconst();
  987. #ifdef TARGET_SCRIPT
  988.   IF (_t==_T_FLOAT) {
  989.     emitlesseqfloat();
  990.   }ELSE IF (_t==_T_BYTE) {
  991.     emitlesseqb();
  992.   }ELSE IF (_t==_T_UINT) {
  993.     emitlesseq();
  994.   }ELSE IF (_t==_T_INT) {
  995.     emitlesseqsigned();
  996. #else
  997.   IF (_t==_T_BYTE) {
  998.     getrold();
  999.     getrnew();
  1000.     emitsubbflags(_rold, _rnew); //new-old
  1001.     freernew();
  1002.     freernew();
  1003.     getrfree(); //_rnew
  1004.     emitinvcytob();
  1005.   }ELSE IF (_t==_T_UINT) {
  1006.     getrold();
  1007.     getrnew();
  1008.     emitsubflags(_rold, _rnew); //new-old
  1009.     freernew();
  1010.     freernew();
  1011.     getrfree(); //_rnew
  1012.     emitinvcytob();
  1013.   }ELSE IF (_t==_T_INT) {
  1014.     getrold();
  1015.     getrnew();
  1016.     emitsubflags(_rold, _rnew); //new-old
  1017.     freernew();
  1018.     freernew();
  1019.     getrfree(); //_rnew
  1020.     emitinvSxorVtob(); //S xor overflow + шэтхЁёш  Їырур Ёхчєы№ЄрЄр
  1021.   //}ELSE IF (_t==_T_LONG) {
  1022. #endif
  1023.   }ELSE errtype("<=",_t);
  1024.   _t = _T_BOOL;
  1025. }
  1026.  
  1027. EXPORT PROC cmdmoreeq() //ёЄрЁюх >= эютюую
  1028. {
  1029. #ifdef USE_COMMENTS
  1030. ;;  cmtstr( ";OPERATION >=" ); endcmt();
  1031. #endif
  1032.   IF (_wasconst) pushconst();
  1033. #ifdef TARGET_SCRIPT
  1034.   IF (_t==_T_FLOAT) {
  1035.     emitmoreeqfloat();
  1036.   }ELSE IF (_t==_T_BYTE) {
  1037.     emitmoreeqb();
  1038.   }ELSE IF (_t==_T_UINT) {
  1039.     emitmoreeq();
  1040.   }ELSE IF (_t==_T_INT) {
  1041.     emitmoreeqsigned();
  1042. #else
  1043.   IF (_t==_T_BYTE) {
  1044.     getrnew();
  1045.     getrold();
  1046.     emitsubbflags(_rnew, _rold); //old-new
  1047.     freernew();
  1048.     freernew();
  1049.     getrfree(); //_rnew
  1050.     emitinvcytob();
  1051.   }ELSE IF (_t==_T_UINT) {
  1052.     getrnew();
  1053.     getrold();
  1054.     emitsubflags(_rnew, _rold); //old-new
  1055.     freernew();
  1056.     freernew();
  1057.     getrfree(); //_rnew
  1058.     emitinvcytob();
  1059.   }ELSE IF (_t==_T_INT) {
  1060.     getrnew();
  1061.     getrold();
  1062.     emitsubflags(_rnew, _rold); //old-new
  1063.     freernew();
  1064.     freernew();
  1065.     getrfree(); //_rnew
  1066.     emitinvSxorVtob(); //S xor overflow + шэтхЁёш  Їырур Ёхчєы№ЄрЄр
  1067.   //}ELSE IF (_t==_T_LONG) {
  1068. #endif
  1069.   }ELSE errtype(">=",_t);
  1070.   _t = _T_BOOL;
  1071. }
  1072.  
  1073. EXPORT PROC cmdeq()
  1074. {
  1075. #ifdef USE_COMMENTS
  1076. ;;  cmtstr( ";OPERATION ==" ); endcmt();
  1077. #endif
  1078.   _sz = _typesz[_t];
  1079. #ifdef TARGET_SCRIPT
  1080.   IF (_t==_T_FLOAT) {
  1081.     emiteqfloat();
  1082.   }ELSE
  1083. #endif
  1084.   IF (_sz==_SZ_BYTE) {
  1085.     IF (_wasconst) {
  1086.       getrnew();
  1087.       emitsubbzconst(); //new-<const>
  1088.       _wasconst = +FALSE;
  1089.       freernew();
  1090.     }ELSE {
  1091.       getrnew();
  1092.       getrold();
  1093.       emitsubbz(); //old-new
  1094.       freernew();
  1095.       freernew();
  1096.     };
  1097.     getrfree(); //_rnew
  1098.     emitztob();
  1099.   }ELSE {
  1100.     IF (_wasconst) pushconst();
  1101.     IF (_sz==_SZ_REG) {
  1102.       getrnew();
  1103.       getrold();
  1104.       emitsubz(); //old-new
  1105.       freernew();
  1106.       freernew();
  1107.       getrfree(); //_rnew
  1108.       emitztob();
  1109.     }ELSE /**IF (_sz==_SZ_LONG)*/ {
  1110.       getrold2(); _rold2 = _rold; //oldlow //схЁ╕ь Ёрэ№°х, ўЄюс√ яюыєўшЄ№ с√ёЄЁ√щ ЁхушёЄЁ
  1111.       getrold3(); _rold3 = _rold; //oldhigh шч ёЄхър //схЁ╕ь Ёрэ№°х, ўЄюс√ яюыєўшЄ№ с√ёЄЁ√щ ЁхушёЄЁ
  1112.       getrnew(); //newlow
  1113.       getrold(); //newhigh
  1114.       emitsublongz(); //old2-new, old3-old
  1115.       freernew();
  1116.       freernew();
  1117.       freernew();
  1118.       freernew();
  1119.       getrfree(); //_rnew
  1120.       emitztob();
  1121.     };//ELSE errtype("==",_t); //яю шфхх эшъюуфр
  1122.   };
  1123.   _t = _T_BOOL;
  1124. }
  1125.  
  1126. EXPORT PROC cmdnoteq()
  1127. {
  1128. #ifdef USE_COMMENTS
  1129. ;;  cmtstr( ";OPERATION !=" ); endcmt();
  1130. #endif
  1131.   _sz = _typesz[_t];
  1132. #ifdef TARGET_SCRIPT
  1133.   IF (_t==_T_FLOAT) {
  1134.     emitneqfloat();
  1135.   }ELSE
  1136. #endif
  1137.   IF (_sz==_SZ_BYTE) {
  1138.     IF (_wasconst) {
  1139.       getrnew();
  1140.       emitsubbzconst(); //new-<const>
  1141.       _wasconst = +FALSE;
  1142.       freernew();
  1143.     }ELSE {
  1144.       getrnew();
  1145.       getrold();
  1146.       emitsubbz(); //old-new
  1147.       freernew();
  1148.       freernew();
  1149.     };
  1150.     getrfree(); //_rnew
  1151.     emitinvztob();
  1152.   }ELSE {
  1153.     IF (_wasconst) pushconst();
  1154.     IF (_sz==_SZ_REG) {
  1155.       getrnew();
  1156.       getrold();
  1157.       emitsubz(); //old-new
  1158.       freernew();
  1159.       freernew();
  1160.       getrfree(); //_rnew
  1161.       emitinvztob();
  1162.     }ELSE /**IF (_sz==_SZ_LONG)*/ {
  1163.       getrold2(); _rold2 = _rold; //oldlow //схЁ╕ь Ёрэ№°х, ўЄюс√ яюыєўшЄ№ с√ёЄЁ√щ ЁхушёЄЁ
  1164.       getrold3(); _rold3 = _rold; //oldhigh шч ёЄхър //схЁ╕ь Ёрэ№°х, ўЄюс√ яюыєўшЄ№ с√ёЄЁ√щ ЁхушёЄЁ
  1165.       getrnew(); //newlow
  1166.       getrold(); //newhigh
  1167.       emitsublongz(); //old2-new, old3-old
  1168.       freernew();
  1169.       freernew();
  1170.       freernew();
  1171.       freernew();
  1172.       getrfree(); //_rnew
  1173.       emitinvztob();
  1174.     };//ELSE errtype("!=",_t); //яю шфхх эшъюуфр
  1175.   };
  1176.   _t = _T_BOOL;
  1177. }
  1178.  
  1179. ///////////////////////////////////
  1180. //ухэхЁрЎш  т√чютют ш яхЁхїюфют
  1181.  
  1182. EXPORT PROC cmdlabel()
  1183. {
  1184.   //IF (_wasconst) pushconst(); //т√ўшёыхэшх чръюэўхэю
  1185.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  1186.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  1187.   getnothing();
  1188.   emitfunclabel(_joined);
  1189. }
  1190.  
  1191. EXPORT PROC cmdjpval()
  1192. {
  1193.   //IF (_wasconst) pushconst();
  1194.   getmainrg();
  1195.   freernew();
  1196.   emitjpmainrg(); //"jp (hl)" //фхырхЄ getnothing
  1197. }
  1198.  
  1199. EXPORT PROC cmdcallval()
  1200. {
  1201.   IF (_wasconst) pushconst();
  1202.   getmainrg();
  1203.   freernew();
  1204.   emitcallmainrg(); //"call (hl)" //фхырхЄ getnothing //todo трЁшрэЄ ё ъюэёЄрэЄющ
  1205. }
  1206.  
  1207. EXPORT PROC cmdjp()
  1208. {
  1209. #ifdef USE_COMMENTS
  1210. ;;  cmtstr( ";JUMP " ); cmtstr(_joined); endcmt();
  1211. #endif
  1212.   //IF (_wasconst) pushconst();
  1213.   emitjp();
  1214. }
  1215.  
  1216. EXPORT PROC cmdjpiffalse()
  1217. {
  1218. #ifdef USE_COMMENTS
  1219. ;;  cmtstr( ";JUMP IF FALSE " ); cmtstr(_joined); endcmt();
  1220. #endif
  1221.   IF (_wasconst) pushconst(); //ьюцхЄ с√Є№ эх яЁшётюхэю т IF (+TRUE)
  1222.   getrnew();
  1223.   emitbtoz();
  1224.   freernew();
  1225.   emitjpiffalse();
  1226. }
  1227.  
  1228. EXPORT PROC cmdcall()
  1229. {
  1230. #ifdef USE_COMMENTS
  1231. ;;  cmtstr( ";CALL " ); cmtstr(_callee); endcmt();
  1232. #endif
  1233.   //IF (_wasconst) pushconst();
  1234.   unproxy();
  1235.   getnothing(); //ёюїЁрэшЄ№ ЁхушёЄЁ√ т ёЄхъх т ёЄрэфрЁЄэюь яюЁ фъх ш юётюсюфшЄ№ ЁхушёЄЁ√
  1236.   emitcallproc();
  1237.   IF (_t!=_T_PROC) {
  1238.     _sz = _typesz[_t];
  1239.     IF (_sz==_SZ_BYTE/**(_t==_T_BYTE)||(_t==_T_CHAR)||(_t==_T_BOOL)*/) {
  1240.       setmainb(); //Ёхчєы№ЄрЄ т RMAIN
  1241.     }ELSE IF (_sz==_SZ_REG/**(_t==_T_INT)||(_t==_T_UINT)||(_t>=_T_POI)*/) {
  1242.       setmainrg(); //Ёхчєы№ЄрЄ т RMAIN
  1243.     }ELSE IF (_sz==_SZ_LONG/**_t==_T_LONG*/) {
  1244.       setmain2rgs(); //Ёхчєы№ЄрЄ т RMAIN,RMAIN2
  1245.     }ELSE errtype("call",_t); //яю шфхх эшъюуфр
  1246.   };
  1247. }
  1248.  
  1249. EXPORT PROC cmdfunc()
  1250. {
  1251. #ifdef USE_COMMENTS
  1252. ;;  cmtstr( ";FUNC" ); endcmt();
  1253. #endif
  1254.   //IF (_wasconst) pushconst();
  1255.   _funcstkdepth = +(INT)0;
  1256.   emitfunchead();
  1257. }
  1258.  
  1259. EXPORT PROC cmdstorergs() //яюёых ёюїЁрэхэш  ыюъры№эющ яхЁхьхээющ ЁхъєЁёштэющ яЁюЎхфєЁ√
  1260. {
  1261. #ifdef USE_COMMENTS
  1262. ;;  cmtstr(";STOREREGS"); endcmt();
  1263. #endif
  1264.   //IF (_wasconst) pushconst();
  1265.   getnothing(); //ўЄюс√ шёяюы№чютрЄ№ hl //todo єсЁрЄ№ (ъюуфр сєфхЄ ЁхчхЁтшЁютрэшх ЁхушёЄЁют) - Єюуфр ыюъры№э√х ярЁрьхЄЁ√ сєфєЄ эх т ёЄхъх, р т ЁхушёЄЁрї
  1266. }
  1267.  
  1268. EXPORT PROC cmdpushpar() //фы  ЁхъєЁёштэ√ї яЁюЎхфєЁ (ёюїЁрэхэшх ярЁрьхЄЁют тэєЄЁш шыш ёэрЁєцш)
  1269. {
  1270. #ifdef USE_COMMENTS
  1271. ;;  cmtstr(";PUSHPAR "); cmtstr(_joined); endcmt();
  1272. #endif
  1273.   //IF (_wasconst) pushconst();
  1274.   _sz = _typesz[_t];
  1275.   IF (_sz==_SZ_BYTE) {
  1276.     getnothing(); //ўЄюс√ шёяюы№чютрЄ№ A //todo єсЁрЄ№ (ъюуфр сєфхЄ ЁхчхЁтшЁютрэшх ЁхушёЄЁют) - Єюуфр ыюъры№э√х ярЁрьхЄЁ√ сєфєЄ эх т ёЄхъх, р т ЁхушёЄЁрї
  1277.     getrfree(); //_rnew
  1278.     emitgetb(); //cmdpushvarb(s); //эхт√уюфэю, їюЄ  чрьхэ хЄ тё╕ т√°хэряшёрээюх
  1279.   }ELSE IF (_sz==_SZ_REG) {
  1280.     getnothing(); //ўЄюс√ шёяюы№чютрЄ№ hl //todo єсЁрЄ№ (ъюуфр сєфхЄ ЁхчхЁтшЁютрэшх ЁхушёЄЁют) - Єюуфр ыюъры№э√х ярЁрьхЄЁ√ сєфєЄ эх т ёЄхъх, р т ЁхушёЄЁрї
  1281.     getrfree(); //_rnew
  1282.     emitgetrg(+FALSE);
  1283.   }ELSE /**IF (_sz==_SZ_LONG)*/ {
  1284.     getnothing(); //ўЄюс√ шёяюы№чютрЄ№ hl //todo єсЁрЄ№ (ъюуфр сєфхЄ ЁхчхЁтшЁютрэшх ЁхушёЄЁют) - Єюуфр ыюъры№э√х ярЁрьхЄЁ√ сєфєЄ эх т ёЄхъх, р т ЁхушёЄЁрї
  1285.     getrfree(); //_rnew
  1286.     emitgetrg(+TRUE); //high
  1287.     getnothing(); //ўЄюс√ шёяюы№чютрЄ№ hl //todo єсЁрЄ№ (ъюуфр сєфхЄ ЁхчхЁтшЁютрэшх ЁхушёЄЁют) - Єюуфр ыюъры№э√х ярЁрьхЄЁ√ сєфєЄ эх т ёЄхъх, р т ЁхушёЄЁрї
  1288.     getrfree(); //_rnew
  1289.     emitgetrg(+FALSE); //low
  1290.   };//ELSE errtype("pushpar",_t); //яю шфхх эшъюуфр
  1291. }
  1292.  
  1293. EXPORT PROC cmdpoppar() //фы  ЁхъєЁёштэ√ї яЁюЎхфєЁ (тюёёЄрэютыхэшх ярЁрьхЄЁют тэєЄЁш шыш ёэрЁєцш)
  1294. { //ьюцхЄ с√Є№ чрэ Єю 1-2 ЁхушёЄЁр (Ёхчєы№ЄрЄ)
  1295. #ifdef USE_COMMENTS
  1296. ;;  cmtstr(";POPPAR"); endcmt();
  1297. #endif
  1298.   //IF (_wasconst) pushconst();
  1299.   _sz = _typesz[_t];
  1300.   IF (_sz==_SZ_BYTE) {
  1301.     getrfree(); //_rnew
  1302.     emitpoprg(_rnew);
  1303.     emitputb();
  1304.     freernew();
  1305.   }ELSE IF (_sz==_SZ_REG) {
  1306.     getrfree(); //_rnew
  1307.     emitpoprg(_rnew);
  1308.     emitputrg(+FALSE); //low
  1309.     freernew();
  1310.   }ELSE /**IF (_sz==_SZ_LONG)*/ {
  1311.     getrfree(); //_rnew
  1312.     emitpoprg(_rnew);
  1313.     emitputrg(+FALSE); //low
  1314.     freernew();
  1315.     getrfree(); //_rnew
  1316.     emitpoprg(_rnew);
  1317.     emitputrg(+TRUE); //high
  1318.     freernew();
  1319.   };//ELSE errtype("poppar",_t); //яю шфхх эшъюуфр
  1320. } //ЄхяхЁ№ т ЁхушёЄЁрї ьюцхЄ с√Є№ яєёЄю, тё╕ т ёЄхъх (яхЁхф ret эрфю чрсЁрЄ№ Ёхчєы№ЄрЄ шч ёЄхър)
  1321.  
  1322. EXPORT PROC cmdresult()
  1323. {
  1324. #ifdef USE_COMMENTS
  1325. ;;  cmtstr( ";RESULT" ); endcmt();
  1326. #endif
  1327.   IF (_wasconst) pushconst();
  1328.   _sz = _typesz[_t];
  1329.   IF (_sz==_SZ_BYTE) {
  1330.   }ELSE IF (_sz==_SZ_REG) {
  1331.     getmainrg(); //todo ЁхчхЁтшЁютрЄ№ ё яхЁхёЄрэютъющ ЁхушёЄЁют
  1332.   }ELSE /**IF (_sz==_SZ_LONG)*/ {
  1333.     getmain2rgs(); //todo ЁхчхЁтшЁютрЄ№ ё яхЁхёЄрэютъющ ЁхушёЄЁют
  1334.   };//ELSE errtype("result",_t); //яю шфхх эшъюуфр
  1335. }
  1336.  
  1337. EXPORT PROC cmdret(BOOL isfunc)
  1338. {
  1339. #ifdef USE_COMMENTS
  1340. ;;  cmtstr( ";ENDFUNC" ); endcmt();
  1341. #endif
  1342.   //IF (_wasconst) pushconst();
  1343.   IF ( isfunc ) {
  1344.     _sz = _typesz[_t];
  1345.     IF (_sz==_SZ_BYTE) {
  1346.       getrnew();
  1347.       proxy(_rnew);
  1348.     }ELSE IF (_sz==_SZ_REG) {
  1349.       getmainrg();
  1350.     }ELSE /**IF (_sz==_SZ_LONG)*/ {
  1351.       getmain2rgs();
  1352.     };//ELSE errtype("endfunc",_t); //яю шфхх эшъюуфр
  1353.   };
  1354.   emitret();
  1355.   IF (+(UINT)_funcstkdepth!=0) { errstr("funcstkdepth=" ); erruint(+(UINT)_funcstkdepth); enderr(); };
  1356.   initrgs();
  1357. }
  1358.  
  1359. EXPORT PROC initcmd()
  1360. {
  1361.   _const  = (PCHAR)_sc;
  1362.   //_wastword  = (PCHAR)_sw;
  1363.   _wasconst = +FALSE;
  1364. }
  1365.