Subversion Repositories NedoOS

Rev

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