Subversion Repositories NedoOS

Rev

Rev 777 | 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 asm_label()
  167. {
  168.   //asmc(+_CMDLABEL); //TODO юяЁхфхы Є№ яю яхЁтющ сєътх ъюьрэф√?
  169. }
  170.  
  171. EXPORT PROC asm_equal()
  172. {
  173.   asmc((BYTE)'='); //asmc(+_TOKEXPR); //TODO схч _TOKEXPR? (єсЁрЄ№ т ёрьє юсЁрсюЄъє _CMDLABEL) (єёыюцэшЄ ¤ъёяюЁЄ)
  174. }
  175.  
  176. EXPORT PROC endasm_label()
  177. {
  178.   /**asmc(+_FMTCMD);*/ endasm(); //Єрь Єюы№ъю яЁютхЁър яхЁхюяЁхфхы╕ээюёЄш, TODO єсЁрЄ№ т ёрьє юсЁрсюЄъє _CMDLABEL
  179. }
  180.  
  181. EXPORT PROC endasm_reequ()
  182. {
  183.   /**asmc(+_TOKENDEXPR); asmc(+_FMTREEQU);*/ endasm(); //TODO єсЁрЄ№
  184. }
  185.  
  186. EXPORT PROC var_label()
  187. {
  188.   //varc(+_CMDLABEL); //TODO юяЁхфхы Є№ яю яхЁтющ сєътх ъюьрэф√?
  189. }
  190.  
  191. EXPORT PROC endvar_label()
  192. {
  193.   /**varc(+_FMTCMD);*/ endvar(); //Єрь Єюы№ъю яЁютхЁър яхЁхюяЁхфхы╕ээюёЄш, TODO єсЁрЄ№ т ёрьє юсЁрсюЄъє _CMDLABEL
  194. }
  195.  
  196. EXPORT PROC endvar_reequ()
  197. {
  198.   /**varc(+_TOKENDEXPR); varc(+_FMTREEQU);*/ endvar(); //TODO єсЁрЄ№
  199. }
  200.  
  201. EXPORT PROC endasm_db()
  202. {
  203.   /**asmc(+_TOKENDEXPR); asmc(+_OPWRVAL); asmc(+_FMTCMD);*/ endasm(); //TODO єсЁрЄ№
  204. }
  205.  
  206. EXPORT PROC endasm_dbstr()
  207. {
  208.   /**asmc(+_TOKENDTEXT);*/ asmc((BYTE)'\"'); /**asmc(+_FMTCMD);*/ endasm(); //TODO єсЁрЄ№
  209. }
  210.  
  211. EXPORT PROC endvar_db()
  212. {
  213.   /**varc(+_TOKENDEXPR); varc(+_OPWRVAL); varc(+_FMTCMD);*/ endvar(); //TODO єсЁрЄ№
  214. }
  215.  
  216. EXPORT PROC endvar_dbstr()
  217. {
  218.   /**varc(+_TOKENDTEXT);*/ varc((BYTE)'\"'); /**varc(+_FMTCMD);*/ endvar(); //TODO єсЁрЄ№
  219. }
  220.  
  221. EXPORT PROC endvar_dw()
  222. {
  223.   /**varc(+_TOKENDEXPR); varc(+_OPWRVAL); varc(+_FMTCMD);*/ endvar(); //TODO єсЁрЄ№
  224. }
  225.  
  226. EXPORT PROC endvar_dl()
  227. {
  228.   /**varc(+_TOKENDEXPR); varc(+_OPWRVAL); varc(+_FMTCMD);*/ endvar(); //TODO єсЁрЄ№
  229. }
  230.  
  231. EXPORT PROC endvar_ds()
  232. {
  233.   /**varc(+_TOKENDEXPR); varc(+_FMTCMD);*/ endvar();
  234. }
  235.  
  236. EXPORT PROC var_db() //фюёЄєяэю шч compile!
  237. {
  238.   varstr( "\tDB " );
  239. }
  240.  
  241. EXPORT PROC var_dbstr() //фюёЄєяэю шч compile!
  242. {
  243.   varstr( "\tDB \"" );
  244. }
  245.  
  246. EXPORT PROC asm_db() //ъюёЄ√ы№ фы  ъюэёЄрэЄэ√ї ьрёёштют ёЄЁюъ TODO
  247. {
  248.   asmstr( "\tDB " );
  249. }
  250.  
  251. EXPORT PROC asm_dbstr() //ъюёЄ√ы№ фы  ъюэёЄрэЄэ√ї ьрёёштют ёЄЁюъ TODO
  252. {
  253.   asmstr( "\tDB \"" );
  254. }
  255.  
  256. EXPORT PROC var_dw() //фюёЄєяэю шч compile!
  257. {
  258.   varstr( "\tDW " );
  259. }
  260.  
  261. PROC var_dl()
  262. {
  263.   varstr( "\tDL " );
  264. }
  265.  
  266. EXPORT PROC var_ds() //фюёЄєяэю шч compile!
  267. {
  268.   varstr( "\tDS " );
  269. }
  270.  
  271. PROC asm_and()
  272. {
  273.   asmstr( "\tAND " );
  274. }
  275.  
  276. PROC asm_or()
  277. {
  278.   asmstr( "\tOR " );
  279. }
  280.  
  281. PROC asm_xor()
  282. {
  283.   asmstr( "\tXOR " );
  284. }
  285.  
  286. PROC asm_sub()
  287. {
  288.   asmstr( "\tSUB " );
  289. }
  290.  
  291. PROC asm_sbc()
  292. {
  293.   asmstr( "\tSBB " );
  294. }
  295.  
  296. PROC asm_add()
  297. {
  298.   asmstr( "\tADD " );
  299. }
  300.  
  301. PROC asm_adc()
  302. {
  303.   asmstr( "\tADC " );
  304. }
  305.  
  306. PROC asm_inc()
  307. {
  308.   asmstr( "\tINC " );
  309. }
  310.  
  311. PROC asm_dec()
  312. {
  313.   asmstr( "\tDEC " );
  314. }
  315.  
  316. PROC asm_not()
  317. {
  318.   asmstr( "\tNOT " );
  319. }
  320.  
  321. PROC asm_ld()
  322. {
  323.   asmstr( "\tMOV " );
  324. }
  325.  
  326. PROC asm_jp()
  327. {
  328.   asmstr( "\tJMP " );
  329. }
  330.  
  331. PROC asm_jnz()
  332. {
  333.   asmstr( "\tJNZ " );
  334. }
  335.  
  336. PROC asm_jz()
  337. {
  338.   asmstr( "\tJZ " );
  339. }
  340.  
  341. PROC asm_jnc()
  342. {
  343.   asmstr( "\tJNC " );
  344. }
  345.  
  346. PROC asm_jc()
  347. {
  348.   asmstr( "\tJC " );
  349. }
  350.  
  351. PROC asm_push()
  352. {
  353.   asmstr( "\tPUSH " );
  354. }
  355.  
  356. PROC asm_pop()
  357. {
  358.   asmstr( "\tPOP " );
  359. }
  360.  
  361. PROC emitccf()
  362. {
  363.   asmstr( "\tCMC" ); endasm();
  364. }
  365.  
  366. PROC emitcall(PCHAR s)
  367. {
  368.   asmstr( "\tCALL " ); asmstr( s ); endasm();
  369. }
  370.  
  371. ///////////////////////////////////
  372. //фюёЄєяэ√ шч commands
  373. PROC unproxy()
  374. {
  375.   //IF (_rproxy != 0x00) { //т яЁюъёш ўЄю-Єю с√ыю
  376.   //  asm_ld(); /**rganame*/asm_rlow(_rproxy); asm_comma_a_eol();
  377.   //  _rproxy = 0x00;
  378.   //};
  379. }
  380.  
  381. PROC proxy(BYTE r)
  382. {
  383.   //IF (_rproxy != r) {
  384.   //  unproxy();
  385.   //  asm_lda_comma(); /**rganame*/asm_rlow(r); endasm();
  386.   //  _rproxy = r;
  387.   //};
  388. }
  389.  
  390. ///////////////////////////////////////////////////////////
  391. //яЁюЎхфєЁ√ ё ьр°шээ√ь ъюфюь фы  rgs
  392.  
  393. PROC emitpushrg(BYTE rnew)
  394. {
  395.   unproxy(); //todo юяЄшьшчшЁютрЄ№
  396.   asm_push(); asm_rname(rnew); endasm();
  397.   INC _funcstkdepth;
  398. }
  399.  
  400. PROC emitpoprg(BYTE rnew) //ЁхушёЄЁ єцх яюьхўхэ т getrfree/getrg
  401. {
  402.   asm_pop(); asm_rname(rnew); endasm();
  403.   DEC _funcstkdepth;
  404. }
  405.  
  406. PROC emitmovrg(BYTE rsrc, BYTE rdest) //эх чрърч√трхЄ ш эх юётюсюцфрхЄ (ёь. emitmoverg)
  407. {
  408.   IF (rsrc!=rdest) { //todo шыш ёЁртэштрЄ№ rsrc!=rdest ёэрЁєцш?
  409.       asm_ld(); asm_rname(rdest); asm_comma(); asm_rname(rsrc); endasm();
  410.   };
  411. }
  412.  
  413. ///////////////////////////////////////////////////////////////////////////////////////
  414. //¤Єш яЁюЎхфєЁ√ ухэхЁшЁє■Є ъюф
  415. //эхфюёЄєяэ√ шч ъюьяшы ЄюЁр, фюёЄєяэ√ шч commands
  416.  
  417. EXPORT PROC emitasmlabel(PCHAR s)
  418. {
  419.   asmstr(s); /**asmc( ':' );*/ endasm();
  420. }
  421.  
  422. EXPORT PROC emitfunclabel(PCHAR s)
  423. {
  424.   asmstr(s); /**asmc( ':' );*/ endasm();
  425. }
  426.  
  427. EXPORT PROC emitvarlabel(PCHAR s)
  428. {
  429.   varstr(s); /**varc( ':' );*/ endvar();
  430. }
  431.  
  432. EXPORT PROC emitexport(PCHAR s) //todo тёхуфр _joined
  433. {
  434.   asmstr("\tEXPORT "); asmstr(s); endasm();
  435. }
  436.  
  437. EXPORT PROC emitvarpreequ(PCHAR s)
  438. {
  439. }
  440.  
  441. EXPORT PROC emitvarpostequ()
  442. {
  443. }
  444.  
  445. EXPORT PROC varequ(PCHAR s)
  446. {
  447.   varstr(s); varc('=');
  448. }
  449.  
  450. EXPORT FUNC UINT varshift(UINT shift, UINT sz)
  451. {
  452.   //IF (sz >= 4) shift = (shift+3)&(UINT)(-4);
  453.   //asmstr(_joined); asmc('='); asmuint(shift); endasm();
  454.   varequ(_joined); /**varstr(_joined); varc('=');*/ varuint(shift); endvar();
  455. RETURN shift;
  456. }
  457.  
  458. PROC emitret()
  459. {
  460.   //unproxy();
  461.   asmstr( "\tRET" ); endasm();
  462. }
  463.  
  464. PROC emitjpmainrg() //"jp (hl)"
  465. {
  466.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  467.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  468.   unproxy();
  469.   getnothing(); //getnothingword();
  470.   //asm_jp(); asm_mhl(); endasm();
  471.   emitpushrg(0x01);
  472.   emitret();
  473. }
  474.  
  475. PROC emitcallmainrg() //"call (hl)"
  476. {
  477.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  478.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  479.   unproxy();
  480.   getnothing(); //getnothingword();
  481.   emitcall("_JPHL.");
  482.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  483. }
  484.  
  485. PROC emitjp()
  486. {
  487.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  488.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  489.   unproxy();
  490.   getnothing(); //getnothingword();
  491.   asm_jp(); asmstr(_joined); endasm();
  492. }
  493.  
  494. PROC emitbtoz() //яхЁхф jp!
  495. {
  496.   //ёЁрчє яюёых ёЁртэхэш  эх эрфю, эю тфЁєу ь√ ўшЄрхь BOOL
  497.   //IF (_jpflag == 0x00) {
  498.   IF (!_fused) { //Ёхчєы№ЄрЄр эхЄ тю Їырурї
  499.     //proxy(_rnew); //todo юяЄшьшчшЁютрЄ№
  500.     //IF (anew==_RGA) {
  501.       //asm_or(); asmrname(_rnew); asm_comma(); asmrname(_rnew); endasm();
  502.     //}ELSE {
  503.       asm_inc(); asm_rlow(_rnew); endasm();
  504.       asm_dec(); asm_rlow(_rnew); endasm();
  505.     //};
  506.   };
  507.   _rproxy = 0x00;
  508. }
  509.  
  510. PROC emitjpiffalse()
  511. {
  512.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  513.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  514.   //unproxy();
  515.   getnothing(); //getnothingword();
  516.   IF       (_jpflag == 0x02) {asm_jnz();
  517.   }ELSE IF (_jpflag == 0x03) {asm_jnc();
  518.   }ELSE IF (_jpflag == 0x04) {asm_jc();
  519.   }ELSE                      {asm_jz();
  520.   };
  521.   asmstr(_joined);
  522.   endasm();
  523.   _fused = +FALSE;
  524.   _jpflag = 0x00;
  525. }
  526.  
  527. PROC emitcall2rgs(PCHAR s)
  528. {
  529.   unproxy();
  530.   getmain2rgs();
  531.   initrgs();
  532.   emitcall(s);
  533.   setmainrg(); //Ёхчєы№ЄрЄ т RMAIN
  534. }
  535. /**
  536. PROC emitcall3rgs(PCHAR s) //todo яЁютхЁшЄ№
  537. {
  538.   unproxy();
  539.   getmain3rgs();
  540.   initrgs();
  541.   emitcall(s);
  542.   //ёхщўрё тёх ЁхушёЄЁ√ юЄьхўхэ√ ъръ ётюсюфэ√х
  543.   //setwordcontext();
  544.   setmain2rgs(); //Ёхчєы№ЄрЄ т RMAIN,RMAIN2
  545. }
  546. */
  547. PROC emitcall4rgs(PCHAR s) //todo яЁютхЁшЄ№
  548. {
  549.   unproxy();
  550.   getmain4rgs();
  551.   initrgs();
  552.   emitcall(s);
  553.   //ёхщўрё тёх ЁхушёЄЁ√ юЄьхўхэ√ ъръ ётюсюфэ√х
  554.   //setwordcontext();
  555.   setmain2rgs(); //Ёхчєы№ЄрЄ т RMAIN,RMAIN2
  556. }
  557.  
  558. PROC emitcallproc()
  559. {
  560.   //_jpflag = 0x00;
  561.   emitcall(_callee);
  562. }
  563.  
  564. PROC emitloadrg(BOOL high) //ЁхушёЄЁ єцх чрэ Є ўхЁхч getrfree
  565. {
  566.   asm_ld();
  567.   asm_rname(_rnew);
  568.   asm_comma();
  569.   asmstr(_const);
  570.   IF (high) {asmstr( ">>32"/**WORDBITS*/ );
  571.   //}ELSE {asmstr( "&0xffff"/**WORDMASK*/ );
  572.   };
  573.   endasm();
  574.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  575. }
  576.  
  577. PROC emitloadrg0() //ЁхушёЄЁ єцх чрэ Є ўхЁхч getrfree
  578. {
  579.   asm_ld(); asm_rname(_rnew); asm_comma(); asmc('0'); endasm();
  580. }
  581.  
  582. PROC emitloadb() //ръъєьєы ЄюЁ єцх чрэ Є ўхЁхч getfreea
  583. {
  584.   asm_ld();
  585.   asm_rlow(_rnew);
  586.   asm_comma();
  587.   asmstr(_const);
  588.   endasm();
  589.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  590. }
  591.  
  592. PROC emitgetrg(BOOL high) //ЁхушёЄЁ єцх чрэ Є ўхЁхч getrfree
  593. {
  594.   asm_ld();
  595.   asm_rname(_rnew);
  596.   asm_comma();
  597.   asm_open();
  598.   asmstr(_joined);
  599.   IF (high) {asmc('+'); asmc('4');
  600.   };
  601.   asm_close();
  602.   endasm();
  603. }
  604.  
  605. PROC emitgetb() //ръъєьєы ЄюЁ єцх чрэ Є ўхЁхч getfreea
  606. {
  607.   asm_ld();
  608.   asm_rlow(_rnew);
  609.   asm_comma();
  610.   asm_open();
  611.   asmstr(_joined);
  612.   asm_close();
  613.   endasm();
  614. }
  615.  
  616. PROC emitputrg(BOOL high) //ld [],new
  617. {
  618.   //_jpflag = 0x00;
  619.   asm_ld(); asm_open();
  620.   asmstr(_joined);
  621.   IF (high) {asmc('+'); asmc('4');
  622.   };
  623.   asm_close(); asm_comma();
  624.   asm_rname(_rnew); endasm();
  625.   endasm();
  626.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  627. }
  628.  
  629. PROC emitputb()
  630. {
  631.   //_jpflag = 0x00;
  632. //  proxy(_rnew);
  633.   asm_ld(); asm_open();
  634.   asmstr(_joined);
  635.   asm_close(); asm_comma();
  636.   asm_rlow(_rnew); endasm();
  637. //  _rproxy = 0x00;
  638.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  639. }
  640.  
  641. PROC emitshl1rg()
  642. {
  643.   asmstr( "\tSHL " ); asm_rname(_rnew); endasm();
  644. }
  645.  
  646. PROC emitshl1b()
  647. {
  648.   asmstr( "\tSHL " ); asm_rlow(_rnew); endasm();
  649. //    proxy(_rnew);
  650.   //IF (_rproxy==_rnew) {
  651. //    asm_add(); asm_a(); asm_comma_a_eol();
  652.   //}ELSE {
  653.   //  asmstr( "\tSLA " ); /**rganame*/asm_rlow(anew); endasm();
  654.   //};
  655. }
  656. /**
  657. PROC emitshr1rg(BYTE rnew)
  658. {
  659.   asmstr( "\tSRL " ); asm_rhigh(rnew); endasm();
  660.   asmstr( "\tRR " ); asm_rlow(rnew); endasm();
  661. }
  662.  
  663. PROC emitshr1signedrg(BYTE rnew)
  664. {
  665.   asmstr( "\tSRA " ); asm_rhigh(rnew); endasm();
  666.   asmstr( "\tRR " ); asm_rlow(rnew); endasm();
  667. }
  668. */
  669. //PROC emitshr1b(BYTE anew)
  670. //{
  671. //  asmstr( "\tSRL " ); /**rganame*/asm_rlow(anew] ); endasm();
  672. //}
  673.  
  674. PROC emitinvb() //~A -> A
  675. {
  676. //  proxy(_rnew);
  677. //  asmstr( "\tCPL" ); endasm();
  678.   asm_not(); asm_rlow(_rnew); endasm();
  679.   _fused = +FALSE; //шэрўх уы■ъ if (!(a||b))
  680. }
  681.  
  682. PROC emitinvrg()
  683. {
  684. //  unproxy();
  685.   asm_not(); asm_rname(_rnew); endasm();
  686. }
  687.  
  688. PROC emitnegrg()
  689. {
  690. //  unproxy();
  691.   asm_not(); asm_rname(_rnew); endasm();
  692.   asm_inc(); asm_rname(_rnew); endasm();
  693. }
  694.  
  695. PROC emitztob()
  696. {
  697.   //asmstr(";emitztoa exprlvl="); asmuint(_exprlvl); endasm();
  698.   IF (_exprlvl != 0x01) { //if (a == b)
  699.     asm_ld(); asm_rlow(_rnew); asm_comma(); asmc('0'); endasm();
  700.     asmstr( "\tJNZ $+3" ); endasm();
  701.     asm_dec(); asm_rlow(_rnew); endasm();
  702.     _fused = +FALSE; //шэрўх уы■ъ яЁш if ((a==b))
  703.     //_jpflag = 0x00;
  704.   }ELSE {
  705.     //_fused = +TRUE;
  706.     _jpflag = 0x02;
  707.   };
  708. }
  709.  
  710. PROC emitinvztob()
  711. {
  712.   //asmstr(";emitinvztoa exprlvl="); asmuint(_exprlvl); endasm();
  713.   IF (_exprlvl != 0x01) { //if (a != b)
  714.     asm_ld(); asm_rlow(_rnew); asm_comma(); asmc('0'); endasm();
  715.     asmstr( "\tJZ $+3" ); endasm();
  716.     asm_dec(); asm_rlow(_rnew); endasm();
  717.     _fused = +FALSE; //шэрўх уы■ъ яЁш if ((a!=b))? todo test //тючьюцхэ уы■ъ ifnot ((a!=b))
  718.     //_jpflag = 0x00;
  719.   }ELSE {
  720.     //_fused = +TRUE;
  721.     _jpflag = 0x01;
  722.   };
  723. }
  724.  
  725. PROC emitcytob()
  726. {
  727.   //asmstr(";emitcytoa exprlvl="); asmuint(_exprlvl); endasm();
  728.   IF (_exprlvl != 0x01) { //if (a < b)
  729. //    unproxy();
  730.     asm_sbc(); asm_rlow(_rnew); asm_comma(); asm_rlow(_rnew); endasm();
  731. //    _rproxy = _rnew;
  732.     //_fused = +FALSE;
  733.     //_jpflag = 0x00;
  734.   }ELSE {
  735.     //_fused = +TRUE;
  736.     _jpflag = 0x03;
  737.   };
  738. }
  739.  
  740. PROC emitinvcytob()
  741. {
  742.   //asmstr(";emitinvcytoa exprlvl="); asmuint(_exprlvl); endasm();
  743.   IF (_exprlvl != 0x01) { //if (a >= b)
  744.     emitccf();
  745. //    unproxy();
  746.     asm_sbc(); asm_rlow(_rnew); asm_comma(); asm_rlow(_rnew); endasm();
  747. //    _rproxy = _rnew;
  748.     //_fused = +FALSE;
  749.     //_jpflag = 0x00;
  750.   }ELSE {
  751.     //_fused = +TRUE;
  752.     _jpflag = 0x04;
  753.   };
  754. }
  755.  
  756. PROC emitSxorVtob() //яюёых subflags, ЁрчЁхчхЁтшЁєхЄ A
  757. { //todo яЁютхЁшЄ№
  758.   asm_ld(); asm_rname(_rnew); asm_comma(); asmc('0'); endasm();
  759.   asmstr( "\tJG $+4" ); endasm();
  760.   asm_not(); asm_rlow(_rnew); endasm();
  761. }
  762.  
  763. PROC emitinvSxorVtob() //яюёых subflags, ЁрчЁхчхЁтшЁєхЄ A
  764. { //todo яЁютхЁшЄ№
  765.   asm_ld(); asm_rname(_rnew); asm_comma(); asmc('0'); endasm();
  766.   asmstr( "\tJLE $+4" ); endasm();
  767.   asm_not(); asm_rlow(_rnew); endasm();
  768. }
  769.  
  770. PROC emitxorrg() //old^new => old
  771. {
  772. //  unproxy();
  773.   asm_xor(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasm();
  774. }
  775.  
  776. PROC getxorb() //RGA^RGA2 -> RGA
  777. {
  778.   asm_xor(); asm_rlow(_rold); asm_comma(); asm_rlow(_rnew); endasm();
  779.   _fused = +TRUE; //^^
  780. }
  781.  
  782. PROC emitorrg() //old|new => old
  783. {
  784. //  unproxy();
  785.   asm_or(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasm();
  786. }
  787.  
  788. PROC getorb() //RGA|RGA2 -> RGA
  789. {
  790.   asm_or(); asm_rlow(_rold); asm_comma(); asm_rlow(_rnew); endasm();
  791.   _fused = +TRUE; //||
  792. }
  793.  
  794. PROC emitandrg() //old&new => old
  795. {
  796. //  unproxy();
  797.   asm_and(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasm();
  798. }
  799.  
  800. PROC getandb() //RGA&RGA2 -> RGA
  801. {
  802.   asm_and(); asm_rlow(_rold); asm_comma(); asm_rlow(_rnew); endasm();
  803.   _fused = +TRUE; //&&
  804. }
  805.  
  806. PROC emitaddrg() //old+new => old
  807. {
  808. //  unproxy();
  809.   asm_add(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasm();
  810. }
  811.  
  812. PROC emitadcrg() //old+new => old
  813. {
  814. //  unproxy();
  815.   asm_adc(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasm();
  816. }
  817.  
  818. PROC emitaddb() //old+new
  819. {
  820.   asm_add(); asm_rlow(_rold); asm_comma(); asm_rlow(_rnew); endasm();
  821. }
  822.  
  823. PROC emitaddbconst() //new8+<const>
  824. {
  825.   asm_add(); asm_rlow(_rnew); asm_comma(); asmstr(_const); endasm();
  826. }
  827.  
  828. PROC emitsubrg() //old-new => old
  829. {
  830. //  unproxy();
  831.   asm_sub(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasm();
  832. }
  833.  
  834. PROC emitsbcrg() //old-new => old
  835. {
  836. //  unproxy();
  837.   asm_sbc(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasm();
  838. }
  839.  
  840. PROC emitsubb() //old-new
  841. {
  842.   asm_sub(); asm_rlow(_rold); asm_comma(); asm_rlow(_rnew); endasm();
  843. }
  844.  
  845. PROC emitsubbconst() //new8-<const>
  846. {
  847.   asm_sub(); asm_rlow(_rnew); asm_comma(); asmstr(_const); endasm();
  848. }
  849.  
  850. PROC emitsubflags(BYTE rnew, BYTE rold) //r2-r1 => CY,sign,overflow
  851. {
  852. //  unproxy();
  853.   asm_sub(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasm();
  854.   _fused = +TRUE;
  855. }
  856.  
  857. PROC emitsubbflags(BYTE anew, BYTE aold) //a2-a1 => CY
  858. { //sign,overflow эх эєцхэ!
  859. //  proxy(aold);
  860.   asm_sub(); asm_rlow(_rold); asm_comma(); asm_rlow(_rnew); endasm();
  861.   _fused = +TRUE;
  862. }
  863.  
  864. PROC emitsubz() //old-new => Z
  865. {
  866. // unproxy();
  867.   asm_sub(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasm();
  868. //    _azused = +TRUE; //A ёюфхЁцшЄ яЁртшы№э√щ 0/эх0 яюёых ёЁртэхэш 
  869.   _fused = +TRUE;
  870. }
  871.  
  872. PROC emitsubbz() //old-new => Z
  873. {
  874.   asm_sub(); asm_rlow(_rold); asm_comma(); asm_rlow(_rnew); endasm();
  875. //  _rproxy = 0x00;
  876. //  _azused = +TRUE; //A ёюфхЁцшЄ яЁртшы№э√щ 0/эх0 яюёых ёЁртэхэш 
  877.   _fused = +TRUE;
  878. }
  879.  
  880. PROC emitsubbzconst() //new-<const> => Z
  881. {
  882. //  proxy(_rnew);
  883.   asm_sub(); asm_rlow(_rnew); asm_comma(); asmstr(_const); endasm();
  884. //  _rproxy = 0x00;
  885. //  _azused = +TRUE; //A ёюфхЁцшЄ яЁртшы№э√щ 0/эх0 яюёых ёЁртэхэш 
  886.   _fused = +TRUE;
  887. }
  888.  
  889. PROC emitsublongz() //old2-new, old3-old => Z
  890. {
  891. //  unproxy();
  892.   asm_sub(); asm_rname(_rold2); asm_comma(); asm_rname(_rnew); endasm();
  893.   asmstr( "\tJNZ $+4" ); endasm();
  894.   asm_sub(); asm_rname(_rold3); asm_comma(); asm_rname(_rold); endasm();
  895.   _fused = +TRUE;
  896. }
  897.  
  898. PROC emitpokerg() //эютюх чряшё√трхь т ёЄрЁє■ ыюърЎш■ ярь Єш
  899. {
  900.   asm_ld(); asm_mrgname(_rold); asm_comma(); asm_rname(_rnew); endasm();
  901.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  902. }
  903.  
  904. PROC emitpokeb() //эютюх чряшё√трхь т ёЄрЁє■ ыюърЎш■ ярь Єш
  905. //т rnew ьюцхЄ эх с√Є№ фрээ√ї, хёыш rproxy==rnew!!!
  906. {
  907.   asm_ld(); asm_mrgname(_rold); asm_comma(); asm_rlow(_rnew); endasm();
  908.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  909. }
  910.  
  911. PROC emitpokelong() //old2(addr), old(high), new(low)
  912. {
  913.   asm_ld(); asm_mrgname(_rold2); asm_comma(); asm_rname(_rold); endasm();
  914.   asm_ld(); asm_open(); asm_rname(_rold2); asmc('+'); asmc('4'); asm_close(); asm_comma(); asm_rname(_rnew); endasm();
  915.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  916. }
  917.  
  918. PROC emitpeekrg() //[new] => new
  919. {
  920.   asm_ld(); asm_rname(_rnew); asm_comma(); asm_mrgname(_rnew); endasm();
  921. }
  922.  
  923. PROC emitpeekb()
  924. {
  925.   asm_ld(); asm_rlow(_rnew); asm_comma(); asm_mrgname(_rold); endasm();
  926. }
  927.  
  928. PROC emitpeeklong() //[old] => old(high),new(low)
  929. {
  930.   asm_ld(); asm_rname(_rnew); asm_comma(); asm_mrgname(_rold); endasm();
  931.   asm_ld(); asm_rname(_rold); asm_comma(); asm_open(); asm_rname(_rold); asmc('+'); asmc('4'); asm_close(); endasm();
  932. }
  933.  
  934. PROC emitrgtob() //эхы№ч  єсшЁрЄ№ - ёяхЎшЇшўэю
  935. {
  936.   asm_and(); asm_rname(_rnew); asm_comma(); asmstr("0xff"); endasm();
  937. }
  938.  
  939. PROC emitbtorg() //эхы№ч  єсшЁрЄ№ - ёяхЎшЇшўэю
  940. {
  941. }
  942.  
  943. PROC emitincrg_byname()
  944. {
  945.   emitgetrg(+FALSE);
  946.   asm_inc(); asm_rname(_rnew); endasm();
  947.   emitputrg(+FALSE);
  948.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  949. }
  950.  
  951. PROC emitincb_bypoi()
  952. {
  953.   asm_inc(); asm_open(); asm_rname(_rnew); asm_close(); endasm();
  954.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  955. }
  956. /**
  957. PROC emitinclong() //todo
  958. {
  959.   asm_inc(); asm_open(); asm_rname(_rnew); asm_close(); endasm();
  960.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  961. }
  962. */
  963. PROC emitdecrg_byname()
  964. {
  965.   emitgetrg(+FALSE);
  966.   asm_dec(); asm_rname(_rnew); endasm();
  967.   emitputrg(+FALSE);
  968.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  969. }
  970.  
  971. PROC emitdecb_bypoi()
  972. {
  973.   asm_dec(); asm_open(); asm_rname(_rnew); asm_close(); endasm();
  974.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  975. }
  976. /**
  977. PROC emitdeclong() //todo
  978. {
  979.   asm_dec(); asm_open(); asm_rname(_rnew); asm_close(); endasm();
  980.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  981. }
  982. */
  983.  
  984. PROC emitincrg_bypoi() //[old], new free
  985. {
  986.   asm_ld(); asm_rname(_rnew); asm_comma(); asm_open(); asm_rname(_rold); asm_close(); endasm();
  987.   asm_inc(); asm_rname(_rnew); endasm();
  988.   asm_ld(); asm_open(); asm_rname(_rold); asm_close(); asm_comma(); asm_rname(_rnew); endasm();
  989.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  990. }
  991.  
  992. PROC emitdecrg_bypoi() //[old], new free
  993. {
  994.   asm_ld(); asm_rname(_rnew); asm_comma(); asm_open(); asm_rname(_rold); asm_close(); endasm();
  995.   asm_dec(); asm_rname(_rnew); endasm();
  996.   asm_ld(); asm_open(); asm_rname(_rold); asm_close(); asm_comma(); asm_rname(_rnew); endasm();
  997.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  998. }
  999.  
  1000. /////////////
  1001. EXPORT PROC initcode()
  1002. {
  1003.   _jpflag = 0x00;
  1004. }
  1005.  
  1006. EXPORT PROC endcode()
  1007. {
  1008. }
  1009.  
  1010. PROC initrgs()
  1011. {
  1012.   rgs_initrgs();
  1013. //  _azused = +FALSE;
  1014.   _fused = +FALSE; //ьюцэю ёфхырЄ№ юфэє яЁюЎхфєЁє initif фы  ¤Єюую (т√ч√трЄ№ т эрўрых if, while, until)
  1015.   _rproxy = 0x00;
  1016. }
  1017.  
  1018. PROC emitfunchead()
  1019. {
  1020.   initrgs();
  1021. }
  1022.  
  1023. PROC setmainb()
  1024. {
  1025.   setmainrg(); //Ёхчєы№ЄрЄ т RMAIN
  1026.   _rproxy = _RMAIN;
  1027. }
  1028.  
  1029. PROC prefernoregs()
  1030. {
  1031.   getnothing(); //Єръ т√уюфэхх inc/dec
  1032. }
  1033.