Subversion Repositories NedoOS

Rev

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