Subversion Repositories NedoOS

Rev

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