Subversion Repositories NedoOS

Rev

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