Subversion Repositories NedoOS

Rev

Rev 8 | Rev 2322 | Go to most recent revision | 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. EXTERN PCHAR _const; //ёЄрЁр  ъюэёЄрэЄр
  15. EXTERN UINT  _lenconst;
  16.  
  17. EXPORT VAR BYTE _exprlvl; //уыєсшэр т√Ёрцхэш  (тхЁїэшщ єЁютхэ№ == 1)
  18.  
  19. //тэх°эшх яЁюЎхфєЁ√ (шч rgs) - todo т codegen эх шёяюы№чютрЄ№ rgs
  20. EXTERN BYTE _rnew;
  21. EXTERN BYTE _rold;
  22. EXTERN BYTE _rold2;
  23. EXTERN BYTE _rold3;
  24.  
  25. //rg pool
  26. PROC getnothing FORWARD(); //ёюїЁрэшЄ№ ЁхушёЄЁ√ ш срщЄ√ т ёЄхъх ш юётюсюфшЄ№
  27. //PROC getmainrg FORWARD(); //тч Є№ RMAIN=new ш юётюсюфшЄ№ юёЄры№э√х ЁхушёЄЁ√
  28. PROC getmain2rgs FORWARD(); //тч Є№ RMAIN=old, RMAIN2=new ш юётюсюфшЄ№ юёЄры№э√х ЁхушёЄЁ√ //фы  call2rgs
  29. //PROC getmain3rgs FORWARD(); //фы  call3rgs
  30. PROC getmain4rgs FORWARD(); //фы  call4rgs
  31. PROC setmainrg FORWARD(); //єёЄрэютшЄ№ яЁшчэръш, ъръ сєфЄю ь√ яюыєўшыш Ёхчєы№ЄрЄ т ЁхушёЄЁх //фы  call2rgs
  32. PROC setmain2rgs FORWARD(); //єёЄрэютшЄ№ яЁшчэръш, ъръ сєфЄю ь√ яюыєўшыш Ёхчєы№ЄрЄ т ЁхушёЄЁрї //фы  call4rgs
  33.  
  34. PROC rgs_initrgs FORWARD();
  35.  
  36. ////
  37. #define _RGBUFSZ (BYTE)(_NRGS+0x01)
  38.  
  39.   //яЁшюЁшЄхЄ√ ЁхушёЄЁют:
  40. CONST BYTE _RMAIN = 0x01; /**HL*/ /**ЁхушёЄЁ Ёхчєы№ЄрЄр ш яхЁтюую ярЁрьхЄЁр ёЄрэфрЁЄэ√ї ЇєэъЎшщ*/
  41. CONST BYTE _RMAIN2= 0x02; /**DE*/ /**ЁхушёЄЁ тЄюЁюую ёыютр Ёхчєы№ЄрЄр ш тЄюЁюую ярЁрьхЄЁр ёЄрэфрЁЄэ√ї ЇєэъЎшщ*/
  42. CONST BYTE _RMAIN3= 0x03;
  43. CONST BYTE _RMAIN4= 0x04;
  44.  
  45. CONST PCHAR _RNAME[_RGBUFSZ] = {
  46.   "", //0 яєёЄющ
  47.   "HL",
  48.   "DE",
  49.   "BC",
  50.   "IX"
  51. };
  52. CONST PCHAR _RHIGH[_RGBUFSZ] = {
  53.   "", //0 яєёЄющ
  54.   "H",
  55.   "D",
  56.   "B",
  57.   "HX"
  58. };
  59. CONST PCHAR _RLOW[_RGBUFSZ] = {
  60.   "", //0 яєёЄющ
  61.   "L",
  62.   "E",
  63.   "C",
  64.   "LX"
  65. };
  66.  
  67. VAR BYTE _rproxy;
  68. VAR BOOL _fused;
  69. VAR BOOL _azused; //A ёюфхЁцшЄ яЁртшы№э√щ 0/эх0 яюёых ёЁртэхэш 
  70.  
  71. VAR INT _funcstkdepth;
  72.  
  73. VAR BYTE _jpflag; //0=OR A:JZ, 1=JZ, 2=JNZ, 3=JNC, 4=JC
  74.  
  75. EXPORT CONST BYTE _typesz[32] = { //ЁрчьхЁ Єшяр т срщЄрї фы  ЄрЁухЄр //чфхё№ эх шёяюы№чєхЄё 
  76.   _SZ_BYTE/**T_BYTE */, //фы  тёхї ЄрЁухЄют
  77.   _SZ_REG/**T_UINT */, //фы  тёхї ЄрЁухЄют
  78.   _SZ_REG/**T_INT  */, //фы  тёхї ЄрЁухЄют
  79.   _SZ_BOOL/**T_BOOL */,
  80.   _SZ_LONG/**T_LONG */,
  81.   _SZ_BYTE/**T_CHAR */,
  82.   _SZ_LONG/**T_FLOAT*/,
  83.   0x00/**unknown*/,
  84.   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  85.   _SZ_REG/**T_PBYTE */,
  86.   _SZ_REG/**T_PUINT */,
  87.   _SZ_REG/**T_PINT  */,
  88.   _SZ_REG/**T_PBOOL */,
  89.   _SZ_REG/**T_PLONG */,
  90.   _SZ_REG/**T_PCHAR */,
  91.   _SZ_REG/**T_PFLOAT*/,
  92.   _SZ_REG/**        */,
  93.   _SZ_REG, _SZ_REG, _SZ_REG, _SZ_REG, _SZ_REG, _SZ_REG, _SZ_REG, _SZ_REG //pointer to...
  94. };
  95.  
  96. CONST BYTE _typeshift[32] = { //log ЁрчьхЁ Єшяр (n фы  2^n срщЄ) фы  ЄрЁухЄр //чфхё№ эх шёяюы№чєхЄё 
  97.   _RL_BYTE/**T_BYTE */, //фы  тёхї ЄрЁухЄют
  98.   _RL_REG/**T_UINT */, //фы  тёхї ЄрЁухЄют
  99.   _RL_REG/**T_INT  */, //фы  тёхї ЄрЁухЄют
  100.   _RL_BOOL/**T_BOOL */,
  101.   _RL_LONG/**T_LONG */,
  102.   _RL_BYTE/**T_CHAR */,
  103.   _RL_LONG/**T_FLOAT*/,
  104.   0x00/**unknown*/,
  105.   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  106.   _RL_REG/**T_BYTE  */,
  107.   _RL_REG/**T_UINT  */,
  108.   _RL_REG/**T_INT   */,
  109.   _RL_REG/**T_BOOL  */,
  110.   _RL_REG/**T_LONG  */,
  111.   _RL_REG/**T_CHAR  */,
  112.   _RL_REG/**T_PFLOAT*/,
  113.   _RL_REG/**        */,
  114.   _RL_REG, _RL_REG, _RL_REG, _RL_REG, _RL_REG, _RL_REG, _RL_REG, _RL_REG //pointer to...
  115. };
  116.  
  117. PROC initrgs FORWARD(); //юўшёЄшЄ№ ёюёЄю эш  ЁхушёЄЁют ш срщЄют (шёяюы№чєхЄё  т cemitfunc)
  118.  
  119. //////////// ьхыъшх яЁюЎхфєЁ√ фы  ёюъЁр∙хэш  ўшёыр ъюэёЄрэЄ
  120.  
  121. EXPORT PROC var_alignwsz()
  122. {
  123. }
  124.  
  125. PROC asm_comma()
  126. {
  127.   asmc(',');
  128. }
  129.  
  130. PROC asm_open()
  131. {
  132.   asmc('[');
  133. }
  134.  
  135. PROC asm_close()
  136. {
  137.   asmc(']');
  138. }
  139.  
  140. PROC asm_rname(BYTE r)
  141. {
  142.   asmstr( _RNAME[+(UINT)r] );
  143. }
  144.  
  145. PROC asm_mrgname(BYTE r)
  146. {
  147.   asm_open(); asm_rname(r); asm_close();
  148. }
  149.  
  150. PROC asm_rlow(BYTE r)
  151. {
  152.   asmstr( _RLOW[+(UINT)r] );
  153. }
  154.  
  155. PROC asm_rhigh(BYTE r)
  156. {
  157.   asmstr( _RHIGH[+(UINT)r] );
  158. }
  159. /**
  160. PROC asm_raname(BYTE r)
  161. {
  162.   asmstr( _RLOW[+(UINT)r] );
  163.   //asmstr( _RGANAME[+(UINT)r] );
  164. }
  165. */
  166. PROC asm_close_eol()
  167. {
  168.   asm_close(); endasm();
  169. }
  170.  
  171. PROC asm_a()
  172. {
  173.   asmc('A');
  174. }
  175.  
  176. PROC asm_hl()
  177. {
  178.   asm_rname(0x01);
  179. }
  180.  
  181. PROC asm_mhl()
  182. {
  183.   asm_mrgname(0x01);
  184. }
  185.  
  186. EXPORT PROC var_db() //фюёЄєяэю шч compile!
  187. {
  188.   varstr( "\tDB " );
  189. }
  190.  
  191. EXPORT PROC asm_db() //ъюёЄ√ы№ фы  ъюэёЄрэЄэ√ї ьрёёштют ёЄЁюъ TODO
  192. {
  193.   asmstr( "\tDB " );
  194. }
  195.  
  196. EXPORT PROC var_dw() //фюёЄєяэю шч compile!
  197. {
  198.   varstr( "\tDW " );
  199. }
  200.  
  201. PROC var_dl()
  202. {
  203.   varstr( "\tDL " );
  204. }
  205.  
  206. EXPORT PROC var_ds() //фюёЄєяэю шч compile!
  207. {
  208.   varstr( "\tDS " );
  209. }
  210.  
  211. PROC asm_and()
  212. {
  213.   asmstr( "\tAND " );
  214. }
  215.  
  216. PROC asm_or()
  217. {
  218.   asmstr( "\tOR " );
  219. }
  220.  
  221. PROC asm_xor()
  222. {
  223.   asmstr( "\tXOR " );
  224. }
  225.  
  226. PROC asm_sub()
  227. {
  228.   asmstr( "\tSUB " );
  229. }
  230.  
  231. PROC asm_sbc()
  232. {
  233.   asmstr( "\tSBC " );
  234. }
  235.  
  236. PROC asm_add()
  237. {
  238.   asmstr( "\tADD " );
  239. }
  240.  
  241. PROC asm_adc()
  242. {
  243.   asmstr( "\tADC " );
  244. }
  245.  
  246. PROC asm_inc()
  247. {
  248.   asmstr( "\tINC " );
  249. }
  250.  
  251. PROC asm_dec()
  252. {
  253.   asmstr( "\tDEC " );
  254. }
  255.  
  256. PROC asm_ld()
  257. {
  258.   asmstr( "\tLD " );
  259. }
  260.  
  261. PROC asm_jp()
  262. {
  263.   asmstr( "\tJP " );
  264. }
  265.  
  266. PROC emitjrnz(CHAR c)
  267. {
  268.   asmstr("\tJR NZ,$+0x");
  269.   asmc(c);
  270.   endasm();
  271. }
  272.  
  273. PROC asm_ex()
  274. {
  275.   asmstr( "\tEX " );
  276. }
  277.  
  278. PROC asm_push()
  279. {
  280.   asmstr( "\tPUSH " );
  281. }
  282.  
  283. PROC asm_pop()
  284. {
  285.   asmstr( "\tPOP " );
  286. }
  287.  
  288. PROC asm_lda_comma()
  289. {
  290.   asm_ld(); asm_a(); asm_comma();
  291. }
  292.  
  293. PROC asm_ldmhl_comma()
  294. {
  295.   asm_ld(); asm_mhl(); asm_comma();
  296. }
  297.  
  298. PROC asm_comma_a_eol()
  299. {
  300.   asm_comma(); asm_a(); endasm();
  301. }
  302.  
  303. PROC asm_comma_mhl_eol()
  304. {
  305.   asm_comma(); asm_mhl(); endasm();
  306. }
  307.  
  308. PROC emitinchl()
  309. {
  310.   asm_inc(); asm_rname(0x01); endasm();
  311. }
  312.  
  313. PROC emitexa()
  314. {
  315.   asm_ex(); asmstr("AF,AF\'"); endasm();
  316. }
  317.  
  318. PROC emitexd()
  319. {
  320.   asm_ex(); asmstr("DE,HL"); endasm();
  321. }
  322.  
  323. PROC emitccf()
  324. {
  325.   asmstr( "\tCCF" ); endasm();
  326. }
  327.  
  328. PROC emitcall(PCHAR s)
  329. {
  330.   asmstr( "\tCALL " ); asmstr( s ); endasm();
  331. }
  332.  
  333. ///////////////////////////////////
  334. //фюёЄєяэ√ шч commands
  335. PROC unproxy()
  336. {
  337.   IF (_rproxy != 0x00) { //т яЁюъёш ўЄю-Єю с√ыю
  338.     asm_ld(); /**rganame*/asm_rlow(_rproxy); asm_comma_a_eol();
  339.     _rproxy = 0x00;
  340.   };
  341. }
  342.  
  343. PROC proxy(BYTE r)
  344. {
  345.   IF (_rproxy != r) {
  346.     unproxy();
  347.     asm_lda_comma(); /**rganame*/asm_rlow(r); endasm();
  348.     _rproxy = r;
  349.   };
  350. }
  351.  
  352. ///////////////////////////////////////////////////////////
  353. //яЁюЎхфєЁ√ ё ьр°шээ√ь ъюфюь фы  rgs
  354.  
  355. PROC emitpushrg(BYTE rnew)
  356. {
  357.   unproxy(); //todo юяЄшьшчшЁютрЄ№
  358.   asm_push(); asm_rname(rnew); endasm();
  359.   INC _funcstkdepth;
  360. }
  361.  
  362. PROC emitpoprg(BYTE rnew) //ЁхушёЄЁ єцх яюьхўхэ т getrfree/getrg
  363. {
  364.   asm_pop(); asm_rname(rnew); endasm();
  365.   DEC _funcstkdepth;
  366. }
  367.  
  368. PROC emitmovrg(BYTE rsrc, BYTE rdest) //эх чрърч√трхЄ ш эх юётюсюцфрхЄ (ёь. emitmoverg)
  369. {
  370.   IF (rsrc!=rdest) { //todo шыш ёЁртэштрЄ№ rsrc!=rdest ёэрЁєцш?
  371.     //rdest эх ьюцхЄ с√Є№ FASTRG4? хёыш ёфхырЄ№ ЇєэъЎш■ getslowrg, Єю ьюцхЄ :(
  372.     IF ( ((rdest==0x04)&&(rsrc==0x01))
  373.        ||((rdest==0x01)&&(rsrc==0x04))
  374.        ) {
  375.       asm_push(); asm_rname(rsrc); endasm();
  376.       asm_pop(); asm_rname(rdest); endasm();
  377.     }ELSE {
  378.       asm_ld(); asm_rhigh(rdest); asm_comma(); asm_rhigh(rsrc); endasm();
  379.       asm_ld(); asm_rlow(rdest); asm_comma(); asm_rlow(rsrc); endasm();
  380.     };
  381.   };
  382. }
  383.  
  384. ///////////////////////////////////////////////////////////////////////////////////////
  385. //¤Єш яЁюЎхфєЁ√ ухэхЁшЁє■Є ъюф
  386. //эхфюёЄєяэ√ шч ъюьяшы ЄюЁр, фюёЄєяэ√ шч commands
  387.  
  388. EXPORT PROC emitasmlabel(PCHAR s)
  389. {
  390.   asmstr(s); /**asmc( ':' );*/ endasm();
  391. }
  392.  
  393. EXPORT PROC emitfunclabel(PCHAR s)
  394. {
  395.   asmstr(s); /**asmc( ':' );*/ endasm();
  396. }
  397.  
  398. EXPORT PROC emitvarlabel(PCHAR s)
  399. {
  400.   varstr(s); /**varc( ':' );*/ endvar();
  401. }
  402.  
  403. EXPORT PROC emitexport(PCHAR s) //todo тёхуфр _joined
  404. {
  405.   asmstr("\tEXPORT "); asmstr(s); endasm();
  406. }
  407.  
  408. EXPORT PROC emitvarpreequ(PCHAR s)
  409. {
  410. }
  411.  
  412. EXPORT PROC emitvarpostequ()
  413. {
  414. }
  415.  
  416. EXPORT PROC varequ(PCHAR s)
  417. {
  418.   varstr(s); varc('=');
  419. }
  420.  
  421. EXPORT FUNC UINT varshift(UINT shift, UINT sz)
  422. {
  423.   //IF (sz >= 4) shift = (shift+3)&(UINT)(-4);
  424.   //asmstr(_joined); asmc('='); asmuint(shift); endasm();
  425.   varequ(_joined); /**varstr(_joined); varc('=');*/ varuint(shift); endvar();
  426. RETURN shift;
  427. }
  428.  
  429. PROC emitjpmainrg() //"jp (hl)"
  430. {
  431.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  432.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  433.   unproxy();
  434.   getnothing(); //getnothingword();
  435.   asm_jp(); asm_mhl(); endasm();
  436. }
  437.  
  438. PROC emitcallmainrg() //"call (hl)"
  439. {
  440.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  441.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  442.   unproxy();
  443.   getnothing(); //getnothingword();
  444.   emitcall("_JPHL.");
  445.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  446. }
  447.  
  448. PROC emitjp()
  449. {
  450.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  451.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  452.   unproxy();
  453.   getnothing(); //getnothingword();
  454.   asm_jp(); asmstr(_joined); endasm();
  455. }
  456.  
  457. PROC emitbtoz() //яхЁхф jp!
  458. {
  459.   //ёЁрчє яюёых ёЁртэхэш  эх эрфю, эю тфЁєу ь√ ўшЄрхь BOOL
  460.   //IF (_jpflag == 0x00) {
  461.   IF (!_fused) { //Ёхчєы№ЄрЄр эхЄ тю Їырурї
  462.     proxy(_rnew); //todo юяЄшьшчшЁютрЄ№
  463.     //IF (anew==_RGA) {
  464.       asm_or(); asm_a(); endasm();
  465.     //}ELSE {
  466.     //  asm_inc(); /**rganame*/asm_rlow(anew); endasm();
  467.     //  asm_dec(); /**rganame*/asm_rlow(anew); endasm();
  468.     //};
  469.   };
  470.   _rproxy = 0x00;
  471. }
  472.  
  473. PROC emitjpiffalse()
  474. {
  475.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  476.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  477.   //unproxy();
  478.   getnothing(); //getnothingword();
  479.   asm_jp();
  480.   IF       (_jpflag == 0x02) {asmstr("NZ");
  481.   }ELSE IF (_jpflag == 0x03) {asmstr("NC");
  482.   }ELSE IF (_jpflag == 0x04) {asmc('C');
  483.   }ELSE                      {asmc('Z');
  484.   };
  485.   asm_comma();
  486.   asmstr(_joined);
  487.   endasm();
  488.   _fused = +FALSE;
  489.   _jpflag = 0x00;
  490. }
  491.  
  492. PROC emitret()
  493. {
  494.   //unproxy();
  495.   asmstr( "\tRET" ); endasm();
  496. }
  497.  
  498. PROC emitcall2rgs(PCHAR s)
  499. {
  500.   unproxy();
  501.   getmain2rgs();
  502.   initrgs();
  503.   emitcall(s);
  504.   setmainrg(); //Ёхчєы№ЄрЄ т RMAIN
  505. }
  506. /**
  507. PROC emitcall3rgs(PCHAR s) //todo яЁютхЁшЄ№
  508. {
  509.   unproxy();
  510.   getmain3rgs();
  511.   initrgs();
  512.   emitcall(s);
  513.   //ёхщўрё тёх ЁхушёЄЁ√ юЄьхўхэ√ ъръ ётюсюфэ√х
  514.   //setwordcontext();
  515.   setmain2rgs(); //Ёхчєы№ЄрЄ т RMAIN,RMAIN2
  516. }
  517. */
  518. PROC emitcall4rgs(PCHAR s) //todo яЁютхЁшЄ№
  519. {
  520.   unproxy();
  521.   getmain4rgs();
  522.   initrgs();
  523.   emitcall(s);
  524.   //ёхщўрё тёх ЁхушёЄЁ√ юЄьхўхэ√ ъръ ётюсюфэ√х
  525.   //setwordcontext();
  526.   setmain2rgs(); //Ёхчєы№ЄрЄ т RMAIN,RMAIN2
  527. }
  528.  
  529. PROC emitcallproc()
  530. {
  531.   //_jpflag = 0x00;
  532.   emitcall(_callee);
  533. }
  534.  
  535. PROC emitloadrg(BOOL high) //ЁхушёЄЁ єцх чрэ Є ўхЁхч getrfree
  536. {
  537.   asm_ld();
  538.   asm_rname(_rnew);
  539.   asm_comma();
  540.   asmstr(_const);
  541.   IF (high) {asmstr( ">>16"/**WORDBITS*/ );
  542.   //}ELSE {asmstr( "&0xffff"/**WORDMASK*/ );
  543.   };
  544.   endasm();
  545.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  546. }
  547.  
  548. PROC emitloadrg0() //ЁхушёЄЁ єцх чрэ Є ўхЁхч getrfree
  549. {
  550.   asm_ld(); asm_rname(_rnew); asm_comma(); asmc('0'); endasm();
  551. }
  552.  
  553. PROC emitloadb() //ръъєьєы ЄюЁ єцх чрэ Є ўхЁхч getfreea
  554. {
  555.   IF (_rproxy == 0x00) {
  556.     _rproxy = _rnew;
  557.     asm_lda_comma();
  558.   }ELSE {
  559.     asm_ld();
  560.     /**rganame*/asm_rlow(_rnew);
  561.     asm_comma();
  562.   };
  563.   asmstr(_const);
  564.   endasm();
  565.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  566. }
  567.  
  568. PROC emitgetrg(BOOL high) //ЁхушёЄЁ єцх чрэ Є ўхЁхч getrfree
  569. {
  570.   asm_ld();
  571.   asm_rname(_rnew);
  572.   asm_comma();
  573.   asm_open();
  574.   asmstr(_joined);
  575.   IF (high) {asmc('+'); asmc('2');
  576.   };
  577.   asm_close();
  578.   endasm();
  579. }
  580.  
  581. PROC emitgetb() //ръъєьєы ЄюЁ єцх чрэ Є ўхЁхч getfreea
  582. {
  583.   unproxy();
  584.   _rproxy = _rnew;
  585.   asm_lda_comma();
  586.   asm_open();
  587.   asmstr(_joined);
  588.   asm_close();
  589.   endasm();
  590. }
  591.  
  592. PROC emitputrg(BOOL high) //ld [],new
  593. {
  594.   //_jpflag = 0x00;
  595.   asm_ld(); asm_open();
  596.   asmstr(_joined);
  597.   IF (high) {asmc('+'); asmc('2'); //asmstr( "+2"/**WORDSIZE*/ );
  598.   };
  599.   asm_close(); asm_comma();
  600.   asm_rname(_rnew);
  601.   endasm();
  602.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  603. }
  604.  
  605. PROC emitputb()
  606. {
  607.   //_jpflag = 0x00;
  608.   proxy(_rnew);
  609.   asm_ld(); asm_open();
  610.   asmstr(_joined);
  611.   asm_close();
  612.   asm_comma_a_eol();
  613.   _rproxy = 0x00;
  614.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  615. }
  616.  
  617. PROC emitshl1rg()
  618. {
  619.   IF ((_rnew == 0x01)||(_rnew == 0x04)) {
  620.     asm_add(); asm_hl(); asm_comma(); asm_hl(); endasm();
  621.   }ELSE {
  622.     asmstr( "\tSLA " ); asm_rlow(_rnew); endasm();
  623.     asmstr( "\tRL " ); asm_rhigh(_rnew); endasm();
  624.   };
  625. }
  626.  
  627. PROC emitshl1b()
  628. {
  629.     proxy(_rnew);
  630.   //IF (_rproxy==_rnew) {
  631.     asm_add(); asm_a(); asm_comma_a_eol();
  632.   //}ELSE {
  633.   //  asmstr( "\tSLA " ); /**rganame*/asm_rlow(anew); endasm();
  634.   //};
  635. }
  636. /**
  637. PROC emitshr1rg(BYTE rnew)
  638. {
  639.   asmstr( "\tSRL " ); asm_rhigh(rnew); endasm();
  640.   asmstr( "\tRR " ); asm_rlow(rnew); endasm();
  641. }
  642.  
  643. PROC emitshr1signedrg(BYTE rnew)
  644. {
  645.   asmstr( "\tSRA " ); asm_rhigh(rnew); endasm();
  646.   asmstr( "\tRR " ); asm_rlow(rnew); endasm();
  647. }
  648. */
  649. //PROC emitshr1b(BYTE anew)
  650. //{
  651. //  asmstr( "\tSRL " ); /**rganame*/asm_rlow(anew] ); endasm();
  652. //}
  653.  
  654. PROC emitinvb() //~A -> A
  655. {
  656.   proxy(_rnew);
  657.   asmstr( "\tCPL" ); endasm();
  658.   _fused = +FALSE; //шэрўх уы■ъ if (!(a||b))
  659. }
  660.  
  661. PROC emitinvrg()
  662. {
  663.   unproxy();
  664.   asm_lda_comma(); asm_rhigh(_rnew); endasm();
  665.   asmstr( "\tCPL" ); endasm();
  666.   asm_ld(); asm_rhigh(_rnew); asm_comma_a_eol();
  667.   emitinvb();
  668.   unproxy(); //шэрўх уы■ъ яхЁхф poke
  669.   //asm_lda_comma(); asm_rlow(_rnew); endasm();
  670.   //asmstr( "\tCPL" ); endasm();
  671.   //asm_ld(); asm_rlow(_rnew); asm_comma_a_eol();
  672.   //unreserverg( _RGA );
  673. }
  674.  
  675. PROC emitnegrg()
  676. {
  677.   unproxy();
  678.   asm_xor(); asm_a(); endasm();
  679.   asm_sub(); asm_rlow(_rnew); endasm();
  680.   asm_ld(); asm_rlow(_rnew); asm_comma_a_eol();
  681.   asm_sbc(); asm_a(); asm_comma(); asm_rhigh(_rnew); endasm();
  682.   asm_sub(); asm_rlow(_rnew); endasm();
  683.   asm_ld(); asm_rhigh(_rnew); asm_comma_a_eol();
  684. }
  685.  
  686. PROC emitztob()
  687. {
  688.   //asmstr(";emitztoa exprlvl="); asmuint(_exprlvl); endasm();
  689.   IF (_exprlvl != 0x01) { //if (a == b)
  690.     IF (_azused) { //A ёюфхЁцшЄ яЁртшы№э√щ 0/эх0 яюёых ёЁртэхэш 
  691.       //unproxy();
  692.       asm_sub(); asmc('1'); endasm();
  693.       asm_sbc(); asm_a(); asm_comma_a_eol();
  694.       _rproxy = _rnew;
  695.       _azused = +FALSE;
  696.     }ELSE {
  697.       asm_ld(); asm_rlow(_rnew); asm_comma(); asmc('0'); endasm();
  698.       IF (_rnew != 0x04) {emitjrnz('3');
  699.       }ELSE emitjrnz('4'); //ix
  700.       asm_dec(); asm_rlow(_rnew); endasm();
  701.     };
  702.     _fused = +FALSE; //шэрўх уы■ъ яЁш if ((a==b))
  703.     //_jpflag = 0x00;
  704.   }ELSE {
  705.     //_fused = +TRUE;
  706.     _jpflag = 0x02;
  707.   };
  708. }
  709.  
  710. PROC emitinvztob()
  711. {
  712.   //asmstr(";emitinvztoa exprlvl="); asmuint(_exprlvl); endasm();
  713.   IF (_exprlvl != 0x01) { //if (a != b)
  714.     IF (_azused) { //A ёюфхЁцшЄ яЁртшы№э√щ 0/эх0 яюёых ёЁртэхэш 
  715.       //unproxy();
  716.       asmstr("\tJR Z,$+4"); endasm();
  717.       asm_lda_comma(); asmstr("-1"); endasm();
  718.       _rproxy = _rnew;
  719.       _azused = +FALSE;
  720.     }ELSE {
  721.       asm_ld(); asm_rlow(_rnew); asm_comma(); asmc('0'); endasm();
  722.       IF (_rnew != 0x04) {asmstr( "\tJR Z,$+3" );
  723.       }ELSE asmstr( "\tJR Z,$+4" ); //ix
  724.       endasm();
  725.       asm_dec(); asm_rlow(_rnew); endasm();
  726.     };
  727.     _fused = +FALSE; //шэрўх уы■ъ яЁш if ((a!=b))? todo test //тючьюцхэ уы■ъ ifnot ((a!=b))
  728.     //_jpflag = 0x00;
  729.   }ELSE {
  730.     //_fused = +TRUE;
  731.     _jpflag = 0x01;
  732.   };
  733. }
  734.  
  735. PROC emitcytob()
  736. {
  737.   //asmstr(";emitcytoa exprlvl="); asmuint(_exprlvl); endasm();
  738.   IF (_exprlvl != 0x01) { //if (a < b)
  739.     unproxy();
  740.     asm_sbc(); asm_a(); asm_comma_a_eol();
  741.     _rproxy = _rnew;
  742.     //_fused = +FALSE;
  743.     //_jpflag = 0x00;
  744.   }ELSE {
  745.     //_fused = +TRUE;
  746.     _jpflag = 0x03;
  747.   };
  748. }
  749.  
  750. PROC emitinvcytob()
  751. {
  752.   //asmstr(";emitinvcytoa exprlvl="); asmuint(_exprlvl); endasm();
  753.   IF (_exprlvl != 0x01) { //if (a >= b)
  754.     emitccf();
  755.     unproxy();
  756.     asm_sbc(); asm_a(); asm_comma_a_eol();
  757.     _rproxy = _rnew;
  758.     //_fused = +FALSE;
  759.     //_jpflag = 0x00;
  760.   }ELSE {
  761.     //_fused = +TRUE;
  762.     _jpflag = 0x04;
  763.   };
  764. }
  765.  
  766. PROC emitSxorVtob() //яюёых subflags, ЁрчЁхчхЁтшЁєхЄ A
  767. {
  768.   asmstr( "\tRLA" ); endasm(); //sign
  769.   asm_jp(); asmstr( "PO,$+4" ); endasm();
  770.   emitccf();
  771.   emitcytob();
  772. }
  773.  
  774. PROC emitinvSxorVtob() //яюёых subflags, ЁрчЁхчхЁтшЁєхЄ A
  775. {
  776.   asmstr( "\tRLA" ); endasm(); //sign
  777.   asm_jp(); asmstr( "PE,$+4" ); endasm();
  778.   emitccf();
  779.   emitcytob();
  780. }
  781.  
  782. PROC emitxorrg() //old^new => old
  783. {
  784.   unproxy();
  785.   asm_lda_comma(); asm_rhigh(_rnew); endasm();
  786.   asm_xor(); asm_rhigh(_rold); endasm();
  787.   asm_ld(); asm_rhigh(_rold); asm_comma_a_eol();
  788.   asm_lda_comma(); asm_rlow(_rnew); endasm();
  789.   asm_xor(); asm_rlow(_rold); endasm();
  790.   asm_ld(); asm_rlow(_rold); asm_comma_a_eol();
  791. }
  792.  
  793. PROC getxorb() //RGA^RGA2 -> RGA
  794. {
  795.   IF (_rproxy == _rnew) {
  796.     asm_xor();
  797.     /**rganame*/asm_rlow(_rold);
  798.     _rproxy = _rold;
  799.   }ELSE {
  800.     proxy(_rold);
  801.     asm_xor();
  802.     /**rganame*/asm_rlow(_rnew);
  803.   };
  804.    endasm();
  805.   _fused = +TRUE; //^^
  806. }
  807.  
  808. PROC emitorrg() //old|new => old
  809. {
  810.   unproxy();
  811.   asm_lda_comma(); asm_rhigh(_rnew); endasm();
  812.   asm_or(); asm_rhigh(_rold); endasm();
  813.   asm_ld(); asm_rhigh(_rold); asm_comma_a_eol();
  814.   asm_lda_comma(); asm_rlow(_rnew); endasm();
  815.   asm_or(); asm_rlow(_rold); endasm();
  816.   asm_ld(); asm_rlow(_rold); asm_comma_a_eol();
  817. }
  818.  
  819. PROC getorb() //RGA|RGA2 -> RGA
  820. {
  821.   IF (_rproxy == _rnew) {
  822.     asm_or();
  823.     /**rganame*/asm_rlow(_rold);
  824.     _rproxy = _rold;
  825.   }ELSE {
  826.     proxy(_rold);
  827.     asm_or();
  828.     /**rganame*/asm_rlow(_rnew);
  829.   };
  830.   endasm();
  831.   _fused = +TRUE; //||
  832. }
  833.  
  834. PROC emitandrg() //old&new => old
  835. {
  836.   unproxy();
  837.   asm_lda_comma(); asm_rhigh(_rnew); endasm();
  838.   asm_and(); asm_rhigh(_rold); endasm();
  839.   asm_ld(); asm_rhigh(_rold); asm_comma_a_eol();
  840.   asm_lda_comma(); asm_rlow(_rnew); endasm();
  841.   asm_and(); asm_rlow(_rold); endasm();
  842.   asm_ld(); asm_rlow(_rold); asm_comma_a_eol();
  843. }
  844.  
  845. PROC getandb() //RGA&RGA2 -> RGA
  846. {
  847.   IF (_rproxy == _rnew) {
  848.     asm_and();
  849.     /**rganame*/asm_rlow(_rold);
  850.     _rproxy = _rold;
  851.   }ELSE {
  852.     proxy(_rold);
  853.     asm_and();
  854.     /**rganame*/asm_rlow(_rnew);
  855.   };
  856.   endasm();
  857.   _fused = +TRUE; //&&
  858. }
  859.  
  860. PROC emitaddrg() //old+new => old
  861. { //add ix эш Ёрчє эх яюЄЁхсютрыё 
  862.   IF ((_rold==0x01)&&(_rnew!=0x04)) {
  863.     asm_add(); asm_hl(); asm_comma(); asm_rname(_rnew); endasm();
  864.   }ELSE IF ((_rold==0x02)&&(_rnew!=0x04)) {
  865.     emitexd(); //todo ўхЁхч swaprgs?
  866.     asm_add(); asm_hl(); asm_comma();
  867.     IF (_rnew==0x01) {asm_rname(0x02); //de+hl
  868.     }ELSE asm_rname(_rnew);
  869.     endasm();
  870.     emitexd(); //todo ўхЁхч swaprgs?
  871.   }ELSE {
  872.     unproxy();
  873.     asm_lda_comma(); asm_rlow(_rold); endasm();
  874.     asm_add(); asm_a(); asm_comma(); asm_rlow(_rnew); endasm();
  875.     asm_ld(); asm_rlow(_rold); asm_comma_a_eol();
  876.     asm_lda_comma(); asm_rhigh(_rold); endasm();
  877.     asm_adc(); asm_a(); asm_comma(); asm_rhigh(_rnew); endasm();
  878.     asm_ld(); asm_rhigh(_rold); asm_comma_a_eol();
  879.   };
  880. }
  881.  
  882. PROC emitadcrg() //old+new => old
  883. {
  884.   IF ((_rold==0x01)&&(_rnew!=0x04)) {
  885.     asm_adc(); asm_hl(); asm_comma(); asm_rname(_rnew); endasm();
  886.   }ELSE IF ((_rold==0x02)&&(_rnew!=0x04)) {
  887.     emitexd(); //todo ўхЁхч swaprgs?
  888.     asm_adc(); asm_hl(); asm_comma();
  889.     IF (_rnew==0x01) {asm_rname(0x02); //de+hl
  890.     }ELSE asm_rname(_rnew);
  891.     endasm();
  892.     emitexd(); //todo ўхЁхч swaprgs?
  893.   }ELSE {
  894.     unproxy();
  895.     asm_lda_comma(); asm_rlow(_rold); endasm();
  896.     asm_adc(); asm_a(); asm_comma(); asm_rlow(_rnew); endasm();
  897.     asm_ld(); asm_rlow(_rold); asm_comma_a_eol();
  898.     asm_lda_comma(); asm_rhigh(_rold); endasm();
  899.     asm_adc(); asm_a(); asm_comma(); asm_rhigh(_rnew); endasm();
  900.     asm_ld(); asm_rhigh(_rold); asm_comma_a_eol();
  901.   };
  902. }
  903.  
  904. PROC emitaddb() //old+new
  905. {
  906.   IF (_rproxy == _rnew) {
  907.     asm_add(); asm_a(); asm_comma(); /**rganame*/asm_rlow(_rold); endasm();
  908.     _rproxy = _rold;
  909.   }ELSE {
  910.     proxy(_rold);
  911.     asm_add(); asm_a(); asm_comma(); /**rganame*/asm_rlow(_rnew); endasm();
  912.   };
  913. }
  914.  
  915. PROC emitaddbconst() //new8+<const>
  916. {
  917.   proxy(_rnew);
  918.   asm_add(); asm_a(); asm_comma(); asmstr(_const); endasm();
  919. }
  920.  
  921. PROC emitsubrg() //old-new => old
  922. {
  923.   IF ((_rold==0x01)&&(_rnew!=0x04)) {
  924.     asm_or(); asm_a(); endasm();
  925.     asm_sbc(); asm_hl(); asm_comma(); asm_rname(_rnew); endasm();
  926. /**  }ELSE IF ((_rold==0x02)&&(_rnew!=0x04)) {
  927.     asmstr("\tOR A"); endasm();
  928.     emitexd(); //todo ўхЁхч swaprgs?
  929.     asmstr("\tSBC HL,"); asm_rname(rnew); endasm();
  930.     emitexd(); //todo ўхЁхч swaprgs?
  931.     //эхт√уюфэю 27 ЄръЄют (хёыш ўхЁхч яхЁхэєьхЁрЎш■ ЁхушёЄЁют, Єю сєфхЄ 23)
  932. */
  933.   }ELSE {
  934.     unproxy();
  935.     asm_lda_comma(); asm_rlow(_rold); endasm();
  936.     asm_sub(); asm_rlow(_rnew); endasm();
  937.     asm_ld(); asm_rlow(_rold); asm_comma_a_eol();
  938.     asm_lda_comma(); asm_rhigh(_rold); endasm();
  939.     asm_sbc(); asm_a(); asm_comma(); asm_rhigh(_rnew); endasm();
  940.     asm_ld(); asm_rhigh(_rold); asm_comma_a_eol();
  941.   };
  942. }
  943.  
  944. PROC emitsbcrg() //old-new => old
  945. {
  946.   IF ((_rold==0x01)&&(_rnew!=0x04)) {
  947.     asm_sbc(); asm_hl(); asm_comma(); asm_rname(_rnew); endasm();
  948.   }ELSE IF ((_rold==0x02)&&(_rnew!=0x04)) {
  949.     emitexd(); //todo ўхЁхч swaprgs?
  950.     asm_sbc(); asm_hl(); asm_comma();
  951.     IF (_rnew==0x01) {asm_rname(0x02); //de-hl
  952.     }ELSE asm_rname(_rnew);
  953.     endasm();
  954.     emitexd(); //todo ўхЁхч swaprgs?
  955.   }ELSE {
  956.     unproxy();
  957.     asm_lda_comma(); asm_rlow(_rold); endasm();
  958.     asm_sbc(); asm_a(); asm_comma(); asm_rlow(_rnew); endasm();
  959.     asm_ld(); asm_rlow(_rold); asm_comma_a_eol();
  960.     asm_lda_comma(); asm_rhigh(_rold); endasm();
  961.     asm_sbc(); asm_a(); asm_comma(); asm_rhigh(_rnew); endasm();
  962.     asm_ld(); asm_rhigh(_rold); asm_comma_a_eol();
  963.   };
  964. }
  965.  
  966. PROC emitsubb() //old-new
  967. {
  968.   proxy(_rold);
  969.   asm_sub(); asm_rlow(_rnew); endasm();
  970. }
  971.  
  972. PROC emitsubbconst() //new8-<const>
  973. {
  974.   proxy(_rnew);
  975.   asm_sub(); asmstr(_const); endasm();
  976. }
  977.  
  978. PROC emitsubflags(BYTE rnew, BYTE rold) //r2-r1 => CY,sign,overflow
  979. {
  980.   unproxy();
  981.   asm_lda_comma(); asm_rlow(rold); endasm();
  982.   asm_sub(); asm_rlow(rnew); endasm();
  983.   asm_lda_comma(); asm_rhigh(rold); endasm();
  984.   asm_sbc(); asm_a(); asm_comma(); asm_rhigh(rnew); endasm();
  985.   _fused = +TRUE;
  986. }
  987.  
  988. PROC emitsubbflags(BYTE anew, BYTE aold) //a2-a1 => CY
  989. { //sign,overflow эх эєцхэ!
  990.   proxy(aold);
  991.   asm_sub(); /**rganame*/asm_rlow(anew); endasm();
  992.   _rproxy = 0x00;
  993.   _fused = +TRUE;
  994. }
  995.  
  996. PROC emitsubz() //old-new => Z
  997. {
  998.   IF (_rold == 0x01) {
  999.     emitsubrg();
  1000.   }ELSE {
  1001.     unproxy();
  1002.     asm_lda_comma(); asm_rlow(_rold); endasm();
  1003.     asm_sub(); asm_rlow(_rnew); endasm();
  1004.     IF ((_rold!=0x04)&&(_rnew!=0x04)) {emitjrnz('4');
  1005.     }ELSE emitjrnz('5'); //ix
  1006.     asm_lda_comma(); asm_rhigh(_rold); endasm();
  1007.     asm_sub(); asm_rhigh(_rnew); endasm();
  1008.     _azused = +TRUE; //A ёюфхЁцшЄ яЁртшы№э√щ 0/эх0 яюёых ёЁртэхэш 
  1009.   };
  1010.   _fused = +TRUE;
  1011. }
  1012.  
  1013. PROC emitsubbz() //old-new => Z
  1014. {
  1015.   IF (_rproxy == _rnew) {
  1016.     asm_sub();
  1017.     /**rganame*/asm_rlow(_rold);
  1018.   }ELSE {
  1019.     proxy(_rold);
  1020.     asm_sub();
  1021.     /**rganame*/asm_rlow(_rnew);
  1022.   };
  1023.   endasm();
  1024.   _rproxy = 0x00;
  1025.   _azused = +TRUE; //A ёюфхЁцшЄ яЁртшы№э√щ 0/эх0 яюёых ёЁртэхэш 
  1026.   _fused = +TRUE;
  1027. }
  1028.  
  1029. PROC emitsubbzconst() //new-<const> => Z
  1030. {
  1031.   proxy(_rnew);
  1032.   asm_sub(); asmstr(_const); endasm();
  1033.   _rproxy = 0x00;
  1034.   _azused = +TRUE; //A ёюфхЁцшЄ яЁртшы№э√щ 0/эх0 яюёых ёЁртэхэш 
  1035.   _fused = +TRUE;
  1036. }
  1037.  
  1038. PROC emitsublongz() //old2-new, old3-old => Z
  1039. //ld a,low(_rold2)
  1040. //sub low(_rnew)
  1041. //jr nz,$+2+2(1)+1 + 2+1(2)+1 + 2+1(2)+1
  1042. //ld a,high(_rold2)
  1043. //sub high(_rnew)
  1044. //jr nz,$+2+1(2)+1 + 2+1(2)+1
  1045. //ld a,low(_rold3)
  1046. //sub low(_rold)
  1047. //jr nz,$+2+1(2)+1
  1048. //ld a,high(_rold3)
  1049. //sub high(_rold)
  1050. {
  1051.   unproxy();
  1052.   asm_lda_comma(); asm_rlow(_rold2); endasm();
  1053.   asm_sub(); asm_rlow(_rnew); endasm();
  1054.   IF ((_rold3!=0x04)&&(_rold!=0x04)) {emitjrnz('d'); //5+4+4//ix т rold2 шыш rnew
  1055.   }ELSE emitjrnz('e'); //4+5+5//ix т rold3 шыш rold
  1056.   asm_lda_comma(); asm_rhigh(_rold2); endasm();
  1057.   asm_sub(); asm_rhigh(_rnew); endasm();
  1058.   IF ((_rold3!=0x04)&&(_rold!=0x04)) {emitjrnz('8');
  1059.   }ELSE emitjrnz('a'); //ix
  1060.   asm_lda_comma(); asm_rlow(_rold3); endasm();
  1061.   asm_sub(); asm_rlow(_rold); endasm();
  1062.   IF ((_rold3!=0x04)&&(_rold!=0x04)) {emitjrnz('4');
  1063.   }ELSE emitjrnz('5'); //ix
  1064.   asm_lda_comma(); asm_rhigh(_rold3); endasm();
  1065.   asm_sub(); asm_rhigh(_rold); endasm();
  1066.   _fused = +TRUE;
  1067. }
  1068.  
  1069. PROC emitpokerg() //эютюх чряшё√трхь т ёЄрЁє■ ыюърЎш■ ярь Єш
  1070. {
  1071.   IF ((_rold == 0x01)&&(_rnew!=0x04)) {
  1072.     asm_ldmhl_comma(); asm_rlow(_rnew); endasm();
  1073.     emitinchl();
  1074.     asm_ldmhl_comma(); asm_rhigh(_rnew); endasm();
  1075.   }ELSE {
  1076.     unproxy();
  1077.     asm_lda_comma(); asm_rlow(_rnew); endasm();
  1078.     asm_ld(); asm_mrgname(_rold); asm_comma_a_eol();
  1079.     asm_inc(); asm_rname(_rold); endasm();
  1080.     asm_lda_comma(); asm_rhigh(_rnew); endasm();
  1081.     asm_ld(); asm_mrgname(_rold); asm_comma_a_eol();
  1082.   };
  1083.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1084. }
  1085.  
  1086. PROC emitpokeb() //эютюх чряшё√трхь т ёЄрЁє■ ыюърЎш■ ярь Єш
  1087. //т rnew ьюцхЄ эх с√Є№ фрээ√ї, хёыш rproxy==rnew!!!
  1088. {
  1089.   IF ((_rold==0x01) && (_rnew!=0x04) && (_rproxy!=_rnew)) {
  1090.     asm_ld(); asm_mhl(); asm_comma(); asm_rlow(_rnew); endasm();
  1091.   }ELSE {
  1092.     proxy(_rnew); //шэрўх эхЄ ъюьрэф√ ld [rp],rg
  1093.     asm_ld(); asm_mrgname(_rold); asm_comma_a_eol();
  1094.   };
  1095.   _rproxy = 0x00;
  1096.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1097. }
  1098.  
  1099. PROC emitpokelong() //old2(addr), old(high), new(low)
  1100. {
  1101.   IF ((_rold2==0x01)&&(_rnew!=0x04)) {
  1102.     asm_ldmhl_comma(); asm_rlow(_rnew); endasm();
  1103.     emitinchl();
  1104.     asm_ldmhl_comma(); asm_rhigh(_rnew); endasm();
  1105.     emitinchl();
  1106.     asm_ldmhl_comma(); asm_rlow(_rold); endasm();
  1107.     emitinchl();
  1108.     asm_ldmhl_comma(); asm_rhigh(_rold); endasm();
  1109.   }ELSE {
  1110.     unproxy();
  1111.     asm_lda_comma(); asm_rlow(_rnew); endasm();
  1112.     asm_ld(); asm_mrgname(_rold2); asm_comma_a_eol();
  1113.     asm_inc(); asm_rname(_rold2); endasm();
  1114.     asm_lda_comma(); asm_rhigh(_rnew); endasm();
  1115.     asm_ld(); asm_mrgname(_rold2); asm_comma_a_eol();
  1116.     asm_inc(); asm_rname(_rold2); endasm();
  1117.     asm_lda_comma(); asm_rlow(_rold); endasm();
  1118.     asm_ld(); asm_mrgname(_rold2); asm_comma_a_eol();
  1119.     asm_inc(); asm_rname(_rold2); endasm();
  1120.     asm_lda_comma(); asm_rhigh(_rold); endasm();
  1121.     asm_ld(); asm_mrgname(_rold2); asm_comma_a_eol();
  1122.   };
  1123.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1124. }
  1125.  
  1126. PROC asm_lda_mrgname_eol(BYTE r)
  1127. {
  1128.   asm_lda_comma(); asm_mrgname(r); endasm();
  1129. }
  1130.  
  1131. PROC emitpeekrg() //[new] => new
  1132. {
  1133.   unproxy();
  1134.   IF (_rnew==0x01) {
  1135.     asm_lda_comma(); asm_mhl(); endasm();
  1136.     emitinchl();
  1137.     asm_ld(); asmc('H'); asm_comma_mhl_eol();
  1138.     asm_ld(); asmc('L'); asm_comma_a_eol();
  1139.   }ELSE {
  1140.     asm_lda_mrgname_eol(_rnew);
  1141.     asm_inc(); asm_rname(_rnew); endasm();
  1142.     emitexa();
  1143.     asm_lda_mrgname_eol(_rnew);
  1144.     asm_ld(); asm_rhigh(_rnew); asm_comma_a_eol();
  1145.     emitexa();
  1146.     asm_ld(); asm_rlow(_rnew); asm_comma_a_eol();
  1147.   };
  1148. }
  1149.  
  1150. PROC emitpeekb()
  1151. {
  1152. //  IF (_rnew == 0x01) {
  1153. //    asm_ld(); asmc('L'); asm_comma_mhl_eol(); //эхт√уюфэю
  1154. //  }ELSE {
  1155.     unproxy();
  1156.     _rproxy = _rnew;
  1157.     asm_lda_mrgname_eol(_rnew);
  1158. //  };
  1159. }
  1160.  
  1161. PROC emitpeeklong() //[old] => old(high),new(low)
  1162. {
  1163.   unproxy();
  1164.   IF ((_rold==0x01)&&(_rnew!=0x04)) {
  1165.     asm_ld(); asm_rlow(_rnew); asm_comma_mhl_eol();
  1166.     emitinchl();
  1167.     asm_ld(); asm_rhigh(_rnew); asm_comma_mhl_eol();
  1168.     emitinchl();
  1169.     asm_lda_comma(); asm_mhl(); endasm();
  1170.     emitinchl();
  1171.     asm_ld(); asmc('H'); asm_comma_mhl_eol();
  1172.     asm_ld(); asmc('L'); asm_comma_a_eol();
  1173.   }ELSE {
  1174.     asm_lda_mrgname_eol(_rold);
  1175.     asm_inc(); asm_rname(_rold); endasm();
  1176.     asm_ld(); asm_rlow(_rnew); asm_comma_a_eol();
  1177.     asm_lda_mrgname_eol(_rold);
  1178.     asm_inc(); asm_rname(_rold); endasm();
  1179.     asm_ld(); asm_rhigh(_rnew); asm_comma_a_eol();
  1180.     asm_lda_mrgname_eol(_rold);
  1181.     asm_inc(); asm_rname(_rold); endasm();
  1182.     emitexa();
  1183.     asm_lda_mrgname_eol(_rold);
  1184.     asm_ld(); asm_rhigh(_rold); asm_comma_a_eol();
  1185.     emitexa();
  1186.     asm_ld(); asm_rlow(_rold); asm_comma_a_eol();
  1187.   };
  1188. }
  1189.  
  1190. PROC emitrgtob() //эхы№ч  єсшЁрЄ№ - ёяхЎшЇшўэю
  1191. {
  1192. }
  1193.  
  1194. PROC emitbtorg()
  1195. {
  1196.   unproxy();
  1197.   asm_ld(); asm_rhigh(_rnew); asm_comma(); asmc('0'); endasm();
  1198. }
  1199.  
  1200. PROC emitincrg_byname()
  1201. {
  1202.   emitgetrg(+FALSE);
  1203.   asm_inc(); asm_rname(_rnew); endasm();
  1204.   emitputrg(+FALSE);
  1205.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1206. }
  1207.  
  1208. PROC emitincb_bypoi()
  1209. {
  1210.   IF ((_rnew==0x01)||(_rnew==0x04)) { //hl/ix
  1211.     asm_inc(); asm_open(); asm_rname(_rnew); asm_close(); endasm();
  1212.   }ELSE IF (_rnew==0x02) { //de
  1213.     emitexd(); //todo ўхЁхч swaprgs?
  1214.     asm_inc(); asm_mhl(); endasm();
  1215.     emitexd(); //todo ўхЁхч swaprgs?
  1216.   }ELSE /**IF (_rnew==0x03)*/ { //bc
  1217.     unproxy();
  1218.     asm_lda_mrgname_eol(_rnew);
  1219.     asm_inc(); asm_a(); endasm();
  1220.     asm_ld(); asm_open(); asm_rname(_rnew); asm_close(); asm_comma_a_eol();
  1221.   };
  1222.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1223. }
  1224. /**
  1225. PROC emitinclong() //todo
  1226. {
  1227.   asm_inc(); asm_open(); asm_rname(_rnew); asm_close(); endasm();
  1228.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1229. }
  1230. */
  1231. PROC emitdecrg_byname()
  1232. {
  1233.   emitgetrg(+FALSE);
  1234.   asm_dec(); asm_rname(_rnew); endasm();
  1235.   emitputrg(+FALSE);
  1236.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1237. }
  1238.  
  1239. PROC emitdecb_bypoi()
  1240. {
  1241.   IF ((_rnew==0x01)||(_rnew==0x04)) { //hl/ix
  1242.     asm_dec(); asm_open(); asm_rname(_rnew); asm_close(); endasm();
  1243.   }ELSE IF (_rnew==0x02) { //de
  1244.     emitexd(); //todo ўхЁхч swaprgs?
  1245.     asm_dec(); asm_mhl(); endasm();
  1246.     emitexd(); //todo ўхЁхч swaprgs?
  1247.   }ELSE /**IF (_rnew==0x03)*/ { //bc
  1248.     unproxy();
  1249.     asm_lda_mrgname_eol(_rnew);
  1250.     asm_dec(); asm_a(); endasm();
  1251.     asm_ld(); asm_open(); asm_rname(_rnew); asm_close(); asm_comma_a_eol();
  1252.   };
  1253.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1254. }
  1255. /**
  1256. PROC emitdeclong() //todo
  1257. {
  1258.   asm_dec(); asm_open(); asm_rname(_rnew); asm_close(); endasm();
  1259.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1260. }
  1261. */
  1262.  
  1263. PROC emitincrg_bypoi() //[old], new free
  1264. {
  1265.   IF (_rold==0x01) {
  1266.     asm_ld(); asm_rlow(_rnew); asm_comma_mhl_eol();
  1267.     emitinchl();
  1268.     asm_ld(); asm_rhigh(_rnew); asm_comma_mhl_eol();
  1269.  
  1270.     asm_inc(); asm_rname(_rnew); endasm();
  1271.  
  1272.     asm_ld(); asm_mhl(); asm_comma(); asm_rhigh(_rnew); endasm();
  1273.     asm_dec(); asm_hl(); endasm();
  1274.     asm_ld(); asm_mhl(); asm_comma(); asm_rlow(_rnew); endasm();
  1275.   }ELSE {
  1276.     unproxy();
  1277.     asm_lda_mrgname_eol(_rold);
  1278.     asm_ld(); asm_rlow(_rnew); asm_comma_a_eol();
  1279.     asm_inc(); asm_rname(_rold); endasm();
  1280.     asm_lda_mrgname_eol(_rold);
  1281.     asm_ld(); asm_rhigh(_rnew); asm_comma_a_eol();
  1282.  
  1283.     asm_inc(); asm_rname(_rnew); endasm();
  1284.  
  1285.     asm_lda_comma(); asm_rhigh(_rnew); endasm();
  1286.     asm_ld(); asm_mrgname(_rold); asm_comma_a_eol();
  1287.     asm_dec(); asm_rname(_rold); endasm();
  1288.     asm_lda_comma(); asm_rlow(_rnew); endasm();
  1289.     asm_ld(); asm_mrgname(_rold); asm_comma_a_eol();
  1290.   };
  1291.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1292. }
  1293.  
  1294. PROC emitdecrg_bypoi() //[old], new free
  1295. {
  1296.   IF (_rold==0x01) {
  1297.     asm_ld(); asm_rlow(_rnew); asm_comma_mhl_eol();
  1298.     emitinchl();
  1299.     asm_ld(); asm_rhigh(_rnew); asm_comma_mhl_eol();
  1300.  
  1301.     asm_dec(); asm_rname(_rnew); endasm();
  1302.  
  1303.     asm_ld(); asm_mhl(); asm_comma(); asm_rhigh(_rnew); endasm();
  1304.     asm_dec(); asm_hl(); endasm();
  1305.     asm_ld(); asm_mhl(); asm_comma(); asm_rlow(_rnew); endasm();
  1306.   }ELSE {
  1307.     unproxy();
  1308.     asm_lda_mrgname_eol(_rold);
  1309.     asm_ld(); asm_rlow(_rnew); asm_comma_a_eol();
  1310.     asm_inc(); asm_rname(_rold); endasm();
  1311.     asm_lda_mrgname_eol(_rold);
  1312.     asm_ld(); asm_rhigh(_rnew); asm_comma_a_eol();
  1313.  
  1314.     asm_dec(); asm_rname(_rnew); endasm();
  1315.  
  1316.     asm_lda_comma(); asm_rhigh(_rnew); endasm();
  1317.     asm_ld(); asm_mrgname(_rold); asm_comma_a_eol();
  1318.     asm_dec(); asm_rname(_rold); endasm();
  1319.     asm_lda_comma(); asm_rlow(_rnew); endasm();
  1320.     asm_ld(); asm_mrgname(_rold); asm_comma_a_eol();
  1321.   };
  1322.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1323. }
  1324.  
  1325. /////////////
  1326. EXPORT PROC initcode()
  1327. {
  1328.   _jpflag = 0x00;
  1329. }
  1330.  
  1331. EXPORT PROC endcode()
  1332. {
  1333. }
  1334.  
  1335. PROC initrgs()
  1336. {
  1337.   rgs_initrgs();
  1338.   _azused = +FALSE;
  1339.   _fused = +FALSE; //ьюцэю ёфхырЄ№ юфэє яЁюЎхфєЁє initif фы  ¤Єюую (т√ч√трЄ№ т эрўрых if, while, until)
  1340.   _rproxy = 0x00;
  1341. }
  1342.  
  1343. PROC emitfunchead()
  1344. {
  1345.   initrgs();
  1346. }
  1347.  
  1348. PROC setmainb()
  1349. {
  1350.   setmainrg(); //Ёхчєы№ЄрЄ т RMAIN
  1351.   _rproxy = _RMAIN;
  1352. }
  1353.  
  1354. PROC prefernoregs()
  1355. {
  1356.   getnothing(); //Єръ т√уюфэхх inc/dec
  1357. }
  1358.