Subversion Repositories NedoOS

Rev

Rev 8 | Rev 473 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download

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