?login_element?

Subversion Repositories NedoOS

Rev

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