Subversion Repositories NedoOS

Rev

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

  1. //// imported
  2. #include "../_sdk/emit.h"
  3.  
  4. #include "sizesarm.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. PROC getrfree FORWARD(); //чрэ Є№ ётюсюфэ√щ ЁхушёЄЁ ш тхЁэєЄ№ хую ъюф
  26. PROC freernew FORWARD(); //юётюсюфшЄ№ ЁхушёЄЁ ё тхЁ°шэ√ ёЄхър
  27.  
  28. //rg pool
  29. PROC getnothing FORWARD(); //ёюїЁрэшЄ№ ЁхушёЄЁ√ ш срщЄ√ т ёЄхъх ш юётюсюфшЄ№
  30. //PROC getmainrg FORWARD(); //тч Є№ RMAIN=new ш юётюсюфшЄ№ юёЄры№э√х ЁхушёЄЁ√
  31. PROC getmain2rgs FORWARD(); //тч Є№ RMAIN=old, RMAIN2=new ш юётюсюфшЄ№ юёЄры№э√х ЁхушёЄЁ√ //фы  call2rgs
  32. //PROC getmain3rgs FORWARD(); //фы  call3rgs
  33. PROC getmain4rgs FORWARD(); //фы  call4rgs
  34. PROC setmainrg FORWARD(); //єёЄрэютшЄ№ яЁшчэръш, ъръ сєфЄю ь√ яюыєўшыш Ёхчєы№ЄрЄ т ЁхушёЄЁх //фы  call2rgs
  35. PROC setmain2rgs FORWARD(); //єёЄрэютшЄ№ яЁшчэръш, ъръ сєфЄю ь√ яюыєўшыш Ёхчєы№ЄрЄ т ЁхушёЄЁрї //фы  call4rgs
  36.  
  37. PROC rgs_initrgs FORWARD();
  38.  
  39. ////
  40. #define _RGBUFSZ (BYTE)(_NRGS+0x01)
  41.  
  42.   //яЁшюЁшЄхЄ√ ЁхушёЄЁют:
  43. CONST BYTE _RMAIN = 0x01; /**HL*/ /**ЁхушёЄЁ Ёхчєы№ЄрЄр ш яхЁтюую ярЁрьхЄЁр ёЄрэфрЁЄэ√ї ЇєэъЎшщ*/
  44. CONST BYTE _RMAIN2= 0x02; /**DE*/ /**ЁхушёЄЁ тЄюЁюую ёыютр Ёхчєы№ЄрЄр ш тЄюЁюую ярЁрьхЄЁр ёЄрэфрЁЄэ√ї ЇєэъЎшщ*/
  45. CONST BYTE _RMAIN3= 0x03;
  46. CONST BYTE _RMAIN4= 0x04;
  47.  
  48. CONST PCHAR _RNAME [_RGBUFSZ] = {
  49.   "R0", //0 яєёЄющ, rtemp
  50.   "R1",
  51.   "R2",
  52.   "R3",
  53.   "R4",
  54. //  "R5",
  55. //  "R6"
  56. };
  57.  
  58. VAR BOOL _fused;
  59.  
  60. VAR INT _funcstkdepth;
  61.  
  62. VAR BYTE _jpflag; //0=OR A:JZ, 1=JZ, 2=JNZ, 3=JNC, 4=JC
  63.  
  64. EXPORT CONST BYTE _typesz[32] = { //ЁрчьхЁ Єшяр т срщЄрї фы  ЄрЁухЄр
  65.   _SZ_BYTE/**T_BYTE */, //фы  тёхї ЄрЁухЄют
  66.   _SZ_REG/**T_UINT */, //фы  тёхї ЄрЁухЄют
  67.   _SZ_REG/**T_INT  */, //фы  тёхї ЄрЁухЄют
  68.   _SZ_BOOL/**T_BOOL */,
  69.   _SZ_LONG/**T_LONG */,
  70.   _SZ_BYTE/**T_CHAR */,
  71.   _SZ_LONG/**T_FLOAT*/,
  72.   0x00/**unknown*/,
  73.   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  74.   _SZ_REG/**T_PBYTE */,
  75.   _SZ_REG/**T_PUINT */,
  76.   _SZ_REG/**T_PINT  */,
  77.   _SZ_REG/**T_PBOOL */,
  78.   _SZ_REG/**T_PLONG */,
  79.   _SZ_REG/**T_PCHAR */,
  80.   _SZ_REG/**T_PFLOAT*/,
  81.   _SZ_REG/**        */,
  82.   _SZ_REG, _SZ_REG, _SZ_REG, _SZ_REG, _SZ_REG, _SZ_REG, _SZ_REG, _SZ_REG //pointer to...
  83. };
  84.  
  85. CONST BYTE _typeshift[32] = { //log ЁрчьхЁ Єшяр (n фы  2^n срщЄ) фы  ЄрЁухЄр
  86.   _RL_BYTE/**T_BYTE */, //фы  тёхї ЄрЁухЄют
  87.   _RL_REG/**T_UINT */, //фы  тёхї ЄрЁухЄют
  88.   _RL_REG/**T_INT  */, //фы  тёхї ЄрЁухЄют
  89.   _RL_BOOL/**T_BOOL */,
  90.   _RL_LONG/**T_LONG */,
  91.   _RL_BYTE/**T_CHAR */,
  92.   _RL_LONG/**T_FLOAT*/,
  93.   0x00/**unknown*/,
  94.   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  95.   _RL_REG/**T_BYTE  */,
  96.   _RL_REG/**T_UINT  */,
  97.   _RL_REG/**T_INT   */,
  98.   _RL_REG/**T_BOOL  */,
  99.   _RL_REG/**T_LONG  */,
  100.   _RL_REG/**T_CHAR  */,
  101.   _RL_REG/**T_PFLOAT*/,
  102.   _RL_REG/**        */,
  103.   _RL_REG, _RL_REG, _RL_REG, _RL_REG, _RL_REG, _RL_REG, _RL_REG, _RL_REG //pointer to...
  104. };
  105.  
  106. //VAR CHAR  _swass[_STRLEN]; //todo єсЁрЄ№?
  107. //VAR PCHAR _wass; //todo єсЁрЄ№
  108. //VAR UINT  _lenwass; //todo єсЁрЄ№
  109.  
  110. VAR UINT constindex;
  111. //VAR UINT wasconstindex; //todo єсЁрЄ№
  112.  
  113. VAR UINT asmcmds; //ёъюы№ъю ъюьрэф яЁю°ыю ё ьюьхэЄр яюёыхфэхщ т√уЁєчъш ьхЄюъ
  114.  
  115. PROC initrgs FORWARD(); //юўшёЄшЄ№ ёюёЄю эш  ЁхушёЄЁют ш срщЄют (шёяюы№чєхЄё  т cemitfunc)
  116.  
  117. VAR CHAR asmlblbuf[65536];
  118. VAR UINT lenasmlblbuf;
  119.  
  120. PROC asm_dw FORWARD();
  121. PROC asm_b FORWARD();
  122.  
  123. FUNC UINT mystrlen(PCHAR s) //фышэр схч ЄхЁьшэрЄюЁр!
  124. {
  125. VAR UINT len;
  126. VAR CHAR c;
  127.   len = 0; //фышэр схч ЄхЁьшэрЄюЁр!
  128.   loop:
  129.     c = *(PCHAR)s;
  130.     IF (c == '\0') goto endloop; //BREAK;
  131.     INC s;
  132.     INC len;
  133.   goto loop;
  134.   endloop:
  135. RETURN len; //фышэр схч ЄхЁьшэрЄюЁр!
  136. }
  137.  
  138. FUNC UINT mystrcopy(PCHAR from, PCHAR to)
  139. {
  140. VAR UINT len;
  141. VAR CHAR c;
  142.   len = 0; //фышэр схч ЄхЁьшэрЄюЁр!
  143.   loop:
  144.     c = from[len];
  145.     to[len] = c;
  146.     IF (c == '\0') goto endloop; //BREAK;
  147.     INC len;
  148.   goto loop;
  149.   endloop:
  150. RETURN len; //фышэр схч ЄхЁьшэрЄюЁр!
  151. }
  152.  
  153. PROC varmangledstr(PCHAR s)
  154. {
  155. VAR CHAR c;
  156.   IF (*(PCHAR)s == '\'') { //'c'
  157.     varstr(s);
  158.   }ELSE {
  159.     loop:
  160.       c = *(PCHAR)s;
  161.       IF (c == '\0') goto quit;
  162.       IF ((c == '.')||(c == '/')) {
  163.         varstr("__");
  164.       }ELSE varc(c);
  165.       INC s;
  166.     goto loop;
  167.     quit:
  168.   }
  169. }
  170.  
  171. PROC asmmangledstr(PCHAR s)
  172. {
  173. VAR CHAR c;
  174.   IF (*(PCHAR)s == '\'') { //'c'
  175.     asmstr(s);
  176.   }ELSE {
  177.     loop:
  178.       c = *(PCHAR)s;
  179.       IF (c == '\0') goto quit;
  180.       IF ((c == '.')||(c == '/')) {
  181.         asmstr("__");
  182.       }ELSE asmc(c);
  183.       INC s;
  184.     goto loop;
  185.     quit:
  186.   }
  187. }
  188.  
  189. PROC asm_pc4_eol()
  190. {
  191.   asmstr("__"); asmuint(constindex); asmmangledstr(_fn); endasm(); //fn эєцхэ, ўЄюс√ ртЄюьхЄъш фы  Ёрчэ√ї ьюфєыхщ эх ёютярыш
  192. }
  193.  
  194. PROC asm_endpc4()
  195. {
  196.   asmstr("__"); asmuint(constindex); asmmangledstr(_fn); endasm(); //fn эєцхэ, ўЄюс√ ртЄюьхЄъш фы  Ёрчэ√ї ьюфєыхщ эх ёютярыш
  197.   INC constindex;
  198. }
  199.  
  200. PROC asm_align4b()
  201. {
  202.   asmstr("\tALIGN 4"); endasm();
  203. }
  204.  
  205. EXPORT PROC emitasmlabel(PCHAR s)
  206. {
  207.   asmmangledstr(s); /**asmc( ':' );*/ endasm();
  208. }
  209.  
  210. EXPORT PROC emitfunclabel(PCHAR s)
  211. {
  212.   asmmangledstr(s); asmstr("\tEQU $+1"); endasm();
  213. }
  214.  
  215. EXPORT PROC emitvarlabel(PCHAR s)
  216. {
  217.   varmangledstr(s); /**varc( ':' );*/ endvar();
  218. }
  219.  
  220. PROC asmaddlabel(PCHAR s, UINT constindex)
  221. {
  222. VAR UINT len;
  223.   POKE *(PUINT)(&asmlblbuf[lenasmlblbuf]) = constindex;
  224.   lenasmlblbuf = lenasmlblbuf + +sizeof(UINT);
  225.   len = mystrcopy(s, &asmlblbuf[lenasmlblbuf]);
  226.   lenasmlblbuf = lenasmlblbuf + len + 1;
  227.   asmstr("__"); asmuint(constindex); asmmangledstr(_fn); //fn эєцхэ, ўЄюс√ ртЄюьхЄъш фы  Ёрчэ√ї ьюфєыхщ эх ёютярыш
  228.   asmstr("__"); asmmangledstr(s); //фы  эруы фэюёЄш
  229. //  IF (high) {asmstr( ">>32"/**WORDBITS*/ );  }; //todo long
  230. }
  231.  
  232. PROC asmflushlabels()
  233. {
  234. VAR UINT i;
  235. VAR UINT len;
  236.   IF (lenasmlblbuf != 0) asm_align4b();
  237.   i = 0;
  238.   WHILE (i != lenasmlblbuf) {
  239.     asmstr("__"); asmuint(*(PUINT)(&asmlblbuf[i])); asmmangledstr(_fn); //fn эєцхэ, ўЄюс√ ртЄюьхЄъш фы  Ёрчэ√ї ьюфєыхщ эх ёютярыш
  240.     i = i + +sizeof(UINT);
  241.     asmstr("__"); emitasmlabel(&asmlblbuf[i]); //фы  эруы фэюёЄш
  242.     //len = mystrcopy(&asmlblbuf[i], _wass);
  243.     asm_dw(); asmmangledstr(&asmlblbuf[i]); endasm();
  244.     i = i + mystrlen(&asmlblbuf[i]) + 1;
  245.   };
  246.   lenasmlblbuf = 0;
  247.   asmcmds = 0;
  248. }
  249.  
  250. PROC asmjpflushlabels()
  251. {
  252.   asm_b();
  253.   asm_pc4_eol();
  254.   asmflushlabels(); //эх ЄЁюурхЄ constindex
  255.   asm_endpc4();
  256. }
  257.  
  258. //////////// ьхыъшх яЁюЎхфєЁ√ фы  ёюъЁр∙хэш  ўшёыр ъюэёЄрэЄ
  259.  
  260. PROC endasmcmd()
  261. {
  262.   endasm();
  263.   INC asmcmds;
  264.   IF (asmcmds >= 250) asmjpflushlabels();
  265. }
  266.  
  267. PROC asm_direct()
  268. {
  269.   asmc('#');
  270. }
  271.  
  272. PROC asm_comma()
  273. {
  274.   asmc(',');
  275. }
  276.  
  277. PROC asm_open()
  278. {
  279.   asmc('[');
  280. }
  281.  
  282. PROC asm_close()
  283. {
  284.   asmc(']');
  285. }
  286.  
  287. PROC asm_opcurl()
  288. {
  289.   asmc('{');
  290. }
  291.  
  292. PROC asm_clcurl()
  293. {
  294.   asmc('}');
  295. }
  296.  
  297. PROC asm_rname(BYTE r)
  298. {
  299.   asmstr( _RNAME[(UINT)r] );
  300. }
  301.  
  302. PROC asm_mrname(BYTE r)
  303. {
  304.   asm_open(); asm_rname(r); asm_close();
  305. }
  306.  
  307. PROC asm_rtemp()
  308. {
  309.   asmstr("R0");
  310. }
  311.  
  312. PROC asm_mrtemp()
  313. {
  314.   asmstr("[R0]");
  315. }
  316.  
  317. PROC asm_rzero()
  318. {
  319.   asmstr("R8");
  320. }
  321.  
  322. PROC asm_rff()
  323. {
  324.   asmstr("R7");
  325. }
  326.  
  327. PROC asm_rmain()
  328. {
  329.   asm_rname(_RMAIN);
  330. }
  331.  
  332. PROC asm_close_eol()
  333. {
  334.   asm_close(); endasmcmd();
  335. }
  336.  
  337. PROC var_alignwsz()
  338. {
  339.   varstr("\tALIGN 4"); endvar();
  340. }
  341.  
  342. EXPORT PROC var_db() //фюёЄєяэю шч compile!
  343. {
  344.   varstr( "\tDCB " );
  345. }
  346.  
  347. EXPORT PROC asm_db() //ъюёЄ√ы№ фы  ъюэёЄрэЄэ√ї ьрёёштют ёЄЁюъ TODO
  348. {
  349.   asmstr( "\tDCB " );
  350. }
  351.  
  352. EXPORT PROC var_dw() //фюёЄєяэю шч compile!
  353. {
  354. //  var_align4b();
  355.   varstr( "\tDCD " );
  356. }
  357.  
  358. EXPORT PROC asm_dw() //ъюёЄ√ы№ фы  ртЄюухэхЁшЁєхь√ї ъюэёЄрэЄ
  359. {
  360. //  asm_align4b();
  361.   asmstr( "\tDCD " );
  362. }
  363.  
  364. PROC var_dl()
  365. {
  366. //  var_align4b();
  367.   varstr( "\tDCQ " );
  368. }
  369.  
  370. EXPORT PROC var_ds() //фюёЄєяэю шч compile!
  371. {
  372.   varstr( "\tSPACE " );
  373. }
  374.  
  375. PROC asm_ands() //ё єёЄрэютъющ Їыруют
  376. {
  377.   asmstr( "\tANDS " );
  378. }
  379.  
  380. PROC asm_ors() //ё єёЄрэютъющ Їыруют
  381. {
  382.   asmstr( "\tORRS " );
  383. }
  384.  
  385. PROC asm_eors() //ё єёЄрэютъющ Їыруют
  386. {
  387.   asmstr( "\tEORS " );
  388. }
  389.  
  390. PROC asm_rsbs() //ё єёЄрэютъющ Їыруют
  391. {
  392.   asmstr( "\tRSBS " );
  393. }
  394.  
  395. PROC asm_subs() //ё єёЄрэютъющ Їыруют
  396. {
  397.   asmstr( "\tSUBS " );
  398. }
  399.  
  400. PROC asm_sbcs() //ё єёЄрэютъющ Їыруют
  401. {
  402.   asmstr( "\tSBCS " );
  403. }
  404.  
  405. PROC asm_adds() //ё єёЄрэютъющ Їыруют
  406. {
  407.   asmstr( "\tADDS " );
  408. }
  409.  
  410. PROC asm_adcs() //ё єёЄрэютъющ Їыруют
  411. {
  412.   asmstr( "\tADCS " );
  413. }
  414.  
  415. PROC asm_ldr()
  416. {
  417.   asmstr( "\tLDR " );
  418. }
  419.  
  420. PROC asm_ldrb()
  421. {
  422.   asmstr( "\tLDRB " );
  423. }
  424.  
  425. PROC asm_str()
  426. {
  427.   asmstr( "\tSTR " );
  428. }
  429.  
  430. PROC asm_strb()
  431. {
  432.   asmstr( "\tSTRB " );
  433. }
  434.  
  435. PROC asm_mov() //┴┼╟ єёЄрэютъш Їыруют
  436. {
  437.   asmstr( "\tMOV " );
  438. }
  439.  
  440. PROC asm_movs() //ё єёЄрэютъющ Їыруют
  441. {
  442.   asmstr( "\tMOVS " );
  443. }
  444.  
  445. PROC asm_mvns() //ё єёЄрэютъющ Їыруют
  446. {
  447.   asmstr( "\tMVNS " );
  448. }
  449.  
  450. PROC asm_b() //jr
  451. {
  452.   asmstr( "\tB " );
  453. }
  454.  
  455. PROC asm_bl() //jp/call
  456. {
  457.   asmstr( "\tBL " );
  458.   INC asmcmds; //long cmd
  459. }
  460.  
  461. PROC asm_beq() //jp z
  462. {
  463.   asmstr( "\tBEQ " );
  464. }
  465.  
  466. PROC asm_bne() //jp nz
  467. {
  468.   asmstr( "\tBNE " );
  469. }
  470.  
  471. PROC asm_bcs() //jp c
  472. {
  473.   asmstr( "\tBCS " );
  474. }
  475.  
  476. PROC asm_bcc() //jp nc
  477. {
  478.   asmstr( "\tBCC " );
  479. }
  480.  
  481. PROC asm_bpl() //jp p
  482. {
  483.   asmstr( "\tBPL " );
  484. }
  485.  
  486. PROC asm_bvc() //jp pe? (no overflow)
  487. {
  488.   asmstr( "\tBVC " );
  489. }
  490.  
  491. PROC asm_bvs() //jp po? (overflow)
  492. {
  493.   asmstr( "\tBVS " );
  494. }
  495.  
  496. PROC asm_blt() //< (чэръютюх ёЁртэхэшх)
  497. {
  498.   asmstr( "\tBLT " );
  499. }
  500.  
  501. PROC asm_bgt() //> (чэръютюх ёЁртэхэшх)
  502. {
  503.   asmstr( "\tBGT " );
  504. }
  505.  
  506. PROC asm_bx() //jp reg
  507. {
  508.   asmstr( "\tBX " );
  509. }
  510.  
  511. PROC asm_blx() //call reg???
  512. {
  513.   asmstr( "\tBLX " );
  514. }
  515.  
  516. PROC asm_nop_eol()
  517. {
  518.   asmstr("\tNOP"); endasmcmd();
  519. }
  520.  
  521. PROC asm_push()
  522. {
  523.   asmstr( "\tPUSH " );
  524. }
  525.  
  526. PROC asm_pop()
  527. {
  528.   asmstr( "\tPOP " );
  529. }
  530.  
  531. PROC emit0(BYTE reg) //схч єёЄрэютъш Їыруют
  532. {
  533.   asm_mov(); asm_rname(reg); asm_comma(); asm_rzero(); endasmcmd();
  534.   //asm_mov(); asm_rname(reg); asm_comma(); asm_direct(); asmc('0'); endasmcmd();
  535.   //asm_sub(); asm_rname(reg); asm_comma(); asm_rname(reg); endasmcmd();
  536. }
  537.  
  538. PROC emitmaskb(BYTE reg)
  539. {
  540.   asm_ands(); asm_rname(reg); asm_comma(); asm_rff(); endasmcmd();
  541. }
  542.  
  543. PROC asm_call_eol(PCHAR s)
  544. {
  545.   asm_bl(); asmmangledstr(s); endasmcmd();
  546. }
  547.  
  548. ///////////////////////////////////
  549. //фюёЄєяэ√ шч commands
  550. PROC unproxy()
  551. {
  552. }
  553.  
  554. PROC proxy(BYTE r)
  555. {
  556. }
  557.  
  558. ///////////////////////////////////////////////////////////
  559. //яЁюЎхфєЁ√ ё ьр°шээ√ь ъюфюь фы  rgs
  560.  
  561. PROC emitpushrg(BYTE rnew)
  562. {
  563.   asm_push(); asm_opcurl(); asm_rname(rnew); asm_clcurl(); endasmcmd();
  564.   INC _funcstkdepth;
  565. }
  566.  
  567. PROC emitpoprg(BYTE rnew) //ЁхушёЄЁ єцх яюьхўхэ т getrfree/getrg
  568. {
  569.   asm_pop(); asm_opcurl(); asm_rname(rnew); asm_clcurl(); endasmcmd();
  570.   DEC _funcstkdepth;
  571. }
  572.  
  573. PROC emitmovrg(BYTE rsrc, BYTE rdest) //эх чрърч√трхЄ ш эх юётюсюцфрхЄ (ёь. emitmoverg)
  574. {
  575.   asm_movs(); asm_rname(rdest); asm_comma(); asm_rname(rsrc); endasmcmd(); //эх mov, яюЄюьє ўЄю юср ЁхушёЄЁр r0..r7
  576. }
  577.  
  578. ///////////////////////////////////////////////////////////////////////////////////////
  579. //¤Єш яЁюЎхфєЁ√ ухэхЁшЁє■Є ъюф
  580. //эхфюёЄєяэ√ шч ъюьяшы ЄюЁр, фюёЄєяэ√ шч commands
  581.  
  582. EXPORT PROC emitexport(PCHAR s)
  583. {
  584.   asmstr("\tEXPORT "); asmmangledstr(s); endasmcmd();
  585. }
  586.  
  587. EXPORT PROC emitvarpreequ(PCHAR s)
  588. {
  589. //  varstr("\tIF :LNOT: :DEF: "); varmangledstr(s); endvar(); //todo єсЁрЄ№ (Keil)
  590. }
  591.  
  592. EXPORT PROC emitvarpostequ()
  593. {
  594. //  varstr("\tENDIF"); endvar(); //todo єсЁрЄ№ (Keil)
  595. }
  596.  
  597. EXPORT PROC varequ(PCHAR s)
  598. {
  599.   varmangledstr(s); varstr("\tEQU ");
  600. }
  601.  
  602. EXPORT FUNC UINT varshift(UINT shift, UINT sz)
  603. {
  604.   IF (sz >= 4) shift = (shift+3)&(UINT)(-4);
  605.   //asmstr(_joined); asmc('='); asmuint(shift); endasm();
  606.   varequ(_joined); /**varstr(_joined); varc('=');*/ varuint(shift); endvar();
  607. RETURN shift;
  608. }
  609.  
  610. PROC emitjpmainrg() //"jp (hl)"
  611. {
  612.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  613.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  614.   getnothing(); //getnothingword();
  615.   asm_bx(); asm_rmain(); endasmcmd();
  616. }
  617.  
  618. PROC emitcallmainrg() //"call (hl)"
  619. {
  620.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  621.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  622.   getnothing(); //getnothingword();
  623. /**  //asm_blx(); asm_rmain(); endasmcmd();
  624.   asm_add(); asm_rtemp(); asm_comma(); asmstr("PC"); asm_comma(); asmstr("#8"); endasmcmd();
  625.   asm_mov(); asmstr("LR"); asm_comma(); asm_rtemp(); endasmcmd();
  626.   asm_bx(); asm_rmain(); endasmcmd();
  627.   asm_nop_eol();
  628. */
  629.   asm_call_eol("_JPHL.");
  630.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  631. }
  632.  
  633. PROC emitjp()
  634. {
  635.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  636.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  637.   unproxy();
  638.   getnothing(); //getnothingword();
  639.   asm_b(); asmmangledstr(_joined); endasmcmd();
  640. }
  641.  
  642. PROC emitbtoz() //яхЁхф jp!
  643. {
  644.   //ёЁрчє яюёых ёЁртэхэш  эх эрфю, эю тфЁєу ь√ ўшЄрхь BOOL
  645.   //IF (_jpflag == 0x00) {
  646.   IF (!_fused) { //Ёхчєы№ЄрЄр эхЄ тю Їырурї
  647.     asm_ors(); asm_rname(_rnew); asm_comma(); asm_rname(_rnew); endasmcmd();
  648.   };
  649. }
  650.  
  651. PROC emitjpiffalse()
  652. {
  653.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  654.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  655.   getnothing(); //getnothingword();
  656.   IF       (_jpflag == 0x02) {asm_beq(); //asm_bne();
  657.   }ELSE IF (_jpflag == 0x03) {asm_bcc(); //asm_bcs();
  658.   }ELSE IF (_jpflag == 0x04) {asm_bcs(); //asm_bcc();
  659.   }ELSE                      {asm_bne(); //asm_beq();
  660.   };
  661.   asm_pc4_eol();
  662.  
  663.   asm_bl(); //long jp
  664.   asmmangledstr(_joined);
  665.   endasmcmd();
  666.  
  667.   asm_endpc4();
  668.   _fused = +FALSE;
  669.   _jpflag = 0x00;
  670. }
  671.  
  672. PROC emitret()
  673. {
  674.   asm_pop(); asmstr( "{PC}" ); endasmcmd();
  675.   asmflushlabels();
  676. }
  677.  
  678. PROC emitcall2rgs(PCHAR s)
  679. {
  680.   unproxy();
  681.   getmain2rgs();
  682.   initrgs();
  683.   asm_call_eol(s);
  684.   setmainrg(); //Ёхчєы№ЄрЄ т RMAIN
  685. }
  686. /**
  687. PROC emitcall3rgs(PCHAR s) //todo яЁютхЁшЄ№
  688. {
  689.   unproxy();
  690.   getmain3rgs();
  691.   initrgs();
  692.   asm_call_eol(s);
  693.   //ёхщўрё тёх ЁхушёЄЁ√ юЄьхўхэ√ ъръ ётюсюфэ√х
  694.   //setwordcontext();
  695.   setmain2rgs(); //Ёхчєы№ЄрЄ т RMAIN,RMAIN2
  696. }
  697. */
  698. PROC emitcall4rgs(PCHAR s) //todo яЁютхЁшЄ№
  699. {
  700.   unproxy();
  701.   getmain4rgs();
  702.   initrgs();
  703.   asm_call_eol(s);
  704.   //ёхщўрё тёх ЁхушёЄЁ√ юЄьхўхэ√ ъръ ётюсюфэ√х
  705.   //setwordcontext();
  706.   setmain2rgs(); //Ёхчєы№ЄрЄ т RMAIN,RMAIN2
  707. }
  708.  
  709. PROC emitcallproc()
  710. {
  711.   //_jpflag = 0x00;
  712.   asm_call_eol(_callee);
  713. }
  714.  
  715. PROC emitloadrtemp(BYTE r, PCHAR s)
  716. {
  717.   asm_ldr(); asm_rname(r); asm_comma();
  718.   //asmc('L'); asmstr(s); //todo яюфяЁюуЁрььр ё т√фхыхэшхь ъюэёЄрэЄ√, ё шёъы■ўхэшхь яютЄюЁэюую яЁшётрштрэш  (rtemp яЁшётрштрхЄё  Єюы№ъю чфхё№ ш т inc/dec)
  719.   asmaddlabel(s, constindex);
  720.   INC constindex;
  721.   endasmcmd();
  722. }
  723.  
  724. PROC emitloadrg(BOOL high) //ЁхушёЄЁ єцх чрэ Є ўхЁхч getrfree
  725. {
  726.   emitloadrtemp(_rnew,_const);
  727. //  asm_ldr(); asm_rname(_rnew); asm_comma(); asm_mrtemp(); endasmcmd(); //todo long
  728.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  729. }
  730.  
  731. PROC emitloadrg0() //ЁхушёЄЁ єцх чрэ Є ўхЁхч getrfree
  732. {
  733.   emit0(_rnew); //Їыруш эх трцэ√
  734. }
  735.  
  736. PROC emitloadb() //ръъєьєы ЄюЁ єцх чрэ Є ўхЁхч getfreea
  737. {
  738.   asm_movs(); asm_rname(_rnew); asm_comma(); asm_direct(); asmmangledstr(_const); endasmcmd();
  739. }
  740.  
  741. PROC emitgetrg(BOOL high) //ЁхушёЄЁ єцх чрэ Є ўхЁхч getrfree
  742. {
  743.   emitloadrtemp(0x00,_joined);
  744.   asm_ldr(); asm_rname(_rnew); asm_comma(); asm_mrtemp(); endasmcmd(); //todo long
  745. }
  746.  
  747. PROC emitgetb() //ръъєьєы ЄюЁ єцх чрэ Є ўхЁхч getfreea
  748. {
  749.   emitloadrtemp(0x00,_joined);
  750.   asm_ldrb(); asm_rname(_rnew); asm_comma(); asm_mrtemp(); endasmcmd();
  751. }
  752.  
  753. PROC emitputrg(BOOL high) //ld [],new
  754. {
  755.   //_jpflag = 0x00;
  756.   emitloadrtemp(0x00,_joined);
  757.   asm_str(); asm_rname(_rnew); asm_comma(); asm_mrtemp(); endasmcmd(); //todo long
  758.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  759. }
  760.  
  761. PROC emitputb()
  762. {
  763.   //_jpflag = 0x00;
  764.   emitloadrtemp(0x00,_joined);
  765.   asm_strb(); asm_rname(_rnew); asm_comma(); asm_mrtemp(); endasmcmd();
  766.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  767. }
  768.  
  769. PROC emitshl1rg()
  770. {
  771.   asm_adds(); asm_rname(_rnew); asm_comma(); asm_rname(_rnew); endasmcmd();
  772. }
  773.  
  774. PROC emitshl1b()
  775. {
  776.   asm_adds(); asm_rname(_rnew); asm_comma(); asm_rname(_rnew); endasmcmd();
  777.   emitmaskb(_rnew);
  778. }
  779. /**
  780. PROC emitshr1rg(BYTE rnew)
  781. {
  782.   asmstr( "\tSRL " ); asm_rhigh(rnew); endasmcmd();
  783.   asmstr( "\tRR " ); asm_rlow(rnew); endasmcmd();
  784. }
  785.  
  786. PROC emitshr1signedrg(BYTE rnew)
  787. {
  788.   asmstr( "\tSRA " ); asm_rhigh(rnew); endasmcmd();
  789.   asmstr( "\tRR " ); asm_rlow(rnew); endasmcmd();
  790. }
  791. */
  792. //PROC emitshr1b(BYTE anew)
  793. //{
  794. //  asmstr( "\tSRL " ); /**rganame*/asm_rlow(anew] ); endasmcmd();
  795. //}
  796.  
  797. PROC emitinvb() //~A -> A
  798. {
  799.   asm_eors(); asm_rname(_rnew); asm_comma(); asm_rff(); endasmcmd();
  800. }
  801.  
  802. PROC emitinvrg()
  803. {
  804.   asm_mvns(); asm_rname(_rnew); asm_comma(); asm_rname(_rnew); endasmcmd();
  805. }
  806.  
  807. PROC emitnegrg()
  808. {
  809.   asm_rsbs(); asm_rname(_rnew); asm_comma(); asm_rname(_rnew); asm_comma(); asm_direct(); asmc('0'); endasmcmd();
  810. }
  811.  
  812. PROC emitSxorVtob() //яюёых subflags (less), ЁрчЁхчхЁтшЁєхЄ A
  813. { //todo яЁютхЁшЄ№
  814.   emit0(_rnew); //схч єёЄрэютъш Їыруют
  815.   asm_bgt(); asm_pc4_eol();
  816.   asm_eors(); asm_rname(_rnew); asm_comma(); asm_rff(); endasmcmd();
  817.   asm_endpc4();
  818. }
  819.  
  820. PROC emitinvSxorVtob() //яюёых subflags (moreeq), ЁрчЁхчхЁтшЁєхЄ A
  821. { //todo яЁютхЁшЄ№
  822.   //emit0(_rnew); //схч єёЄрэютъш Їыруют
  823.   //asm_blt(); asm_pc4_eol();
  824.   //asm_eors(); asm_rname(_rnew); asm_comma(); asm_rff(); endasmcmd();
  825.   asm_mov(); asm_rname(_rnew); asm_comma(); asm_rff(); endasmcmd();
  826.   asm_bgt(); asm_pc4_eol();
  827.   asm_eors(); asm_rname(_rnew); asm_comma(); asm_rff(); endasmcmd();
  828.   asm_endpc4();
  829. }
  830.  
  831. PROC emitxorrg() //old^new => old
  832. {
  833.   asm_eors(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  834.   _fused = +TRUE; //^^
  835. }
  836.  
  837. PROC getxorb() //RGA^RGA2 -> RGA
  838. {
  839.   asm_eors(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  840.   _fused = +TRUE; //^^
  841. }
  842.  
  843. PROC emitorrg() //old|new => old
  844. {
  845.   asm_ors(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  846.   _fused = +TRUE; //||
  847. }
  848.  
  849. PROC getorb() //RGA|RGA2 -> RGA
  850. {
  851.   asm_ors(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  852.   _fused = +TRUE; //||
  853. }
  854.  
  855. PROC emitandrg() //old&new => old
  856. {
  857.   asm_ands(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  858.   _fused = +TRUE; //&&
  859. }
  860.  
  861. PROC getandb() //RGA&RGA2 -> RGA
  862. {
  863.   asm_ands(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  864.   _fused = +TRUE; //&&
  865. }
  866.  
  867. PROC emitaddrg() //old+new => old
  868. {
  869.   asm_adds(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  870. }
  871.  
  872. PROC emitadcrg() //old+new => old
  873. {
  874.   asm_adcs(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  875. }
  876.  
  877. PROC emitaddb() //old+new
  878. {
  879.   asm_adds(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  880.   emitmaskb(_rold);
  881. }
  882.  
  883. PROC emitaddbconst() //new8+<const>
  884. {
  885.   asm_adds(); asm_rname(_rnew); asm_comma(); asm_direct(); asmmangledstr(_const); endasmcmd();
  886.   emitmaskb(_rnew);
  887. }
  888.  
  889. PROC emitsubrg() //old-new => old
  890. {
  891.   asm_subs(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  892. }
  893.  
  894. PROC emitsbcrg() //old-new => old
  895. {
  896.   asm_sbcs(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  897. }
  898.  
  899. PROC emitsubb() //old-new
  900. {
  901.   asm_subs(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  902.   emitmaskb(_rold);
  903. }
  904.  
  905. PROC emitsubbconst() //new8-<const>
  906. {
  907.   asm_subs(); asm_rname(_rnew); asm_comma(); asm_direct(); asmmangledstr(_const); endasmcmd();
  908.   emitmaskb(_rnew);
  909. }
  910.  
  911. PROC emitsubflags(BYTE rnew, BYTE rold) //r2-r1 => CY,sign,overflow
  912. {
  913.   asm_subs(); asm_rname(rold); asm_comma(); asm_rname(rnew); endasmcmd();
  914.   _fused = +TRUE;
  915. }
  916.  
  917. PROC emitsubbflags(BYTE anew, BYTE aold) //a2-a1 => CY
  918. { //sign,overflow эх эєцхэ!
  919.   asm_subs(); asm_rname(aold); asm_comma(); asm_rname(anew); endasmcmd();
  920.   _fused = +TRUE;
  921. }
  922.  
  923. PROC emitsubz() //old-new => Z
  924. {
  925.   asm_subs(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  926.   _fused = +TRUE;
  927. }
  928.  
  929. PROC emitsubbz() //old-new => Z
  930. {
  931.   asm_subs(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  932.   _fused = +TRUE;
  933. }
  934.  
  935. PROC emitsubbzconst() //new-<const> => Z
  936. {
  937.   asm_subs(); asm_rname(_rnew); asm_comma(); asm_direct(); asmmangledstr(_const); endasmcmd();
  938.   _fused = +TRUE;
  939. }
  940.  
  941. PROC emitsublongz() //old2-new, old3-old => Z
  942. { //todo
  943.   _fused = +TRUE;
  944. }
  945.  
  946. PROC emitpokerg() //эютюх чряшё√трхь т ёЄрЁє■ ыюърЎш■ ярь Єш
  947. {
  948.   asm_str(); asm_rname(_rnew); asm_comma(); asm_mrname(_rold); endasmcmd();
  949.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  950. }
  951.  
  952. PROC emitpokeb() //эютюх чряшё√трхь т ёЄрЁє■ ыюърЎш■ ярь Єш
  953. {
  954.   asm_strb(); asm_rname(_rnew); asm_comma(); asm_mrname(_rold); endasmcmd();
  955.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  956. }
  957.  
  958. PROC emitpokelong() //old2(addr), old(high), new(low)
  959. {
  960.   asm_str(); asm_rname(_rnew); asm_comma(); asm_mrname(_rold2); endasmcmd();
  961.   asm_adds(); asm_rname(_rold2); asm_comma(); asmstr("#4"); endasmcmd();
  962.   asm_str(); asm_rname(_rold); asm_comma(); asm_mrname(_rold2); endasmcmd();
  963.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  964. }
  965.  
  966. PROC emitpeekrg() //[new] => new
  967. {
  968.   asm_ldr(); asm_rname(_rnew); asm_comma(); asm_mrname(_rnew); endasmcmd();
  969. }
  970.  
  971. PROC emitpeekb()
  972. {
  973.   asm_ldrb(); asm_rname(_rnew); asm_comma(); asm_mrname(_rnew); endasmcmd();
  974. }
  975.  
  976. PROC emitpeeklong() //[old] => old(high),new(low)
  977. {
  978.   asm_ldr(); asm_rname(_rnew); asm_comma(); asm_mrname(_rold); endasmcmd();
  979.   asm_adds(); asm_rname(_rold); asm_comma(); asmstr("#4"); endasmcmd();
  980.   asm_ldr(); asm_rname(_rold); asm_comma(); asm_mrname(_rold); endasmcmd();
  981. }
  982.  
  983. PROC emitztob()
  984. {
  985.   //asmstr(";emitztoa exprlvl="); asmuint(_exprlvl); endasmcmd();
  986.   IF (_exprlvl != 0x01) { //if (a == b)
  987.     emit0(_rnew); //схч єёЄрэютъш Їыруют
  988.     asm_bne(); asm_pc4_eol();
  989.     emitinvb();
  990.     asm_endpc4();
  991.     _fused = +FALSE; //шэрўх уы■ъ яЁш if ((a==b))
  992.     //_jpflag = 0x00;
  993.   }ELSE {
  994.     //_fused = +TRUE;
  995.     _jpflag = 0x02;
  996.   };
  997. }
  998.  
  999. PROC emitinvztob()
  1000. {
  1001.   //asmstr(";emitinvztoa exprlvl="); asmuint(_exprlvl); endasmcmd();
  1002.   IF (_exprlvl != 0x01) { //if (a != b)
  1003.     emit0(_rnew); //схч єёЄрэютъш Їыруют
  1004.     asm_beq(); asm_pc4_eol();
  1005.     emitinvb();
  1006.     asm_endpc4();
  1007.     _fused = +FALSE; //шэрўх уы■ъ яЁш if ((a!=b))? todo test //тючьюцхэ уы■ъ ifnot ((a!=b))
  1008.     //_jpflag = 0x00;
  1009.   }ELSE {
  1010.     //_fused = +TRUE;
  1011.     _jpflag = 0x01;
  1012.   };
  1013. }
  1014.  
  1015. PROC emitcytob()
  1016. {
  1017.   //asmstr(";emitcytoa exprlvl="); asmuint(_exprlvl); endasmcmd();
  1018.   IF (_exprlvl != 0x01) { //if (a < b)
  1019.     asm_sbcs(); asm_rname(_rnew); asm_comma(); asm_rname(_rnew); endasmcmd();
  1020.     //_fused = +FALSE;
  1021.     //_jpflag = 0x00;
  1022.   }ELSE {
  1023.     //_fused = +TRUE;
  1024.     _jpflag = 0x03;
  1025.   };
  1026. }
  1027.  
  1028. PROC emitinvcytob()
  1029. {
  1030.   //asmstr(";emitinvcytoa exprlvl="); asmuint(_exprlvl); endasmcmd();
  1031.   IF (_exprlvl != 0x01) { //if (a >= b)
  1032.     asm_sbcs(); asm_rname(_rnew); asm_comma(); asm_rname(_rnew); endasmcmd();
  1033.     asm_eors(); asm_rname(_rnew); asm_comma(); asm_rff(); endasmcmd();
  1034.     //_fused = +FALSE;
  1035.     //_jpflag = 0x00;
  1036.   }ELSE {
  1037.     //_fused = +TRUE;
  1038.     _jpflag = 0x04;
  1039.   };
  1040. }
  1041.  
  1042. PROC emitrgtob() //эхы№ч  єсшЁрЄ№ - ёяхЎшЇшўэю
  1043. {
  1044.   emitmaskb(_rnew); //todo эрюсюЁюЄ, шуэюЁшЁютрЄ№ ёЄ.ўрёЄ№ ёыютр, ъЁюьх ёЁртэхэшщ
  1045. }
  1046.  
  1047. PROC emitbtorg()
  1048. {
  1049. }
  1050.  
  1051. PROC emitincrg_byname()
  1052. {
  1053.   emitloadrtemp(_rnew,_joined);
  1054.   asm_ldr(); asm_rtemp(); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1055.   asm_adds(); asm_rtemp(); asm_comma(); asmstr("#1"); endasmcmd();
  1056.   asm_str(); asm_rtemp(); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1057.   //asm_adds(); asm_rname(_rnew); asm_comma(); asm_direct(); asmc('1'); endasmcmd();
  1058.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1059. }
  1060.  
  1061. PROC emitincb_bypoi()
  1062. {
  1063.   asm_ldrb(); asm_rtemp(); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1064.   asm_adds(); asm_rtemp(); asm_comma(); asmstr("#1"); endasmcmd();
  1065.   asm_strb(); asm_rtemp(); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1066.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1067. }
  1068. /**
  1069. PROC emitinclong() //todo
  1070. {
  1071.   asm_inc(); asm_open(); asm_rname(_rnew); asm_close(); endasmcmd();
  1072.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1073. }
  1074. */
  1075. PROC emitdecrg_byname()
  1076. {
  1077.   emitloadrtemp(_rnew,_joined);
  1078.   asm_ldr(); asm_rtemp(); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1079.   asm_subs(); asm_rtemp(); asm_comma(); asmstr("#1"); endasmcmd();
  1080.   asm_str(); asm_rtemp(); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1081.   //asm_subs(); asm_rname(_rnew); asm_comma(); asmstr("#1"); endasmcmd();
  1082.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1083. }
  1084.  
  1085. PROC emitdecb_bypoi()
  1086. {
  1087.   asm_ldrb(); asm_rtemp(); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1088.   asm_subs(); asm_rtemp(); asm_comma(); asmstr("#1"); endasmcmd();
  1089.   asm_strb(); asm_rtemp(); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1090.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1091. }
  1092. /**
  1093. PROC emitdeclong() //todo
  1094. {
  1095.   asm_dec(); asm_open(); asm_rname(_rnew); asm_close(); endasmcmd();
  1096.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1097. }
  1098. */
  1099.  
  1100. PROC emitincrg_bypoi() //[old], new free
  1101. {
  1102.   asm_ldr(); asm_rtemp(); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1103.   asm_adds(); asm_rtemp(); asm_comma(); asmstr("#1"); endasmcmd();
  1104.   asm_str(); asm_rtemp(); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1105.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1106. }
  1107.  
  1108. PROC emitdecrg_bypoi() //[old], new free
  1109. {
  1110.   asm_ldr(); asm_rtemp(); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1111.   asm_subs(); asm_rtemp(); asm_comma(); asmstr("#1"); endasmcmd();
  1112.   asm_str(); asm_rtemp(); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1113.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1114. }
  1115.  
  1116. /////////////
  1117. EXPORT PROC initcode()
  1118. {
  1119. //  _wass = (PCHAR)_swass;
  1120.   _jpflag = 0x00;
  1121.   constindex = 0;
  1122.   asmcmds = 0;
  1123.   asmstr("\tALIGN 2"); endasm();
  1124. }
  1125.  
  1126. EXPORT PROC endcode()
  1127. {
  1128.   asmflushlabels();
  1129.   asmstr("\tEND"); endasmcmd();
  1130.   varstr("\tEND"); endvar();
  1131. }
  1132.  
  1133. PROC initrgs()
  1134. {
  1135.   rgs_initrgs();
  1136.   _fused = +FALSE; //ьюцэю ёфхырЄ№ юфэє яЁюЎхфєЁє initif фы  ¤Єюую (т√ч√трЄ№ т эрўрых if, while, until)
  1137. }
  1138.  
  1139. PROC emitfunchead()
  1140. {
  1141.   asm_push(); asmstr( "{LR}" ); endasmcmd();
  1142.   initrgs();
  1143. }
  1144.  
  1145. PROC setmainb()
  1146. {
  1147.   setmainrg(); //Ёхчєы№ЄрЄ т RMAIN
  1148. }
  1149.  
  1150. PROC prefernoregs()
  1151. {
  1152. }
  1153.  
  1154.