Subversion Repositories NedoOS

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download

  1. //// imported
  2. #include "../_sdk/emit.h"
  3.  
  4. #include "sizes386.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; /**EAX*/ /**ЁхушёЄЁ Ёхчєы№ЄрЄр ш яхЁтюую ярЁрьхЄЁр ёЄрэфрЁЄэ√ї ЇєэъЎшщ*/
  41. CONST BYTE _RMAIN2= 0x02; /**EBX*/ /**ЁхушёЄЁ тЄюЁюую ёыютр Ёхчєы№ЄрЄр ш тЄюЁюую ярЁрьхЄЁр ёЄрэфрЁЄэ√ї ЇєэъЎшщ*/
  42. CONST BYTE _RMAIN3= 0x03;
  43. CONST BYTE _RMAIN4= 0x04;
  44.  
  45. CONST PCHAR _RNAME[_RGBUFSZ] = {
  46.   "", //0 яєёЄющ
  47.   "EAX",
  48.   "EBX",
  49.   "ECX",
  50.   "EDX"
  51. };
  52. /**
  53. CONST PCHAR _RHIGH[_RGBUFSZ] = {
  54.   "", //0 яєёЄющ
  55.   "H",
  56.   "D",
  57.   "B",
  58.   "HX"
  59. };*/
  60. CONST PCHAR _RLOW[_RGBUFSZ] = {
  61.   "", //0 яєёЄющ
  62.   "AL",
  63.   "BL",
  64.   "CL",
  65.   "DL"
  66. };
  67.  
  68. VAR BYTE _rproxy;
  69. VAR BOOL _fused;
  70. //VAR BOOL _azused; //A ёюфхЁцшЄ яЁртшы№э√щ 0/эх0 яюёых ёЁртэхэш 
  71.  
  72. VAR INT _funcstkdepth;
  73.  
  74. VAR BYTE _jpflag; //0=OR A:JZ, 1=JZ, 2=JNZ, 3=JNC, 4=JC
  75.  
  76. EXPORT CONST BYTE _typesz[32] = { //ЁрчьхЁ Єшяр т срщЄрї фы  ЄрЁухЄр //чфхё№ эх шёяюы№чєхЄё 
  77.   _SZ_BYTE/**T_BYTE */, //фы  тёхї ЄрЁухЄют
  78.   _SZ_REG/**T_UINT */, //фы  тёхї ЄрЁухЄют
  79.   _SZ_REG/**T_INT  */, //фы  тёхї ЄрЁухЄют
  80.   _SZ_BOOL/**T_BOOL */,
  81.   _SZ_LONG/**T_LONG */,
  82.   _SZ_BYTE/**T_CHAR */,
  83.   _SZ_LONG/**T_FLOAT*/,
  84.   0x00/**unknown*/,
  85.   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  86.   _SZ_REG/**T_PBYTE */,
  87.   _SZ_REG/**T_PUINT */,
  88.   _SZ_REG/**T_PINT  */,
  89.   _SZ_REG/**T_PBOOL */,
  90.   _SZ_REG/**T_PLONG */,
  91.   _SZ_REG/**T_PCHAR */,
  92.   _SZ_REG/**T_PFLOAT*/,
  93.   _SZ_REG/**        */,
  94.   _SZ_REG, _SZ_REG, _SZ_REG, _SZ_REG, _SZ_REG, _SZ_REG, _SZ_REG, _SZ_REG //pointer to...
  95. };
  96.  
  97. CONST BYTE _typeshift[32] = { //log ЁрчьхЁ Єшяр (n фы  2^n срщЄ) фы  ЄрЁухЄр //чфхё№ эх шёяюы№чєхЄё 
  98.   _RL_BYTE/**T_BYTE */, //фы  тёхї ЄрЁухЄют
  99.   _RL_REG/**T_UINT */, //фы  тёхї ЄрЁухЄют
  100.   _RL_REG/**T_INT  */, //фы  тёхї ЄрЁухЄют
  101.   _RL_BOOL/**T_BOOL */,
  102.   _RL_LONG/**T_LONG */,
  103.   _RL_BYTE/**T_CHAR */,
  104.   _RL_LONG/**T_FLOAT*/,
  105.   0x00/**unknown*/,
  106.   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  107.   _RL_REG/**T_BYTE  */,
  108.   _RL_REG/**T_UINT  */,
  109.   _RL_REG/**T_INT   */,
  110.   _RL_REG/**T_BOOL  */,
  111.   _RL_REG/**T_LONG  */,
  112.   _RL_REG/**T_CHAR  */,
  113.   _RL_REG/**T_PFLOAT*/,
  114.   _RL_REG/**        */,
  115.   _RL_REG, _RL_REG, _RL_REG, _RL_REG, _RL_REG, _RL_REG, _RL_REG, _RL_REG //pointer to...
  116. };
  117.  
  118. PROC initrgs FORWARD(); //юўшёЄшЄ№ ёюёЄю эш  ЁхушёЄЁют ш срщЄют (шёяюы№чєхЄё  т cemitfunc)
  119.  
  120. //////////// ьхыъшх яЁюЎхфєЁ√ фы  ёюъЁр∙хэш  ўшёыр ъюэёЄрэЄ
  121.  
  122. EXPORT PROC var_alignwsz()
  123. {
  124. }
  125.  
  126. PROC asm_comma()
  127. {
  128.   asmc(',');
  129. }
  130.  
  131. PROC asm_open()
  132. {
  133.   asmc('[');
  134. }
  135.  
  136. PROC asm_close()
  137. {
  138.   asmc(']');
  139. }
  140.  
  141. PROC asm_rname(BYTE r)
  142. {
  143.   asmstr( _RNAME[(UINT)r] );
  144. }
  145.  
  146. PROC asm_mrgname(BYTE r)
  147. {
  148.   asm_open(); asm_rname(r); asm_close();
  149. }
  150.  
  151. PROC asm_rlow(BYTE r)
  152. {
  153.   asmstr( _RLOW[(UINT)r] );
  154. }
  155. /**
  156. PROC asm_rhigh(BYTE r)
  157. {
  158.   asmstr( _RHIGH[(UINT)r] );
  159. }
  160. */
  161. PROC asm_close_eol()
  162. {
  163.   asm_close(); endasm();
  164. }
  165.  
  166. EXPORT PROC var_db() //фюёЄєяэю шч compile!
  167. {
  168.   varstr( "\tDB " );
  169. }
  170.  
  171. EXPORT PROC asm_db() //ъюёЄ√ы№ фы  ъюэёЄрэЄэ√ї ьрёёштют ёЄЁюъ TODO
  172. {
  173.   asmstr( "\tDB " );
  174. }
  175.  
  176. EXPORT PROC var_dw() //фюёЄєяэю шч compile!
  177. {
  178.   varstr( "\tDW " );
  179. }
  180.  
  181. PROC var_dl()
  182. {
  183.   varstr( "\tDL " );
  184. }
  185.  
  186. EXPORT PROC var_ds() //фюёЄєяэю шч compile!
  187. {
  188.   varstr( "\tDS " );
  189. }
  190.  
  191. PROC asm_and()
  192. {
  193.   asmstr( "\tAND " );
  194. }
  195.  
  196. PROC asm_or()
  197. {
  198.   asmstr( "\tOR " );
  199. }
  200.  
  201. PROC asm_xor()
  202. {
  203.   asmstr( "\tXOR " );
  204. }
  205.  
  206. PROC asm_sub()
  207. {
  208.   asmstr( "\tSUB " );
  209. }
  210.  
  211. PROC asm_sbc()
  212. {
  213.   asmstr( "\tSBB " );
  214. }
  215.  
  216. PROC asm_add()
  217. {
  218.   asmstr( "\tADD " );
  219. }
  220.  
  221. PROC asm_adc()
  222. {
  223.   asmstr( "\tADC " );
  224. }
  225.  
  226. PROC asm_inc()
  227. {
  228.   asmstr( "\tINC " );
  229. }
  230.  
  231. PROC asm_dec()
  232. {
  233.   asmstr( "\tDEC " );
  234. }
  235.  
  236. PROC asm_not()
  237. {
  238.   asmstr( "\tNOT " );
  239. }
  240.  
  241. PROC asm_ld()
  242. {
  243.   asmstr( "\tMOV " );
  244. }
  245.  
  246. PROC asm_jp()
  247. {
  248.   asmstr( "\tJMP " );
  249. }
  250.  
  251. PROC asm_jnz()
  252. {
  253.   asmstr( "\tJNZ " );
  254. }
  255.  
  256. PROC asm_jz()
  257. {
  258.   asmstr( "\tJZ " );
  259. }
  260.  
  261. PROC asm_jnc()
  262. {
  263.   asmstr( "\tJNC " );
  264. }
  265.  
  266. PROC asm_jc()
  267. {
  268.   asmstr( "\tJC " );
  269. }
  270.  
  271. PROC asm_push()
  272. {
  273.   asmstr( "\tPUSH " );
  274. }
  275.  
  276. PROC asm_pop()
  277. {
  278.   asmstr( "\tPOP " );
  279. }
  280.  
  281. PROC emitccf()
  282. {
  283.   asmstr( "\tCMC" ); endasm();
  284. }
  285.  
  286. PROC emitcall(PCHAR s)
  287. {
  288.   asmstr( "\tCALL " ); asmstr( s ); endasm();
  289. }
  290.  
  291. ///////////////////////////////////
  292. //фюёЄєяэ√ шч commands
  293. PROC unproxy()
  294. {
  295.   //IF (_rproxy != 0x00) { //т яЁюъёш ўЄю-Єю с√ыю
  296.   //  asm_ld(); /**rganame*/asm_rlow(_rproxy); asm_comma_a_eol();
  297.   //  _rproxy = 0x00;
  298.   //};
  299. }
  300.  
  301. PROC proxy(BYTE r)
  302. {
  303.   //IF (_rproxy != r) {
  304.   //  unproxy();
  305.   //  asm_lda_comma(); /**rganame*/asm_rlow(r); endasm();
  306.   //  _rproxy = r;
  307.   //};
  308. }
  309.  
  310. ///////////////////////////////////////////////////////////
  311. //яЁюЎхфєЁ√ ё ьр°шээ√ь ъюфюь фы  rgs
  312.  
  313. PROC emitpushrg(BYTE rnew)
  314. {
  315.   unproxy(); //todo юяЄшьшчшЁютрЄ№
  316.   asm_push(); asm_rname(rnew); endasm();
  317.   INC _funcstkdepth;
  318. }
  319.  
  320. PROC emitpoprg(BYTE rnew) //ЁхушёЄЁ єцх яюьхўхэ т getrfree/getrg
  321. {
  322.   asm_pop(); asm_rname(rnew); endasm();
  323.   DEC _funcstkdepth;
  324. }
  325.  
  326. PROC emitmovrg(BYTE rsrc, BYTE rdest) //эх чрърч√трхЄ ш эх юётюсюцфрхЄ (ёь. emitmoverg)
  327. {
  328.   IF (rsrc!=rdest) { //todo шыш ёЁртэштрЄ№ rsrc!=rdest ёэрЁєцш?
  329.       asm_ld(); asm_rname(rdest); asm_comma(); asm_rname(rsrc); endasm();
  330.   };
  331. }
  332.  
  333. ///////////////////////////////////////////////////////////////////////////////////////
  334. //¤Єш яЁюЎхфєЁ√ ухэхЁшЁє■Є ъюф
  335. //эхфюёЄєяэ√ шч ъюьяшы ЄюЁр, фюёЄєяэ√ шч commands
  336.  
  337. EXPORT PROC emitasmlabel(PCHAR s)
  338. {
  339.   asmstr(s); /**asmc( ':' );*/ endasm();
  340. }
  341.  
  342. EXPORT PROC emitfunclabel(PCHAR s)
  343. {
  344.   asmstr(s); /**asmc( ':' );*/ endasm();
  345. }
  346.  
  347. EXPORT PROC emitvarlabel(PCHAR s)
  348. {
  349.   varstr(s); /**varc( ':' );*/ endvar();
  350. }
  351.  
  352. EXPORT PROC emitexport(PCHAR s) //todo тёхуфр _joined
  353. {
  354.   asmstr("\tEXPORT "); asmstr(s); endasm();
  355. }
  356.  
  357. EXPORT PROC emitvarpreequ(PCHAR s)
  358. {
  359. }
  360.  
  361. EXPORT PROC emitvarpostequ()
  362. {
  363. }
  364.  
  365. EXPORT PROC varequ(PCHAR s)
  366. {
  367.   varstr(s); varc('=');
  368. }
  369.  
  370. EXPORT FUNC UINT varshift(UINT shift, UINT sz)
  371. {
  372.   //IF (sz >= 4) shift = (shift+3)&(UINT)(-4);
  373.   //asmstr(_joined); asmc('='); asmuint(shift); endasm();
  374.   varequ(_joined); /**varstr(_joined); varc('=');*/ varuint(shift); endvar();
  375. RETURN shift;
  376. }
  377.  
  378. PROC emitret()
  379. {
  380.   //unproxy();
  381.   asmstr( "\tRET" ); endasm();
  382. }
  383.  
  384. PROC emitjpmainrg() //"jp (hl)"
  385. {
  386.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  387.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  388.   unproxy();
  389.   getnothing(); //getnothingword();
  390.   //asm_jp(); asm_mhl(); endasm();
  391.   emitpushrg(0x01);
  392.   emitret();
  393. }
  394.  
  395. PROC emitcallmainrg() //"call (hl)"
  396. {
  397.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  398.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  399.   unproxy();
  400.   getnothing(); //getnothingword();
  401.   emitcall("_JPHL.");
  402.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  403. }
  404.  
  405. PROC emitjp()
  406. {
  407.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  408.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  409.   unproxy();
  410.   getnothing(); //getnothingword();
  411.   asm_jp(); asmstr(_joined); endasm();
  412. }
  413.  
  414. PROC emitbtoz() //яхЁхф jp!
  415. {
  416.   //ёЁрчє яюёых ёЁртэхэш  эх эрфю, эю тфЁєу ь√ ўшЄрхь BOOL
  417.   //IF (_jpflag == 0x00) {
  418.   IF (!_fused) { //Ёхчєы№ЄрЄр эхЄ тю Їырурї
  419.     //proxy(_rnew); //todo юяЄшьшчшЁютрЄ№
  420.     //IF (anew==_RGA) {
  421.       //asm_or(); asmrname(_rnew); asm_comma(); asmrname(_rnew); endasm();
  422.     //}ELSE {
  423.       asm_inc(); asm_rlow(_rnew); endasm();
  424.       asm_dec(); asm_rlow(_rnew); endasm();
  425.     //};
  426.   };
  427.   _rproxy = 0x00;
  428. }
  429.  
  430. PROC emitjpiffalse()
  431. {
  432.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  433.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  434.   //unproxy();
  435.   getnothing(); //getnothingword();
  436.   IF       (_jpflag == 0x02) {asm_jnz();
  437.   }ELSE IF (_jpflag == 0x03) {asm_jnc();
  438.   }ELSE IF (_jpflag == 0x04) {asm_jc();
  439.   }ELSE                      {asm_jz();
  440.   };
  441.   asmstr(_joined);
  442.   endasm();
  443.   _fused = +FALSE;
  444.   _jpflag = 0x00;
  445. }
  446.  
  447. PROC emitcall2rgs(PCHAR s)
  448. {
  449.   unproxy();
  450.   getmain2rgs();
  451.   initrgs();
  452.   emitcall(s);
  453.   setmainrg(); //Ёхчєы№ЄрЄ т RMAIN
  454. }
  455. /**
  456. PROC emitcall3rgs(PCHAR s) //todo яЁютхЁшЄ№
  457. {
  458.   unproxy();
  459.   getmain3rgs();
  460.   initrgs();
  461.   emitcall(s);
  462.   //ёхщўрё тёх ЁхушёЄЁ√ юЄьхўхэ√ ъръ ётюсюфэ√х
  463.   //setwordcontext();
  464.   setmain2rgs(); //Ёхчєы№ЄрЄ т RMAIN,RMAIN2
  465. }
  466. */
  467. PROC emitcall4rgs(PCHAR s) //todo яЁютхЁшЄ№
  468. {
  469.   unproxy();
  470.   getmain4rgs();
  471.   initrgs();
  472.   emitcall(s);
  473.   //ёхщўрё тёх ЁхушёЄЁ√ юЄьхўхэ√ ъръ ётюсюфэ√х
  474.   //setwordcontext();
  475.   setmain2rgs(); //Ёхчєы№ЄрЄ т RMAIN,RMAIN2
  476. }
  477.  
  478. PROC emitcallproc()
  479. {
  480.   //_jpflag = 0x00;
  481.   emitcall(_callee);
  482. }
  483.  
  484. PROC emitloadrg(BOOL high) //ЁхушёЄЁ єцх чрэ Є ўхЁхч getrfree
  485. {
  486.   asm_ld();
  487.   asm_rname(_rnew);
  488.   asm_comma();
  489.   asmstr(_const);
  490.   IF (high) {asmstr( ">>32"/**WORDBITS*/ );
  491.   //}ELSE {asmstr( "&0xffff"/**WORDMASK*/ );
  492.   };
  493.   endasm();
  494.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  495. }
  496.  
  497. PROC emitloadrg0() //ЁхушёЄЁ єцх чрэ Є ўхЁхч getrfree
  498. {
  499.   asm_ld(); asm_rname(_rnew); asm_comma(); asmc('0'); endasm();
  500. }
  501.  
  502. PROC emitloadb() //ръъєьєы ЄюЁ єцх чрэ Є ўхЁхч getfreea
  503. {
  504.   asm_ld();
  505.   asm_rlow(_rnew);
  506.   asm_comma();
  507.   asmstr(_const);
  508.   endasm();
  509.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  510. }
  511.  
  512. PROC emitgetrg(BOOL high) //ЁхушёЄЁ єцх чрэ Є ўхЁхч getrfree
  513. {
  514.   asm_ld();
  515.   asm_rname(_rnew);
  516.   asm_comma();
  517.   asm_open();
  518.   asmstr(_joined);
  519.   IF (high) {asmc('+'); asmc('4');
  520.   };
  521.   asm_close();
  522.   endasm();
  523. }
  524.  
  525. PROC emitgetb() //ръъєьєы ЄюЁ єцх чрэ Є ўхЁхч getfreea
  526. {
  527.   asm_ld();
  528.   asm_rlow(_rnew);
  529.   asm_comma();
  530.   asm_open();
  531.   asmstr(_joined);
  532.   asm_close();
  533.   endasm();
  534. }
  535.  
  536. PROC emitputrg(BOOL high) //ld [],new
  537. {
  538.   //_jpflag = 0x00;
  539.   asm_ld(); asm_open();
  540.   asmstr(_joined);
  541.   IF (high) {asmc('+'); asmc('4');
  542.   };
  543.   asm_close(); asm_comma();
  544.   asm_rname(_rnew); endasm();
  545.   endasm();
  546.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  547. }
  548.  
  549. PROC emitputb()
  550. {
  551.   //_jpflag = 0x00;
  552. //  proxy(_rnew);
  553.   asm_ld(); asm_open();
  554.   asmstr(_joined);
  555.   asm_close(); asm_comma();
  556.   asm_rlow(_rnew); endasm();
  557. //  _rproxy = 0x00;
  558.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  559. }
  560.  
  561. PROC emitshl1rg()
  562. {
  563.   asmstr( "\tSHL " ); asm_rname(_rnew); endasm();
  564. }
  565.  
  566. PROC emitshl1b()
  567. {
  568.   asmstr( "\tSHL " ); asm_rlow(_rnew); endasm();
  569. //    proxy(_rnew);
  570.   //IF (_rproxy==_rnew) {
  571. //    asm_add(); asm_a(); asm_comma_a_eol();
  572.   //}ELSE {
  573.   //  asmstr( "\tSLA " ); /**rganame*/asm_rlow(anew); endasm();
  574.   //};
  575. }
  576. /**
  577. PROC emitshr1rg(BYTE rnew)
  578. {
  579.   asmstr( "\tSRL " ); asm_rhigh(rnew); endasm();
  580.   asmstr( "\tRR " ); asm_rlow(rnew); endasm();
  581. }
  582.  
  583. PROC emitshr1signedrg(BYTE rnew)
  584. {
  585.   asmstr( "\tSRA " ); asm_rhigh(rnew); endasm();
  586.   asmstr( "\tRR " ); asm_rlow(rnew); endasm();
  587. }
  588. */
  589. //PROC emitshr1b(BYTE anew)
  590. //{
  591. //  asmstr( "\tSRL " ); /**rganame*/asm_rlow(anew] ); endasm();
  592. //}
  593.  
  594. PROC emitinvb() //~A -> A
  595. {
  596. //  proxy(_rnew);
  597. //  asmstr( "\tCPL" ); endasm();
  598.   asm_not(); asm_rlow(_rnew); endasm();
  599.   _fused = +FALSE; //шэрўх уы■ъ if (!(a||b))
  600. }
  601.  
  602. PROC emitinvrg()
  603. {
  604. //  unproxy();
  605.   asm_not(); asm_rname(_rnew); endasm();
  606. }
  607.  
  608. PROC emitnegrg()
  609. {
  610. //  unproxy();
  611.   asm_not(); asm_rname(_rnew); endasm();
  612.   asm_inc(); asm_rname(_rnew); endasm();
  613. }
  614.  
  615. PROC emitztob()
  616. {
  617.   //asmstr(";emitztoa exprlvl="); asmuint(_exprlvl); endasm();
  618.   IF (_exprlvl != 0x01) { //if (a == b)
  619.     asm_ld(); asm_rlow(_rnew); asm_comma(); asmc('0'); endasm();
  620.     asmstr( "\tJNZ $+3" ); endasm();
  621.     asm_dec(); asm_rlow(_rnew); endasm();
  622.     _fused = +FALSE; //шэрўх уы■ъ яЁш if ((a==b))
  623.     //_jpflag = 0x00;
  624.   }ELSE {
  625.     //_fused = +TRUE;
  626.     _jpflag = 0x02;
  627.   };
  628. }
  629.  
  630. PROC emitinvztob()
  631. {
  632.   //asmstr(";emitinvztoa exprlvl="); asmuint(_exprlvl); endasm();
  633.   IF (_exprlvl != 0x01) { //if (a != b)
  634.     asm_ld(); asm_rlow(_rnew); asm_comma(); asmc('0'); endasm();
  635.     asmstr( "\tJZ $+3" ); endasm();
  636.     asm_dec(); asm_rlow(_rnew); endasm();
  637.     _fused = +FALSE; //шэрўх уы■ъ яЁш if ((a!=b))? todo test //тючьюцхэ уы■ъ ifnot ((a!=b))
  638.     //_jpflag = 0x00;
  639.   }ELSE {
  640.     //_fused = +TRUE;
  641.     _jpflag = 0x01;
  642.   };
  643. }
  644.  
  645. PROC emitcytob()
  646. {
  647.   //asmstr(";emitcytoa exprlvl="); asmuint(_exprlvl); endasm();
  648.   IF (_exprlvl != 0x01) { //if (a < b)
  649. //    unproxy();
  650.     asm_sbc(); asm_rlow(_rnew); asm_comma(); asm_rlow(_rnew); endasm();
  651. //    _rproxy = _rnew;
  652.     //_fused = +FALSE;
  653.     //_jpflag = 0x00;
  654.   }ELSE {
  655.     //_fused = +TRUE;
  656.     _jpflag = 0x03;
  657.   };
  658. }
  659.  
  660. PROC emitinvcytob()
  661. {
  662.   //asmstr(";emitinvcytoa exprlvl="); asmuint(_exprlvl); endasm();
  663.   IF (_exprlvl != 0x01) { //if (a >= b)
  664.     emitccf();
  665. //    unproxy();
  666.     asm_sbc(); asm_rlow(_rnew); asm_comma(); asm_rlow(_rnew); endasm();
  667. //    _rproxy = _rnew;
  668.     //_fused = +FALSE;
  669.     //_jpflag = 0x00;
  670.   }ELSE {
  671.     //_fused = +TRUE;
  672.     _jpflag = 0x04;
  673.   };
  674. }
  675.  
  676. PROC emitSxorVtob() //яюёых subflags, ЁрчЁхчхЁтшЁєхЄ A
  677. { //todo яЁютхЁшЄ№
  678.   asm_ld(); asm_rname(_rnew); asm_comma(); asmc('0'); endasm();
  679.   asmstr( "\tJG $+4" ); endasm();
  680.   asm_not(); asm_rlow(_rnew); endasm();
  681. }
  682.  
  683. PROC emitinvSxorVtob() //яюёых subflags, ЁрчЁхчхЁтшЁєхЄ A
  684. { //todo яЁютхЁшЄ№
  685.   asm_ld(); asm_rname(_rnew); asm_comma(); asmc('0'); endasm();
  686.   asmstr( "\tJLE $+4" ); endasm();
  687.   asm_not(); asm_rlow(_rnew); endasm();
  688. }
  689.  
  690. PROC emitxorrg() //old^new => old
  691. {
  692. //  unproxy();
  693.   asm_xor(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasm();
  694. }
  695.  
  696. PROC getxorb() //RGA^RGA2 -> RGA
  697. {
  698.   asm_xor(); asm_rlow(_rold); asm_comma(); asm_rlow(_rnew); endasm();
  699.   _fused = +TRUE; //^^
  700. }
  701.  
  702. PROC emitorrg() //old|new => old
  703. {
  704. //  unproxy();
  705.   asm_or(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasm();
  706. }
  707.  
  708. PROC getorb() //RGA|RGA2 -> RGA
  709. {
  710.   asm_or(); asm_rlow(_rold); asm_comma(); asm_rlow(_rnew); endasm();
  711.   _fused = +TRUE; //||
  712. }
  713.  
  714. PROC emitandrg() //old&new => old
  715. {
  716. //  unproxy();
  717.   asm_and(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasm();
  718. }
  719.  
  720. PROC getandb() //RGA&RGA2 -> RGA
  721. {
  722.   asm_and(); asm_rlow(_rold); asm_comma(); asm_rlow(_rnew); endasm();
  723.   _fused = +TRUE; //&&
  724. }
  725.  
  726. PROC emitaddrg() //old+new => old
  727. {
  728. //  unproxy();
  729.   asm_add(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasm();
  730. }
  731.  
  732. PROC emitadcrg() //old+new => old
  733. {
  734. //  unproxy();
  735.   asm_adc(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasm();
  736. }
  737.  
  738. PROC emitaddb() //old+new
  739. {
  740.   asm_add(); asm_rlow(_rold); asm_comma(); asm_rlow(_rnew); endasm();
  741. }
  742.  
  743. PROC emitaddbconst() //new8+<const>
  744. {
  745.   asm_add(); asm_rlow(_rnew); asm_comma(); asmstr(_const); endasm();
  746. }
  747.  
  748. PROC emitsubrg() //old-new => old
  749. {
  750. //  unproxy();
  751.   asm_sub(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasm();
  752. }
  753.  
  754. PROC emitsbcrg() //old-new => old
  755. {
  756. //  unproxy();
  757.   asm_sbc(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasm();
  758. }
  759.  
  760. PROC emitsubb() //old-new
  761. {
  762.   asm_sub(); asm_rlow(_rold); asm_comma(); asm_rlow(_rnew); endasm();
  763. }
  764.  
  765. PROC emitsubbconst() //new8-<const>
  766. {
  767.   asm_sub(); asm_rlow(_rnew); asm_comma(); asmstr(_const); endasm();
  768. }
  769.  
  770. PROC emitsubflags(BYTE rnew, BYTE rold) //r2-r1 => CY,sign,overflow
  771. {
  772. //  unproxy();
  773.   asm_sub(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasm();
  774.   _fused = +TRUE;
  775. }
  776.  
  777. PROC emitsubbflags(BYTE anew, BYTE aold) //a2-a1 => CY
  778. { //sign,overflow эх эєцхэ!
  779. //  proxy(aold);
  780.   asm_sub(); asm_rlow(_rold); asm_comma(); asm_rlow(_rnew); endasm();
  781.   _fused = +TRUE;
  782. }
  783.  
  784. PROC emitsubz() //old-new => Z
  785. {
  786. // unproxy();
  787.   asm_sub(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasm();
  788. //    _azused = +TRUE; //A ёюфхЁцшЄ яЁртшы№э√щ 0/эх0 яюёых ёЁртэхэш 
  789.   _fused = +TRUE;
  790. }
  791.  
  792. PROC emitsubbz() //old-new => Z
  793. {
  794.   asm_sub(); asm_rlow(_rold); asm_comma(); asm_rlow(_rnew); endasm();
  795. //  _rproxy = 0x00;
  796. //  _azused = +TRUE; //A ёюфхЁцшЄ яЁртшы№э√щ 0/эх0 яюёых ёЁртэхэш 
  797.   _fused = +TRUE;
  798. }
  799.  
  800. PROC emitsubbzconst() //new-<const> => Z
  801. {
  802. //  proxy(_rnew);
  803.   asm_sub(); asm_rlow(_rnew); asm_comma(); asmstr(_const); endasm();
  804. //  _rproxy = 0x00;
  805. //  _azused = +TRUE; //A ёюфхЁцшЄ яЁртшы№э√щ 0/эх0 яюёых ёЁртэхэш 
  806.   _fused = +TRUE;
  807. }
  808.  
  809. PROC emitsublongz() //old2-new, old3-old => Z
  810. {
  811. //  unproxy();
  812.   asm_sub(); asm_rname(_rold2); asm_comma(); asm_rname(_rnew); endasm();
  813.   asmstr( "\tJNZ $+4" ); endasm();
  814.   asm_sub(); asm_rname(_rold3); asm_comma(); asm_rname(_rold); endasm();
  815.   _fused = +TRUE;
  816. }
  817.  
  818. PROC emitpokerg() //эютюх чряшё√трхь т ёЄрЁє■ ыюърЎш■ ярь Єш
  819. {
  820.   asm_ld(); asm_mrgname(_rold); asm_comma(); asm_rname(_rnew); endasm();
  821.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  822. }
  823.  
  824. PROC emitpokeb() //эютюх чряшё√трхь т ёЄрЁє■ ыюърЎш■ ярь Єш
  825. //т rnew ьюцхЄ эх с√Є№ фрээ√ї, хёыш rproxy==rnew!!!
  826. {
  827.   asm_ld(); asm_mrgname(_rold); asm_comma(); asm_rlow(_rnew); endasm();
  828.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  829. }
  830.  
  831. PROC emitpokelong() //old2(addr), old(high), new(low)
  832. {
  833.   asm_ld(); asm_mrgname(_rold2); asm_comma(); asm_rname(_rold); endasm();
  834.   asm_ld(); asm_open(); asm_rname(_rold2); asmc('+'); asmc('4'); asm_close(); asm_comma(); asm_rname(_rnew); endasm();
  835.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  836. }
  837.  
  838. PROC emitpeekrg() //[new] => new
  839. {
  840.   asm_ld(); asm_rname(_rnew); asm_comma(); asm_mrgname(_rnew); endasm();
  841. }
  842.  
  843. PROC emitpeekb()
  844. {
  845.   asm_ld(); asm_rlow(_rnew); asm_comma(); asm_mrgname(_rold); endasm();
  846. }
  847.  
  848. PROC emitpeeklong() //[old] => old(high),new(low)
  849. {
  850.   asm_ld(); asm_rname(_rnew); asm_comma(); asm_mrgname(_rold); endasm();
  851.   asm_ld(); asm_rname(_rold); asm_comma(); asm_open(); asm_rname(_rold); asmc('+'); asmc('4'); asm_close(); endasm();
  852. }
  853.  
  854. PROC emitrgtob() //эхы№ч  єсшЁрЄ№ - ёяхЎшЇшўэю
  855. {
  856.   asm_and(); asm_rname(_rnew); asm_comma(); asmstr("0xff"); endasm();
  857. }
  858.  
  859. PROC emitbtorg() //эхы№ч  єсшЁрЄ№ - ёяхЎшЇшўэю
  860. {
  861. }
  862.  
  863. PROC emitincrg_byname()
  864. {
  865.   emitgetrg(+FALSE);
  866.   asm_inc(); asm_rname(_rnew); endasm();
  867.   emitputrg(+FALSE);
  868.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  869. }
  870.  
  871. PROC emitincb_bypoi()
  872. {
  873.   asm_inc(); asm_open(); asm_rname(_rnew); asm_close(); endasm();
  874.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  875. }
  876. /**
  877. PROC emitinclong() //todo
  878. {
  879.   asm_inc(); asm_open(); asm_rname(_rnew); asm_close(); endasm();
  880.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  881. }
  882. */
  883. PROC emitdecrg_byname()
  884. {
  885.   emitgetrg(+FALSE);
  886.   asm_dec(); asm_rname(_rnew); endasm();
  887.   emitputrg(+FALSE);
  888.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  889. }
  890.  
  891. PROC emitdecb_bypoi()
  892. {
  893.   asm_dec(); asm_open(); asm_rname(_rnew); asm_close(); endasm();
  894.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  895. }
  896. /**
  897. PROC emitdeclong() //todo
  898. {
  899.   asm_dec(); asm_open(); asm_rname(_rnew); asm_close(); endasm();
  900.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  901. }
  902. */
  903.  
  904. PROC emitincrg_bypoi() //[old], new free
  905. {
  906.   asm_ld(); asm_rname(_rnew); asm_comma(); asm_open(); asm_rname(_rold); asm_close(); endasm();
  907.   asm_inc(); asm_rname(_rnew); endasm();
  908.   asm_ld(); asm_open(); asm_rname(_rold); asm_close(); asm_comma(); asm_rname(_rnew); endasm();
  909.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  910. }
  911.  
  912. PROC emitdecrg_bypoi() //[old], new free
  913. {
  914.   asm_ld(); asm_rname(_rnew); asm_comma(); asm_open(); asm_rname(_rold); asm_close(); endasm();
  915.   asm_dec(); asm_rname(_rnew); endasm();
  916.   asm_ld(); asm_open(); asm_rname(_rold); asm_close(); asm_comma(); asm_rname(_rnew); endasm();
  917.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  918. }
  919.  
  920. /////////////
  921. EXPORT PROC initcode()
  922. {
  923.   _jpflag = 0x00;
  924. }
  925.  
  926. EXPORT PROC endcode()
  927. {
  928. }
  929.  
  930. PROC initrgs()
  931. {
  932.   rgs_initrgs();
  933. //  _azused = +FALSE;
  934.   _fused = +FALSE; //ьюцэю ёфхырЄ№ юфэє яЁюЎхфєЁє initif фы  ¤Єюую (т√ч√трЄ№ т эрўрых if, while, until)
  935.   _rproxy = 0x00;
  936. }
  937.  
  938. PROC emitfunchead()
  939. {
  940.   initrgs();
  941. }
  942.  
  943. PROC setmainb()
  944. {
  945.   setmainrg(); //Ёхчєы№ЄрЄ т RMAIN
  946.   _rproxy = _RMAIN;
  947. }
  948.  
  949. PROC prefernoregs()
  950. {
  951.   getnothing(); //Єръ т√уюфэхх inc/dec
  952. }
  953.