Subversion Repositories NedoOS

Rev

Rev 2325 | Blame | Compare with Previous | Last modification | View Log | Download

  1. //// imported
  2. #include "../_sdk/emit.h"
  3.  
  4. #include "sizesz80.h"
  5.  
  6. //тхчфх, уфх эєцхэ ёЄЁюъют√щ ярЁрьхЄЁ, шёяюы№чєхЄё  _joined
  7. //(ъЁюьх call - Єрь _callee, ш ъЁюьх loadrg/b - Єрь _const)
  8. //т ъюэЎх ы■сюую т√ўшёыхэш  (put, call, jpiffalse) фхыры _jpflag = 0x00 (шэрўх яЁхф√фє∙хх "юяЄшьшчшЁютрээюх" ёЁртэхэшх ьюцхЄ шёяюЁЄшЄ№ эют√щ єёыютэ√щ яхЁхїюф)
  9. //юёЄртшы Єюы№ъю т jpiffalse, Є.ъ. юёЄры№э√х эх ьюуєЄ с√Є№ "юяЄшьшчшЁютрээ√ьш"
  10. EXPORT VAR PCHAR _callee; //эрчтрэшх т√ч√трхьющ яЁюЎхфєЁ√ (ё єў╕Єюь ьюфєы )
  11. EXPORT VAR UINT  _lencallee;
  12. EXTERN PCHAR _joined; //ртЄюьхЄър
  13. EXTERN UINT  _lenjoined;
  14. VAR UINT _oldlen;
  15. EXTERN PCHAR _const; //ёЄрЁр  ъюэёЄрэЄр
  16. EXTERN UINT  _lenconst;
  17.  
  18. EXPORT VAR BYTE _exprlvl; //уыєсшэр т√Ёрцхэш  (тхЁїэшщ єЁютхэ№ == 1)
  19.  
  20. //тэх°эшх яЁюЎхфєЁ√ (шч rgs) - todo т codegen эх шёяюы№чютрЄ№ rgs
  21. EXTERN BYTE _rnew;
  22. EXTERN BYTE _rold;
  23. EXTERN BYTE _rold2;
  24. EXTERN BYTE _rold3;
  25.  
  26. //rg pool
  27. PROC getnothing FORWARD(); //ёюїЁрэшЄ№ ЁхушёЄЁ√ ш срщЄ√ т ёЄхъх ш юётюсюфшЄ№
  28. //PROC getmainrg FORWARD(); //тч Є№ RMAIN=new ш юётюсюфшЄ№ юёЄры№э√х ЁхушёЄЁ√
  29. PROC getmain2rgs FORWARD(); //тч Є№ RMAIN=old, RMAIN2=new ш юётюсюфшЄ№ юёЄры№э√х ЁхушёЄЁ√ //фы  call2rgs
  30. //PROC getmain3rgs FORWARD(); //фы  call3rgs
  31. PROC getmain4rgs FORWARD(); //фы  call4rgs
  32. PROC setmainrg FORWARD(); //єёЄрэютшЄ№ яЁшчэръш, ъръ сєфЄю ь√ яюыєўшыш Ёхчєы№ЄрЄ т ЁхушёЄЁх //фы  call2rgs
  33. PROC setmain2rgs FORWARD(); //єёЄрэютшЄ№ яЁшчэръш, ъръ сєфЄю ь√ яюыєўшыш Ёхчєы№ЄрЄ т ЁхушёЄЁрї //фы  call4rgs
  34.  
  35. PROC rgs_initrgs FORWARD();
  36.  
  37. ////
  38. #define _RGBUFSZ (BYTE)(_NRGS+0x01)
  39.  
  40.   //яЁшюЁшЄхЄ√ ЁхушёЄЁют:
  41. CONST BYTE _RMAIN = 0x01; /**HL*/ /**ЁхушёЄЁ Ёхчєы№ЄрЄр ш яхЁтюую ярЁрьхЄЁр ёЄрэфрЁЄэ√ї ЇєэъЎшщ*/
  42. CONST BYTE _RMAIN2= 0x02; /**DE*/ /**ЁхушёЄЁ тЄюЁюую ёыютр Ёхчєы№ЄрЄр ш тЄюЁюую ярЁрьхЄЁр ёЄрэфрЁЄэ√ї ЇєэъЎшщ*/
  43. CONST BYTE _RMAIN3= 0x03;
  44. CONST BYTE _RMAIN4= 0x04;
  45.  
  46. CONST BYTE _RNAME[_RGBUFSZ] = {
  47.   0x00, //0 яєёЄющ
  48.   +_RG_HL,
  49.   +_RG_DE,
  50.   +_RG_BC,
  51.   +_RG_IX
  52. };
  53. CONST BYTE _RHIGH[_RGBUFSZ] = {
  54.   0x00, //0 яєёЄющ
  55.   +_RG_H,
  56.   +_RG_D,
  57.   +_RG_B,
  58.   +_RG_HX
  59. };
  60. CONST BYTE _RLOW[_RGBUFSZ] = {
  61.   0x00, //0 яєёЄющ
  62.   +_RG_L,
  63.   +_RG_E,
  64.   +_RG_C,
  65.   +_RG_LX
  66. };
  67.  
  68. VAR BYTE _rproxy;
  69. VAR BOOL _fused;
  70. VAR BOOL _azused; //A ёюфхЁцшЄ яЁртшы№э√щ 0/эх0 яюёых ёЁртэхэш 
  71.  
  72. VAR INT _funcstkdepth;
  73.  
  74. VAR BYTE _jpflag; //0=OR A:JZ, 1=JZ, 2=JNZ, 3=JNC, 4=JC
  75.  
  76. EXPORT CONST BYTE _typesz[32] = { //ЁрчьхЁ Єшяр т срщЄрї фы  ЄрЁухЄр //чфхё№ эх шёяюы№чєхЄё 
  77.   _SZ_BYTE/**T_BYTE */, //фы  тёхї ЄрЁухЄют
  78.   _SZ_REG/**T_UINT */, //фы  тёхї ЄрЁухЄют
  79.   _SZ_REG/**T_INT  */, //фы  тёхї ЄрЁухЄют
  80.   _SZ_BOOL/**T_BOOL */,
  81.   _SZ_LONG/**T_LONG */,
  82.   _SZ_BYTE/**T_CHAR */,
  83.   _SZ_LONG/**T_FLOAT*/,
  84.   0x00/**unknown*/,
  85.   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  86.   _SZ_REG/**T_PBYTE */,
  87.   _SZ_REG/**T_PUINT */,
  88.   _SZ_REG/**T_PINT  */,
  89.   _SZ_REG/**T_PBOOL */,
  90.   _SZ_REG/**T_PLONG */,
  91.   _SZ_REG/**T_PCHAR */,
  92.   _SZ_REG/**T_PFLOAT*/,
  93.   _SZ_REG/**        */,
  94.   _SZ_REG, _SZ_REG, _SZ_REG, _SZ_REG, _SZ_REG, _SZ_REG, _SZ_REG, _SZ_REG //pointer to...
  95. };
  96.  
  97. CONST BYTE _typeshift[32] = { //log ЁрчьхЁ Єшяр (n фы  2^n срщЄ) фы  ЄрЁухЄр //чфхё№ эх шёяюы№чєхЄё 
  98.   _RL_BYTE/**T_BYTE */, //фы  тёхї ЄрЁухЄют
  99.   _RL_REG/**T_UINT */, //фы  тёхї ЄрЁухЄют
  100.   _RL_REG/**T_INT  */, //фы  тёхї ЄрЁухЄют
  101.   _RL_BOOL/**T_BOOL */,
  102.   _RL_LONG/**T_LONG */,
  103.   _RL_BYTE/**T_CHAR */,
  104.   _RL_LONG/**T_FLOAT*/,
  105.   0x00/**unknown*/,
  106.   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  107.   _RL_REG/**T_BYTE  */,
  108.   _RL_REG/**T_UINT  */,
  109.   _RL_REG/**T_INT   */,
  110.   _RL_REG/**T_BOOL  */,
  111.   _RL_REG/**T_LONG  */,
  112.   _RL_REG/**T_CHAR  */,
  113.   _RL_REG/**T_PFLOAT*/,
  114.   _RL_REG/**        */,
  115.   _RL_REG, _RL_REG, _RL_REG, _RL_REG, _RL_REG, _RL_REG, _RL_REG, _RL_REG //pointer to...
  116. };
  117.  
  118. PROC initrgs FORWARD(); //юўшёЄшЄ№ ёюёЄю эш  ЁхушёЄЁют ш срщЄют (шёяюы№чєхЄё  т cemitfunc)
  119.  
  120. EXPORT PROC asm_label()
  121. {
  122.   asmc(+_CMDLABEL); //TODO юяЁхфхы Є№ яю яхЁтющ сєътх ъюьрэф√?
  123. }
  124.  
  125. EXPORT PROC asm_equal()
  126. {
  127.   asmc((BYTE)'='); asmc(+_TOKEXPR); //TODO схч _TOKEXPR? (єсЁрЄ№ т ёрьє юсЁрсюЄъє _CMDLABEL) (єёыюцэшЄ ¤ъёяюЁЄ)
  128. }
  129.  
  130. EXPORT PROC endasm_label()
  131. {
  132.   asmc(+_FMTCMD); endasm(); //Єрь Єюы№ъю яЁютхЁър яхЁхюяЁхфхы╕ээюёЄш, TODO єсЁрЄ№ т ёрьє юсЁрсюЄъє _CMDLABEL
  133. }
  134.  
  135. EXPORT PROC endasm_reequ()
  136. {
  137.   asmc(+_TOKENDEXPR); asmc(+_FMTREEQU); endasm(); //TODO єсЁрЄ№
  138. }
  139.  
  140. EXPORT PROC var_label()
  141. {
  142.   varc(+_CMDLABEL); //TODO юяЁхфхы Є№ яю яхЁтющ сєътх ъюьрэф√?
  143. }
  144.  
  145. EXPORT PROC endvar_label()
  146. {
  147.   varc(+_FMTCMD); endvar(); //Єрь Єюы№ъю яЁютхЁър яхЁхюяЁхфхы╕ээюёЄш, TODO єсЁрЄ№ т ёрьє юсЁрсюЄъє _CMDLABEL
  148. }
  149.  
  150. EXPORT PROC varequ(PCHAR s)
  151. {
  152.   varc(+_CMDLABEL); varstr(s); varc((BYTE)'='); varc(+_TOKEXPR); //TODO схч _TOKEXPR? (єсЁрЄ№ т ёрьє юсЁрсюЄъє _CMDLABEL) (єёыюцэшЄ ¤ъёяюЁЄ)
  153. }
  154.  
  155. EXPORT PROC endvar_reequ()
  156. {
  157.   varc(+_TOKENDEXPR); varc(+_FMTREEQU); endvar(); //TODO єсЁрЄ№
  158. }
  159.  
  160. EXPORT PROC endasm_db()
  161. {
  162.   asmc(+_TOKENDEXPR); asmc(+_OPWRVAL); asmc(+_FMTCMD); endasm(); //TODO єсЁрЄ№
  163. }
  164.  
  165. EXPORT PROC endasm_dbstr()
  166. {
  167.   asmc(+_TOKENDTEXT); asmc((BYTE)'\"'); asmc(+_FMTCMD); endasm(); //TODO єсЁрЄ№
  168. }
  169.  
  170. EXPORT PROC endvar_db()
  171. {
  172.   varc(+_TOKENDEXPR); varc(+_OPWRVAL); varc(+_FMTCMD); endvar(); //TODO єсЁрЄ№
  173. }
  174.  
  175. EXPORT PROC endvar_dbstr()
  176. {
  177.   varc(+_TOKENDTEXT); varc((BYTE)'\"'); varc(+_FMTCMD); endvar(); //TODO єсЁрЄ№
  178. }
  179.  
  180. EXPORT PROC endvar_dw()
  181. {
  182.   varc(+_TOKENDEXPR); varc(+_OPWRVAL); varc(+_FMTCMD); endvar(); //TODO єсЁрЄ№
  183. }
  184.  
  185. EXPORT PROC endvar_dl()
  186. {
  187.   varc(+_TOKENDEXPR); varc(+_OPWRVAL); varc(+_FMTCMD); endvar(); //TODO єсЁрЄ№
  188. }
  189.  
  190. EXPORT PROC endvar_ds()
  191. {
  192.   varc(+_TOKENDEXPR); varc(+_FMTCMD); endvar();
  193. }
  194.  
  195. PROC asmexprstr(PCHAR s)
  196. {
  197.   asmc(+_TOKEXPR); asmstr(s); asmc(+_TOKENDEXPR);
  198. }
  199.  
  200. PROC asmcmd(BYTE c)
  201. {
  202.   asmc(+_TOKSPC8); asmc(c); asmc(+_TOKSPC1);
  203. }
  204.  
  205. PROC asmcmdfull(BYTE c)
  206. {
  207.   asmc(+_TOKSPC8); asmc(c); asmc(+_FMTXX); endasm(); //TODO яшёрЄ№ ъюф т ёрьшї ъюьрэфрї
  208. }
  209.  
  210. //////////// ьхыъшх яЁюЎхфєЁ√ фы  ёюъЁр∙хэш  ўшёыр ъюэёЄрэЄ
  211.  
  212. EXPORT PROC var_alignwsz()
  213. {
  214. }
  215.  
  216. PROC flushcall()
  217. {
  218.   if (_wascall) {
  219.     asmcmd(+_ASMCALL); asmexprstr( _callee2 ); asmc(+_FMTJPNN); endasm();
  220.     _wascall = +FALSE;
  221.   };
  222. }
  223.  
  224. PROC losea()
  225. {
  226.   _callee2[0] = '\0'; //_lencallee2 = 0; //чрс√трхь ёюёЄю эшх A (чряшё№ т ярь Є№ эх шч A шыш т√ўшёыхэшх)
  227. }
  228.  
  229. PROC asmexprstr_joined_keep()
  230. {
  231.   asmexprstr(_joined);
  232.   _lencallee2 = strcopy(_joined, _lenjoined, _callee2);
  233. }
  234.  
  235. PROC asm_comma()
  236. {
  237.   asmc(+_TOKCOMMA);
  238. }
  239.  
  240. PROC asm_open()
  241. {
  242.   asmc(+_TOKOPENSQ);
  243. }
  244.  
  245. PROC asm_close()
  246. {
  247.   asmc(+_TOKCLOSESQ);
  248. }
  249.  
  250. PROC asm_rname(BYTE r){  asmc( _RNAME[(UINT)r] );}
  251. PROC asm_mrgname(BYTE r){  asm_open(); asm_rname(r); asm_close();}
  252.  
  253. PROC asm_rlow(BYTE r){  asmc( _RLOW[(UINT)r] );}
  254. PROC asm_rhigh(BYTE r){  asmc( _RHIGH[(UINT)r] );}
  255.  
  256. FUNC BYTE rlow_rnew(){  RETURN _RLOW[(UINT)_rnew];}
  257. FUNC BYTE rhigh_rnew(){  RETURN _RHIGH[(UINT)_rnew];}
  258. FUNC BYTE rlow_rold(){  RETURN _RLOW[(UINT)_rold];}
  259. FUNC BYTE rhigh_rold(){  RETURN _RHIGH[(UINT)_rold];}
  260.  
  261. PROC asm_rlow_rnew()
  262. {
  263.   asm_rlow(_rnew);
  264. }
  265.  
  266. PROC asm_rhigh_rnew()
  267. {
  268.   asm_rhigh(_rnew);
  269. }
  270.  
  271. PROC asm_rlow_rold()
  272. {
  273.   asm_rlow(_rold);
  274. }
  275.  
  276. PROC asm_rhigh_rold()
  277. {
  278.   asm_rhigh(_rold);
  279. }
  280.  
  281. PROC asm_close_eol()
  282. {
  283.   asm_close(); endasm();
  284. }
  285.  
  286. PROC asm_a()
  287. {
  288.   asmc(+_RG_A);
  289. }
  290.  
  291. PROC asm_hl()
  292. {
  293.   asm_rname(0x01);
  294. }
  295.  
  296. PROC asm_mhl()
  297. {
  298.   asm_mrgname(0x01);
  299. }
  300.  
  301. EXPORT PROC asm_db() //ъюёЄ√ы№ фы  ъюэёЄрэЄэ√ї ьрёёштют ёЄЁюъ TODO
  302. {
  303.   asmc(+_TOKSPC8); asmc(+_CMDDB); asmc(+_TOKSPC1); asmc(+_TOKEXPR); //TODO схч _TOKEXPR? (єсЁрЄ№ т ёрьє юсЁрсюЄъє ъюьрэф√) (єёыюцэшЄ ¤ъёяюЁЄ)
  304. }
  305.  
  306. EXPORT PROC asm_dbstr() //ъюёЄ√ы№ фы  ъюэёЄрэЄэ√ї ьрёёштют ёЄЁюъ TODO
  307. {
  308.   asmc(+_TOKSPC8); asmc(+_CMDDB); asmc(+_TOKSPC1); asmc((BYTE)'\"'); asmc(+_OPWRSTR); asmc(+_TOKTEXT); //TODO єсЁрЄ№ т ёрьє юсЁрсюЄъє ъюьрэф√ (єёыюцэшЄ ¤ъёяюЁЄ)
  309. }
  310.  
  311. EXPORT PROC var_db() //фюёЄєяэю шч compile!
  312. {
  313.   varc(+_TOKSPC8); varc(+_CMDDB); varc(+_TOKSPC1); varc(+_TOKEXPR); //TODO схч _TOKEXPR? (єсЁрЄ№ т ёрьє юсЁрсюЄъє ъюьрэф√) (єёыюцэшЄ ¤ъёяюЁЄ)
  314. }
  315.  
  316. EXPORT PROC var_dbstr()
  317. {
  318.   varc(+_TOKSPC8); varc(+_CMDDB); varc(+_TOKSPC1); varc((BYTE)'\"'); varc(+_OPWRSTR); varc(+_TOKTEXT); //TODO єсЁрЄ№ т ёрьє юсЁрсюЄъє ъюьрэф√ (єёыюцэшЄ ¤ъёяюЁЄ)
  319. }
  320.  
  321. EXPORT PROC var_dw() //фюёЄєяэю шч compile!
  322. {
  323.   varc(+_TOKSPC8); varc(+_CMDDW); varc(+_TOKSPC1); varc(+_TOKEXPR); //TODO схч _TOKEXPR? (єсЁрЄ№ т ёрьє юсЁрсюЄъє ъюьрэф√) (єёыюцэшЄ ¤ъёяюЁЄ)
  324. }
  325.  
  326. PROC var_dl()
  327. {
  328.   varc(+_TOKSPC8); varc(+_CMDDL); varc(+_TOKSPC1); varc(+_TOKEXPR); //TODO схч _TOKEXPR? (єсЁрЄ№ т ёрьє юсЁрсюЄъє ъюьрэф√) (єёыюцэшЄ ¤ъёяюЁЄ)
  329. }
  330.  
  331. EXPORT PROC var_ds() //фюёЄєяэю шч compile!
  332. {
  333.   varc(+_TOKSPC8); varc(+_CMDDS); varc(+_TOKSPC1); varc(+_TOKEXPR); //TODO схч _TOKEXPR? (єсЁрЄ№ т ёрьє юсЁрсюЄъє ъюьрэф√) (єёыюцэшЄ ¤ъёяюЁЄ)
  334. }
  335.  
  336. PROC asm_and()
  337. {
  338.   flushcall();
  339.   asmcmd(+_ASMAND);
  340.   losea();
  341. }
  342.  
  343. PROC asm_or()
  344. {
  345.   flushcall();
  346.   asmcmd(+_ASMOR);
  347.   losea();
  348. }
  349.  
  350. PROC asm_xor()
  351. {
  352.   flushcall();
  353.   asmcmd(+_ASMXOR);
  354.   losea();
  355. }
  356.  
  357. PROC asm_inc()
  358. {
  359.   flushcall();
  360.   asmcmd(+_ASMINC);
  361.   losea();
  362. }
  363.  
  364. PROC asm_dec()
  365. {
  366.   flushcall();
  367.   asmcmd(+_ASMDEC);
  368.   losea();
  369. }
  370.  
  371. PROC asm_ld()
  372. {
  373.   flushcall();
  374.   asmcmd(+_ASMLD);
  375. }
  376.  
  377. PROC asm_jp()
  378. {
  379.   flushcall();
  380.   asmcmd(+_ASMJP);
  381. }
  382.  
  383. PROC emitjrnz(CHAR c)
  384. {
  385.   flushcall();
  386.   asmcmd(+_ASMJR);
  387.   asmc(+_ASMNZ);
  388.   asm_comma();
  389.   asmc(+_TOKEXPR); asmstr( "$+0x" ); asmc((BYTE)c); asmc(+_TOKENDEXPR);
  390.   asmc(+_FMTJRDD);
  391.   endasm();
  392. }
  393.  
  394. PROC emitjrz(CHAR c)
  395. {
  396.   flushcall();
  397.   asmcmd(+_ASMJR);
  398.   asmc(+_ASMZ);
  399.   asm_comma();
  400.   asmc(+_TOKEXPR); asmstr( "$+0x" ); asmc((BYTE)c); asmc(+_TOKENDEXPR);
  401.   asmc(+_FMTJRDD);
  402.   endasm();
  403. }
  404.  
  405. PROC asm_ex()
  406. {
  407.   flushcall();
  408.   asmcmd(+_ASMEX);
  409. }
  410.  
  411. PROC asm_push()
  412. {
  413.   flushcall();
  414.   asmcmd(+_ASMPUSH);
  415. }
  416.  
  417. PROC asm_pop()
  418. {
  419.   flushcall();
  420.   asmcmd(+_ASMPOP);
  421. }
  422.  
  423. PROC asm_lda_comma()
  424. {
  425.   asm_ld(); asm_a(); asm_comma();
  426.   losea();
  427. }
  428.  
  429. PROC asm_ldmhl_comma()
  430. {
  431.   asm_ld(); asm_mhl(); asm_comma();
  432. }
  433.  
  434. PROC asm_comma_a()
  435. {
  436.   asm_comma(); asm_a();
  437. }
  438.  
  439. PROC asm_comma_mhl()
  440. {
  441.   asm_comma(); asm_mhl();
  442. }
  443.  
  444. PROC emitexa()
  445. {
  446.   asm_ex(); asmc(+_RG_AF); asm_comma(); asmc(+_RG_AF); asmc(+_TOKPRIME); asmc(+_FMTEXRPRP); endasm(); //TODO т ёрьюь юсЁрсюЄўшъх EX
  447. }
  448.  
  449. PROC emitexd()
  450. {
  451.   asm_ex(); asmc(+_RG_DE); asm_comma(); asmc(+_RG_HL); asmc(+_FMTEXRPRP); endasm(); //TODO т ёрьюь юсЁрсюЄўшъх EX
  452. }
  453.  
  454. PROC emitccf()
  455. {
  456.   flushcall();
  457.   asmcmdfull(+_ASMCCF);
  458. }
  459.  
  460. PROC emitrla()
  461. {
  462.   flushcall();
  463.   asmcmdfull(+_ASMRLA);
  464.   losea();
  465. }
  466.  
  467. PROC emitcpl()
  468. {
  469.   flushcall();
  470.   asmcmdfull(+_ASMCPL);
  471.   losea();
  472. }
  473.  
  474. PROC emitcall(PCHAR s)
  475. {
  476.   flushcall();
  477.   asmcmd(+_ASMCALL); asmexprstr(s); asmc(+_FMTJPNN); endasm();
  478. }
  479.  
  480. PROC emitrb0(BYTE r)
  481. {
  482.   asm_ld(); asmc(r); asm_comma(); asmexprstr("0"); asmc(+_FMTLDRBN); endasm();
  483. }
  484.  
  485. PROC emitarb(BYTE r)
  486. {
  487.   asm_lda_comma(); /**losea*/ asmc(r); asmc(+_FMTMOVRBRB); endasm();
  488. }
  489.  
  490. PROC emitrba(BYTE r)
  491. {
  492.   asm_ld(); asmc(r); asm_comma_a(); asmc(+_FMTMOVRBRB); endasm();
  493. }
  494.  
  495. PROC emitamrgn(BYTE r)
  496. {
  497.   asm_lda_comma(); /**losea*/ asm_mrgname(r);
  498.   IF (r==0x01) {asmc(+_FMTGETRBMHL);
  499.   }ELSE asmc(+_FMTGETAMRP);
  500.   endasm();
  501. }
  502.  
  503. PROC emitmrgna(BYTE r)
  504. {
  505.   asm_ld(); asm_mrgname(r); asm_comma_a();
  506.   IF (r==0x01) {asmc(+_FMTPUTMHLRB);
  507.   }ELSE asmc(+_FMTPUTMRPA);
  508.   endasm();
  509. }
  510.  
  511. PROC emitrbmhl(BYTE r)
  512. {
  513.   asm_ld(); asmc(r); asm_comma(); asm_mhl(); asmc(+_FMTGETRBMHL); endasm();
  514. }
  515.  
  516. PROC emitmhlrb(BYTE r)
  517. {
  518.   asm_ld(); asm_mhl(); asm_comma(); asmc(r); asmc(+_FMTPUTMHLRB); endasm();
  519. }
  520.  
  521. PROC emitincrgn(BYTE r)
  522. {
  523.   flushcall();
  524.   asmcmd(+_ASMINC); asm_rname(r); asmc(+_FMTINCRP); endasm();
  525. }
  526.  
  527. PROC emitdecrgn(BYTE r)
  528. {
  529.   flushcall();
  530.   asmcmd(+_ASMDEC); asm_rname(r); asmc(+_FMTDECRP); endasm();
  531. }
  532.  
  533. PROC emitinchl(){  emitincrgn(0x01);}
  534. PROC emitdechl(){  emitdecrgn(0x01);}
  535.  
  536. PROC emitsubn(PCHAR s)
  537. {
  538.   flushcall();
  539.   asmcmd(+_ASMSUB); asmexprstr(s); asmc(+_FMTALUCMDN); endasm();
  540.   losea();
  541. }
  542.  
  543. PROC emitsubrb(BYTE r)
  544. {
  545.   flushcall();
  546.   asmcmd(+_ASMSUB); asmc(r); asmc(+_FMTALUCMDRB); endasm();
  547.   losea();
  548. }
  549.  
  550. PROC emitsbcrgn(BYTE r)
  551. {
  552.   flushcall();
  553.   asmcmd(+_ASMSBC); asm_hl(); asm_comma(); asm_rname(r); asmc(+_FMTSBCHLRP); endasm();
  554. }
  555.  
  556. PROC emitsbcrb(BYTE r)
  557. {
  558.   flushcall();
  559.   asmcmd(+_ASMSBC); asm_a(); asm_comma(); asmc(r); asmc(+_FMTALUCMDRB); endasm();
  560.   losea();
  561. }
  562.  
  563. PROC emitaddrgn(BYTE r)
  564. {
  565.   flushcall();
  566.   asmcmd(+_ASMADD);
  567.   IF (r==0x04) {asmc(+_RG_IX); }ELSE asm_hl();
  568.   asm_comma(); asm_rname(r); asmc(+_FMTADDHLRP); endasm();
  569. }
  570.  
  571. PROC emitaddrb(BYTE r)
  572. {
  573.   flushcall();
  574.   asmcmd(+_ASMADD); asm_a(); asm_comma(); asmc(r); asmc(+_FMTALUCMDRB); endasm();
  575.   losea();
  576. }
  577.  
  578. PROC emitadcrgn(BYTE r)
  579. {
  580.   flushcall();
  581.   asmcmd(+_ASMADC); asm_hl(); asm_comma(); asm_rname(r); asmc(+_FMTADCHLRP); endasm();
  582. }
  583.  
  584. PROC emitadcrb(BYTE r)
  585. {
  586.   flushcall();
  587.   asmcmd(+_ASMADC); asm_a(); asm_comma(); asmc(r); asmc(+_FMTALUCMDRB); endasm();
  588.   losea();
  589. }
  590.  
  591. ///////////////////////////////////
  592. //фюёЄєяэ√ шч commands
  593. PROC unproxy() //A тючтЁр∙рхЄ Ёхчєы№ЄрЄ т ЁхушёЄЁ
  594. {
  595.   IF (_rproxy != 0x00) { //т яЁюъёш ўЄю-Єю с√ыю
  596.     emitrba( _RLOW[_rproxy] );
  597.     _rproxy = 0x00;
  598.   };
  599. }
  600.  
  601. PROC proxy(BYTE r) //A фєсышЁєхЄ ЁхушёЄЁ
  602. {
  603.   IF (_rproxy != r) {
  604.     unproxy();
  605.     emitarb( _RLOW[r] );
  606.     _rproxy = r;
  607.     losea();
  608.   };
  609. }
  610.  
  611. ///////////////////////////////////////////////////////////
  612. //яЁюЎхфєЁ√ ё ьр°шээ√ь ъюфюь фы  rgs
  613.  
  614. PROC emitpushrg(BYTE rnew)
  615. {
  616.   unproxy(); //todo юяЄшьшчшЁютрЄ№
  617.   asm_push(); asm_rname(rnew); asmc(+_FMTPUSHPOPRP); endasm();
  618.   INC _funcstkdepth;
  619. }
  620.  
  621. PROC emitpoprg(BYTE rnew) //ЁхушёЄЁ єцх яюьхўхэ т getrfree/getrg
  622. {
  623.   asm_pop(); asm_rname(rnew); asmc(+_FMTPUSHPOPRP); endasm();
  624.   DEC _funcstkdepth;
  625. }
  626.  
  627. PROC emitmovrg(BYTE rsrc, BYTE rdest) //эх чрърч√трхЄ ш эх юётюсюцфрхЄ (ёь. emitmoverg)
  628. {
  629.   IF (rsrc!=rdest) { //todo шыш ёЁртэштрЄ№ rsrc!=rdest ёэрЁєцш?
  630.     //rdest эх ьюцхЄ с√Є№ FASTRG4? хёыш ёфхырЄ№ ЇєэъЎш■ getslowrg, Єю ьюцхЄ :(
  631.     IF ( ((rdest==0x04)&&(rsrc==0x01))
  632.        ||((rdest==0x01)&&(rsrc==0x04))
  633.        ) {
  634.       asm_push(); asm_rname(rsrc); asmc(+_FMTPUSHPOPRP); endasm();
  635.       asm_pop(); asm_rname(rdest); asmc(+_FMTPUSHPOPRP); endasm();
  636.     }ELSE {
  637.       asm_ld(); asm_rhigh(rdest); asm_comma(); asm_rhigh(rsrc); asmc(+_FMTMOVRBRB); endasm();
  638.       asm_ld(); asm_rlow(rdest); asm_comma(); asm_rlow(rsrc); asmc(+_FMTMOVRBRB); endasm();
  639.     };
  640.   };
  641. }
  642.  
  643. ///////////////////////////////////////////////////////////////////////////////////////
  644. //¤Єш яЁюЎхфєЁ√ ухэхЁшЁє■Є ъюф
  645. //эхфюёЄєяэ√ шч ъюьяшы ЄюЁр, фюёЄєяэ√ шч commands
  646.  
  647. EXPORT PROC emitasmlabel(PCHAR s)
  648. {
  649.   flushcall();
  650.   asm_label(); asmstr(s); /**asmc( ':' );*/ endasm_label();
  651.   losea();
  652. }
  653.  
  654. EXPORT PROC emitfunclabel(PCHAR s)
  655. {
  656.   flushcall();
  657.   asm_label(); asmstr(s); /**asmc( ':' );*/ endasm_label();
  658.   losea();
  659. }
  660.  
  661. EXPORT PROC emitvarlabel(PCHAR s)
  662. {
  663.   var_label(); varstr(s); /**varc( ':' );*/ endvar_label();
  664. }
  665.  
  666. EXPORT PROC emitexport(PCHAR s) //todo тёхуфр _joined
  667. {
  668.   flushcall();
  669.   asmcmd(+_CMDEXPORT); asmc(+_TOKLABEL); asmstr(s); asmc(+_FMTCMD); endasm(); //TODO єсЁрЄ№ +_FMTCMD
  670. }
  671.  
  672. EXPORT PROC emitvarpreequ(PCHAR s)
  673. {
  674. }
  675.  
  676. EXPORT PROC emitvarpostequ()
  677. {
  678. }
  679.  
  680. EXPORT FUNC UINT varshift(UINT shift, UINT sz)
  681. {
  682.   //IF (sz >= 4) shift = (shift+3)&(UINT)(-4);
  683.   //asmexprstr_joined_keep(); asmc('='); asmuint(shift); endasm();
  684.   varequ(_joined); /**varstr(_joined); varc('=');*/ varuint(shift); endvar_reequ();
  685. RETURN shift;
  686. }
  687.  
  688. PROC emitjpmainrg() //"jp (hl)"
  689. {
  690.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  691.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  692.   unproxy();
  693.   getnothing(); //getnothingword();
  694.   asm_jp(); asm_mhl(); asmc(+_FMTJPRP); endasm();
  695. }
  696.  
  697. PROC emitcallmainrg() //"call (hl)"
  698. {
  699.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  700.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  701.   unproxy();
  702.   getnothing(); //getnothingword();
  703.   emitcall("_JPHL.");
  704.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  705. }
  706.  
  707. PROC emitjp()
  708. {
  709.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  710.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  711.   unproxy();
  712.   getnothing(); //getnothingword();
  713.   asm_jp(); asmexprstr(_joined); asmc(+_FMTJPNN); endasm();
  714. }
  715.  
  716. PROC emitbtoz() //яхЁхф jp!
  717. {
  718.   //ёЁрчє яюёых ёЁртэхэш  эх эрфю, эю тфЁєу ь√ ўшЄрхь BOOL
  719.   //IF (_jpflag == 0x00) {
  720.   IF (!_fused) { //Ёхчєы№ЄрЄр эхЄ тю Їырурї
  721.     proxy(_rnew); //todo юяЄшьшчшЁютрЄ№
  722.     //IF (anew==_RGA) {
  723.       asm_or(); asm_a(); asmc(+_FMTALUCMDRB); endasm();
  724.     //}ELSE {
  725.     //  asm_inc(); /**rganame*/asm_rlow(anew); asmc(+_FMTINCDECRB); endasm();
  726.     //  asm_dec(); /**rganame*/asm_rlow(anew); asmc(+_FMTINCDECRB); endasm();
  727.     //};
  728.   };
  729.   _rproxy = 0x00;
  730. }
  731.  
  732. PROC emitjpiffalse()
  733. {
  734.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  735.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  736.   //unproxy();
  737.   getnothing(); //getnothingword();
  738.   asm_jp();
  739.   IF       (_jpflag == 0x02) {asmc(+_ASMNZ);
  740.   }ELSE IF (_jpflag == 0x03) {asmc(+_ASMNC);
  741.   }ELSE IF (_jpflag == 0x04) {asmc(+_ASMC);
  742.   }ELSE                      {asmc(+_ASMZ);
  743.   };
  744.   asm_comma();
  745.   asmexprstr(_joined);
  746.   asmc(+_FMTJPNN);
  747.   endasm();
  748.   _fused = +FALSE;
  749.   _jpflag = 0x00;
  750. }
  751.  
  752. PROC emitret()
  753. {
  754.   //unproxy();
  755.   if (_wascall) {
  756.     asmcmd(+_ASMJP); asmexprstr(_callee2); asmc(+_FMTJPNN); endasm();
  757.     _wascall = +FALSE;
  758.   }else {
  759.     //flushcall();
  760.     asmcmdfull(+_ASMRET);
  761.   };
  762. }
  763.  
  764. PROC emitcall2rgs(PCHAR s)
  765. {
  766.   unproxy();
  767.   getmain2rgs();
  768.   initrgs();
  769.   emitcall(s);
  770.   setmainrg(); //Ёхчєы№ЄрЄ т RMAIN
  771. }
  772. /**
  773. PROC emitcall3rgs(PCHAR s) //todo яЁютхЁшЄ№
  774. {
  775.   unproxy();
  776.   getmain3rgs();
  777.   initrgs();
  778.   emitcall(s);
  779.   //ёхщўрё тёх ЁхушёЄЁ√ юЄьхўхэ√ ъръ ётюсюфэ√х
  780.   //setwordcontext();
  781.   setmain2rgs(); //Ёхчєы№ЄрЄ т RMAIN,RMAIN2
  782. }
  783. */
  784. PROC emitcall4rgs(PCHAR s) //todo яЁютхЁшЄ№
  785. {
  786.   unproxy();
  787.   getmain4rgs();
  788.   initrgs();
  789.   emitcall(s);
  790.   //ёхщўрё тёх ЁхушёЄЁ√ юЄьхўхэ√ ъръ ётюсюфэ√х
  791.   //setwordcontext();
  792.   setmain2rgs(); //Ёхчєы№ЄрЄ т RMAIN,RMAIN2
  793. }
  794.  
  795. PROC emitcallproc()
  796. {
  797.   //_jpflag = 0x00;
  798.   flushcall();
  799.   _lencallee2 = strcopy(_callee, _lencallee, _callee2);
  800.   _wascall = +TRUE;
  801. }
  802.  
  803. PROC emitloadrg(BOOL high) //ЁхушёЄЁ єцх чрэ Є ўхЁхч getrfree
  804. {
  805.   IF (high) {
  806.     _lenconst = strjoin(/**to=*/_const, 4, ">>16");
  807.     _joined[_lenjoined] = '\0';
  808.   };
  809.   asm_ld();
  810.   asm_rname(_rnew);
  811.   asm_comma();
  812.   asmexprstr(_const);
  813.   asmc(+_FMTLDRPNN);
  814.   endasm();
  815.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  816. }
  817.  
  818. PROC emitloadrg0() //ЁхушёЄЁ єцх чрэ Є ўхЁхч getrfree
  819. {
  820.   asm_ld();
  821.   asm_rname(_rnew);
  822.   asm_comma();
  823.   asmexprstr("0");
  824.   asmc(+_FMTLDRPNN);
  825.   endasm();
  826. }
  827.  
  828. PROC emitloadb() //ръъєьєы ЄюЁ єцх чрэ Є ўхЁхч getfreea
  829. {
  830.   IF (_rproxy == 0x00) {
  831.     _rproxy = _rnew;
  832.     asm_lda_comma();
  833.   }ELSE {
  834.     asm_ld();
  835.     /**rganame*/asmc(rlow_rnew());
  836.     asm_comma();
  837.   };
  838.   asmexprstr(_const);
  839.   asmc(+_FMTLDRBN);
  840.   endasm();
  841.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  842. }
  843.  
  844. PROC emitgetrg(BOOL high) //ЁхушёЄЁ єцх чрэ Є ўхЁхч getrfree
  845. {
  846.   _oldlen = _lenjoined;
  847.   IF (high) { //TODO эрЁєцє
  848.     joinedadd('+');
  849.     joinedadd('2');
  850.   };
  851.   asm_ld();
  852.   asm_rname(_rnew);
  853.   asm_comma();
  854.   asm_open();
  855.   asmexprstr(_joined);
  856.   asm_close();
  857.   asmc(+_FMTGETRPMNN);
  858.   endasm();
  859.   _lenjoined = _oldlen; _joined[_lenjoined] = '\0';
  860. }
  861.  
  862. PROC emitgetb() //ръъєьєы ЄюЁ єцх чрэ Є ўхЁхч getfreea
  863. {
  864. //хёыш ръъєьєы ЄюЁ эх яЁюъёш? ш эхфртэю (фю фЁєуюую шьхэютрээюую юсЁр∙хэш  (ё■фр Єръцх тїюф Є т√ўшёыхэшх ш яхЁхїюф), ьхЄъш) ёюїЁрэ ыё  т шьхэютрээє■  ўхщъє ўхЁхч emitputb(), Єю эшўхую эх фхырЄ№
  865.   unproxy();
  866.   _rproxy = _rnew;
  867.   if (!strcp(_joined, _callee2)) { //ъЁштю!
  868.     asm_lda_comma();
  869.     asm_open();
  870.     asmexprstr_joined_keep();
  871.     asm_close();
  872.     asmc(+_FMTGETAMNN);
  873.     endasm();
  874.   };
  875. }
  876.  
  877. PROC emitputrg(BOOL high) //ld [],new
  878. {
  879.   //_jpflag = 0x00;
  880.   IF (high) { //TODO эрЁєцє
  881.     joinedadd('+');
  882.     joinedadd('2');
  883.   };
  884.   asm_ld(); asm_open();
  885.   asmexprstr(_joined);
  886.   asm_close(); asm_comma();
  887.   asm_rname(_rnew);
  888.   asmc(+_FMTPUTMNNRP);
  889.   endasm();
  890.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  891. }
  892.  
  893. PROC emitputb()
  894. {
  895.   //_jpflag = 0x00;
  896.   proxy(_rnew);
  897.   asm_ld(); asm_open();
  898.   asmexprstr_joined_keep();
  899.   asm_close();
  900.   asm_comma_a();
  901.   asmc(+_FMTPUTMNNA);
  902.   endasm();
  903.   _rproxy = 0x00;
  904.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  905. }
  906.  
  907. PROC emitshl1rg()
  908. {
  909.   IF ((_rnew==0x01)||(_rnew==0x04)) {
  910.     emitaddrgn(_rnew); //add hl,ix єцх Єрь ухэхЁшЁєхЄё  ъръ add ix,ix
  911.   }ELSE {
  912.     flushcall();
  913.     asmcmd(+_ASMSLA); asmc(rlow_rnew()); asmc(+_FMTCBCMDRB); endasm();
  914.     asmcmd(+_ASMRL); asmc(rhigh_rnew()); asmc(+_FMTCBCMDRB); endasm();
  915.   };
  916. }
  917.  
  918. PROC emitshl1b()
  919. {
  920.     proxy(_rnew);
  921.   //IF (_rproxy==_rnew) {
  922.     emitaddrb(+_RG_A);
  923.   //}ELSE {
  924.   //  flushcall();
  925.   //  asmcmd(+_ASMSLA); /**rganame*/asm_rlow(anew); asmc(+_FMTCBCMDRB); endasm();
  926.   //};
  927. }
  928. /**
  929. PROC emitshr1rg(BYTE rnew)
  930. {
  931.   flushcall();
  932.   asmcmd(+_ASMSRL); asm_rhigh(rnew); asmc(+_FMTCBCMDRB); endasm();
  933.   asmcmd(+_ASMRR); asm_rlow(rnew); asmc(+_FMTCBCMDRB); endasm();
  934. }
  935.  
  936. PROC emitshr1signedrg(BYTE rnew)
  937. {
  938.   flushcall();
  939.   asmcmd(+_ASMSRA); asm_rhigh(rnew); asmc(+_FMTCBCMDRB); endasm();
  940.   asmcmd(+_ASMRR); asm_rlow(rnew); asmc(+_FMTCBCMDRB); endasm();
  941. }
  942. */
  943. //PROC emitshr1b(BYTE anew)
  944. //{
  945. //  flushcall();
  946. //  asmcmd(+_ASMSRL); /**rganame*/asm_rlow(anew] ); asmc(+_FMTCBCMDRB); endasm();
  947. //}
  948.  
  949. PROC emitinvb() //~A -> A
  950. {
  951.   proxy(_rnew);
  952.   emitcpl();
  953.   _fused = +FALSE; //шэрўх уы■ъ if (!(a||b))
  954. }
  955.  
  956. PROC emitinvrg()
  957. {
  958.   unproxy();
  959.   emitarb( rhigh_rnew() );
  960.   emitcpl();
  961.   emitrba( rhigh_rnew() );
  962.   emitinvb(); //_rlow
  963.   unproxy(); //шэрўх уы■ъ яхЁхф poke
  964. }
  965.  
  966. PROC emitnegrg()
  967. {
  968.   unproxy();
  969.   asm_xor(); asm_a(); asmc(+_FMTALUCMDRB); endasm();
  970.   emitsubrb(rlow_rnew());
  971.   emitrba( rlow_rnew() );
  972.   emitsbcrb(rhigh_rnew());
  973.   emitsubrb(rlow_rnew());
  974.   emitrba( rhigh_rnew() );
  975. }
  976.  
  977. PROC emitztob()
  978. {
  979.   //asmexprstr(";emitztoa exprlvl="); asmuint(_exprlvl); endasm();
  980.   IF (_exprlvl != 0x01) { //if (a == b)
  981.     IF (_azused) { //A ёюфхЁцшЄ яЁртшы№э√щ 0/эх0 яюёых ёЁртэхэш 
  982.       //unproxy();
  983.       emitsubn("1");
  984.       emitsbcrb(+_RG_A);
  985.       _rproxy = _rnew;
  986.       _azused = +FALSE;
  987.     }ELSE {
  988.       emitrb0(rlow_rnew());
  989.       IF (_rnew != 0x04) {emitjrnz('3');
  990.       }ELSE emitjrnz('4'); //ix
  991.       asm_dec(); asmc(rlow_rnew()); asmc(+_FMTINCDECRB); endasm();
  992.     };
  993.     _fused = +FALSE; //шэрўх уы■ъ яЁш if ((a==b))
  994.     //_jpflag = 0x00;
  995.   }ELSE {
  996.     //_fused = +TRUE;
  997.     _jpflag = 0x02;
  998.   };
  999. }
  1000.  
  1001. PROC emitinvztob()
  1002. {
  1003.   //asmexprstr(";emitinvztoa exprlvl="); asmuint(_exprlvl); endasm();
  1004.   IF (_exprlvl != 0x01) { //if (a != b)
  1005.     IF (_azused) { //A ёюфхЁцшЄ яЁртшы№э√щ 0/эх0 яюёых ёЁртэхэш 
  1006.       //unproxy();
  1007.       emitjrz('4');
  1008.       asm_lda_comma(); asmexprstr("-1"); asmc(+_FMTLDRBN); endasm();
  1009.       _rproxy = _rnew;
  1010.       _azused = +FALSE;
  1011.     }ELSE {
  1012.       emitrb0(rlow_rnew());
  1013.       IF (_rnew != 0x04) {emitjrz('3');
  1014.       }ELSE emitjrz('4'); //ix
  1015.       asm_dec(); asmc(rlow_rnew()); asmc(+_FMTINCDECRB); endasm();
  1016.     };
  1017.     _fused = +FALSE; //шэрўх уы■ъ яЁш if ((a!=b))? todo test //тючьюцхэ уы■ъ ifnot ((a!=b))
  1018.     //_jpflag = 0x00;
  1019.   }ELSE {
  1020.     //_fused = +TRUE;
  1021.     _jpflag = 0x01;
  1022.   };
  1023. }
  1024.  
  1025. PROC emitcytob()
  1026. {
  1027.   //asmexprstr(";emitcytoa exprlvl="); asmuint(_exprlvl); endasm();
  1028.   IF (_exprlvl != 0x01) { //if (a < b)
  1029.     unproxy();
  1030.     emitsbcrb(+_RG_A);
  1031.     _rproxy = _rnew;
  1032.     //_fused = +FALSE;
  1033.     //_jpflag = 0x00;
  1034.   }ELSE {
  1035.     //_fused = +TRUE;
  1036.     _jpflag = 0x03;
  1037.   };
  1038. }
  1039.  
  1040. PROC emitinvcytob()
  1041. {
  1042.   //asmexprstr(";emitinvcytoa exprlvl="); asmuint(_exprlvl); endasm();
  1043.   IF (_exprlvl != 0x01) { //if (a >= b)
  1044.     emitccf();
  1045.     unproxy();
  1046.     emitsbcrb(+_RG_A);
  1047.     _rproxy = _rnew;
  1048.     //_fused = +FALSE;
  1049.     //_jpflag = 0x00;
  1050.   }ELSE {
  1051.     //_fused = +TRUE;
  1052.     _jpflag = 0x04;
  1053.   };
  1054. }
  1055.  
  1056. PROC emitSxorVtob() //яюёых subflags, ЁрчЁхчхЁтшЁєхЄ A
  1057. {
  1058.   emitrla(); //sign
  1059.   asm_jp(); asmc(+_ASMPO); asm_comma(); asmexprstr( "$+4" ); asmc(+_FMTJPNN); endasm();
  1060.   emitccf();
  1061.   emitcytob();
  1062. }
  1063.  
  1064. PROC emitinvSxorVtob() //яюёых subflags, ЁрчЁхчхЁтшЁєхЄ A
  1065. {
  1066.   emitrla(); //sign
  1067.   asm_jp(); asmc(+_ASMPE); asm_comma(); asmexprstr( "$+4" ); asmc(+_FMTJPNN); endasm();
  1068.   emitccf();
  1069.   emitcytob();
  1070. }
  1071.  
  1072. PROC emitxorrg() //old^new => old
  1073. {
  1074.   unproxy();
  1075.   emitarb( rhigh_rnew() );
  1076.   asm_xor(); asm_rhigh_rold(); asmc(+_FMTALUCMDRB); endasm();
  1077.   emitrba( rhigh_rold() );
  1078.   emitarb( rlow_rnew() );
  1079.   asm_xor(); asm_rlow_rold(); asmc(+_FMTALUCMDRB); endasm();
  1080.   emitrba( rlow_rold() );
  1081. }
  1082.  
  1083. PROC getxorb() //RGA^RGA2 -> RGA
  1084. {
  1085.   IF (_rproxy == _rnew) {
  1086.     asm_xor();
  1087.     /**rganame*/asm_rlow_rold();
  1088.     _rproxy = _rold;
  1089.   }ELSE {
  1090.     proxy(_rold);
  1091.     asm_xor();
  1092.     /**rganame*/asmc(rlow_rnew());
  1093.   };
  1094.   asmc(+_FMTALUCMDRB);
  1095.   endasm();
  1096.   _fused = +TRUE; //^^
  1097. }
  1098.  
  1099. PROC emitorrg() //old|new => old
  1100. {
  1101.   unproxy();
  1102.   emitarb( rhigh_rnew() );
  1103.   asm_or(); asm_rhigh_rold(); asmc(+_FMTALUCMDRB); endasm();
  1104.   emitrba( rhigh_rold() );
  1105.   emitarb( rlow_rnew() );
  1106.   asm_or(); asm_rlow_rold(); asmc(+_FMTALUCMDRB); endasm();
  1107.   emitrba( rlow_rold() );
  1108. }
  1109.  
  1110. PROC getorb() //RGA|RGA2 -> RGA
  1111. {
  1112.   IF (_rproxy == _rnew) {
  1113.     asm_or();
  1114.     /**rganame*/asm_rlow_rold();
  1115.     _rproxy = _rold;
  1116.   }ELSE {
  1117.     proxy(_rold);
  1118.     asm_or();
  1119.     /**rganame*/asmc(rlow_rnew());
  1120.   };
  1121.   asmc(+_FMTALUCMDRB);
  1122.   endasm();
  1123.   _fused = +TRUE; //||
  1124. }
  1125.  
  1126. PROC emitandrg() //old&new => old
  1127. {
  1128.   unproxy();
  1129.   emitarb( rhigh_rnew() );
  1130.   asm_and(); asm_rhigh_rold(); asmc(+_FMTALUCMDRB); endasm();
  1131.   emitrba( rhigh_rold() );
  1132.   emitarb( rlow_rnew() );
  1133.   asm_and(); asm_rlow_rold(); asmc(+_FMTALUCMDRB); endasm();
  1134.   emitrba( rlow_rold() );
  1135. }
  1136.  
  1137. PROC getandb() //RGA&RGA2 -> RGA
  1138. {
  1139.   IF (_rproxy == _rnew) {
  1140.     asm_and();
  1141.     /**rganame*/asm_rlow_rold();
  1142.     _rproxy = _rold;
  1143.   }ELSE {
  1144.     proxy(_rold);
  1145.     asm_and();
  1146.     /**rganame*/asmc(rlow_rnew());
  1147.   };
  1148.   asmc(+_FMTALUCMDRB);
  1149.   endasm();
  1150.   _fused = +TRUE; //&&
  1151. }
  1152.  
  1153. PROC emitaddrg() //old+new => old
  1154. { //add ix эш Ёрчє эх яюЄЁхсютрыё 
  1155.   IF ((_rold==0x01)&&(_rnew!=0x04)) {
  1156.     emitaddrgn(_rnew);
  1157.   }ELSE IF ((_rold==0x02)&&(_rnew!=0x04)) {
  1158.     emitexd(); //todo ўхЁхч swaprgs?
  1159.     IF (_rnew==0x01) {emitaddrgn(0x02); //de+hl
  1160.     }ELSE emitaddrgn(_rnew);
  1161.     emitexd(); //todo ўхЁхч swaprgs?
  1162.   }ELSE {
  1163.     unproxy();
  1164.     emitarb(rlow_rold());
  1165.     emitaddrb(rlow_rnew());
  1166.     emitrba(rlow_rold());
  1167.     emitarb(rhigh_rold());
  1168.     emitadcrb(rhigh_rnew());
  1169.     emitrba(rhigh_rold());
  1170.   };
  1171. }
  1172.  
  1173. PROC emitadcrg() //old+new => old
  1174. {
  1175.   IF ((_rold==0x01)&&(_rnew!=0x04)) {
  1176.     emitadcrgn(_rnew);
  1177.   }ELSE IF ((_rold==0x02)&&(_rnew!=0x04)) {
  1178.     emitexd(); //todo ўхЁхч swaprgs?
  1179.     IF (_rnew==0x01) {emitadcrgn(0x02); //de+hl
  1180.     }ELSE emitadcrgn(_rnew);
  1181.     emitexd(); //todo ўхЁхч swaprgs?
  1182.   }ELSE {
  1183.     unproxy();
  1184.     emitarb(rlow_rold());
  1185.     emitadcrb(rlow_rnew());
  1186.     emitrba(rlow_rold());
  1187.     emitarb(rhigh_rold());
  1188.     emitadcrb(rhigh_rnew());
  1189.     emitrba(rhigh_rold());
  1190.   };
  1191. }
  1192.  
  1193. PROC emitaddb() //old+new
  1194. {
  1195.   IF (_rproxy == _rnew) {
  1196.     emitaddrb(rlow_rold());
  1197.     _rproxy = _rold;
  1198.   }ELSE {
  1199.     proxy(_rold);
  1200.     emitaddrb(rlow_rnew());
  1201.   };
  1202. }
  1203.  
  1204. PROC emitaddbconst() //new8+<const>
  1205. {
  1206.   proxy(_rnew);
  1207.   flushcall();
  1208.   asmcmd(+_ASMADD); asm_a(); asm_comma(); asmexprstr(_const); asmc(+_FMTALUCMDN); endasm();
  1209.   losea();
  1210. }
  1211.  
  1212. PROC emitsubrg() //old-new => old
  1213. {
  1214.   IF ((_rold==0x01)&&(_rnew!=0x04)) {
  1215.     asm_or(); asm_a(); asmc(+_FMTALUCMDRB); endasm();
  1216.     emitsbcrgn(_rnew);
  1217. //exd..exd эхт√уюфэю 27 ЄръЄют (хёыш ўхЁхч яхЁхэєьхЁрЎш■ ЁхушёЄЁют, Єю сєфхЄ 23)
  1218.   }ELSE {
  1219.     unproxy();
  1220.     emitarb(rlow_rold());
  1221.     emitsubrb(rlow_rnew());
  1222.     emitrba(rlow_rold());
  1223.     emitarb(rhigh_rold());
  1224.     emitsbcrb(rhigh_rnew());
  1225.     emitrba(rhigh_rold());
  1226.   };
  1227. }
  1228.  
  1229. PROC emitsbcrg() //old-new => old
  1230. {
  1231.   IF ((_rold==0x01)&&(_rnew!=0x04)) {
  1232.     emitsbcrgn(_rnew);
  1233.   }ELSE IF ((_rold==0x02)&&(_rnew!=0x04)) {
  1234.     emitexd(); //todo ўхЁхч swaprgs?
  1235.     IF (_rnew==0x01) {emitsbcrgn(0x02); //de-hl
  1236.     }ELSE emitsbcrgn(_rnew);
  1237.     emitexd(); //todo ўхЁхч swaprgs?
  1238.   }ELSE {
  1239.     unproxy();
  1240.     emitarb(rlow_rold());
  1241.     emitsbcrb(rlow_rnew());
  1242.     emitrba(rlow_rold());
  1243.     emitarb(rhigh_rold());
  1244.     emitsbcrb(rhigh_rnew());
  1245.     emitrba(rhigh_rold());
  1246.   };
  1247. }
  1248.  
  1249. PROC emitsubb() //old-new
  1250. {
  1251.   proxy(_rold);
  1252.   emitsubrb(rlow_rnew());
  1253. }
  1254.  
  1255. PROC emitsubbconst() //new8-<const>
  1256. {
  1257.   proxy(_rnew);
  1258.   emitsubn(_const);
  1259. }
  1260.  
  1261. PROC emitsubflags(BYTE rnew, BYTE rold) //r2-r1 => CY,sign,overflow
  1262. {
  1263.   unproxy();
  1264.   emitarb(_RLOW[(UINT)rold]);
  1265.   emitsubrb(_RLOW[(UINT)rnew]);
  1266.   emitarb(_RHIGH[(UINT)rold]);
  1267.   emitsbcrb(_RHIGH[(UINT)rnew]);
  1268.   _fused = +TRUE;
  1269. }
  1270.  
  1271. PROC emitsubbflags(BYTE anew, BYTE aold) //a2-a1 => CY
  1272. { //sign,overflow эх эєцхэ!
  1273.   proxy(aold);
  1274.   emitsubrb(_RLOW[(UINT)anew]);
  1275.   _rproxy = 0x00;
  1276.   _fused = +TRUE;
  1277. }
  1278.  
  1279. PROC emitsubz() //old-new => Z
  1280. {
  1281.   IF (_rold == 0x01) {
  1282.     emitsubrg();
  1283.   }ELSE {
  1284.     unproxy();
  1285.     emitarb(rlow_rold());
  1286.     emitsubrb(rlow_rnew());
  1287.     IF ((_rold!=0x04)&&(_rnew!=0x04)) {emitjrnz('4');
  1288.     }ELSE emitjrnz('5'); //ix
  1289.     emitarb(rhigh_rold());
  1290.     emitsubrb(rhigh_rnew());
  1291.     _azused = +TRUE; //A ёюфхЁцшЄ яЁртшы№э√щ 0/эх0 яюёых ёЁртэхэш 
  1292.   };
  1293.   _fused = +TRUE;
  1294. }
  1295.  
  1296. PROC emitsubbz() //old-new => Z
  1297. {
  1298.   IF (_rproxy == _rnew) {
  1299.     emitsubrb(rlow_rold());
  1300.   }ELSE {
  1301.     proxy(_rold);
  1302.     emitsubrb(rlow_rnew());
  1303.   };
  1304.   _rproxy = 0x00;
  1305.   _azused = +TRUE; //A ёюфхЁцшЄ яЁртшы№э√щ 0/эх0 яюёых ёЁртэхэш 
  1306.   _fused = +TRUE;
  1307. }
  1308.  
  1309. PROC emitsubbzconst() //new-<const> => Z
  1310. {
  1311.   proxy(_rnew);
  1312.   emitsubn(_const);
  1313.   _rproxy = 0x00;
  1314.   _azused = +TRUE; //A ёюфхЁцшЄ яЁртшы№э√щ 0/эх0 яюёых ёЁртэхэш 
  1315.   _fused = +TRUE;
  1316. }
  1317.  
  1318. PROC emitsublongz() //old2-new, old3-old => Z
  1319. //ld a,low(_rold2)
  1320. //sub low(_rnew)
  1321. //jr nz,$+2+2(1)+1 + 2+1(2)+1 + 2+1(2)+1
  1322. //ld a,high(_rold2)
  1323. //sub high(_rnew)
  1324. //jr nz,$+2+1(2)+1 + 2+1(2)+1
  1325. //ld a,low(_rold3)
  1326. //sub low(_rold)
  1327. //jr nz,$+2+1(2)+1
  1328. //ld a,high(_rold3)
  1329. //sub high(_rold)
  1330. {
  1331.   unproxy();
  1332.   emitarb(_RLOW[(UINT)_rold2]);
  1333.   emitsubrb(rlow_rnew());
  1334.   IF ((_rold3!=0x04)&&(_rold!=0x04)) {emitjrnz('d'); //5+4+4//ix т rold2 шыш rnew
  1335.   }ELSE emitjrnz('e'); //4+5+5//ix т rold3 шыш rold
  1336.   emitarb(_RHIGH[(UINT)_rold2]);
  1337.   emitsubrb(rhigh_rnew());
  1338.   IF ((_rold3!=0x04)&&(_rold!=0x04)) {emitjrnz('8');
  1339.   }ELSE emitjrnz('a'); //ix
  1340.   emitarb(_RLOW[(UINT)_rold3]);
  1341.   emitsubrb(rlow_rold());
  1342.   IF ((_rold3!=0x04)&&(_rold!=0x04)) {emitjrnz('4');
  1343.   }ELSE emitjrnz('5'); //ix
  1344.   emitarb(_RHIGH[(UINT)_rold3]);
  1345.   emitsubrb(rhigh_rold());
  1346.   _fused = +TRUE;
  1347. }
  1348.  
  1349. PROC emitpokerg() //эютюх чряшё√трхь т ёЄрЁє■ ыюърЎш■ ярь Єш
  1350. {
  1351.   IF ((_rold == 0x01)&&(_rnew!=0x04)) {
  1352.     emitmhlrb(rlow_rnew());
  1353.     emitinchl();
  1354.     emitmhlrb(rhigh_rnew());
  1355.   }ELSE {
  1356.     unproxy();
  1357.     emitarb(rlow_rnew());
  1358.     emitmrgna(_rold);
  1359.     emitincrgn(_rold);
  1360.     emitarb(rhigh_rnew());
  1361.     emitmrgna(_rold);
  1362.   };
  1363.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1364.   losea();
  1365. }
  1366.  
  1367. PROC emitpokeb() //эютюх чряшё√трхь т ёЄрЁє■ ыюърЎш■ ярь Єш
  1368. //т rnew ьюцхЄ эх с√Є№ фрээ√ї, хёыш rproxy==rnew!!!
  1369. {
  1370.   IF ((_rold==0x01) && (_rnew!=0x04) && (_rproxy!=_rnew)) {
  1371.     emitmhlrb(rlow_rnew());
  1372.     losea(); //хёыш ёяхЎшры№эю чряшёрыш т  ўхщъє, ъюЄюЁє■ їЁрэшЄ A
  1373.   }ELSE {
  1374.     proxy(_rnew); //шэрўх эхЄ ъюьрэф√ ld [rp],rg
  1375.     emitmrgna(_rold);
  1376.   };
  1377.   _rproxy = 0x00;
  1378.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1379. }
  1380.  
  1381. PROC emitpokelong() //old2(addr), old(high), new(low)
  1382. {
  1383.   IF ((_rold2==0x01)&&(_rnew!=0x04)) {
  1384.     emitmhlrb(rlow_rnew());
  1385.     emitinchl();
  1386.     emitmhlrb(rhigh_rnew());
  1387.     emitinchl();
  1388.     emitmhlrb(rlow_rold());
  1389.     emitinchl();
  1390.     emitmhlrb(rhigh_rold());
  1391.   }ELSE {
  1392.     unproxy();
  1393.     emitarb(rlow_rnew());
  1394.     emitmrgna(_rold2);
  1395.     emitincrgn(_rold2);
  1396.     emitarb(rhigh_rnew());
  1397.     emitmrgna(_rold2);
  1398.     emitincrgn(_rold2);
  1399.     emitarb(rlow_rold());
  1400.     emitmrgna(_rold2);
  1401.     emitincrgn(_rold2);
  1402.     emitarb(rhigh_rold());
  1403.     emitmrgna(_rold2);
  1404.   };
  1405.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1406.   losea();
  1407. }
  1408.  
  1409. PROC emitpeekrg() //[new] => new
  1410. {
  1411.   unproxy();
  1412.   IF (_rnew==0x01) { //hl
  1413.     emitamrgn(0x01);
  1414.     emitinchl();
  1415.     emitrbmhl(+_RG_H);
  1416.     emitrba(+_RG_L);
  1417.   }ELSE {
  1418.     emitamrgn(_rnew);
  1419.     emitincrgn(_rnew);
  1420.     emitexa();
  1421.     emitamrgn(_rnew);
  1422.     emitrba(rhigh_rnew());
  1423.     emitexa();
  1424.     emitrba(rlow_rnew());
  1425.   };
  1426. }
  1427.  
  1428. PROC emitpeekb()
  1429. {
  1430. //  IF (_rnew==0x01) {
  1431. //    emitrbmhl(+_RG_L); //эхт√уюфэю
  1432. //  }ELSE {
  1433.     unproxy();
  1434.     _rproxy = _rnew;
  1435.     emitamrgn(_rnew);
  1436. //  };
  1437. }
  1438.  
  1439. PROC emitpeeklong() //[old] => old(high),new(low)
  1440. {
  1441.   unproxy();
  1442.   IF ((_rold==0x01)&&(_rnew!=0x04)) {
  1443.     emitrbmhl(rlow_rnew());
  1444.     emitinchl();
  1445.     emitrbmhl(rhigh_rnew());
  1446.     emitinchl();
  1447.     emitamrgn(0x01);
  1448.     emitinchl();
  1449.     emitrbmhl(+_RG_H);
  1450.     emitrba(+_RG_L);
  1451.   }ELSE {
  1452.     emitamrgn(_rold);
  1453.     emitincrgn(_rold);
  1454.     emitrba(rlow_rnew());
  1455.     emitamrgn(_rold);
  1456.     emitincrgn(_rold);
  1457.     emitrba(rhigh_rnew());
  1458.     emitamrgn(_rold);
  1459.     emitincrgn(_rold);
  1460.     emitexa();
  1461.     emitamrgn(_rold);
  1462.     emitrba(rhigh_rold());
  1463.     emitexa();
  1464.     emitrba(rlow_rold());
  1465.   };
  1466. }
  1467.  
  1468. PROC emitrgtob() //эхы№ч  єсшЁрЄ№ - ёяхЎшЇшўэю
  1469. {
  1470. }
  1471.  
  1472. PROC emitbtorg()
  1473. {
  1474.   unproxy();
  1475.   emitrb0(rhigh_rnew());
  1476. }
  1477.  
  1478. PROC emitincrg_byname()
  1479. {
  1480.   emitgetrg(+FALSE);
  1481.   emitincrgn(_rnew);
  1482.   emitputrg(+FALSE);
  1483.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1484. }
  1485.  
  1486. PROC emitincb_bypoi()
  1487. {
  1488.   IF (_rnew==0x01) { //hl
  1489.     asm_inc(); asm_open(); asm_rname(0x01); asm_close(); asmc(+_FMTINCDECMHL); endasm();
  1490.   }ELSE IF (_rnew==0x04) { //ix
  1491.     asm_inc(); asm_open(); asm_rname(0x04); asm_close(); asmc(+_FMTINCDECIDX); endasm();
  1492.   }ELSE IF (_rnew==0x02) { //de
  1493.     emitexd(); //todo ўхЁхч swaprgs?
  1494.     asm_inc(); asm_mhl(); asmc(+_FMTINCDECMHL); endasm();
  1495.     emitexd(); //todo ўхЁхч swaprgs?
  1496.   }ELSE /**IF (_rnew==0x03)*/ { //bc
  1497.     unproxy();
  1498.     emitamrgn(_rnew);
  1499.     asm_inc(); asm_a(); asmc(+_FMTINCDECRB); endasm();
  1500.     asm_ld(); asm_open(); asm_rname(_rnew); asm_close(); asm_comma_a(); asmc(+_FMTPUTMRPA); endasm();
  1501.   };
  1502.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1503.   losea();
  1504. }
  1505. /**
  1506. PROC emitinclong() //todo
  1507. {
  1508.   asm_inc(); asm_open(); asm_rname(_rnew); asm_close(); asmc(+_FMTINCDECMHL); endasm();
  1509.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1510. }
  1511. */
  1512. PROC emitdecrg_byname()
  1513. {
  1514.   emitgetrg(+FALSE);
  1515.   emitdecrgn(_rnew);
  1516.   emitputrg(+FALSE);
  1517.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1518. }
  1519.  
  1520. PROC emitdecb_bypoi()
  1521. {
  1522.   IF (_rnew==0x01) { //hl
  1523.     asm_dec(); asm_open(); asm_rname(0x01); asm_close(); asmc(+_FMTINCDECMHL); endasm();
  1524.   }ELSE IF (_rnew==0x04) { //ix
  1525.     asm_dec(); asm_open(); asm_rname(0x04); asm_close(); asmc(+_FMTINCDECIDX); endasm();
  1526.   }ELSE IF (_rnew==0x02) { //de
  1527.     emitexd(); //todo ўхЁхч swaprgs?
  1528.     asm_dec(); asm_mhl(); asmc(+_FMTINCDECMHL); endasm();
  1529.     emitexd(); //todo ўхЁхч swaprgs?
  1530.   }ELSE /**IF (_rnew==0x03)*/ { //bc
  1531.     unproxy();
  1532.     emitamrgn(_rnew);
  1533.     asm_dec(); asm_a(); asmc(+_FMTINCDECRB); endasm();
  1534.     asm_ld(); asm_open(); asm_rname(_rnew); asm_close(); asm_comma_a(); asmc(+_FMTPUTMRPA); endasm();
  1535.   };
  1536.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1537.   losea();
  1538. }
  1539. /**
  1540. PROC emitdeclong() //todo
  1541. {
  1542.   asm_dec(); asm_open(); asm_rname(_rnew); asm_close(); asmc(+_FMTINCDECMHL); endasm();
  1543.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1544. }
  1545. */
  1546.  
  1547. PROC emitincrg_bypoi() //[old], new free
  1548. {
  1549.   IF (_rold==0x01) { //hl
  1550.     emitrbmhl(rlow_rnew());
  1551.     emitinchl();
  1552.     emitrbmhl(rhigh_rnew());
  1553.  
  1554.     emitincrgn(_rnew);
  1555.  
  1556.     emitmhlrb(rhigh_rnew());
  1557.     emitdechl();
  1558.     emitmhlrb(rlow_rnew());
  1559.   }ELSE {
  1560.     unproxy();
  1561.     emitamrgn(_rold);
  1562.     emitrba(rlow_rnew());
  1563.     emitincrgn(_rold);
  1564.     emitamrgn(_rold);
  1565.     emitrba(rhigh_rnew());
  1566.  
  1567.     emitincrgn(_rnew);
  1568.  
  1569.     emitarb(rhigh_rnew());
  1570.     emitmrgna(_rold);
  1571.     emitdecrgn(_rold);
  1572.     emitarb(rlow_rnew());
  1573.     emitmrgna(_rold);
  1574.   };
  1575.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1576.   losea();
  1577. }
  1578.  
  1579. PROC emitdecrg_bypoi() //[old], new free
  1580. {
  1581.   IF (_rold==0x01) { //hl
  1582.     emitrbmhl(rlow_rnew());
  1583.     emitinchl();
  1584.     emitrbmhl(rhigh_rnew());
  1585.  
  1586.     emitdecrgn(_rnew);
  1587.  
  1588.     emitmhlrb(rhigh_rnew());
  1589.     emitdechl();
  1590.     emitmhlrb(rlow_rnew());
  1591.   }ELSE {
  1592.     unproxy();
  1593.     emitamrgn(_rold);
  1594.     emitrba(rlow_rnew());
  1595.     emitincrgn(_rold);
  1596.     emitamrgn(_rold);
  1597.     emitrba(rhigh_rnew());
  1598.  
  1599.     emitdecrgn(_rnew);
  1600.  
  1601.     emitarb(rhigh_rnew());
  1602.     emitmrgna(_rold);
  1603.     emitdecrgn(_rold);
  1604.     emitarb(rlow_rnew());
  1605.     emitmrgna(_rold);
  1606.   };
  1607.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1608.   losea();
  1609. }
  1610.  
  1611. /////////////
  1612. EXPORT PROC initcode()
  1613. {
  1614.   _jpflag = 0x00;
  1615. }
  1616.  
  1617. EXPORT PROC endcode()
  1618. {
  1619.   asmc(+_TOKEOF);
  1620.   varc(+_TOKEOF);
  1621. }
  1622.  
  1623. PROC initrgs()
  1624. {
  1625.   rgs_initrgs();
  1626.   _azused = +FALSE;
  1627.   _fused = +FALSE; //ьюцэю ёфхырЄ№ юфэє яЁюЎхфєЁє initif фы  ¤Єюую (т√ч√трЄ№ т эрўрых if, while, until)
  1628.   _rproxy = 0x00;
  1629. }
  1630.  
  1631. PROC emitfunchead()
  1632. {
  1633.   initrgs();
  1634. }
  1635.  
  1636. PROC setmainb()
  1637. {
  1638.   setmainrg(); //Ёхчєы№ЄрЄ т RMAIN
  1639.   _rproxy = _RMAIN;
  1640. }
  1641.  
  1642. PROC prefernoregs()
  1643. {
  1644.   getnothing(); //Єръ т√уюфэхх inc/dec
  1645. }
  1646.