Subversion Repositories NedoOS

Rev

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