?login_element?

Subversion Repositories NedoOS

Rev

Rev 477 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. //// imported
  2. #include "../_sdk/emit.h"
  3.  
  4. //фы  script эрфю т рёёхьсыхЁх яю ъюьрэфх DW яшёрЄ№ uint64_t т Їрщы, эю єърчрЄхы№ шэъЁхьхэЄшЁютрЄ№ Єюы№ъю эр 1
  5.  
  6. //#include "sizesz80.h"
  7.  
  8. //тхчфх, уфх эєцхэ ёЄЁюъют√щ ярЁрьхЄЁ, шёяюы№чєхЄё  _joined
  9. //(ъЁюьх call - Єрь _callee, ш ъЁюьх loadrg/b - Єрь _const)
  10. //т ъюэЎх ы■сюую т√ўшёыхэш  (put, call, jpiffalse) фхыры _jpflag = 0x00 (шэрўх яЁхф√фє∙хх "юяЄшьшчшЁютрээюх" ёЁртэхэшх ьюцхЄ шёяюЁЄшЄ№ эют√щ єёыютэ√щ яхЁхїюф)
  11. //юёЄртшы Єюы№ъю т jpiffalse, Є.ъ. юёЄры№э√х эх ьюуєЄ с√Є№ "юяЄшьшчшЁютрээ√ьш"
  12. EXPORT VAR PCHAR _callee; //эрчтрэшх т√ч√трхьющ яЁюЎхфєЁ√ (ё єў╕Єюь ьюфєы )
  13. EXPORT VAR UINT  _lencallee;
  14. EXTERN PCHAR _joined; //ртЄюьхЄър
  15. EXTERN UINT  _lenjoined;
  16. EXTERN PCHAR _const; //ёЄрЁр  ъюэёЄрэЄр
  17. EXTERN UINT  _lenconst;
  18.  
  19. EXPORT VAR BYTE _exprlvl; //уыєсшэр т√Ёрцхэш  (тхЁїэшщ єЁютхэ№ == 1)
  20.  
  21. //тэх°эшх яЁюЎхфєЁ√ (шч rgs) - todo т codegen эх шёяюы№чютрЄ№ rgs
  22. EXTERN BYTE _rnew;
  23. EXTERN BYTE _rold;
  24. EXTERN BYTE _rold2;
  25. EXTERN BYTE _rold3;
  26.  
  27. //rg pool
  28. PROC getnothing FORWARD(); //ёюїЁрэшЄ№ ЁхушёЄЁ√ ш срщЄ√ т ёЄхъх ш юётюсюфшЄ№
  29. //PROC getmainrg FORWARD(); //тч Є№ RMAIN=new ш юётюсюфшЄ№ юёЄры№э√х ЁхушёЄЁ√
  30. PROC getmain2rgs FORWARD(); //тч Є№ RMAIN=old, RMAIN2=new ш юётюсюфшЄ№ юёЄры№э√х ЁхушёЄЁ√ //фы  call2rgs
  31. //PROC getmain3rgs FORWARD(); //фы  call3rgs
  32. PROC getmain4rgs FORWARD(); //фы  call4rgs
  33. PROC setmainrg FORWARD(); //єёЄрэютшЄ№ яЁшчэръш, ъръ сєфЄю ь√ яюыєўшыш Ёхчєы№ЄрЄ т ЁхушёЄЁх //фы  call2rgs
  34. PROC setmain2rgs FORWARD(); //єёЄрэютшЄ№ яЁшчэръш, ъръ сєфЄю ь√ яюыєўшыш Ёхчєы№ЄрЄ т ЁхушёЄЁрї //фы  call4rgs
  35.  
  36. PROC rgs_initrgs FORWARD();
  37.  
  38. ////
  39. #define _RGBUFSZ (BYTE)(_NRGS+0x01)
  40.  
  41.   //яЁшюЁшЄхЄ√ ЁхушёЄЁют:
  42. CONST BYTE _RMAIN = 0x01; /**HL*/ /**ЁхушёЄЁ Ёхчєы№ЄрЄр ш яхЁтюую ярЁрьхЄЁр ёЄрэфрЁЄэ√ї ЇєэъЎшщ*/
  43. CONST BYTE _RMAIN2= 0x02; /**DE*/ /**ЁхушёЄЁ тЄюЁюую ёыютр Ёхчєы№ЄрЄр ш тЄюЁюую ярЁрьхЄЁр ёЄрэфрЁЄэ√ї ЇєэъЎшщ*/
  44. CONST BYTE _RMAIN3= 0x03;
  45. CONST BYTE _RMAIN4= 0x04;
  46.  
  47. CONST PCHAR _RNAME[_RGBUFSZ] = {
  48.   "", //0 яєёЄющ
  49.   "HL",
  50.   "DE",
  51.   "BC",
  52.   "IX"
  53. };
  54. CONST PCHAR _RHIGH[_RGBUFSZ] = {
  55.   "", //0 яєёЄющ
  56.   "H",
  57.   "D",
  58.   "B",
  59.   "HX"
  60. };
  61. CONST PCHAR _RLOW[_RGBUFSZ] = {
  62.   "", //0 яєёЄющ
  63.   "L",
  64.   "E",
  65.   "C",
  66.   "LX"
  67. };
  68.  
  69. VAR BYTE _rproxy;
  70. VAR BOOL _fused;
  71. VAR BOOL _azused; //A ёюфхЁцшЄ яЁртшы№э√щ 0/эх0 яюёых ёЁртэхэш 
  72.  
  73. VAR INT _funcstkdepth;
  74.  
  75. VAR BYTE _jpflag; //0=OR A:JZ, 1=JZ, 2=JNZ, 3=JNC, 4=JC
  76.  
  77. EXPORT CONST BYTE _typesz[32] = { //ЁрчьхЁ Єшяр т срщЄрї фы  ЄрЁухЄр //чфхё№ эх шёяюы№чєхЄё 
  78.   _SZ_BYTE/**T_BYTE */, //фы  тёхї ЄрЁухЄют
  79.   _SZ_REG/**T_UINT */, //фы  тёхї ЄрЁухЄют
  80.   _SZ_REG/**T_INT  */, //фы  тёхї ЄрЁухЄют
  81.   _SZ_BOOL/**T_BOOL */,
  82.   _SZ_LONG/**T_LONG */,
  83.   _SZ_BYTE/**T_CHAR */,
  84.   _SZ_LONG/**T_FLOAT*/,
  85.   0x00/**unknown*/,
  86.   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  87.   _SZ_REG/**T_PBYTE */,
  88.   _SZ_REG/**T_PUINT */,
  89.   _SZ_REG/**T_PINT  */,
  90.   _SZ_REG/**T_PBOOL */,
  91.   _SZ_REG/**T_PLONG */,
  92.   _SZ_REG/**T_PCHAR */,
  93.   _SZ_REG/**T_PFLOAT*/,
  94.   _SZ_REG/**        */,
  95.   _SZ_REG, _SZ_REG, _SZ_REG, _SZ_REG, _SZ_REG, _SZ_REG, _SZ_REG, _SZ_REG //pointer to...
  96. };
  97.  
  98. CONST BYTE _typeshift[32] = { //log ЁрчьхЁ Єшяр (n фы  2^n срщЄ) фы  ЄрЁухЄр //чфхё№ эх шёяюы№чєхЄё 
  99.   _RL_BYTE/**T_BYTE */, //фы  тёхї ЄрЁухЄют
  100.   _RL_REG/**T_UINT */, //фы  тёхї ЄрЁухЄют
  101.   _RL_REG/**T_INT  */, //фы  тёхї ЄрЁухЄют
  102.   _RL_BOOL/**T_BOOL */,
  103.   _RL_LONG/**T_LONG */,
  104.   _RL_BYTE/**T_CHAR */,
  105.   _RL_LONG/**T_FLOAT*/,
  106.   0x00/**unknown*/,
  107.   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  108.   _RL_REG/**T_BYTE  */,
  109.   _RL_REG/**T_UINT  */,
  110.   _RL_REG/**T_INT   */,
  111.   _RL_REG/**T_BOOL  */,
  112.   _RL_REG/**T_LONG  */,
  113.   _RL_REG/**T_CHAR  */,
  114.   _RL_REG/**T_PFLOAT*/,
  115.   _RL_REG/**        */,
  116.   _RL_REG, _RL_REG, _RL_REG, _RL_REG, _RL_REG, _RL_REG, _RL_REG, _RL_REG //pointer to...
  117. };
  118.  
  119. PROC initrgs FORWARD(); //юўшёЄшЄ№ ёюёЄю эш  ЁхушёЄЁют ш срщЄют (шёяюы№чєхЄё  т cemitfunc)
  120.  
  121. //////////// ьхыъшх яЁюЎхфєЁ√ фы  ёюъЁр∙хэш  ўшёыр ъюэёЄрэЄ
  122.  
  123. EXPORT PROC var_alignwsz()
  124. {
  125. }
  126.  
  127. EXPORT PROC var_db() //фюёЄєяэю шч compile фы  ёЄЁюъ!
  128. {
  129.   varstr( "\tDB " );
  130. }
  131.  
  132. EXPORT PROC asm_db() //ъюёЄ√ы№ фы  ъюэёЄрэЄэ√ї ьрёёштют ёЄЁюъ TODO
  133. {
  134.   asmstr( "\tDB " );
  135. }
  136.  
  137. EXPORT PROC var_dw() //фюёЄєяэю шч compile!
  138. {
  139.   varstr( "\tDW " );
  140. }
  141.  
  142. PROC var_dl()
  143. {
  144.   varstr( "\tDL " );
  145. }
  146.  
  147. EXPORT PROC var_ds() //фюёЄєяэю шч compile!
  148. {
  149.   varstr( "\tDS " );
  150. }
  151.  
  152. PROC asm_add_eol()
  153. {
  154.   asmstr( "\tDW CMD_ADD" ); endasm();
  155. }
  156.  
  157. PROC asm_sub_eol()
  158. {
  159.   asmstr( "\tDW CMD_SUB" ); endasm();
  160. }
  161.  
  162. PROC asm_mul_eol()
  163. {
  164.   asmstr( "\tDW CMD_MUL" ); endasm();
  165. }
  166.  
  167. PROC asm_div_eol()
  168. {
  169.   asmstr( "\tDW CMD_DIV" ); endasm();
  170. }
  171.  
  172. PROC asm_addfloat_eol()
  173. {
  174.   asmstr( "\tDW CMD_ADDFLOAT" ); endasm();
  175. }
  176.  
  177. PROC asm_subfloat_eol()
  178. {
  179.   asmstr( "\tDW CMD_SUBFLOAT" ); endasm();
  180. }
  181.  
  182. PROC asm_mulfloat_eol()
  183. {
  184.   asmstr( "\tDW CMD_MULFLOAT" ); endasm();
  185. }
  186.  
  187. PROC asm_divfloat_eol()
  188. {
  189.   asmstr( "\tDW CMD_DIVFLOAT" ); endasm();
  190. }
  191.  
  192. PROC asm_divsigned_eol()
  193. {
  194.   asmstr( "\tDW CMD_DIVSIGNED" ); endasm();
  195. }
  196.  
  197. PROC asm_negfloat_eol()
  198. {
  199.   asmstr( "\tDW CMD_NEGFLOAT" ); endasm();
  200. }
  201.  
  202. PROC asm_if0goto()
  203. {
  204.   asmstr( "\tDW CMD_IF0GOTO," );
  205. }
  206.  
  207. PROC asm_goto()
  208. {
  209.   asmstr( "\tDW CMD_GOTO," );
  210. }
  211.  
  212. PROC asm_dup_eol()
  213. {
  214.   asmstr( "\tDW CMD_DUP" ); endasm();
  215. }
  216.  
  217. PROC asm_drop_eol()
  218. {
  219.   asmstr( "\tDW CMD_DROP" ); endasm();
  220. }
  221.  
  222. PROC asm_swap_eol()
  223. {
  224.   asmstr( "\tDW CMD_SWAP" ); endasm();
  225. }
  226.  
  227. PROC asm_readvar_eol()
  228. {
  229.   asmstr( "\tDW CMD_READVAR" ); endasm();
  230. }
  231.  
  232. PROC asm_writevar_eol()
  233. {
  234.   asmstr( "\tDW CMD_WRITEVAR" ); endasm();
  235. }
  236.  
  237. PROC asm_const()
  238. {
  239.   asmstr( "\tDW CMD_CONST," );
  240. }
  241.  
  242. PROC asm_ret_eol()
  243. {
  244.   asmstr( "\tDW CMD_RET" ); endasm();
  245. }
  246.  
  247. PROC asm_call()
  248. {
  249.   asmstr( "\tDW CMD_CALL," );
  250. }
  251.  
  252. PROC asm_and_eol()
  253. {
  254.   asmstr( "\tDW CMD_AND" ); endasm();
  255. }
  256.  
  257. PROC asm_or_eol()
  258. {
  259.   asmstr( "\tDW CMD_OR" ); endasm();
  260. }
  261.  
  262. PROC asm_xor_eol()
  263. {
  264.   asmstr( "\tDW CMD_XOR" ); endasm();
  265. }
  266.  
  267. PROC asm_eq_eol()
  268. {
  269.   asmstr( "\tDW CMD_EQ" ); endasm();
  270. }
  271.  
  272. PROC asm_moreeq_eol()
  273. {
  274.   asmstr( "\tDW CMD_MOREEQ" ); endasm();
  275. }
  276.  
  277. PROC asm_moreeqsigned_eol()
  278. {
  279.   asmstr( "\tDW CMD_MOREEQSIGNED" ); endasm();
  280. }
  281.  
  282. PROC asm_eqfloat_eol()
  283. {
  284.   asmstr( "\tDW CMD_EQFLOAT" ); endasm();
  285. }
  286.  
  287. PROC asm_moreeqfloat_eol()
  288. {
  289.   asmstr( "\tDW CMD_MOREEQFLOAT" ); endasm();
  290. }
  291.  
  292. PROC asm_inv_eol()
  293. {
  294.   asmstr( "\tDW CMD_INV" ); endasm();
  295. }
  296.  
  297. PROC asm_rst()
  298. {
  299.   asmstr( "\tDW CMD_RST," );
  300. }
  301.  
  302. PROC asm_shr_eol()
  303. {
  304.   asmstr( "\tDW CMD_SHR" ); endasm();
  305. }
  306.  
  307. PROC asm_shrsigned_eol()
  308. {
  309.   asmstr( "\tDW CMD_SHRSIGNED" ); endasm();
  310. }
  311.  
  312. PROC asm_shl_eol()
  313. {
  314.   asmstr( "\tDW CMD_SHL" ); endasm();
  315. }
  316.  
  317. PROC asm_mod_eol()
  318. {
  319.   asmstr( "\tDW CMD_MOD" ); endasm();
  320. }
  321.  
  322. PROC asm_done_eol()
  323. {
  324.   asmstr( "\tDW CMD_DONE" ); endasm();
  325. }
  326.  
  327. PROC asm_1_eol()
  328. {
  329.   asmstr( "\tDW CMD_CONST,1" ); endasm();
  330. }
  331.  
  332. PROC asm_floattoint_eol()
  333. {
  334.   asmstr( "\tDW CMD_FLOATTOINT" ); endasm();
  335. }
  336.  
  337. PROC asm_inttofloat_eol()
  338. {
  339.   asmstr( "\tDW CMD_INTTOFLOAT" ); endasm();
  340. }
  341.  
  342. PROC emitinc()
  343. {
  344.   asm_1_eol();
  345.   asm_add_eol();
  346. }
  347.  
  348. PROC emitdec()
  349. {
  350.   asm_1_eol();
  351.   asm_sub_eol();
  352. }
  353.  
  354. PROC emitcall(PCHAR s)
  355. {
  356.   asm_call(); asmstr( s ); endasm();
  357. }
  358.  
  359. ///////////////////////////////////
  360. //фюёЄєяэ√ шч commands
  361. PROC unproxy()
  362. {
  363. }
  364.  
  365. PROC proxy(BYTE r)
  366. {
  367. }
  368.  
  369. ///////////////////////////////////////////////////////////
  370. //яЁюЎхфєЁ√ ё ьр°шээ√ь ъюфюь фы  rgs
  371.  
  372. PROC emitpushrg(BYTE rnew)
  373. {
  374.   //unproxy(); //todo юяЄшьшчшЁютрЄ№
  375.   //asm_push(); asm_rname(rnew); endasm();
  376.   //INC _funcstkdepth;
  377. }
  378.  
  379. PROC emitpoprg(BYTE rnew) //ЁхушёЄЁ єцх яюьхўхэ т getrfree/getrg
  380. {
  381.   //asm_pop(); asm_rname(rnew); endasm();
  382.   //DEC _funcstkdepth;
  383. }
  384.  
  385. PROC emitmovrg(BYTE rsrc, BYTE rdest) //эх чрърч√трхЄ ш эх юётюсюцфрхЄ (ёь. emitmoverg)
  386. {
  387.    //asm_push(); asm_rname(rsrc); endasm();
  388.    //asm_pop(); asm_rname(rdest); endasm();
  389. }
  390.  
  391. ///////////////////////////////////////////////////////////////////////////////////////
  392. //¤Єш яЁюЎхфєЁ√ ухэхЁшЁє■Є ъюф
  393. //эхфюёЄєяэ√ шч ъюьяшы ЄюЁр, фюёЄєяэ√ шч commands
  394.  
  395. EXPORT PROC emitasmlabel(PCHAR s)
  396. {
  397.   asmstr(s); /**asmc( ':' );*/ endasm();
  398. }
  399.  
  400. EXPORT PROC emitfunclabel(PCHAR s)
  401. {
  402.   asmstr(s); /**asmc( ':' );*/ endasm();
  403. }
  404.  
  405. EXPORT PROC emitvarlabel(PCHAR s)
  406. {
  407.   varstr(s); /**varc( ':' );*/ endvar();
  408. }
  409.  
  410. EXPORT PROC emitexport(PCHAR s) //todo тёхуфр _joined
  411. {
  412.   asmstr("\tEXPORT "); asmstr(s); endasm();
  413. }
  414.  
  415. EXPORT PROC emitvarpreequ(PCHAR s)
  416. {
  417. }
  418.  
  419. EXPORT PROC emitvarpostequ()
  420. {
  421. }
  422.  
  423. EXPORT PROC varequ(PCHAR s)
  424. {
  425.   varstr(s); varc('=');
  426. }
  427.  
  428. EXPORT FUNC UINT varshift(UINT shift, UINT sz)
  429. {
  430.   //IF (sz >= 4) shift = (shift+3)&(UINT)(-4);
  431.   //asmstr(_joined); asmc('='); asmuint(shift); endasm();
  432.   varequ(_joined); /**varstr(_joined); varc('=');*/ varuint(shift); endvar();
  433. RETURN shift;
  434. }
  435.  
  436. PROC emitjpmainrg() //"jp (hl)"
  437. {
  438.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  439.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  440.   unproxy();
  441.   getnothing(); //getnothingword();
  442.   asmstr("unsupported: emitjpmainrg()"); endasm();
  443. }
  444.  
  445. PROC emitcallmainrg() //"call (hl)"
  446. {
  447.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  448.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  449.   unproxy();
  450.   getnothing(); //getnothingword();
  451.   asmstr("unsupported: emitcallmainrg()"); endasm();
  452.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  453. }
  454.  
  455. PROC emitjp()
  456. {
  457.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  458.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  459.   unproxy();
  460.   getnothing(); //getnothingword();
  461.   asm_goto(); asmstr(_joined); endasm();
  462. }
  463.  
  464. PROC emitbtoz() //яхЁхф jp!
  465. {
  466.   //ёЁрчє яюёых ёЁртэхэш  эх эрфю, эю тфЁєу ь√ ўшЄрхь BOOL
  467. }
  468.  
  469. PROC emitless()
  470. {
  471.   asm_moreeq_eol();
  472.   asm_inv_eol();
  473.   _jpflag = 0x00;
  474. }
  475.  
  476. PROC emitlesssigned()
  477. {
  478.   asm_moreeqsigned_eol();
  479.   asm_inv_eol();
  480.   _jpflag = 0x00;
  481. }
  482.  
  483. PROC emitlessb()
  484. {
  485.   emitless();
  486. }
  487.  
  488. PROC emitlessfloat()
  489. {
  490.   asm_moreeqfloat_eol();
  491.   asm_inv_eol();
  492.   _jpflag = 0x00;
  493. }
  494.  
  495. PROC emitlesseq()
  496. {
  497.   asm_swap_eol();
  498.   asm_moreeq_eol();
  499.   _jpflag = 0x00;
  500. }
  501.  
  502. PROC emitlesseqsigned()
  503. {
  504.   asm_swap_eol();
  505.   asm_moreeqsigned_eol();
  506.   _jpflag = 0x00;
  507. }
  508.  
  509. PROC emitlesseqb()
  510. {
  511.   emitlesseq();
  512. }
  513.  
  514. PROC emitlesseqfloat()
  515. {
  516.   asm_swap_eol();
  517.   asm_moreeqfloat_eol();
  518.   _jpflag = 0x00;
  519. }
  520.  
  521. PROC emitmore()
  522. {
  523.   asm_swap_eol();
  524.   asm_moreeq_eol();
  525.   asm_inv_eol();
  526.   _jpflag = 0x00;
  527. }
  528.  
  529. PROC emitmoresigned()
  530. {
  531.   asm_swap_eol();
  532.   asm_moreeqsigned_eol();
  533.   asm_inv_eol();
  534.   _jpflag = 0x00;
  535. }
  536.  
  537. PROC emitmoreb()
  538. {
  539.   emitmore();
  540. }
  541.  
  542. PROC emitmorefloat()
  543. {
  544.   asm_swap_eol();
  545.   asm_moreeqfloat_eol();
  546.   asm_inv_eol();
  547.   _jpflag = 0x00;
  548. }
  549.  
  550. PROC emitmoreeq()
  551. {
  552.   asm_moreeq_eol();
  553.   _jpflag = 0x00;
  554. }
  555.  
  556. PROC emitmoreeqsigned()
  557. {
  558.   asm_moreeqsigned_eol();
  559.   _jpflag = 0x00;
  560. }
  561.  
  562. PROC emitmoreeqb()
  563. {
  564.   emitmoreeq();
  565. }
  566.  
  567. PROC emitmoreeqfloat()
  568. {
  569.   asm_moreeqfloat_eol();
  570.   _jpflag = 0x00;
  571. }
  572.  
  573. PROC emiteqfloat()
  574. {
  575.   asm_eqfloat_eol();
  576.   _jpflag = 0x00;
  577. }
  578.  
  579. PROC emitneqfloat()
  580. {
  581.   asm_eqfloat_eol();
  582.   asm_inv_eol();
  583.   _jpflag = 0x00;
  584. }
  585.  
  586. PROC emitjpiffalse()
  587. {
  588.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  589.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  590.   //unproxy();
  591.   getnothing(); //getnothingword();
  592.   IF       (_jpflag == 0x02) {asm_eq_eol(); //asmstr("NZ");
  593.   }ELSE IF (_jpflag == 0x03) {asm_moreeq_eol(); asm_inv_eol(); //asmstr("NC");
  594.   }ELSE IF (_jpflag == 0x04) {asm_moreeq_eol(); //asmc('C');
  595.   }ELSE IF (_jpflag == 0x01) {asm_eq_eol(); asm_inv_eol(); //asmc('Z');
  596.   };
  597.   asm_if0goto();
  598.   asmstr(_joined);
  599.   endasm();
  600.   _fused = +FALSE;
  601.   _jpflag = 0x00;
  602. }
  603.  
  604. PROC emitret()
  605. {
  606.   //unproxy();
  607.   asm_ret_eol();
  608. }
  609.  
  610. PROC emitaddfloat()
  611. {
  612.   asm_addfloat_eol();
  613. }
  614. PROC emitsubfloat()
  615. {
  616.   asm_subfloat_eol();
  617. }
  618.  
  619. PROC emitmulbyte()
  620. {
  621.   asm_mul_eol();
  622. }
  623. PROC emitmuluint()
  624. {
  625.   asm_mul_eol();
  626. }
  627. PROC emitmullong()
  628. {
  629.   asm_mul_eol();
  630. }
  631. PROC emitmulfloat()
  632. {
  633.   asm_mulfloat_eol();
  634. }
  635.  
  636. PROC emitdivbyte()
  637. {
  638.   asm_div_eol();
  639. }
  640. PROC emitdivint()
  641. {
  642.   asm_divsigned_eol();
  643. }
  644. PROC emitdivuint()
  645. {
  646.   asm_div_eol();
  647. }
  648. PROC emitdivlong()
  649. {
  650.   asm_div_eol();
  651. }
  652. PROC emitdivfloat()
  653. {
  654.   asm_divfloat_eol();
  655. }
  656.  
  657. PROC emitnegfloat()
  658. {
  659.   asm_negfloat_eol();
  660. }
  661.  
  662. PROC emitshlbyte()
  663. {
  664.   asm_shl_eol();
  665. }
  666. PROC emitshluint()
  667. {
  668.   asm_shl_eol();
  669. }
  670. PROC emitshllong()
  671. {
  672.   asm_shl_eol();
  673. }
  674.  
  675. PROC emitshrbyte()
  676. {
  677.   asm_shr_eol();
  678. }
  679. PROC emitshrint()
  680. {
  681.   asm_shrsigned_eol();
  682. }
  683. PROC emitshruint()
  684. {
  685.   asm_shr_eol();
  686. }
  687. PROC emitshrlong()
  688. {
  689.   asm_shr_eol();
  690. }
  691.  
  692. PROC emitcallproc()
  693. {
  694.   _jpflag = 0x00;
  695.   emitcall(_callee);
  696. }
  697.  
  698. PROC emitloadrg(BOOL high) //ЁхушёЄЁ єцх чрэ Є ўхЁхч getrfree
  699. {
  700.   asm_const();
  701.   asmstr(_const);
  702.   //IF (high) {asmstr( ">>32"/**WORDBITS*/ );
  703.   //}ELSE {asmstr( "&0xffffffff"/**WORDMASK*/ );
  704.   //};
  705.   endasm();
  706.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  707. }
  708.  
  709. PROC emitloadrg0() //ЁхушёЄЁ єцх чрэ Є ўхЁхч getrfree
  710. {
  711.   asm_const(); asmc('0'); endasm();
  712. }
  713.  
  714. PROC emitloadb() //ръъєьєы ЄюЁ єцх чрэ Є ўхЁхч getfreea
  715. {
  716.   asm_const(); asmstr(_const); endasm();
  717.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  718. }
  719.  
  720. PROC emitgetrg(BOOL high) //ЁхушёЄЁ єцх чрэ Є ўхЁхч getrfree
  721. {
  722.   asm_const(); asmstr(_joined);
  723.   //IF (high) {asmc('+'); asmc('1');
  724.   //};
  725.   endasm();
  726.   asm_readvar_eol();
  727. }
  728.  
  729. PROC emitgetb() //ръъєьєы ЄюЁ єцх чрэ Є ўхЁхч getfreea
  730. {
  731.   asm_const(); asmstr(_joined); endasm();
  732.   asm_readvar_eol();
  733. }
  734.  
  735. PROC emitputrg(BOOL high) //ld [],new
  736. {
  737.   //_jpflag = 0x00;
  738.   asm_const(); asmstr(_joined);
  739.   //IF (high) {asmc('+'); asmc('1');
  740.   //};
  741.   endasm();
  742.   asm_swap_eol();
  743.   asm_writevar_eol();
  744.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  745. }
  746.  
  747. PROC emitputb()
  748. {
  749.   //_jpflag = 0x00;
  750.   asm_const(); asmstr(_joined); endasm();
  751.   asm_swap_eol();
  752.   asm_writevar_eol();
  753.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  754. }
  755.  
  756. PROC emitshl1rg()
  757. {
  758.   asm_1_eol();
  759.   asm_shl_eol();
  760. }
  761.  
  762. PROC emitshl1b()
  763. {
  764.   asm_1_eol();
  765.   asm_shl_eol();
  766. }
  767.  
  768. PROC emitinvb() //~A -> A
  769. {
  770.   asm_inv_eol();
  771. }
  772.  
  773. PROC emitinvrg()
  774. {
  775.   asm_inv_eol();
  776. }
  777.  
  778. PROC emitnegrg()
  779. {
  780.   asm_inv_eol();
  781.   emitinc();
  782. }
  783.  
  784. PROC emitztob()
  785. {
  786.   IF (_exprlvl != 0x01) { //if (a == b)
  787.     asm_eq_eol();
  788.     _fused = +FALSE; //шэрўх уы■ъ яЁш if ((a==b))
  789.     //_jpflag = 0x00;
  790.   }ELSE {
  791.     //_fused = +TRUE;
  792.     _jpflag = 0x02;
  793.   };
  794. }
  795.  
  796. PROC emitinvztob()
  797. {
  798.   //asmstr(";emitinvztoa exprlvl="); asmuint(_exprlvl); endasm();
  799.   IF (_exprlvl != 0x01) { //if (a != b)
  800.     asm_eq_eol();
  801.     asm_inv_eol();
  802.     _fused = +FALSE; //шэрўх уы■ъ яЁш if ((a!=b))? todo test //тючьюцхэ уы■ъ ifnot ((a!=b))
  803.     //_jpflag = 0x00;
  804.   }ELSE {
  805.     //_fused = +TRUE;
  806.     _jpflag = 0x01;
  807.   };
  808. }
  809. /*
  810. PROC emitcytob()
  811. {
  812.   //asmstr(";emitcytoa exprlvl="); asmuint(_exprlvl); endasm();
  813.   IF (_exprlvl != 0x01) { //if (a < b)
  814.     unproxy();
  815.     asm_sbc(); asm_a(); asm_comma_a_eol();
  816.     _rproxy = _rnew;
  817.     //_fused = +FALSE;
  818.     //_jpflag = 0x00;
  819.   }ELSE {
  820.     //_fused = +TRUE;
  821.     _jpflag = 0x03;
  822.   };
  823. }
  824. */
  825. /**
  826. PROC emitinvcytob()
  827. {
  828.   //asmstr(";emitinvcytoa exprlvl="); asmuint(_exprlvl); endasm();
  829.   IF (_exprlvl != 0x01) { //if (a >= b)
  830.     emitccf();
  831.     unproxy();
  832.     asm_sbc(); asm_a(); asm_comma_a_eol();
  833.     _rproxy = _rnew;
  834.     //_fused = +FALSE;
  835.     //_jpflag = 0x00;
  836.   }ELSE {
  837.     //_fused = +TRUE;
  838.     _jpflag = 0x04;
  839.   };
  840. }
  841. */
  842. /**
  843. PROC emitSxorVtob() //яюёых subflags, ЁрчЁхчхЁтшЁєхЄ A
  844. {
  845.   asmstr( "\tRLA" ); endasm(); //sign
  846.   asm_jp(); asmstr( "PO,$+4" ); endasm();
  847.   emitccf();
  848.   emitcytob();
  849. }
  850. */
  851. /**
  852. PROC emitinvSxorVtob() //яюёых subflags, ЁрчЁхчхЁтшЁєхЄ A
  853. {
  854.   asmstr( "\tRLA" ); endasm(); //sign
  855.   asm_jp(); asmstr( "PE,$+4" ); endasm();
  856.   emitccf();
  857.   emitcytob();
  858. }
  859. */
  860. PROC emitxorrg() //old^new => old
  861. {
  862.   asm_xor_eol();
  863. }
  864.  
  865. PROC getxorb() //RGA^RGA2 -> RGA
  866. {
  867.   asm_xor_eol();
  868.   _fused = +TRUE; //^^
  869. }
  870.  
  871. PROC emitorrg() //old|new => old
  872. {
  873.   asm_or_eol();
  874. }
  875.  
  876. PROC getorb() //RGA|RGA2 -> RGA
  877. {
  878.   asm_or_eol();
  879.   _fused = +TRUE; //||
  880. }
  881.  
  882. PROC emitandrg() //old&new => old
  883. {
  884.   asm_and_eol();
  885. }
  886.  
  887. PROC getandb() //RGA&RGA2 -> RGA
  888. {
  889.   asm_and_eol();
  890.   _fused = +TRUE; //&&
  891. }
  892.  
  893. PROC emitaddrg() //old+new => old
  894. {
  895.   asm_add_eol();
  896. }
  897.  
  898. PROC emitadcrg() //old+new => old
  899. {
  900.   //asm_add_eol();
  901.   asmstr("unsupported: emitadcrg()"); endasm();
  902. }
  903.  
  904. PROC emitaddb() //old+new
  905. {
  906.   asm_add_eol();
  907. }
  908.  
  909. PROC emitaddbconst() //new8+<const>
  910. {
  911.   emitloadb();
  912.   asm_add_eol();
  913. }
  914.  
  915. PROC emitsubrg() //old-new => old
  916. {
  917.   asm_sub_eol();
  918. }
  919.  
  920. PROC emitsbcrg() //old-new => old
  921. {
  922.   //asm_sub_eol();
  923.   asmstr("unsupported: emitsbcrg()"); endasm();
  924. }
  925.  
  926. PROC emitsubb() //old-new
  927. {
  928.   asm_sub_eol();
  929. }
  930.  
  931. PROC emitsubbconst() //new8-<const>
  932. {
  933.   emitloadb();
  934.   asm_sub_eol();
  935. }
  936.  
  937. PROC emitsubflags(BYTE rnew, BYTE rold) //r2-r1 => CY,sign,overflow
  938. {
  939.   asm_sub_eol();
  940. //TODO!!!
  941.  
  942.   _fused = +TRUE;
  943. }
  944.  
  945. PROC emitsubbflags(BYTE anew, BYTE aold) //a2-a1 => CY
  946. { //sign,overflow эх эєцхэ!
  947.   asm_sub_eol();
  948. //TODO!!!
  949.  
  950.   _fused = +TRUE;
  951. }
  952.  
  953. PROC emitsubz() //old-new => Z
  954. {
  955.   //_fused = +TRUE;
  956. }
  957.  
  958. PROC emitsubbz() //old-new => Z
  959. {
  960.   //_fused = +TRUE;
  961. }
  962.  
  963. PROC emitsubbzconst() //new-<const> => Z
  964. {
  965.   emitloadb();
  966.   emitsubbz();
  967. }
  968.  
  969. PROC emitsublongz() //old2-new, old3-old => Z
  970. {
  971. //TODO!!!
  972.   asm_drop_eol();
  973.   asm_drop_eol();
  974.   asm_drop_eol();
  975.  
  976.   _fused = +TRUE;
  977. }
  978.  
  979. PROC emitpokerg() //эютюх чряшё√трхь т ёЄрЁє■ ыюърЎш■ ярь Єш
  980. {
  981.   asm_writevar_eol();
  982.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  983. }
  984.  
  985. PROC emitpokeb() //эютюх чряшё√трхь т ёЄрЁє■ ыюърЎш■ ярь Єш
  986. {
  987.   asm_writevar_eol();
  988.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  989. }
  990.  
  991. PROC emitpokelong() //old2(addr), old(high), new(low)
  992. {
  993. //TODO!!!
  994.   asm_drop_eol();
  995.   asm_writevar_eol();
  996.  
  997.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  998. }
  999. /**
  1000. PROC asm_lda_mrgname_eol(BYTE r)
  1001. {
  1002.   asm_lda_comma(); asm_mrgname(r); endasm();
  1003. }
  1004. */
  1005. PROC emitpeekrg() //[new] => new
  1006. {
  1007.   asm_readvar_eol();
  1008. }
  1009.  
  1010. PROC emitpeekb()
  1011. {
  1012.   asm_readvar_eol();
  1013. }
  1014.  
  1015. PROC emitpeeklong() //[old] => old(high),new(low)
  1016. {
  1017. //TODO!!!
  1018.   asm_readvar_eol();
  1019.   asm_dup_eol();
  1020.  
  1021. }
  1022.  
  1023. PROC emitrgtob() //эхы№ч  єсшЁрЄ№ - ёяхЎшЇшўэю
  1024. {
  1025. }
  1026.  
  1027. PROC emitbtorg()
  1028. {
  1029. }
  1030.  
  1031. PROC emitinttofloat()
  1032. {
  1033.   asm_inttofloat_eol();
  1034. }
  1035.  
  1036. PROC emitfloattoint()
  1037. {
  1038.   asm_floattoint_eol();
  1039. }
  1040.  
  1041. PROC emitincrg_byname()
  1042. {
  1043.   asm_const(); asmstr(_joined); endasm();
  1044.   asm_dup_eol();
  1045.   asm_readvar_eol();
  1046.   emitinc();
  1047.   asm_writevar_eol();
  1048.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1049. }
  1050.  
  1051. PROC emitincb_bypoi()
  1052. {
  1053.   asm_dup_eol();
  1054.   asm_readvar_eol();
  1055.   emitinc();
  1056.   asm_writevar_eol();
  1057.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1058. }
  1059. /**
  1060. PROC emitinclong() //todo
  1061. {
  1062.   asm_inc(); asm_open(); asm_rname(_rnew); asm_close(); endasm();
  1063.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1064. }
  1065. */
  1066. PROC emitdecrg_byname()
  1067. {
  1068.   asm_const(); asmstr(_joined); endasm();
  1069.   asm_dup_eol();
  1070.   asm_readvar_eol();
  1071.   emitdec();
  1072.   asm_writevar_eol();
  1073.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1074. }
  1075.  
  1076. PROC emitdecb_bypoi()
  1077. {
  1078.   asm_dup_eol();
  1079.   asm_readvar_eol();
  1080.   emitdec();
  1081.   asm_writevar_eol();
  1082.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1083. }
  1084. /**
  1085. PROC emitdeclong() //todo
  1086. {
  1087.   asm_dec(); asm_open(); asm_rname(_rnew); asm_close(); endasm();
  1088.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1089. }
  1090. */
  1091.  
  1092. PROC emitincrg_bypoi() //[old], new free
  1093. {
  1094.   asm_dup_eol();
  1095.   asm_readvar_eol();
  1096.   emitinc();
  1097.   asm_writevar_eol();
  1098.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1099. }
  1100.  
  1101. PROC emitdecrg_bypoi() //[old], new free
  1102. {
  1103.   asm_dup_eol();
  1104.   asm_readvar_eol();
  1105.   emitdec();
  1106.   asm_writevar_eol();
  1107.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1108. }
  1109.  
  1110. /////////////
  1111. EXPORT PROC initcode()
  1112. {
  1113.   _jpflag = 0x00;
  1114. }
  1115.  
  1116. EXPORT PROC endcode()
  1117. {
  1118. }
  1119.  
  1120. PROC initrgs()
  1121. {
  1122.   rgs_initrgs();
  1123.   _azused = +FALSE;
  1124.   _fused = +FALSE; //ьюцэю ёфхырЄ№ юфэє яЁюЎхфєЁє initif фы  ¤Єюую (т√ч√трЄ№ т эрўрых if, while, until)
  1125.   _rproxy = 0x00;
  1126. }
  1127.  
  1128. PROC emitfunchead()
  1129. {
  1130.   initrgs();
  1131. }
  1132.  
  1133. PROC setmainb()
  1134. {
  1135.   //setmainrg(); //Ёхчєы№ЄрЄ т RMAIN
  1136.   //_rproxy = _RMAIN;
  1137. }
  1138.  
  1139. PROC prefernoregs()
  1140. {
  1141.   getnothing(); //Єръ т√уюфэхх inc/dec
  1142. }
  1143.