Subversion Repositories NedoOS

Rev

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

  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 asm_readconstvar()
  343. {
  344.   asmstr( "\tDW CMD_READCONSTVAR," );
  345. }
  346.  
  347. PROC asm_writeconstvar()
  348. {
  349.   asmstr( "\tDW CMD_WRITECONSTVAR," );
  350. }
  351.  
  352. PROC asm_incconstvar()
  353. {
  354.   asmstr( "\tDW CMD_INCCONSTVAR," );
  355. }
  356.  
  357. PROC asm_decconstvar()
  358. {
  359.   asmstr( "\tDW CMD_DECCONSTVAR," );
  360. }
  361.  
  362. PROC emitinc()
  363. {
  364.   asm_1_eol();
  365.   asm_add_eol();
  366. }
  367.  
  368. PROC emitdec()
  369. {
  370.   asm_1_eol();
  371.   asm_sub_eol();
  372. }
  373.  
  374. PROC emitcall(PCHAR s)
  375. {
  376.   asm_call(); asmstr( s ); endasm();
  377. }
  378.  
  379. ///////////////////////////////////
  380. //фюёЄєяэ√ шч commands
  381. PROC unproxy()
  382. {
  383. }
  384.  
  385. PROC proxy(BYTE r)
  386. {
  387. }
  388.  
  389. ///////////////////////////////////////////////////////////
  390. //яЁюЎхфєЁ√ ё ьр°шээ√ь ъюфюь фы  rgs
  391.  
  392. PROC emitpushrg(BYTE rnew)
  393. {
  394.   //unproxy(); //todo юяЄшьшчшЁютрЄ№
  395.   //asm_push(); asm_rname(rnew); endasm();
  396.   //INC _funcstkdepth;
  397. }
  398.  
  399. PROC emitpoprg(BYTE rnew) //ЁхушёЄЁ єцх яюьхўхэ т getrfree/getrg
  400. {
  401.   //asm_pop(); asm_rname(rnew); endasm();
  402.   //DEC _funcstkdepth;
  403. }
  404.  
  405. PROC emitmovrg(BYTE rsrc, BYTE rdest) //эх чрърч√трхЄ ш эх юётюсюцфрхЄ (ёь. emitmoverg)
  406. {
  407.    //asm_push(); asm_rname(rsrc); endasm();
  408.    //asm_pop(); asm_rname(rdest); endasm();
  409. }
  410.  
  411. ///////////////////////////////////////////////////////////////////////////////////////
  412. //¤Єш яЁюЎхфєЁ√ ухэхЁшЁє■Є ъюф
  413. //эхфюёЄєяэ√ шч ъюьяшы ЄюЁр, фюёЄєяэ√ шч commands
  414.  
  415. EXPORT PROC emitasmlabel(PCHAR s)
  416. {
  417.   asmstr(s); /**asmc( ':' );*/ endasm();
  418. }
  419.  
  420. EXPORT PROC emitfunclabel(PCHAR s)
  421. {
  422.   asmstr(s); /**asmc( ':' );*/ endasm();
  423. }
  424.  
  425. EXPORT PROC emitvarlabel(PCHAR s)
  426. {
  427.   varstr(s); /**varc( ':' );*/ endvar();
  428. }
  429.  
  430. EXPORT PROC emitexport(PCHAR s) //todo тёхуфр _joined
  431. {
  432.   asmstr("\tEXPORT "); asmstr(s); endasm();
  433. }
  434.  
  435. EXPORT PROC emitvarpreequ(PCHAR s)
  436. {
  437. }
  438.  
  439. EXPORT PROC emitvarpostequ()
  440. {
  441. }
  442.  
  443. EXPORT PROC varequ(PCHAR s)
  444. {
  445.   varstr(s); varc('=');
  446. }
  447.  
  448. EXPORT FUNC UINT varshift(UINT shift, UINT sz)
  449. {
  450.   //IF (sz >= 4) shift = (shift+3)&(UINT)(-4);
  451.   //asmstr(_joined); asmc('='); asmuint(shift); endasm();
  452.   varequ(_joined); /**varstr(_joined); varc('=');*/ varuint(shift); endvar();
  453. RETURN shift;
  454. }
  455.  
  456. PROC emitjpmainrg() //"jp (hl)"
  457. {
  458.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  459.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  460.   unproxy();
  461.   getnothing(); //getnothingword();
  462.   asmstr("unsupported: emitjpmainrg()"); endasm();
  463. }
  464.  
  465. PROC emitcallmainrg() //"call (hl)"
  466. {
  467.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  468.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  469.   unproxy();
  470.   getnothing(); //getnothingword();
  471.   asmstr("unsupported: emitcallmainrg()"); endasm();
  472.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  473. }
  474.  
  475. PROC emitjp()
  476. {
  477.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  478.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  479.   unproxy();
  480.   getnothing(); //getnothingword();
  481.   asm_goto(); asmstr(_joined); endasm();
  482. }
  483.  
  484. PROC emitbtoz() //яхЁхф jp!
  485. {
  486.   //ёЁрчє яюёых ёЁртэхэш  эх эрфю, эю тфЁєу ь√ ўшЄрхь BOOL
  487. }
  488.  
  489. PROC emitless()
  490. {
  491.   asm_moreeq_eol();
  492.   asm_inv_eol();
  493.   _jpflag = 0x00;
  494. }
  495.  
  496. PROC emitlesssigned()
  497. {
  498.   asm_moreeqsigned_eol();
  499.   asm_inv_eol();
  500.   _jpflag = 0x00;
  501. }
  502.  
  503. PROC emitlessb()
  504. {
  505.   emitless();
  506. }
  507.  
  508. PROC emitlessfloat()
  509. {
  510.   asm_moreeqfloat_eol();
  511.   asm_inv_eol();
  512.   _jpflag = 0x00;
  513. }
  514.  
  515. PROC emitlesseq()
  516. {
  517.   asm_swap_eol();
  518.   asm_moreeq_eol();
  519.   _jpflag = 0x00;
  520. }
  521.  
  522. PROC emitlesseqsigned()
  523. {
  524.   asm_swap_eol();
  525.   asm_moreeqsigned_eol();
  526.   _jpflag = 0x00;
  527. }
  528.  
  529. PROC emitlesseqb()
  530. {
  531.   emitlesseq();
  532. }
  533.  
  534. PROC emitlesseqfloat()
  535. {
  536.   asm_swap_eol();
  537.   asm_moreeqfloat_eol();
  538.   _jpflag = 0x00;
  539. }
  540.  
  541. PROC emitmore()
  542. {
  543.   asm_swap_eol();
  544.   asm_moreeq_eol();
  545.   asm_inv_eol();
  546.   _jpflag = 0x00;
  547. }
  548.  
  549. PROC emitmoresigned()
  550. {
  551.   asm_swap_eol();
  552.   asm_moreeqsigned_eol();
  553.   asm_inv_eol();
  554.   _jpflag = 0x00;
  555. }
  556.  
  557. PROC emitmoreb()
  558. {
  559.   emitmore();
  560. }
  561.  
  562. PROC emitmorefloat()
  563. {
  564.   asm_swap_eol();
  565.   asm_moreeqfloat_eol();
  566.   asm_inv_eol();
  567.   _jpflag = 0x00;
  568. }
  569.  
  570. PROC emitmoreeq()
  571. {
  572.   asm_moreeq_eol();
  573.   _jpflag = 0x00;
  574. }
  575.  
  576. PROC emitmoreeqsigned()
  577. {
  578.   asm_moreeqsigned_eol();
  579.   _jpflag = 0x00;
  580. }
  581.  
  582. PROC emitmoreeqb()
  583. {
  584.   emitmoreeq();
  585. }
  586.  
  587. PROC emitmoreeqfloat()
  588. {
  589.   asm_moreeqfloat_eol();
  590.   _jpflag = 0x00;
  591. }
  592.  
  593. PROC emiteqfloat()
  594. {
  595.   asm_eqfloat_eol();
  596.   _jpflag = 0x00;
  597. }
  598.  
  599. PROC emitneqfloat()
  600. {
  601.   asm_eqfloat_eol();
  602.   asm_inv_eol();
  603.   _jpflag = 0x00;
  604. }
  605.  
  606. PROC emitjpiffalse()
  607. {
  608.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  609.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  610.   //unproxy();
  611.   getnothing(); //getnothingword();
  612.   IF       (_jpflag == 0x02) {asm_eq_eol(); //asmstr("NZ");
  613.   }ELSE IF (_jpflag == 0x03) {asm_moreeq_eol(); asm_inv_eol(); //asmstr("NC");
  614.   }ELSE IF (_jpflag == 0x04) {asm_moreeq_eol(); //asmc('C');
  615.   }ELSE IF (_jpflag == 0x01) {asm_eq_eol(); asm_inv_eol(); //asmc('Z');
  616.   };
  617.   asm_if0goto();
  618.   asmstr(_joined);
  619.   endasm();
  620.   _fused = +FALSE;
  621.   _jpflag = 0x00;
  622. }
  623.  
  624. PROC emitret()
  625. {
  626.   //unproxy();
  627.   asm_ret_eol();
  628. }
  629.  
  630. PROC emitaddfloat()
  631. {
  632.   asm_addfloat_eol();
  633. }
  634. PROC emitsubfloat()
  635. {
  636.   asm_subfloat_eol();
  637. }
  638.  
  639. PROC emitmulbyte()
  640. {
  641.   asm_mul_eol();
  642. }
  643. PROC emitmuluint()
  644. {
  645.   asm_mul_eol();
  646. }
  647. PROC emitmullong()
  648. {
  649.   asm_mul_eol();
  650. }
  651. PROC emitmulfloat()
  652. {
  653.   asm_mulfloat_eol();
  654. }
  655.  
  656. PROC emitdivbyte()
  657. {
  658.   asm_div_eol();
  659. }
  660. PROC emitdivint()
  661. {
  662.   asm_divsigned_eol();
  663. }
  664. PROC emitdivuint()
  665. {
  666.   asm_div_eol();
  667. }
  668. PROC emitdivlong()
  669. {
  670.   asm_div_eol();
  671. }
  672. PROC emitdivfloat()
  673. {
  674.   asm_divfloat_eol();
  675. }
  676.  
  677. PROC emitnegfloat()
  678. {
  679.   asm_negfloat_eol();
  680. }
  681.  
  682. PROC emitshlbyte()
  683. {
  684.   asm_shl_eol();
  685. }
  686. PROC emitshluint()
  687. {
  688.   asm_shl_eol();
  689. }
  690. PROC emitshllong()
  691. {
  692.   asm_shl_eol();
  693. }
  694.  
  695. PROC emitshrbyte()
  696. {
  697.   asm_shr_eol();
  698. }
  699. PROC emitshrint()
  700. {
  701.   asm_shrsigned_eol();
  702. }
  703. PROC emitshruint()
  704. {
  705.   asm_shr_eol();
  706. }
  707. PROC emitshrlong()
  708. {
  709.   asm_shr_eol();
  710. }
  711.  
  712. PROC emitcallproc()
  713. {
  714.   _jpflag = 0x00;
  715.   emitcall(_callee);
  716. }
  717.  
  718. PROC emitloadrg(BOOL high) //ЁхушёЄЁ єцх чрэ Є ўхЁхч getrfree
  719. {
  720.   asm_const();
  721.   asmstr(_const);
  722.   //IF (high) {asmstr( ">>32"/**WORDBITS*/ );
  723.   //}ELSE {asmstr( "&0xffffffff"/**WORDMASK*/ );
  724.   //};
  725.   endasm();
  726.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  727. }
  728.  
  729. PROC emitloadrg0() //ЁхушёЄЁ єцх чрэ Є ўхЁхч getrfree
  730. {
  731.   asm_const(); asmc('0'); endasm();
  732. }
  733.  
  734. PROC emitloadb() //ръъєьєы ЄюЁ єцх чрэ Є ўхЁхч getfreea
  735. {
  736.   asm_const(); asmstr(_const); endasm();
  737.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  738. }
  739.  
  740. PROC emitgetrg(BOOL high) //ЁхушёЄЁ єцх чрэ Є ўхЁхч getrfree
  741. {
  742. //  asm_const(); asmstr(_joined);
  743.   //IF (high) {asmc('+'); asmc('1');
  744.   //};
  745. //  endasm();
  746. //  asm_readvar_eol();
  747.   asm_readconstvar();
  748.   asmstr(_joined); endasm();
  749. }
  750.  
  751. PROC emitgetb() //ръъєьєы ЄюЁ єцх чрэ Є ўхЁхч getfreea
  752. {
  753. //  asm_const(); asmstr(_joined); endasm();
  754. //  asm_readvar_eol();
  755.   asm_readconstvar();
  756.   asmstr(_joined); endasm();
  757. }
  758.  
  759. PROC emitputrg(BOOL high) //ld [],new
  760. {
  761.   //_jpflag = 0x00;
  762. //  asm_const(); asmstr(_joined);
  763.   //IF (high) {asmc('+'); asmc('1');
  764.   //};
  765. //  endasm();
  766. //  asm_swap_eol();
  767. //  asm_writevar_eol();
  768.   asm_writeconstvar();
  769.   asmstr(_joined); endasm();
  770.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  771. }
  772.  
  773. PROC emitputb()
  774. {
  775.   //_jpflag = 0x00;
  776. //  asm_const(); asmstr(_joined); endasm();
  777. //  asm_swap_eol();
  778. //  asm_writevar_eol();
  779.   asm_writeconstvar();
  780.   asmstr(_joined); endasm();
  781.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  782. }
  783.  
  784. PROC emitshl1rg()
  785. {
  786.   asm_1_eol();
  787.   asm_shl_eol();
  788. }
  789.  
  790. PROC emitshl1b()
  791. {
  792.   asm_1_eol();
  793.   asm_shl_eol();
  794. }
  795.  
  796. PROC emitinvb() //~A -> A
  797. {
  798.   asm_inv_eol();
  799. }
  800.  
  801. PROC emitinvrg()
  802. {
  803.   asm_inv_eol();
  804. }
  805.  
  806. PROC emitnegrg()
  807. {
  808.   asm_inv_eol();
  809.   emitinc();
  810. }
  811.  
  812. PROC emitztob()
  813. {
  814.   IF (_exprlvl != 0x01) { //if (a == b)
  815.     asm_eq_eol();
  816.     _fused = +FALSE; //шэрўх уы■ъ яЁш if ((a==b))
  817.     //_jpflag = 0x00;
  818.   }ELSE {
  819.     //_fused = +TRUE;
  820.     _jpflag = 0x02;
  821.   };
  822. }
  823.  
  824. PROC emitinvztob()
  825. {
  826.   //asmstr(";emitinvztoa exprlvl="); asmuint(_exprlvl); endasm();
  827.   IF (_exprlvl != 0x01) { //if (a != b)
  828.     asm_eq_eol();
  829.     asm_inv_eol();
  830.     _fused = +FALSE; //шэрўх уы■ъ яЁш if ((a!=b))? todo test //тючьюцхэ уы■ъ ifnot ((a!=b))
  831.     //_jpflag = 0x00;
  832.   }ELSE {
  833.     //_fused = +TRUE;
  834.     _jpflag = 0x01;
  835.   };
  836. }
  837. /*
  838. PROC emitcytob()
  839. {
  840.   //asmstr(";emitcytoa exprlvl="); asmuint(_exprlvl); endasm();
  841.   IF (_exprlvl != 0x01) { //if (a < b)
  842.     unproxy();
  843.     asm_sbc(); asm_a(); asm_comma_a_eol();
  844.     _rproxy = _rnew;
  845.     //_fused = +FALSE;
  846.     //_jpflag = 0x00;
  847.   }ELSE {
  848.     //_fused = +TRUE;
  849.     _jpflag = 0x03;
  850.   };
  851. }
  852. */
  853. /**
  854. PROC emitinvcytob()
  855. {
  856.   //asmstr(";emitinvcytoa exprlvl="); asmuint(_exprlvl); endasm();
  857.   IF (_exprlvl != 0x01) { //if (a >= b)
  858.     emitccf();
  859.     unproxy();
  860.     asm_sbc(); asm_a(); asm_comma_a_eol();
  861.     _rproxy = _rnew;
  862.     //_fused = +FALSE;
  863.     //_jpflag = 0x00;
  864.   }ELSE {
  865.     //_fused = +TRUE;
  866.     _jpflag = 0x04;
  867.   };
  868. }
  869. */
  870. /**
  871. PROC emitSxorVtob() //яюёых subflags, ЁрчЁхчхЁтшЁєхЄ A
  872. {
  873.   asmstr( "\tRLA" ); endasm(); //sign
  874.   asm_jp(); asmstr( "PO,$+4" ); endasm();
  875.   emitccf();
  876.   emitcytob();
  877. }
  878. */
  879. /**
  880. PROC emitinvSxorVtob() //яюёых subflags, ЁрчЁхчхЁтшЁєхЄ A
  881. {
  882.   asmstr( "\tRLA" ); endasm(); //sign
  883.   asm_jp(); asmstr( "PE,$+4" ); endasm();
  884.   emitccf();
  885.   emitcytob();
  886. }
  887. */
  888. PROC emitxorrg() //old^new => old
  889. {
  890.   asm_xor_eol();
  891. }
  892.  
  893. PROC getxorb() //RGA^RGA2 -> RGA
  894. {
  895.   asm_xor_eol();
  896.   _fused = +TRUE; //^^
  897. }
  898.  
  899. PROC emitorrg() //old|new => old
  900. {
  901.   asm_or_eol();
  902. }
  903.  
  904. PROC getorb() //RGA|RGA2 -> RGA
  905. {
  906.   asm_or_eol();
  907.   _fused = +TRUE; //||
  908. }
  909.  
  910. PROC emitandrg() //old&new => old
  911. {
  912.   asm_and_eol();
  913. }
  914.  
  915. PROC getandb() //RGA&RGA2 -> RGA
  916. {
  917.   asm_and_eol();
  918.   _fused = +TRUE; //&&
  919. }
  920.  
  921. PROC emitaddrg() //old+new => old
  922. {
  923.   asm_add_eol();
  924. }
  925.  
  926. PROC emitadcrg() //old+new => old
  927. {
  928.   //asm_add_eol();
  929.   asmstr("unsupported: emitadcrg()"); endasm();
  930. }
  931.  
  932. PROC emitaddb() //old+new
  933. {
  934.   asm_add_eol();
  935. }
  936.  
  937. PROC emitaddbconst() //new8+<const>
  938. {
  939.   emitloadb();
  940.   asm_add_eol();
  941. }
  942.  
  943. PROC emitsubrg() //old-new => old
  944. {
  945.   asm_sub_eol();
  946. }
  947.  
  948. PROC emitsbcrg() //old-new => old
  949. {
  950.   //asm_sub_eol();
  951.   asmstr("unsupported: emitsbcrg()"); endasm();
  952. }
  953.  
  954. PROC emitsubb() //old-new
  955. {
  956.   asm_sub_eol();
  957. }
  958.  
  959. PROC emitsubbconst() //new8-<const>
  960. {
  961.   emitloadb();
  962.   asm_sub_eol();
  963. }
  964.  
  965. PROC emitsubflags(BYTE rnew, BYTE rold) //r2-r1 => CY,sign,overflow
  966. {
  967.   asm_sub_eol();
  968. //TODO!!!
  969.  
  970.   _fused = +TRUE;
  971. }
  972.  
  973. PROC emitsubbflags(BYTE anew, BYTE aold) //a2-a1 => CY
  974. { //sign,overflow эх эєцхэ!
  975.   asm_sub_eol();
  976. //TODO!!!
  977.  
  978.   _fused = +TRUE;
  979. }
  980.  
  981. PROC emitsubz() //old-new => Z
  982. {
  983.   //_fused = +TRUE;
  984. }
  985.  
  986. PROC emitsubbz() //old-new => Z
  987. {
  988.   //_fused = +TRUE;
  989. }
  990.  
  991. PROC emitsubbzconst() //new-<const> => Z
  992. {
  993.   emitloadb();
  994.   emitsubbz();
  995. }
  996.  
  997. PROC emitsublongz() //old2-new, old3-old => Z
  998. {
  999. //TODO!!!
  1000.   asm_drop_eol();
  1001.   asm_drop_eol();
  1002.   asm_drop_eol();
  1003.  
  1004.   _fused = +TRUE;
  1005. }
  1006.  
  1007. PROC emitpokerg() //эютюх чряшё√трхь т ёЄрЁє■ ыюърЎш■ ярь Єш
  1008. {
  1009.   asm_writevar_eol();
  1010.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1011. }
  1012.  
  1013. PROC emitpokeb() //эютюх чряшё√трхь т ёЄрЁє■ ыюърЎш■ ярь Єш
  1014. {
  1015.   asm_writevar_eol();
  1016.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1017. }
  1018.  
  1019. PROC emitpokelong() //old2(addr), old(high), new(low)
  1020. {
  1021. //TODO!!!
  1022.   asm_drop_eol();
  1023.   asm_writevar_eol();
  1024.  
  1025.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1026. }
  1027. /**
  1028. PROC asm_lda_mrgname_eol(BYTE r)
  1029. {
  1030.   asm_lda_comma(); asm_mrgname(r); endasm();
  1031. }
  1032. */
  1033. PROC emitpeekrg() //[new] => new
  1034. {
  1035.   asm_readvar_eol();
  1036. }
  1037.  
  1038. PROC emitpeekb()
  1039. {
  1040.   asm_readvar_eol();
  1041. }
  1042.  
  1043. PROC emitpeeklong() //[old] => old(high),new(low)
  1044. {
  1045. //TODO!!!
  1046.   asm_readvar_eol();
  1047.   asm_dup_eol();
  1048.  
  1049. }
  1050.  
  1051. PROC emitrgtob() //эхы№ч  єсшЁрЄ№ - ёяхЎшЇшўэю
  1052. {
  1053. }
  1054.  
  1055. PROC emitbtorg()
  1056. {
  1057. }
  1058.  
  1059. PROC emitinttofloat()
  1060. {
  1061.   asm_inttofloat_eol();
  1062. }
  1063.  
  1064. PROC emitfloattoint()
  1065. {
  1066.   asm_floattoint_eol();
  1067. }
  1068.  
  1069. PROC emitincrg_byname()
  1070. {
  1071. //  asm_const(); asmstr(_joined); endasm();
  1072. //  asm_dup_eol();
  1073. //  asm_readvar_eol();
  1074. //  emitinc();
  1075. //  asm_writevar_eol();
  1076.   asm_incconstvar();
  1077.   asmstr(_joined); endasm();
  1078.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1079. }
  1080.  
  1081. PROC emitincb_bypoi()
  1082. {
  1083.   asm_dup_eol();
  1084.   asm_readvar_eol();
  1085.   emitinc();
  1086.   asm_writevar_eol();
  1087.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1088. }
  1089. /**
  1090. PROC emitinclong() //todo
  1091. {
  1092.   asm_inc(); asm_open(); asm_rname(_rnew); asm_close(); endasm();
  1093.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1094. }
  1095. */
  1096. PROC emitdecrg_byname()
  1097. {
  1098. //  asm_const(); asmstr(_joined); endasm();
  1099. //  asm_dup_eol();
  1100. //  asm_readvar_eol();
  1101. //  emitdec();
  1102. //  asm_writevar_eol();
  1103.   asm_decconstvar();
  1104.   asmstr(_joined); endasm();
  1105.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1106. }
  1107.  
  1108. PROC emitdecb_bypoi()
  1109. {
  1110.   asm_dup_eol();
  1111.   asm_readvar_eol();
  1112.   emitdec();
  1113.   asm_writevar_eol();
  1114.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1115. }
  1116. /**
  1117. PROC emitdeclong() //todo
  1118. {
  1119.   asm_dec(); asm_open(); asm_rname(_rnew); asm_close(); endasm();
  1120.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1121. }
  1122. */
  1123.  
  1124. PROC emitincrg_bypoi() //[old], new free
  1125. {
  1126.   asm_dup_eol();
  1127.   asm_readvar_eol();
  1128.   emitinc();
  1129.   asm_writevar_eol();
  1130.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1131. }
  1132.  
  1133. PROC emitdecrg_bypoi() //[old], new free
  1134. {
  1135.   asm_dup_eol();
  1136.   asm_readvar_eol();
  1137.   emitdec();
  1138.   asm_writevar_eol();
  1139.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1140. }
  1141.  
  1142. /////////////
  1143. EXPORT PROC initcode()
  1144. {
  1145.   _jpflag = 0x00;
  1146. }
  1147.  
  1148. EXPORT PROC endcode()
  1149. {
  1150. }
  1151.  
  1152. PROC initrgs()
  1153. {
  1154.   rgs_initrgs();
  1155.   _azused = +FALSE;
  1156.   _fused = +FALSE; //ьюцэю ёфхырЄ№ юфэє яЁюЎхфєЁє initif фы  ¤Єюую (т√ч√трЄ№ т эрўрых if, while, until)
  1157.   _rproxy = 0x00;
  1158. }
  1159.  
  1160. PROC emitfunchead()
  1161. {
  1162.   initrgs();
  1163. }
  1164.  
  1165. PROC setmainb()
  1166. {
  1167.   //setmainrg(); //Ёхчєы№ЄрЄ т RMAIN
  1168.   //_rproxy = _RMAIN;
  1169. }
  1170.  
  1171. PROC prefernoregs()
  1172. {
  1173.   getnothing(); //Єръ т√уюфэхх inc/dec
  1174. }
  1175.