Subversion Repositories NedoOS

Rev

Rev 777 | Blame | Compare with Previous | Last modification | View Log | Download

  1. //// imported
  2. #include "../_sdk/emit.h"
  3.  
  4. #include "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. EXPORT PROC asm_label()
  259. {
  260.   //asmc(+_CMDLABEL); //TODO юяЁхфхы Є№ яю яхЁтющ сєътх ъюьрэф√?
  261. }
  262.  
  263. EXPORT PROC asm_equal()
  264. {
  265.   asmc((BYTE)'='); //asmc(+_TOKEXPR); //TODO схч _TOKEXPR? (єсЁрЄ№ т ёрьє юсЁрсюЄъє _CMDLABEL) (єёыюцэшЄ ¤ъёяюЁЄ)
  266. }
  267.  
  268. EXPORT PROC endasm_label()
  269. {
  270.   /**asmc(+_FMTCMD);*/ endasm(); //Єрь Єюы№ъю яЁютхЁър яхЁхюяЁхфхы╕ээюёЄш, TODO єсЁрЄ№ т ёрьє юсЁрсюЄъє _CMDLABEL
  271. }
  272.  
  273. EXPORT PROC endasm_reequ()
  274. {
  275.   /**asmc(+_TOKENDEXPR); asmc(+_FMTREEQU);*/ endasm(); //TODO єсЁрЄ№
  276. }
  277.  
  278. EXPORT PROC var_label()
  279. {
  280.   //varc(+_CMDLABEL); //TODO юяЁхфхы Є№ яю яхЁтющ сєътх ъюьрэф√?
  281. }
  282.  
  283. EXPORT PROC endvar_label()
  284. {
  285.   /**varc(+_FMTCMD);*/ endvar(); //Єрь Єюы№ъю яЁютхЁър яхЁхюяЁхфхы╕ээюёЄш, TODO єсЁрЄ№ т ёрьє юсЁрсюЄъє _CMDLABEL
  286. }
  287.  
  288. EXPORT PROC varequ(PCHAR s)
  289. {
  290.   varmangledstr(s); varstr("\tEQU ");
  291.   //varc(+_CMDLABEL); varmangledstr(s); varc((BYTE)'='); varc(+_TOKEXPR); //TODO схч _TOKEXPR? (єсЁрЄ№ т ёрьє юсЁрсюЄъє _CMDLABEL) (єёыюцэшЄ ¤ъёяюЁЄ)
  292. }
  293.  
  294. EXPORT PROC endvar_reequ()
  295. {
  296.   /**varc(+_TOKENDEXPR); varc(+_FMTREEQU);*/ endvar(); //TODO єсЁрЄ№
  297. }
  298.  
  299. EXPORT PROC endasm_db()
  300. {
  301.   /**asmc(+_TOKENDEXPR); asmc(+_OPWRVAL); asmc(+_FMTCMD);*/ endasm(); //TODO єсЁрЄ№
  302. }
  303.  
  304. EXPORT PROC endasm_dbstr()
  305. {
  306.   /**asmc(+_TOKENDTEXT);*/ asmc((BYTE)'\"'); /**asmc(+_FMTCMD);*/ endasm(); //TODO єсЁрЄ№
  307. }
  308.  
  309. EXPORT PROC endvar_db()
  310. {
  311.   /**varc(+_TOKENDEXPR); varc(+_OPWRVAL); varc(+_FMTCMD);*/ endvar(); //TODO єсЁрЄ№
  312. }
  313.  
  314. EXPORT PROC endvar_dbstr()
  315. {
  316.   /**varc(+_TOKENDTEXT);*/ varc((BYTE)'\"'); /**varc(+_FMTCMD);*/ endvar(); //TODO єсЁрЄ№
  317. }
  318.  
  319. EXPORT PROC endvar_dw()
  320. {
  321.   /**varc(+_TOKENDEXPR); varc(+_OPWRVAL); varc(+_FMTCMD);*/ endvar(); //TODO єсЁрЄ№
  322. }
  323.  
  324. EXPORT PROC endvar_dl()
  325. {
  326.   /**varc(+_TOKENDEXPR); varc(+_OPWRVAL); varc(+_FMTCMD);*/ endvar(); //TODO єсЁрЄ№
  327. }
  328.  
  329. EXPORT PROC endvar_ds()
  330. {
  331.   /**varc(+_TOKENDEXPR); varc(+_FMTCMD);*/ endvar();
  332. }
  333. /**
  334. PROC asmexprstr(PCHAR s)
  335. {
  336.   asmc(+_TOKEXPR); asmstr(s); asmc(+_TOKENDEXPR);
  337. }
  338. */
  339. /**
  340. PROC asmcmd(BYTE c)
  341. {
  342.   asmc(+_TOKSPC8); asmc(c); asmc(+_TOKSPC1);
  343. }
  344.  
  345. PROC asmcmdfull(BYTE c)
  346. {
  347.   asmc(+_TOKSPC8); asmc(c); asmc(+_FMTXX); endasm(); //TODO яшёрЄ№ ъюф т ёрьшї ъюьрэфрї
  348. }
  349. */
  350. //////////// ьхыъшх яЁюЎхфєЁ√ фы  ёюъЁр∙хэш  ўшёыр ъюэёЄрэЄ
  351.  
  352. PROC endasmcmd()
  353. {
  354.   endasm();
  355.   INC asmcmds;
  356.   IF (asmcmds >= 250) asmjpflushlabels();
  357. }
  358.  
  359. PROC asm_direct()
  360. {
  361.   asmc('#');
  362. }
  363.  
  364. PROC asm_comma()
  365. {
  366.   asmc(',');
  367. }
  368.  
  369. PROC asm_open()
  370. {
  371.   asmc('[');
  372. }
  373.  
  374. PROC asm_close()
  375. {
  376.   asmc(']');
  377. }
  378.  
  379. PROC asm_opcurl()
  380. {
  381.   asmc('{');
  382. }
  383.  
  384. PROC asm_clcurl()
  385. {
  386.   asmc('}');
  387. }
  388.  
  389. PROC asm_rname(BYTE r)
  390. {
  391.   asmstr( _RNAME[(UINT)r] );
  392. }
  393.  
  394. PROC asm_mrname(BYTE r)
  395. {
  396.   asm_open(); asm_rname(r); asm_close();
  397. }
  398.  
  399. PROC asm_rtemp()
  400. {
  401.   asmstr("R0");
  402. }
  403.  
  404. PROC asm_mrtemp()
  405. {
  406.   asmstr("[R0]");
  407. }
  408.  
  409. PROC asm_rzero()
  410. {
  411.   asmstr("R8");
  412. }
  413.  
  414. PROC asm_rff()
  415. {
  416.   asmstr("R7");
  417. }
  418.  
  419. PROC asm_rmain()
  420. {
  421.   asm_rname(_RMAIN);
  422. }
  423.  
  424. PROC asm_close_eol()
  425. {
  426.   asm_close(); endasmcmd();
  427. }
  428.  
  429. PROC var_alignwsz()
  430. {
  431.   varstr("\tALIGN 4"); endvar();
  432. }
  433.  
  434. EXPORT PROC asm_dw() //ъюёЄ√ы№ фы  ртЄюухэхЁшЁєхь√ї ъюэёЄрэЄ
  435. {
  436. //  asm_align4b();
  437.   asmstr( "\tDCD " );
  438. //  asmc(+_TOKSPC8); asmc(+_CMDDW); asmc(+_TOKSPC1); asmc(+_TOKEXPR); //TODO схч _TOKEXPR? (єсЁрЄ№ т ёрьє юсЁрсюЄъє ъюьрэф√) (єёыюцэшЄ ¤ъёяюЁЄ)
  439. }
  440.  
  441. EXPORT PROC asm_db() //ъюёЄ√ы№ фы  ъюэёЄрэЄэ√ї ьрёёштют ёЄЁюъ TODO
  442. {
  443.   asmstr( "\tDCB " );
  444. //  asmc(+_TOKSPC8); asmc(+_CMDDB); asmc(+_TOKSPC1); asmc(+_TOKEXPR); //TODO схч _TOKEXPR? (єсЁрЄ№ т ёрьє юсЁрсюЄъє ъюьрэф√) (єёыюцэшЄ ¤ъёяюЁЄ)
  445. }
  446.  
  447. EXPORT PROC asm_dbstr() //ъюёЄ√ы№ фы  ъюэёЄрэЄэ√ї ьрёёштют ёЄЁюъ TODO
  448. {
  449.   asm_db(); asmc((BYTE)'\"');
  450. //  asmc(+_TOKSPC8); asmc(+_CMDDB); asmc(+_TOKSPC1); asmc((BYTE)'\"'); asmc(+_OPWRSTR); asmc(+_TOKTEXT); //TODO єсЁрЄ№ т ёрьє юсЁрсюЄъє ъюьрэф√ (єёыюцэшЄ ¤ъёяюЁЄ)
  451. }
  452.  
  453. EXPORT PROC var_db() //фюёЄєяэю шч compile!
  454. {
  455.   varstr( "\tDCB " );
  456. //  varc(+_TOKSPC8); varc(+_CMDDB); varc(+_TOKSPC1); varc(+_TOKEXPR); //TODO схч _TOKEXPR? (єсЁрЄ№ т ёрьє юсЁрсюЄъє ъюьрэф√) (єёыюцэшЄ ¤ъёяюЁЄ)
  457. }
  458.  
  459. EXPORT PROC var_dbstr()
  460. {
  461.   var_db(); varc((BYTE)'\"');
  462. //  varc(+_TOKSPC8); varc(+_CMDDB); varc(+_TOKSPC1); varc((BYTE)'\"'); varc(+_OPWRSTR); varc(+_TOKTEXT); //TODO єсЁрЄ№ т ёрьє юсЁрсюЄъє ъюьрэф√ (єёыюцэшЄ ¤ъёяюЁЄ)
  463. }
  464.  
  465. EXPORT PROC var_dw() //фюёЄєяэю шч compile!
  466. {
  467. //  var_align4b();
  468.   varstr( "\tDCD " );
  469. //  varc(+_TOKSPC8); varc(+_CMDDW); varc(+_TOKSPC1); varc(+_TOKEXPR); //TODO схч _TOKEXPR? (єсЁрЄ№ т ёрьє юсЁрсюЄъє ъюьрэф√) (єёыюцэшЄ ¤ъёяюЁЄ)
  470. }
  471.  
  472. PROC var_dl()
  473. {
  474. //  var_align4b();
  475.   varstr( "\tDCQ " );
  476. //  varc(+_TOKSPC8); varc(+_CMDDL); varc(+_TOKSPC1); varc(+_TOKEXPR); //TODO схч _TOKEXPR? (єсЁрЄ№ т ёрьє юсЁрсюЄъє ъюьрэф√) (єёыюцэшЄ ¤ъёяюЁЄ)
  477. }
  478.  
  479. EXPORT PROC var_ds() //фюёЄєяэю шч compile!
  480. {
  481.   varstr( "\tSPACE " );
  482. //  varc(+_TOKSPC8); varc(+_CMDDS); varc(+_TOKSPC1); varc(+_TOKEXPR); //TODO схч _TOKEXPR? (єсЁрЄ№ т ёрьє юсЁрсюЄъє ъюьрэф√) (єёыюцэшЄ ¤ъёяюЁЄ)
  483. }
  484.  
  485. PROC asm_ands() //ё єёЄрэютъющ Їыруют
  486. {
  487.   asmstr( "\tANDS " );
  488. }
  489.  
  490. PROC asm_ors() //ё єёЄрэютъющ Їыруют
  491. {
  492.   asmstr( "\tORRS " );
  493. }
  494.  
  495. PROC asm_eors() //ё єёЄрэютъющ Їыруют
  496. {
  497.   asmstr( "\tEORS " );
  498. }
  499.  
  500. PROC asm_rsbs() //ё єёЄрэютъющ Їыруют
  501. {
  502.   asmstr( "\tRSBS " );
  503. }
  504.  
  505. PROC asm_subs() //ё єёЄрэютъющ Їыруют
  506. {
  507.   asmstr( "\tSUBS " );
  508. }
  509.  
  510. PROC asm_sbcs() //ё єёЄрэютъющ Їыруют
  511. {
  512.   asmstr( "\tSBCS " );
  513. }
  514.  
  515. PROC asm_adds() //ё єёЄрэютъющ Їыруют
  516. {
  517.   asmstr( "\tADDS " );
  518. }
  519.  
  520. PROC asm_adcs() //ё єёЄрэютъющ Їыруют
  521. {
  522.   asmstr( "\tADCS " );
  523. }
  524.  
  525. PROC asm_ldr()
  526. {
  527.   asmstr( "\tLDR " );
  528. }
  529.  
  530. PROC asm_ldrb()
  531. {
  532.   asmstr( "\tLDRB " );
  533. }
  534.  
  535. PROC asm_str()
  536. {
  537.   asmstr( "\tSTR " );
  538. }
  539.  
  540. PROC asm_strb()
  541. {
  542.   asmstr( "\tSTRB " );
  543. }
  544.  
  545. PROC asm_mov() //┴┼╟ єёЄрэютъш Їыруют
  546. {
  547.   asmstr( "\tMOV " );
  548. }
  549.  
  550. PROC asm_movs() //ё єёЄрэютъющ Їыруют
  551. {
  552.   asmstr( "\tMOVS " );
  553. }
  554.  
  555. PROC asm_mvns() //ё єёЄрэютъющ Їыруют
  556. {
  557.   asmstr( "\tMVNS " );
  558. }
  559.  
  560. PROC asm_b() //jr
  561. {
  562.   asmstr( "\tB " );
  563. }
  564.  
  565. PROC asm_bl() //jp/call
  566. {
  567.   asmstr( "\tBL " );
  568.   INC asmcmds; //long cmd
  569. }
  570.  
  571. PROC asm_beq() //jp z
  572. {
  573.   asmstr( "\tBEQ " );
  574. }
  575.  
  576. PROC asm_bne() //jp nz
  577. {
  578.   asmstr( "\tBNE " );
  579. }
  580.  
  581. PROC asm_bcs() //jp c
  582. {
  583.   asmstr( "\tBCS " );
  584. }
  585.  
  586. PROC asm_bcc() //jp nc
  587. {
  588.   asmstr( "\tBCC " );
  589. }
  590.  
  591. PROC asm_bpl() //jp p
  592. {
  593.   asmstr( "\tBPL " );
  594. }
  595.  
  596. PROC asm_bvc() //jp pe? (no overflow)
  597. {
  598.   asmstr( "\tBVC " );
  599. }
  600.  
  601. PROC asm_bvs() //jp po? (overflow)
  602. {
  603.   asmstr( "\tBVS " );
  604. }
  605.  
  606. PROC asm_blt() //< (чэръютюх ёЁртэхэшх)
  607. {
  608.   asmstr( "\tBLT " );
  609. }
  610.  
  611. PROC asm_bgt() //> (чэръютюх ёЁртэхэшх)
  612. {
  613.   asmstr( "\tBGT " );
  614. }
  615.  
  616. PROC asm_bx() //jp reg
  617. {
  618.   asmstr( "\tBX " );
  619. }
  620.  
  621. PROC asm_blx() //call reg???
  622. {
  623.   asmstr( "\tBLX " );
  624. }
  625.  
  626. PROC asm_nop_eol()
  627. {
  628.   asmstr("\tNOP"); endasmcmd();
  629. }
  630.  
  631. PROC asm_push()
  632. {
  633.   asmstr( "\tPUSH " );
  634. }
  635.  
  636. PROC asm_pop()
  637. {
  638.   asmstr( "\tPOP " );
  639. }
  640.  
  641. PROC emit0(BYTE reg) //схч єёЄрэютъш Їыруют
  642. {
  643.   asm_mov(); asm_rname(reg); asm_comma(); asm_rzero(); endasmcmd();
  644.   //asm_mov(); asm_rname(reg); asm_comma(); asm_direct(); asmc('0'); endasmcmd();
  645.   //asm_sub(); asm_rname(reg); asm_comma(); asm_rname(reg); endasmcmd();
  646. }
  647.  
  648. PROC emitmaskb(BYTE reg)
  649. {
  650.   asm_ands(); asm_rname(reg); asm_comma(); asm_rff(); endasmcmd();
  651. }
  652.  
  653. PROC asm_call_eol(PCHAR s)
  654. {
  655.   asm_bl(); asmmangledstr(s); endasmcmd();
  656. }
  657.  
  658. ///////////////////////////////////
  659. //фюёЄєяэ√ шч commands
  660. PROC unproxy()
  661. {
  662. }
  663.  
  664. PROC proxy(BYTE r)
  665. {
  666. }
  667.  
  668. ///////////////////////////////////////////////////////////
  669. //яЁюЎхфєЁ√ ё ьр°шээ√ь ъюфюь фы  rgs
  670.  
  671. PROC emitpushrg(BYTE rnew)
  672. {
  673.   asm_push(); asm_opcurl(); asm_rname(rnew); asm_clcurl(); endasmcmd();
  674.   INC _funcstkdepth;
  675. }
  676.  
  677. PROC emitpoprg(BYTE rnew) //ЁхушёЄЁ єцх яюьхўхэ т getrfree/getrg
  678. {
  679.   asm_pop(); asm_opcurl(); asm_rname(rnew); asm_clcurl(); endasmcmd();
  680.   DEC _funcstkdepth;
  681. }
  682.  
  683. PROC emitmovrg(BYTE rsrc, BYTE rdest) //эх чрърч√трхЄ ш эх юётюсюцфрхЄ (ёь. emitmoverg)
  684. {
  685.   asm_movs(); asm_rname(rdest); asm_comma(); asm_rname(rsrc); endasmcmd(); //эх mov, яюЄюьє ўЄю юср ЁхушёЄЁр r0..r7
  686. }
  687.  
  688. ///////////////////////////////////////////////////////////////////////////////////////
  689. //¤Єш яЁюЎхфєЁ√ ухэхЁшЁє■Є ъюф
  690. //эхфюёЄєяэ√ шч ъюьяшы ЄюЁр, фюёЄєяэ√ шч commands
  691.  
  692. EXPORT PROC emitexport(PCHAR s)
  693. {
  694.   asmstr("\tEXPORT "); asmmangledstr(s); endasmcmd();
  695. //  asmcmd(+_CMDEXPORT); asmc(+_TOKLABEL); asmmangledstr(s); asmc(+_FMTCMD); endasm(); //TODO єсЁрЄ№ +_FMTCMD
  696. }
  697.  
  698. EXPORT PROC emitvarpreequ(PCHAR s)
  699. {
  700. //  varstr("\tIF :LNOT: :DEF: "); varmangledstr(s); endvar(); //todo єсЁрЄ№ (Keil)
  701. }
  702.  
  703. EXPORT PROC emitvarpostequ()
  704. {
  705. //  varstr("\tENDIF"); endvar(); //todo єсЁрЄ№ (Keil)
  706. }
  707.  
  708. EXPORT FUNC UINT varshift(UINT shift, UINT sz)
  709. {
  710.   IF (sz >= 4) shift = (shift+3)&(UINT)(-4);
  711.   //asmstr(_joined); asmc('='); asmuint(shift); endasm();
  712.   varequ(_joined); /**varstr(_joined); varc('=');*/ varuint(shift); endvar();
  713. RETURN shift;
  714. }
  715.  
  716. PROC emitjpmainrg() //"jp (hl)"
  717. {
  718.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  719.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  720.   getnothing(); //getnothingword();
  721.   asm_bx(); asm_rmain(); endasmcmd();
  722. }
  723.  
  724. PROC emitcallmainrg() //"call (hl)"
  725. {
  726.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  727.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  728.   getnothing(); //getnothingword();
  729. /**  //asm_blx(); asm_rmain(); endasmcmd();
  730.   asm_add(); asm_rtemp(); asm_comma(); asmstr("PC"); asm_comma(); asmstr("#8"); endasmcmd();
  731.   asm_mov(); asmstr("LR"); asm_comma(); asm_rtemp(); endasmcmd();
  732.   asm_bx(); asm_rmain(); endasmcmd();
  733.   asm_nop_eol();
  734. */
  735.   asm_call_eol("_JPHL.");
  736.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  737. }
  738.  
  739. PROC emitjp()
  740. {
  741.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  742.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  743.   unproxy();
  744.   getnothing(); //getnothingword();
  745.   asm_b(); asmmangledstr(_joined); endasmcmd();
  746. }
  747.  
  748. PROC emitbtoz() //яхЁхф jp!
  749. {
  750.   //ёЁрчє яюёых ёЁртэхэш  эх эрфю, эю тфЁєу ь√ ўшЄрхь BOOL
  751.   //IF (_jpflag == 0x00) {
  752.   IF (!_fused) { //Ёхчєы№ЄрЄр эхЄ тю Їырурї
  753.     asm_ors(); asm_rname(_rnew); asm_comma(); asm_rname(_rnew); endasmcmd();
  754.   };
  755. }
  756.  
  757. PROC emitjpiffalse()
  758. {
  759.   //эр ¤ЄюЄ ьюьхэЄ фы  яЁхфёърчєхьюёЄш тёх ЁхушёЄЁ√ фюыцэ√ с√Є№ ётюсюфэ√
  760.   //(ёхщўрё ¤Єю яюыєўшЄё  ртЄюьрЄшўхёъш, эю схч storergs ш ё ЁхчхЁтшЁютрэшхь ЁхушёЄЁют эрфю юётюсюцфрЄ№ тЁєўэє■)
  761.   getnothing(); //getnothingword();
  762.   IF       (_jpflag == 0x02) {asm_beq(); //asm_bne();
  763.   }ELSE IF (_jpflag == 0x03) {asm_bcc(); //asm_bcs();
  764.   }ELSE IF (_jpflag == 0x04) {asm_bcs(); //asm_bcc();
  765.   }ELSE                      {asm_bne(); //asm_beq();
  766.   };
  767.   asm_pc4_eol();
  768.  
  769.   asm_bl(); //long jp
  770.   asmmangledstr(_joined);
  771.   endasmcmd();
  772.  
  773.   asm_endpc4();
  774.   _fused = +FALSE;
  775.   _jpflag = 0x00;
  776. }
  777.  
  778. PROC emitret()
  779. {
  780.   asm_pop(); asmstr( "{PC}" ); endasmcmd();
  781.   asmflushlabels();
  782. }
  783.  
  784. PROC emitcall2rgs(PCHAR s)
  785. {
  786.   unproxy();
  787.   getmain2rgs();
  788.   initrgs();
  789.   asm_call_eol(s);
  790.   setmainrg(); //Ёхчєы№ЄрЄ т RMAIN
  791. }
  792. /**
  793. PROC emitcall3rgs(PCHAR s) //todo яЁютхЁшЄ№
  794. {
  795.   unproxy();
  796.   getmain3rgs();
  797.   initrgs();
  798.   asm_call_eol(s);
  799.   //ёхщўрё тёх ЁхушёЄЁ√ юЄьхўхэ√ ъръ ётюсюфэ√х
  800.   //setwordcontext();
  801.   setmain2rgs(); //Ёхчєы№ЄрЄ т RMAIN,RMAIN2
  802. }
  803. */
  804. PROC emitcall4rgs(PCHAR s) //todo яЁютхЁшЄ№
  805. {
  806.   unproxy();
  807.   getmain4rgs();
  808.   initrgs();
  809.   asm_call_eol(s);
  810.   //ёхщўрё тёх ЁхушёЄЁ√ юЄьхўхэ√ ъръ ётюсюфэ√х
  811.   //setwordcontext();
  812.   setmain2rgs(); //Ёхчєы№ЄрЄ т RMAIN,RMAIN2
  813. }
  814.  
  815. PROC emitcallproc()
  816. {
  817.   //_jpflag = 0x00;
  818.   asm_call_eol(_callee);
  819. }
  820.  
  821. PROC emitloadrtemp(BYTE r, PCHAR s)
  822. {
  823.   asm_ldr(); asm_rname(r); asm_comma();
  824.   //asmc('L'); asmstr(s); //todo яюфяЁюуЁрььр ё т√фхыхэшхь ъюэёЄрэЄ√, ё шёъы■ўхэшхь яютЄюЁэюую яЁшётрштрэш  (rtemp яЁшётрштрхЄё  Єюы№ъю чфхё№ ш т inc/dec)
  825.   asmaddlabel(s, constindex);
  826.   INC constindex;
  827.   endasmcmd();
  828. }
  829.  
  830. PROC emitloadrg(BOOL high) //ЁхушёЄЁ єцх чрэ Є ўхЁхч getrfree
  831. {
  832.   emitloadrtemp(_rnew,_const);
  833. //  asm_ldr(); asm_rname(_rnew); asm_comma(); asm_mrtemp(); endasmcmd(); //todo long
  834.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  835. }
  836.  
  837. PROC emitloadrg0() //ЁхушёЄЁ єцх чрэ Є ўхЁхч getrfree
  838. {
  839.   emit0(_rnew); //Їыруш эх трцэ√
  840. }
  841.  
  842. PROC emitloadb() //ръъєьєы ЄюЁ єцх чрэ Є ўхЁхч getfreea
  843. {
  844.   asm_movs(); asm_rname(_rnew); asm_comma(); asm_direct(); asmmangledstr(_const); endasmcmd();
  845. }
  846.  
  847. PROC emitgetrg(BOOL high) //ЁхушёЄЁ єцх чрэ Є ўхЁхч getrfree
  848. {
  849.   emitloadrtemp(0x00,_joined);
  850.   asm_ldr(); asm_rname(_rnew); asm_comma(); asm_mrtemp(); endasmcmd(); //todo long
  851. }
  852.  
  853. PROC emitgetb() //ръъєьєы ЄюЁ єцх чрэ Є ўхЁхч getfreea
  854. {
  855.   emitloadrtemp(0x00,_joined);
  856.   asm_ldrb(); asm_rname(_rnew); asm_comma(); asm_mrtemp(); endasmcmd();
  857. }
  858.  
  859. PROC emitputrg(BOOL high) //ld [],new
  860. {
  861.   //_jpflag = 0x00;
  862.   emitloadrtemp(0x00,_joined);
  863.   asm_str(); asm_rname(_rnew); asm_comma(); asm_mrtemp(); endasmcmd(); //todo long
  864.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  865. }
  866.  
  867. PROC emitputb()
  868. {
  869.   //_jpflag = 0x00;
  870.   emitloadrtemp(0x00,_joined);
  871.   asm_strb(); asm_rname(_rnew); asm_comma(); asm_mrtemp(); endasmcmd();
  872.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  873. }
  874.  
  875. PROC emitshl1rg()
  876. {
  877.   asm_adds(); asm_rname(_rnew); asm_comma(); asm_rname(_rnew); endasmcmd();
  878. }
  879.  
  880. PROC emitshl1b()
  881. {
  882.   asm_adds(); asm_rname(_rnew); asm_comma(); asm_rname(_rnew); endasmcmd();
  883.   emitmaskb(_rnew);
  884. }
  885. /**
  886. PROC emitshr1rg(BYTE rnew)
  887. {
  888.   asmstr( "\tSRL " ); asm_rhigh(rnew); endasmcmd();
  889.   asmstr( "\tRR " ); asm_rlow(rnew); endasmcmd();
  890. }
  891.  
  892. PROC emitshr1signedrg(BYTE rnew)
  893. {
  894.   asmstr( "\tSRA " ); asm_rhigh(rnew); endasmcmd();
  895.   asmstr( "\tRR " ); asm_rlow(rnew); endasmcmd();
  896. }
  897. */
  898. //PROC emitshr1b(BYTE anew)
  899. //{
  900. //  asmstr( "\tSRL " ); /**rganame*/asm_rlow(anew] ); endasmcmd();
  901. //}
  902.  
  903. PROC emitinvb() //~A -> A
  904. {
  905.   asm_eors(); asm_rname(_rnew); asm_comma(); asm_rff(); endasmcmd();
  906. }
  907.  
  908. PROC emitinvrg()
  909. {
  910.   asm_mvns(); asm_rname(_rnew); asm_comma(); asm_rname(_rnew); endasmcmd();
  911. }
  912.  
  913. PROC emitnegrg()
  914. {
  915.   asm_rsbs(); asm_rname(_rnew); asm_comma(); asm_rname(_rnew); asm_comma(); asm_direct(); asmc('0'); endasmcmd();
  916. }
  917.  
  918. PROC emitSxorVtob() //яюёых subflags (less), ЁрчЁхчхЁтшЁєхЄ A
  919. { //todo яЁютхЁшЄ№
  920.   emit0(_rnew); //схч єёЄрэютъш Їыруют
  921.   asm_bgt(); asm_pc4_eol();
  922.   asm_eors(); asm_rname(_rnew); asm_comma(); asm_rff(); endasmcmd();
  923.   asm_endpc4();
  924. }
  925.  
  926. PROC emitinvSxorVtob() //яюёых subflags (moreeq), ЁрчЁхчхЁтшЁєхЄ A
  927. { //todo яЁютхЁшЄ№
  928.   //emit0(_rnew); //схч єёЄрэютъш Їыруют
  929.   //asm_blt(); asm_pc4_eol();
  930.   //asm_eors(); asm_rname(_rnew); asm_comma(); asm_rff(); endasmcmd();
  931.   asm_mov(); asm_rname(_rnew); asm_comma(); asm_rff(); endasmcmd();
  932.   asm_bgt(); asm_pc4_eol();
  933.   asm_eors(); asm_rname(_rnew); asm_comma(); asm_rff(); endasmcmd();
  934.   asm_endpc4();
  935. }
  936.  
  937. PROC emitxorrg() //old^new => old
  938. {
  939.   asm_eors(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  940.   _fused = +TRUE; //^^
  941. }
  942.  
  943. PROC getxorb() //RGA^RGA2 -> RGA
  944. {
  945.   asm_eors(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  946.   _fused = +TRUE; //^^
  947. }
  948.  
  949. PROC emitorrg() //old|new => old
  950. {
  951.   asm_ors(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  952.   _fused = +TRUE; //||
  953. }
  954.  
  955. PROC getorb() //RGA|RGA2 -> RGA
  956. {
  957.   asm_ors(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  958.   _fused = +TRUE; //||
  959. }
  960.  
  961. PROC emitandrg() //old&new => old
  962. {
  963.   asm_ands(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  964.   _fused = +TRUE; //&&
  965. }
  966.  
  967. PROC getandb() //RGA&RGA2 -> RGA
  968. {
  969.   asm_ands(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  970.   _fused = +TRUE; //&&
  971. }
  972.  
  973. PROC emitaddrg() //old+new => old
  974. {
  975.   asm_adds(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  976. }
  977.  
  978. PROC emitadcrg() //old+new => old
  979. {
  980.   asm_adcs(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  981. }
  982.  
  983. PROC emitaddb() //old+new
  984. {
  985.   asm_adds(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  986.   emitmaskb(_rold);
  987. }
  988.  
  989. PROC emitaddbconst() //new8+<const>
  990. {
  991.   asm_adds(); asm_rname(_rnew); asm_comma(); asm_direct(); asmmangledstr(_const); endasmcmd();
  992.   emitmaskb(_rnew);
  993. }
  994.  
  995. PROC emitsubrg() //old-new => old
  996. {
  997.   asm_subs(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  998. }
  999.  
  1000. PROC emitsbcrg() //old-new => old
  1001. {
  1002.   asm_sbcs(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  1003. }
  1004.  
  1005. PROC emitsubb() //old-new
  1006. {
  1007.   asm_subs(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  1008.   emitmaskb(_rold);
  1009. }
  1010.  
  1011. PROC emitsubbconst() //new8-<const>
  1012. {
  1013.   asm_subs(); asm_rname(_rnew); asm_comma(); asm_direct(); asmmangledstr(_const); endasmcmd();
  1014.   emitmaskb(_rnew);
  1015. }
  1016.  
  1017. PROC emitsubflags(BYTE rnew, BYTE rold) //r2-r1 => CY,sign,overflow
  1018. {
  1019.   asm_subs(); asm_rname(rold); asm_comma(); asm_rname(rnew); endasmcmd();
  1020.   _fused = +TRUE;
  1021. }
  1022.  
  1023. PROC emitsubbflags(BYTE anew, BYTE aold) //a2-a1 => CY
  1024. { //sign,overflow эх эєцхэ!
  1025.   asm_subs(); asm_rname(aold); asm_comma(); asm_rname(anew); endasmcmd();
  1026.   _fused = +TRUE;
  1027. }
  1028.  
  1029. PROC emitsubz() //old-new => Z
  1030. {
  1031.   asm_subs(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  1032.   _fused = +TRUE;
  1033. }
  1034.  
  1035. PROC emitsubbz() //old-new => Z
  1036. {
  1037.   asm_subs(); asm_rname(_rold); asm_comma(); asm_rname(_rnew); endasmcmd();
  1038.   _fused = +TRUE;
  1039. }
  1040.  
  1041. PROC emitsubbzconst() //new-<const> => Z
  1042. {
  1043.   asm_subs(); asm_rname(_rnew); asm_comma(); asm_direct(); asmmangledstr(_const); endasmcmd();
  1044.   _fused = +TRUE;
  1045. }
  1046.  
  1047. PROC emitsublongz() //old2-new, old3-old => Z
  1048. { //todo
  1049.   _fused = +TRUE;
  1050. }
  1051.  
  1052. PROC emitpokerg() //эютюх чряшё√трхь т ёЄрЁє■ ыюърЎш■ ярь Єш
  1053. {
  1054.   asm_str(); asm_rname(_rnew); asm_comma(); asm_mrname(_rold); endasmcmd();
  1055.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1056. }
  1057.  
  1058. PROC emitpokeb() //эютюх чряшё√трхь т ёЄрЁє■ ыюърЎш■ ярь Єш
  1059. {
  1060.   asm_strb(); asm_rname(_rnew); asm_comma(); asm_mrname(_rold); endasmcmd();
  1061.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1062. }
  1063.  
  1064. PROC emitpokelong() //old2(addr), old(high), new(low)
  1065. {
  1066.   asm_str(); asm_rname(_rnew); asm_comma(); asm_mrname(_rold2); endasmcmd();
  1067.   asm_adds(); asm_rname(_rold2); asm_comma(); asmstr("#4"); endasmcmd();
  1068.   asm_str(); asm_rname(_rold); asm_comma(); asm_mrname(_rold2); endasmcmd();
  1069.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1070. }
  1071.  
  1072. PROC emitpeekrg() //[new] => new
  1073. {
  1074.   asm_ldr(); asm_rname(_rnew); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1075. }
  1076.  
  1077. PROC emitpeekb()
  1078. {
  1079.   asm_ldrb(); asm_rname(_rnew); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1080. }
  1081.  
  1082. PROC emitpeeklong() //[old] => old(high),new(low)
  1083. {
  1084.   asm_ldr(); asm_rname(_rnew); asm_comma(); asm_mrname(_rold); endasmcmd();
  1085.   asm_adds(); asm_rname(_rold); asm_comma(); asmstr("#4"); endasmcmd();
  1086.   asm_ldr(); asm_rname(_rold); asm_comma(); asm_mrname(_rold); endasmcmd();
  1087. }
  1088.  
  1089. PROC emitztob()
  1090. {
  1091.   //asmstr(";emitztoa exprlvl="); asmuint(_exprlvl); endasmcmd();
  1092.   IF (_exprlvl != 0x01) { //if (a == b)
  1093.     emit0(_rnew); //схч єёЄрэютъш Їыруют
  1094.     asm_bne(); asm_pc4_eol();
  1095.     emitinvb();
  1096.     asm_endpc4();
  1097.     _fused = +FALSE; //шэрўх уы■ъ яЁш if ((a==b))
  1098.     //_jpflag = 0x00;
  1099.   }ELSE {
  1100.     //_fused = +TRUE;
  1101.     _jpflag = 0x02;
  1102.   };
  1103. }
  1104.  
  1105. PROC emitinvztob()
  1106. {
  1107.   //asmstr(";emitinvztoa exprlvl="); asmuint(_exprlvl); endasmcmd();
  1108.   IF (_exprlvl != 0x01) { //if (a != b)
  1109.     emit0(_rnew); //схч єёЄрэютъш Їыруют
  1110.     asm_beq(); asm_pc4_eol();
  1111.     emitinvb();
  1112.     asm_endpc4();
  1113.     _fused = +FALSE; //шэрўх уы■ъ яЁш if ((a!=b))? todo test //тючьюцхэ уы■ъ ifnot ((a!=b))
  1114.     //_jpflag = 0x00;
  1115.   }ELSE {
  1116.     //_fused = +TRUE;
  1117.     _jpflag = 0x01;
  1118.   };
  1119. }
  1120.  
  1121. PROC emitcytob()
  1122. {
  1123.   //asmstr(";emitcytoa exprlvl="); asmuint(_exprlvl); endasmcmd();
  1124.   IF (_exprlvl != 0x01) { //if (a < b)
  1125.     asm_sbcs(); asm_rname(_rnew); asm_comma(); asm_rname(_rnew); endasmcmd();
  1126.     //_fused = +FALSE;
  1127.     //_jpflag = 0x00;
  1128.   }ELSE {
  1129.     //_fused = +TRUE;
  1130.     _jpflag = 0x03;
  1131.   };
  1132. }
  1133.  
  1134. PROC emitinvcytob()
  1135. {
  1136.   //asmstr(";emitinvcytoa exprlvl="); asmuint(_exprlvl); endasmcmd();
  1137.   IF (_exprlvl != 0x01) { //if (a >= b)
  1138.     asm_sbcs(); asm_rname(_rnew); asm_comma(); asm_rname(_rnew); endasmcmd();
  1139.     asm_eors(); asm_rname(_rnew); asm_comma(); asm_rff(); endasmcmd();
  1140.     //_fused = +FALSE;
  1141.     //_jpflag = 0x00;
  1142.   }ELSE {
  1143.     //_fused = +TRUE;
  1144.     _jpflag = 0x04;
  1145.   };
  1146. }
  1147.  
  1148. PROC emitrgtob() //эхы№ч  єсшЁрЄ№ - ёяхЎшЇшўэю
  1149. {
  1150.   emitmaskb(_rnew); //todo эрюсюЁюЄ, шуэюЁшЁютрЄ№ ёЄ.ўрёЄ№ ёыютр, ъЁюьх ёЁртэхэшщ
  1151. }
  1152.  
  1153. PROC emitbtorg()
  1154. {
  1155. }
  1156.  
  1157. PROC emitincrg_byname()
  1158. {
  1159.   emitloadrtemp(_rnew,_joined);
  1160.   asm_ldr(); asm_rtemp(); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1161.   asm_adds(); asm_rtemp(); asm_comma(); asmstr("#1"); endasmcmd();
  1162.   asm_str(); asm_rtemp(); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1163.   //asm_adds(); asm_rname(_rnew); asm_comma(); asm_direct(); asmc('1'); endasmcmd();
  1164.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1165. }
  1166.  
  1167. PROC emitincb_bypoi()
  1168. {
  1169.   asm_ldrb(); asm_rtemp(); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1170.   asm_adds(); asm_rtemp(); asm_comma(); asmstr("#1"); endasmcmd();
  1171.   asm_strb(); asm_rtemp(); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1172.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1173. }
  1174. /**
  1175. PROC emitinclong() //todo
  1176. {
  1177.   asm_inc(); asm_open(); asm_rname(_rnew); asm_close(); endasmcmd();
  1178.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1179. }
  1180. */
  1181. PROC emitdecrg_byname()
  1182. {
  1183.   emitloadrtemp(_rnew,_joined);
  1184.   asm_ldr(); asm_rtemp(); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1185.   asm_subs(); asm_rtemp(); asm_comma(); asmstr("#1"); endasmcmd();
  1186.   asm_str(); asm_rtemp(); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1187.   //asm_subs(); asm_rname(_rnew); asm_comma(); asmstr("#1"); endasmcmd();
  1188.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1189. }
  1190.  
  1191. PROC emitdecb_bypoi()
  1192. {
  1193.   asm_ldrb(); asm_rtemp(); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1194.   asm_subs(); asm_rtemp(); asm_comma(); asmstr("#1"); endasmcmd();
  1195.   asm_strb(); asm_rtemp(); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1196.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1197. }
  1198. /**
  1199. PROC emitdeclong() //todo
  1200. {
  1201.   asm_dec(); asm_open(); asm_rname(_rnew); asm_close(); endasmcmd();
  1202.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1203. }
  1204. */
  1205.  
  1206. PROC emitincrg_bypoi() //[old], new free
  1207. {
  1208.   asm_ldr(); asm_rtemp(); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1209.   asm_adds(); asm_rtemp(); asm_comma(); asmstr("#1"); endasmcmd();
  1210.   asm_str(); asm_rtemp(); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1211.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1212. }
  1213.  
  1214. PROC emitdecrg_bypoi() //[old], new free
  1215. {
  1216.   asm_ldr(); asm_rtemp(); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1217.   asm_subs(); asm_rtemp(); asm_comma(); asmstr("#1"); endasmcmd();
  1218.   asm_str(); asm_rtemp(); asm_comma(); asm_mrname(_rnew); endasmcmd();
  1219.   _fused = +FALSE; //ъюэхЎ т√ўшёыхэш 
  1220. }
  1221.  
  1222. /////////////
  1223. EXPORT PROC initcode()
  1224. {
  1225. //  _wass = (PCHAR)_swass;
  1226.   _jpflag = 0x00;
  1227.   constindex = 0;
  1228.   asmcmds = 0;
  1229.   asmstr("\tALIGN 2"); endasm();
  1230. }
  1231.  
  1232. EXPORT PROC endcode()
  1233. {
  1234.   asmflushlabels();
  1235.   asmstr("\tEND"); endasmcmd();
  1236.   varstr("\tEND"); endvar();
  1237. }
  1238.  
  1239. PROC initrgs()
  1240. {
  1241.   rgs_initrgs();
  1242.   _fused = +FALSE; //ьюцэю ёфхырЄ№ юфэє яЁюЎхфєЁє initif фы  ¤Єюую (т√ч√трЄ№ т эрўрых if, while, until)
  1243. }
  1244.  
  1245. PROC emitfunchead()
  1246. {
  1247.   asm_push(); asmstr( "{LR}" ); endasmcmd();
  1248.   initrgs();
  1249. }
  1250.  
  1251. PROC setmainb()
  1252. {
  1253.   setmainrg(); //Ёхчєы№ЄрЄ т RMAIN
  1254. }
  1255.  
  1256. PROC prefernoregs()
  1257. {
  1258. }
  1259.  
  1260.