Subversion Repositories NedoOS

Rev

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