Subversion Repositories NedoOS

Rev

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

  1. //ЄюъхэшчрЄюЁ эх чэрхЄ ъюф√ ъюьрэф
  2. //ЄюъхэшчрЄюЁ эх яюфуы ф√трхЄ тяхЁ╕ф ш эх юЄьрЄ√трхЄ эрчрф
  3. //_asmwaseol ухэхЁшЁєхЄё  т asmrdword_tokspc(), р eol т√тюфшЄё  яюёых ъюьрэф√
  4.  
  5. //// imported
  6. #include "../_sdk/str.h"
  7. #include "../_sdk/io.h"
  8.  
  9. VAR UINT _curlnbeg; //эюьхЁ ёЄЁюъш эр ьюьхэЄ эрўрыр Єюъхэр //фы  read, emit
  10. VAR BOOL _cmts; //фы  read, emit
  11.  
  12. CONST BOOL _isalphanum[256];
  13. VAR CHAR txt_low[10];
  14.  
  15. EXTERN PCHAR _tword; //Єхъє∙хх ёыютю
  16. EXTERN UINT _lentword;
  17. //EXTERN CHAR _s0[_STRLEN]; //Єхъє∙хх ёыютю
  18.  
  19. EXTERN BOOL _waseof;
  20. EXTERN PBYTE _fin;
  21. EXTERN PBYTE _fout;
  22. FUNC BYTE readfin FORWARD();
  23.  
  24. EXTERN UINT _curline; //Єхъє∙шщ эюьхЁ ёЄЁюъш
  25. EXTERN UINT _waseols; //ўшёыю EOL ё яЁю°ыюую Ёрчр
  26. EXTERN UINT _spcsize; //ўшёыю яЁюсхыют яюёых яЁюўшЄрээющ ъюьрэф√
  27. EXTERN CHAR _cnext;
  28.  
  29. FUNC UINT stradd FORWARD(PCHAR s, UINT len, CHAR c);
  30. FUNC BOOL strcplow FORWARD(PCHAR s1, PCHAR s2);
  31.  
  32. PROC rdchcmt FORWARD();
  33. PROC rdch FORWARD();
  34. PROC rdquotes FORWARD(CHAR eol);
  35. PROC initrd FORWARD();
  36.  
  37. CONST BYTE _ASMMAXSPC;
  38.  
  39. PROC tokpre FORWARD(); //чряюыэшЄ№ ЄрсышЎє ьхЄюъ
  40.  
  41. ////
  42. VAR CHAR _c1small;
  43. VAR CHAR _c2small;
  44. VAR BOOL _asmwaseof;
  45. VAR UINT _asmwaseols; //ўшёыю EOL ё яЁю°ыюую Ёрчр
  46. VAR UINT _asmspcsize;
  47.  
  48. VAR CHAR _stokfn[_STRLEN]; //Єхъє∙хх ёыютю
  49. VAR PCHAR _tokfn; //Єхъє∙хх ёыютю
  50. VAR UINT _lentokfn;
  51.  
  52. VAR BYTE _temppar;
  53.  
  54. #define _TOKLBLBUFSIZE 0x1200
  55. VAR UINT _toklblbuffreestart; //[1];
  56. //VAR UINT _tokoldlblbuffreestart; //[1];
  57. CONST UINT _TOKLBLBUFEOF = 0xffff;
  58. //CONST UINT _TOKLBLBUFMAXSHIFT  = 0x1fb0/**(_LBLBUFSIZE-0x0100)*/; //0x3f00
  59. #define _TOKLBLBUFMAXSHIFT (UINT)(_TOKLBLBUFSIZE-_STRLEN-10)
  60. //todo фшэрьшўхёъш т√фхышЄ№
  61. VAR UINT _toklblshift[0x100];
  62. //VAR UINT _tokoldlblshift[0x100];
  63. VAR BYTE _toklbls[_TOKLBLBUFSIZE]; //0x4000
  64. VAR BYTE _toklblhash;
  65.  
  66. PROC rdaddwordall() //яюфъыхшЄ№ ёыхфє■∙є■ ъюьрэфє ъ Єхъє∙хщ
  67. {
  68.   _spcsize = 0; //ўшёыю яЁюсхыют яюёых яЁюўшЄрээющ ъюьрэф√
  69.   _waseols = 0;
  70.   _curlnbeg = _curline;
  71.  
  72.   IF (_isalphanum[(BYTE)_cnext] ) { //ёыютю ё ЎшЇЁюсєът√
  73.     REPEAT { //цф╕ь эхЎшЇЁюсєътє (EOF эх ЎшЇЁюсєътр)
  74.       IF (_lentword < _STRMAX) { //т рёьх шч ъюьяшы ЄюЁр тёх ёыютр ъюЁюўх, эю эх т Ёєўэюь рёьх
  75.         _tword[_lentword] = _cnext;
  76.         INC _lentword;
  77.       };
  78.       _cnext = (CHAR)readfin();
  79.     }UNTIL (!_isalphanum[(BYTE)_cnext]/** || _waseof*/ );
  80.   }ELSE { //ёыютю шч эхЎшЇЁюсєътхээюую ёшьтюыр - ўшЄрхь юфэє эхЎшЇЁюсєътє (шэрўх с√ эх ўшЄрыш)
  81.     //rdch(); //ўшЄрхь тё■ уЁєяяє фшхЁхчшёют + ёшьтюы ъръ юфшэ ёшьтюы
  82.     IF (_lentword < _STRMAX) { //т рёьх шч ъюьяшы ЄюЁр тёх ёыютр ъюЁюўх, эю эх т Ёєўэюь рёьх
  83.       _tword[_lentword] = _cnext;
  84.       INC _lentword;
  85.     };
  86.     _cnext = (CHAR)readfin();
  87.   }; //эхы№ч  яюфъыхшЄ№ ¤Єю єёыютшх ъ Ўшъыє, Є.ъ. юэю фы  шчэрўры№эюую cnext ш юфшэ Ёрч
  88.  
  89.   goto loopgo;
  90.   loop: //REPEAT { //цф╕ь эхфшхЁхчшё шыш EOF
  91.     _cnext = (CHAR)readfin();
  92.   loopgo:
  93.     IF ((BYTE)_cnext < (BYTE)'!') { //єёъюЁхэшх т√їюфр
  94.       INC _spcsize; //spaces after tword
  95.       IF ((BYTE)_cnext == 0x0a) {
  96.         INC _curline;
  97.         _spcsize = 0;
  98.         INC _waseols;
  99.       }ELSE IF ((BYTE)_cnext == 0x09) {
  100.         _spcsize = _spcsize + 7;
  101.       };
  102.       IF (!_waseof) goto loop;
  103.     };
  104.   //}UNTIL (_wasdieresis || _waseof );
  105.   _tword[_lentword] = '\0';
  106. }
  107. /**
  108. PROC rdwordall()
  109. //ўшЄрхь ёыютю _tword (шч ЄхъёЄр ё фшхЁхчшёрьш тьхёЄю яЁюсхыют, хэЄхЁют, Єрсєы Ўшщ)
  110. //ёыютю чрърэўштрхЄё , ъюуфр фшхЁхчшё шыш эхЎшЇЁюсєътхээ√щ ёшьтюы (юэ яюярф╕Є т cnext, р ъєЁёюЁ т Їрщых яюёых эхую)
  111. {
  112.   _lentword = 0; //strclear(_tword); //todo эрЁє°хэр ярЁэюёЄ№ clear..close
  113.   rdaddwordall();
  114. }
  115. */
  116. //////////////////
  117.  
  118. PROC asmtoken(BYTE token)
  119. {
  120.   writebyte(_fout, token);
  121. }
  122.  
  123. PROC tokspc()
  124. {
  125. //IF (!_waseol) { //уы■ъ эр ъюьрэфрї шч юфэюую ёыютр
  126.   WHILE (_asmspcsize > (UINT)_ASMMAXSPC) { //ўшёыю яЁюсхыют яюёых яЁюўшЄрээющ ъюьрэф√
  127.     asmtoken(+_TOKSPC0+_ASMMAXSPC);
  128.     _asmspcsize = _asmspcsize - (UINT)_ASMMAXSPC;
  129.   };
  130.   IF (_asmspcsize!=0) asmtoken(+_TOKSPC0 + (BYTE)_asmspcsize);
  131. //};
  132. }
  133.  
  134. PROC asmrdword_tokspc() //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ ъюьрэф√ ш ўшЄрхЄ эютє■
  135. //todo т√фртрЄ№ eol ъръ ъюьрэфє?
  136. {
  137.   _asmwaseof = _waseof;
  138.   _asmwaseols = _waseols;
  139.   _asmspcsize = _spcsize; //ўшёыю яЁюсхыют яюёых яЁюўшЄрээющ ъюьрэф√
  140.   IF (_waseols==0) tokspc(); //ЄюъхэшчшЁєхь яЁюсхы√ яюёых яЁю°ыющ ъюьрэф√ (шэрўх юЄъырф√трхь эр яюёых eol)
  141.   //rdwordall();
  142.   _lentword = 0/**strclear(_tword)*/; //todo эрЁє°хэр ярЁэюёЄ№ clear..close
  143.   rdaddwordall();
  144.   _c1small = (CHAR)((BYTE)(*(PCHAR)_tword)|0x20);
  145.   _c2small = (CHAR)((BYTE)_tword[1]|0x20);
  146. }
  147.  
  148. PROC toktext() //ухэхЁшЁєхЄ <text>text<endtext>
  149. {
  150.   asmtoken(+_TOKTEXT);
  151.   fputs(_tword, _fout);
  152.   asmtoken(+_TOKENDTEXT);
  153. }
  154.  
  155. //ёухэхЁшЁютрЄ№ Єюъхэ ю°шсъш ё ЄхъёЄрьш юЄё■фр фю ъюэЎр шэёЄЁєъЎшш/ёЄЁюъш (тъы■ўр  _tword)
  156. //тъы■ўр  яюёыхфэ■■ ъюьрэфє т ёЄЁюъх, ъюЄюЁр  ё waseol шыш ъюЄюЁр  ':'
  157. PROC tokerr(BYTE token)
  158. {
  159.   asmtoken(+_ERR);
  160.   asmtoken(token);
  161.   WHILE (+TRUE) {
  162.     toktext(); //ухэхЁшЁєхЄ <text>text<endtext>
  163.     IF ((_waseols!=0)||(_waseof)||(*(PCHAR)_tword==':')) BREAK;
  164.     asmrdword_tokspc();
  165.   }; //TODO т юфэє ёЄЁюъє
  166.   asmtoken(+_TOKENDERR);
  167.   asmrdword_tokspc(); //[ЄюъхэшчшЁєхЄ ъюэхўэ√х яЁюсхы√ шыш EOL,] схЁ╕Є ёыхфє■∙є■ ъюьрэфє (яюёых шэёЄЁєъЎшш)
  168.   //todo asmfmt_err?
  169. }
  170.  
  171. //ёухэхЁшЁютрЄ№ Єюъхэ ю°шсъш ё ЄхъёЄюь юЄё■фр фю ъюэЎр ёЄЁюъш (тъы■ўр  _tword)
  172. //шыш фю ъюэЎр ъюьрэф√???
  173. PROC tokerrcmd()
  174. {
  175.   tokerr(+_ERRCMD); //todo ёфхырЄ№ asmcmd_err...asmfmt_err тюъЁєу?
  176. }
  177.  
  178. PROC tokinitlblbuf()
  179. {
  180.   _toklblhash = 0x00;
  181.   REPEAT {
  182.     _toklblshift[_toklblhash] = _TOKLBLBUFEOF;
  183.     INC _toklblhash;
  184.   }UNTIL (_toklblhash == 0x00);
  185.   _toklblbuffreestart = 0;
  186. };
  187.  
  188. PROC tokcalllbl()
  189. {
  190. VAR PBYTE plbl; //ьхЄър т ЄрсышЎх чрърэўштрхЄё  эєы╕ь
  191. //VAR PBYTE pstr; //ьхЄър т ёЄЁюъх чрърэўштрхЄё  эєы╕ь
  192. //VAR BYTE cstr; //ёшьтюы шч ёЄЁюъш
  193. //VAR BYTE clbl; //ёшьтюы шч ЄрсышЎ√ ьхЄюъ
  194. //VAR BOOL res;
  195. VAR UINT plbl_idx;
  196. VAR PBYTE calladdr;
  197.   //res = +FALSE;
  198.   _toklblhash = (BYTE)hash((PBYTE)_tword);
  199.  
  200.   plbl_idx = _toklblshift[_toklblhash];
  201.   WHILE (plbl_idx != _TOKLBLBUFEOF) { //яюър Ўхяюўър ьхЄюъ эх чръюэўшырё№
  202.     plbl = &_toklbls[plbl_idx];
  203.     plbl_idx = *(PUINT)(plbl);
  204.     plbl = &plbl[+sizeof(UINT)/**+1*/]; //skip string size
  205.     IF (strcp((PCHAR)_tword, (PCHAR)plbl)) { //ьхЄър эрщфхэр
  206.       plbl = &plbl[10/**_lenname+1*/];
  207.       calladdr = (PBYTE)*(PLONG)(plbl); //todo PPOI
  208.       plbl = &plbl[+sizeof(LONG)]; //todo POI
  209.       _temppar = *(PBYTE)(plbl);
  210.       //INC plbl;
  211.       CALL (calladdr);
  212.       //res = +TRUE;
  213.       //BREAK;
  214.       goto e;
  215.     };
  216.   };
  217.   tokerrcmd(); //not found
  218.   e: ; //RETURN res;
  219. //asmtoken(0xfd);
  220. }
  221.  
  222. PROC tokaddlbl1(PCHAR txt, PBYTE proc, BYTE data)
  223. {
  224. VAR PBYTE plbl;
  225. //VAR UINT freestart_idx;
  226. //VAR UINT plbl_idx;
  227.   _toklblhash = (BYTE)hash((PBYTE)txt);
  228.  
  229.   //ьхЄъш эхЄ: яш°хь т эрўрыю Ўхяюўъш рфЁхё ъюэЎр ёЄЁрэшЎ√ ш ёючфр╕ь ьхЄъє Єрь ёю ёё√ыъющ эр ёЄрЁюх эрўрыю Ўхяюўъш
  230.   //freestart_idx = _toklblbuffreestart; //[0] //эрўрыю ётюсюфэюую ьхёЄр
  231.   //plbl_idx = _toklblbuffreestart; //[0] //freestart_idx; //єърчрЄхы№ эр эрўрыю фрээ√ї ёючфртрхьющ ьхЄъш (эрфю юс чрЄхы№эю чряюьэшЄ№!) //эрўрыю ётюсюфэюую ьхёЄр
  232.   plbl = &_toklbls[_toklblbuffreestart]; //[0] [plbl_idx]; //єърчрЄхы№ эр эрўрыю ёючфртрхьющ ьхЄъш //эрўрыю ётюсюфэюую ьхёЄр
  233.   //яш°хь ьхЄъє
  234.   POKE *(PUINT)(plbl) = _toklblshift[_toklblhash]; //ёЄрЁ√щ єърчрЄхы№ эр эрўрыю Ўхяюўъш
  235.   _toklblshift[_toklblhash] = _toklblbuffreestart; //[0] //freestart_idx; //эют√щ єърчрЄхы№ эр эрўрыю Ўхяюўъш //эрўрыю ётюсюфэюую ьхёЄр
  236.   plbl = &plbl[+sizeof(UINT)];
  237.   //POKE *(PBYTE)(plbl) = (BYTE)10/**(BYTE)_lenname*/;
  238.   //INC plbl;
  239.   strcopy(txt, 9/**_lenname*/, (PCHAR)plbl);
  240.   plbl = &plbl[10/**_lenname+1*/];
  241.   POKE *(PLONG)(plbl) = (LONG)proc; //todo PPOI
  242.   plbl = &plbl[+sizeof(LONG)]; //todo POI
  243.   POKE *(PBYTE)(plbl) = data;
  244.   //INC plbl;
  245.   //plbl_idx = (UINT)(plbl - _toklbls); //єърчрЄхы№ ъюэхЎ ёючфртрхьющ ьхЄъш
  246.   //_toklblshift[_toklblhash] = freestart_idx; //эют√щ єърчрЄхы№ эр эрўрыю Ўхяюўъш
  247.   //_toklblbuflen = _toklblbuflen + plbl_idx - freestart_idx;
  248.   _toklblbuffreestart = (UINT)(plbl - _toklbls) + 1; //єърчрЄхы№ ъюэхЎ ёючфртрхьющ ьхЄъш //plbl_idx; /**[0]*/
  249.   //INC _toklblcount;
  250. }
  251.  
  252. PROC stringdecapitalize(PCHAR s1, PCHAR s2)
  253. {
  254. VAR CHAR c;
  255.   loop:
  256.     c = *(PCHAR)s1;
  257.     IF (((BYTE)c>=(BYTE)'A') && ((BYTE)c<=(BYTE)'Z')) {
  258.       c = (CHAR)((BYTE)c | 0x20);
  259.     };
  260.     POKE *(PCHAR)(s2) = c;
  261.     INC s1;
  262.     INC s2;
  263.     IF (c != '\0') goto loop;
  264. }
  265.  
  266. PROC tokaddlbl(PCHAR txt, PBYTE proc, BYTE data)
  267. {
  268.   tokaddlbl1(txt, proc, data);
  269.   stringdecapitalize(txt, txt_low);
  270.   tokaddlbl1(txt_low, proc, data);
  271. }
  272.  
  273. //////////////////////////////////////
  274. //хёыш match ёЁрсюЄры, Єю _tword ё·хфрхЄё  (ўшЄрхЄё  ёыхфє■∙р ) ш т√тюфшЄё  ёююЄтхЄёЄтє■∙шщ Єюъхэ
  275. //хёыш эх ёЁрсюЄры, Єю _tword эх ё·хфрхЄё , ю°шсър эх т√фр╕Єё  (Єюы№ъю Їыру +FALSE)
  276. //хёыш ю°шсър, Єю ю°шсър эх т√фр╕Єё  (Єюы№ъю Їыру +FALSE)
  277.  
  278.     //reg ш rp ьюуєЄ тёЄЁхЄшЄ№ё  т юфэющ яючшЎшш т inc,dec,[ld],[add],[adc],[sbc]
  279.     //шэрўх ышсю reg (b,c,d,e,h,l,a,hx,lx,hy,ly, эю эх i,r!), ышсю rp (bc,de,hl,sp,ix,iy, эю эх af!)
  280.     //i,r ш af юсЁрсрЄ√трЄ№ юЄфхы№эю, Є.ъ. эрфю Єюы№ъю фы  эхъюЄюЁ√ї ъюьрэф, юёЄры№э√х ъюьрэф√ эх фюыцэ√ яЁютхЁ Є№ ¤Єє ю°шсъє яЁш ёрьющ ъюьяшы Ўшш
  281.  
  282. FUNC BOOL matchdirect()
  283. {
  284. VAR BOOL ok;
  285.   IF (*(PCHAR)_tword=='#') {
  286.     asmtoken(+_TOKDIRECT);
  287.     asmrdword_tokspc();
  288.     ok = +TRUE;
  289.   }ELSE ok = +FALSE;
  290. RETURN ok;
  291. }
  292.  
  293. FUNC BOOL matchcomma()
  294. {
  295. VAR BOOL ok;
  296.   IF (*(PCHAR)_tword==',') {
  297.     asmtoken(+_TOKCOMMA);
  298.     asmrdword_tokspc();
  299.     ok = +TRUE;
  300.   }ELSE ok = +FALSE;
  301. RETURN ok;
  302. }
  303.  
  304. FUNC BOOL matchprime()
  305. {
  306. VAR BOOL ok;
  307.   IF (*(PCHAR)_tword=='\'') {
  308.     asmtoken(+_TOKPRIMESYM);
  309.     asmrdword_tokspc();
  310.     ok = +TRUE;
  311.   }ELSE ok = +FALSE;
  312. RETURN ok;
  313. }
  314.  
  315. FUNC BOOL matchquote()
  316. {
  317. VAR BOOL ok;
  318.   IF (*(PCHAR)_tword=='\"') {
  319.     asmtoken(+_TOKDBLQUOTESYM);
  320.     //asmrdword_tokspc();
  321.     ok = +TRUE;
  322.   }ELSE ok = +FALSE;
  323. RETURN ok;
  324. }
  325.  
  326. FUNC BOOL matchreequ()
  327. {
  328. VAR BOOL ok;
  329.   IF ( (*(PCHAR)_tword=='=') || ((_c1small=='e')&&(_c2small=='q')) ) {
  330.     asmtoken(+_TOKEQUAL/**'='*/);
  331.     asmrdword_tokspc();
  332.     ok = +TRUE;
  333.   }ELSE ok = +FALSE;
  334. RETURN ok;
  335. }
  336.  
  337. FUNC BOOL matchopen()
  338. {
  339. VAR BOOL ok;
  340.   IF       (*(PCHAR)_tword=='(') {asmtoken(+_TOKOPEN); asmrdword_tokspc(); ok = +TRUE;
  341.   }ELSE IF (*(PCHAR)_tword=='[') {asmtoken(+_TOKOPENSQ); asmrdword_tokspc(); ok = +TRUE;
  342.   }ELSE ok = +FALSE;
  343. RETURN ok;
  344. }
  345.  
  346. FUNC BOOL matchclose()
  347. {
  348. VAR BOOL ok;
  349.   IF       (*(PCHAR)_tword==')') {asmtoken(+_TOKCLOSE); asmrdword_tokspc(); ok = +TRUE;
  350.   }ELSE IF (*(PCHAR)_tword==']') {asmtoken(+_TOKCLOSESQ); asmrdword_tokspc(); ok = +TRUE;
  351.   }ELSE ok = +FALSE;
  352. RETURN ok;
  353. }
  354.  
  355. //////////////////////////////////////
  356. FUNC BOOL tokexpr RECURSIVE FORWARD();
  357.  
  358. PROC eatlabel(BYTE token)
  359. {
  360.   WHILE ((_cnext=='.')||(_cnext=='#')) {
  361.     rdaddwordall(); //яЁшъыхшЄ№ Єюўъє
  362.     IF (_spcsize==0)
  363.       IF (_isalphanum[(BYTE)_cnext]) //с√ыю isalpha
  364.         IF (_waseols==0)
  365.           //IF (!_waseof)
  366.             rdaddwordall(); //яЁшъыхшЄ№ ёыхфє■∙хх ёыютю
  367.   };
  368.   asmtoken(token/**_TOKLABEL шыш _CMDLABEL*/);
  369.   asmtoken(+_TOKTEXT);
  370.   fputs(_tword, _fout);
  371.   asmtoken(+_TOKENDTEXT);
  372.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  373.   //хёыш ьхЄър с√ыр яюёыхфэшь ёыютюь т ёЄЁюъх, Єюуфр ¤Єющ ЄюъхэшчрЎшхщ ь√ чрс√ыш с√ яЁю хэЄхЁ (юэ ЄхяхЁ№ т _asmwaseol)
  374. }
  375.  
  376. PROC eatval RECURSIVE() //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш  (ёъюсър, чря Єр , ъюэхЎ ёЄЁюъш)
  377. //<val>::=
  378. //(<expr>) //т√Ёрцхэшх (т√ўшёы хЄё )
  379. //|<num> //фхё Єшўэюх ўшёыю (яхЁхфр╕Єё  Ўхышъюь)
  380. //|<var> //ьхЄър шыш ярЁрьхЄЁ ьръЁюёр (TODO эх ёююЄтхЄёЄтєхЄ  ч√ъє: Єрь ¤Єю &<var>)
  381. //|$
  382. //|'CHAR' //ёшьтюы№эр  ъюэёЄрэЄр
  383. //|-<val> //т√ўшёышЄ№ val, яюЄюь ёфхырЄ№ NEG
  384. //|+<val> //т√ўшёышЄ№ val
  385. //|~<val> //т√ўшёышЄ№ val, яюЄюь ёфхырЄ№ INV
  386. //|!<val> //т√ўшёышЄ№ val, яюЄюь ёфхырЄ№ INV(BOOL)
  387. //|*<val> //яЁюўшЄрЄ№ ярь Є№ яю рфЁхёє (т√ўшёышЄ№ val, яюЄюь ёфхырЄ№ PEEK)
  388. { //ъюьрэфр єцх яЁюўшЄрэр
  389. VAR CHAR opsym;
  390. {
  391.   opsym = *(PCHAR)_tword;
  392.   IF (!_asmwaseof) { //чр∙шЄр юЄ чрЎшъыштрэш  т ъюэЎх ю°шсюўэюую Їрщыр
  393.     IF ((BYTE)((BYTE)opsym - (BYTE)'0') < 0x0a) { //<num> //т√фр╕Є <num><text>digits<endtext> //extra BYTE for C bug
  394.       asmtoken(+_TOKNUM);
  395.       asmtoken(+_TOKTEXT);
  396. //for float:
  397.       IF (_cnext=='.') {
  398.         rdaddwordall(); //яЁшъыхшЄ№ Єюўъє
  399.         rdaddwordall(); //яЁшъыхшЄ№ фЁюсэє■ ўрёЄ№
  400.         IF ( (_tword[_lentword-1]=='e') && (_cnext=='-') ) {
  401.           rdaddwordall(); //яЁшъыхшЄ№ '-' юЄЁшЎрЄхы№эющ ¤ъёяюэхэЄ√
  402.           rdaddwordall(); //яЁшъыхшЄ№ юЄЁшЎрЄхы№эє■ ¤ъёяюэхэЄє
  403.         };
  404. /*        asmrdword_tokspc();
  405.         fputs(_tword, _fout);
  406.         asmrdword_tokspc();*/ //todo e-12
  407.       };
  408.       fputs(_tword, _fout);
  409.       asmtoken(+_TOKENDTEXT);
  410.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  411.       //хёыш ўшёыю с√ыю яюёыхфэшь ёыютюь т ёЄЁюъх, Єюуфр ¤Єющ ЄюъхэшчрЎшхщ ь√ чрс√ыш с√ яЁю хэЄхЁ (юэ ЄхяхЁ№ т _asmwaseol)
  412.     }ELSE IF (_isalphanum[(BYTE)opsym] || (opsym=='.') ) { //todo єсЁрЄ№ '.', хёыш чряЁхЄшЄ№ эрўшэрЄ№ ьхЄъш ё Єюўъш //с√ыю isalpha
  413.       eatlabel(+_TOKLABEL);
  414.     }ELSE IF ( opsym=='$' ) {
  415.       asmtoken(+_TOKDOLLAR);
  416.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  417.     }ELSE IF ( opsym=='(' ) {
  418.       asmtoken(+_TOKOPEN);
  419.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  420.       tokexpr(); //ЁхъєЁёш  //эр т√їюфх шч expr єцх яЁюўшЄрэр ')', эю ёыхфє■∙шщ ёшьтюы шыш ъюьрэфр эх яЁюўшЄрэ√
  421.       asmtoken(+_TOKCLOSE);
  422.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  423.     }ELSE IF ( opsym=='\'' ) { //todo тёЄртшЄ№ TOK_TEXT...TOK_ENDTEXT
  424.       asmtoken(+_TOKPRIME);
  425.       _lentword = 0/**strclear(_tword)*/; //ўшЄрхь ё яєёЄющ ёЄЁюъш
  426.       rdquotes('\''/**, +FALSE*/);
  427.       toktext(); //ухэхЁшЁєхЄ <text>text<endtext>
  428.       rdch(); //яЁюяєёЄшЄ№ чръЁ√тр■∙є■ ърт√ўъє
  429.       asmtoken(+_TOKPRIME);
  430.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  431.     }ELSE IF ( opsym=='-' ) {
  432.       asmtoken(+_OPPUSH0); asmtoken(+_TOKMINUS/**'-'*/);
  433.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  434.       eatval(); //ЁхъєЁёштэ√щ т√чют val
  435.       asmtoken(+_OPSUB);
  436.     }ELSE IF ( opsym=='+' ) {
  437.       asmtoken(+_OPPUSH0); asmtoken(+_TOKPLUS/**'+'*/);
  438.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  439.       eatval(); //ЁхъєЁёштэ√щ т√чют val
  440.       asmtoken(+_OPADD);
  441.     }ELSE IF ( opsym=='*' ) {
  442.       asmtoken(+_OPPUSH0); asmtoken(+_TOKSTAR/**'*'*/);
  443.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  444.       eatval(); //ЁхъєЁёштэ√щ т√чют val
  445.       asmtoken(+_OPPEEK);
  446.     }ELSE IF ( opsym=='~' ) {
  447.       asmtoken(+_OPPUSH0); asmtoken(+_TOKTILDE);
  448.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  449.       eatval(); //ЁхъєЁёштэ√щ т√чют val
  450.       asmtoken(+_OPINV);
  451.     }ELSE IF ( opsym=='!' ) {
  452.       asmtoken(+_OPPUSH0); asmtoken(+_TOKEXCL);
  453.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  454.       eatval(); //ЁхъєЁёштэ√щ т√чют val
  455.       asmtoken(+_OPINV); //todo BOOL
  456.     }ELSE { tokerr(+_ERREXPR);/**errstr( ">>>WRONG PREFIX " ); err( opsym ); enderr();*/ };
  457.   };
  458. }
  459. }
  460.  
  461. PROC eatmul()
  462. {
  463.   /**asmtoken(_ASMOPPUSHSKIP1);*/ asmtoken(+_TOKSTAR/**'*'*/);
  464.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  465.   eatval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  466.   asmtoken(+_OPMUL);
  467. }
  468.  
  469. PROC eatdiv()
  470. {
  471.   /**asmtoken(_ASMOPPUSHSKIP1);*/ asmtoken(+_TOKSLASH/**'/'*/);
  472.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  473.   eatval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  474.   asmtoken(+_OPDIV);
  475. }
  476.  
  477. PROC eatand()
  478. {
  479.   /**asmtoken(_ASMOPPUSHSKIP1);*/ asmtoken(+_TOKAND/**'&'*/);
  480.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  481.   eatval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  482.   asmtoken(+_OPAND);
  483. }
  484.  
  485. PROC eatandbool()
  486. {
  487.   /**asmtoken(_ASMOPPUSHSKIP2);*/ asmtoken(+_TOKAND/**'&'*/); asmtoken(+_TOKAND/**'&'*/);
  488.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  489.   eatval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  490.   asmtoken(+_OPAND);
  491. }
  492.  
  493. PROC eatmulval RECURSIVE() //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш  (ёъюсър, чря Єр , ъюэхЎ ёЄЁюъш)
  494. { //ъюьрэфр єцх яЁюўшЄрэр
  495. VAR CHAR opsym;
  496. VAR BOOL dbl;
  497. {
  498.   eatval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  499.   WHILE ((!_asmwaseof)&&(_asmwaseols==0)) { //єцх яЁюўшЄрэр юяхЁрЎш  ш яЁюсхы√-хэЄхЁ√ яюёых эх╕ (_asmwaseol - хэЄхЁ яюёых val)
  500.     opsym=*(PCHAR)_tword;
  501.     dbl = (opsym=='&')&&(_cnext==opsym); //C compatibility
  502.     IF (dbl) asmrdword_tokspc(); //use '&' //C compatibility
  503.     IF       (opsym=='*') {eatmul();
  504.     }ELSE IF (opsym=='/') {eatdiv();
  505.     }ELSE IF (opsym=='&') {
  506.       IF (dbl) {eatandbool();
  507.       }ELSE eatand();
  508.     }ELSE BREAK;
  509.   };
  510. }
  511. }
  512.  
  513. PROC eatadd()
  514. {
  515.   /**asmtoken(_ASMOPPUSHSKIP1);*/ asmtoken(+_TOKPLUS/**'+'*/);
  516.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  517.   eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  518.   asmtoken(+_OPADD);
  519. }
  520.  
  521. PROC eatsub()
  522. {
  523.   /**asmtoken(_ASMOPPUSHSKIP1);*/ asmtoken(+_TOKMINUS/**'-'*/);
  524.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  525.   eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  526.   asmtoken(+_OPSUB);
  527. }
  528.  
  529. PROC eator()
  530. {
  531.   /**asmtoken(_ASMOPPUSHSKIP1);*/ asmtoken(+_TOKPIPE/**'|'*/);
  532.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  533.   eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  534.   asmtoken(+_OPOR);
  535. }
  536.  
  537. PROC eatorbool()
  538. {
  539.   /**asmtoken(_ASMOPPUSHSKIP2);*/ asmtoken(+_TOKPIPE/**'|'*/); asmtoken(+_TOKPIPE/**'|'*/);
  540.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  541.   eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  542.   asmtoken(+_OPOR);
  543. }
  544.  
  545. PROC eatxor()
  546. {
  547.   /**asmtoken(_ASMOPPUSHSKIP1);*/ asmtoken(+_TOKCARON/**'^'*/);
  548.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  549.   eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  550.   asmtoken(+_OPXOR);
  551. }
  552.  
  553. PROC eatxorbool()
  554. {
  555.   /**asmtoken(_ASMOPPUSHSKIP2);*/ asmtoken(+_TOKCARON/**'^'*/); asmtoken(+_TOKCARON/**'^'*/);
  556.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  557.   eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  558.   asmtoken(+_OPXOR);
  559. }
  560.  
  561. PROC eatsumval RECURSIVE() //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш  (ёъюсър, чря Єр , ъюэхЎ ёЄЁюъш)
  562. { //ъюьрэфр єцх яЁюўшЄрэр
  563. VAR CHAR opsym;
  564. VAR BOOL dbl;
  565. {
  566.   eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  567.   WHILE ((!_asmwaseof)&&(_asmwaseols==0)) { //єцх яЁюўшЄрэр юяхЁрЎш  ш яЁюсхы√-хэЄхЁ√ яюёых эх╕ (_asmwaseol - хэЄхЁ яюёых val)
  568.     opsym=*(PCHAR)_tword;
  569.     dbl = ( (opsym=='|')||(opsym=='^') )&&(_cnext==opsym); //C compatibility
  570.     IF (dbl) asmrdword_tokspc(); //use '|' or '^' //C compatibility
  571.     IF (opsym=='+') {eatadd();
  572.     }ELSE IF (opsym=='-') {eatsub();
  573.     }ELSE IF (opsym=='|') {
  574.       IF (dbl) {eatorbool();
  575.       }ELSE eator();
  576.     }ELSE IF (opsym=='^') {
  577.       IF (dbl) {eatxorbool();
  578.       }ELSE eatxor();
  579.     }ELSE BREAK;
  580.   };
  581. }
  582. }
  583.  
  584. PROC eatshl()
  585. {
  586.   /**asmtoken(_ASMOPPUSHSKIP2);*/ asmtoken(+_TOKLESS/**'<'*/); asmtoken(+_TOKLESS/**'<'*/);
  587.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  588.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  589.   asmtoken(+_OPSHL);
  590. }
  591.  
  592. PROC eatshr()
  593. {
  594.   /**asmtoken(_ASMOPPUSHSKIP2);*/ asmtoken(+_TOKMORE/**'>'*/); asmtoken(+_TOKMORE/**'>'*/);
  595.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  596.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  597.   asmtoken(+_OPSHR);
  598. }
  599.  
  600. PROC eatless()
  601. {
  602.   asmtoken(+_TOKLESS);
  603.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  604.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  605.   asmtoken(+_OPLESS);
  606. }
  607.  
  608. PROC eatlesseq()
  609. {
  610.   asmtoken(+_TOKLESS); asmtoken(+_TOKEQUAL);
  611.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  612.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  613.   asmtoken(+_OPLESSEQ);
  614. }
  615.  
  616. PROC eatmore()
  617. {
  618.   asmtoken(+_TOKMORE);
  619.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  620.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  621.   asmtoken(+_OPMORE);
  622. }
  623.  
  624. PROC eatmoreeq()
  625. {
  626.   asmtoken(+_TOKMORE); asmtoken(+_TOKEQUAL);
  627.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  628.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  629.   asmtoken(+_OPMOREEQ);
  630. }
  631.  
  632. PROC eateq()
  633. {
  634.   asmtoken(+_TOKEQUAL); asmtoken(+_TOKEQUAL);
  635.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  636.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  637.   asmtoken(+_OPEQ);
  638. }
  639.  
  640. PROC eatnoteq()
  641. {
  642.   asmtoken(+_TOKEXCL); asmtoken(+_TOKEQUAL);
  643.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  644.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  645.   asmtoken(+_OPNOTEQ);
  646. }
  647.  
  648. FUNC BOOL tokexpr RECURSIVE() //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш  (ёъюсър, чря Єр , ъюэхЎ ёЄЁюъш)
  649. { //ъюьрэфр єцх яЁюўшЄрэр
  650. VAR CHAR opsym;
  651. VAR BOOL modified;
  652. VAR BOOL dbl;
  653. //VAR BOOL ok;
  654. {
  655.   //ok = +TRUE;
  656.   matchdirect(); //яЁюяєёъ '#'
  657.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  658.   WHILE ((!_asmwaseof)&&(_asmwaseols==0)) { //єцх яЁюўшЄрэр юяхЁрЎш  ш яЁюсхы√-хэЄхЁ√ яюёых эх╕ (_asmwaseol - хэЄхЁ яюёых val)
  659.     opsym = *(PCHAR)_tword;
  660.     modified = (_cnext=='=');
  661.     dbl = (_cnext==opsym);
  662.     IF (modified||dbl) asmrdword_tokspc(); //use '=' or '>' or '<'
  663.     IF (opsym=='<') {
  664.       IF (dbl) {eatshl(); //ёЄрЁюх ёфтшэєЄ№ ёЄюы№ъю Ёрч, ёъюы№ъю уырёшЄ эютюх!
  665.       }ELSE IF (modified) {eatlesseq();
  666.       }ELSE {eatless();
  667.       };
  668.     }ELSE IF (opsym=='>') {
  669.       IF (dbl) {eatshr(); //ёЄрЁюх ёфтшэєЄ№ ёЄюы№ъю Ёрч, ёъюы№ъю уырёшЄ эютюх!
  670.       }ELSE IF (modified) {eatmoreeq();
  671.       }ELSE {eatmore();
  672.       };
  673.     }ELSE IF (opsym=='=') {eateq();
  674.     }ELSE IF (opsym=='!') {eatnoteq();
  675.     }ELSE BREAK;
  676.   };
  677.   RETURN +TRUE; //ok; //todo err
  678. }
  679. }
  680.  
  681. FUNC BOOL tokexpr_close() //яюёых эхую эшўхую сюы№°х эхы№ч  яЁютхЁ Є№, Є.ъ. ъєЁёюЁ ьюу ёфтшэєЄ№ё 
  682. {
  683. VAR BOOL ok;
  684.   ok = tokexpr();
  685.   IF (ok) ok = matchclose();
  686.   RETURN ok;
  687. }
  688.  
  689. PROC asm_direct_expr_close_token(BYTE token)
  690. {
  691.   //if(matchdirect()) {
  692.     IF (tokexpr()) {
  693.       IF (matchclose()) {asmtoken(token);
  694.       }ELSE tokerr(+_ERRCLOSE); //no closing bracket
  695.     }ELSE tokerr(+_ERREXPR); //wrong expr
  696.   //}else tokerr(_ERRPAR); //no direct
  697. }
  698.  
  699. PROC tokcomment()
  700. {
  701.   asmtoken(+_TOKCOMMENT);
  702.   _lentword = 0/**strclear(_tword)*/; //ўшЄрхь ё яєёЄющ ёЄЁюъш
  703.   IF (_waseols==0) { //юсїюф эр ёыєўрщ ъюэхўэюую ; яхЁхф ъюьрэфющ
  704.     WHILE (_spcsize != 0) { //фюсртшЄ№ ё·хфхээ√х яЁюсхы√
  705.       _lentword = stradd(_tword, _lentword, ' ');
  706.       DEC _spcsize;
  707.     };
  708.     WHILE (_waseols==0/**&&(!_waseof)*//**&&(_cnext!=_DIERESIS)*/) {
  709.       rdchcmt(); //яЁюяєёърхЄ тёх хэЄхЁ√
  710.     };
  711.   };
  712.   _tword[_lentword] = '\0';
  713.   toktext(); //ухэхЁшЁєхЄ <text>text<endtext>
  714.   asmtoken(+_TOKENDCOMMENT);
  715.   IF ((BYTE)_cnext < (BYTE)'!') {
  716.     IF (_cnext == '\t') {
  717.       _spcsize = _spcsize + 8;
  718.     }ELSE {
  719.       INC _spcsize;
  720.     };
  721.     rdch(); //ўшЄрхь тё■ уЁєяяє фшхЁхчшёют + ёшьтюы ъръ юфшэ ёшьтюы
  722.   };
  723.   asmrdword_tokspc(); //[ЄюъхэшчшЁєхЄ ъюэхўэ√х яЁюсхы√ шыш EOL,] схЁ╕Є ёыхфє■∙є■ ъюьрэфє (яюёых шэёЄЁєъЎшш)
  724. }
  725.  
  726. PROC tokorg()
  727. {
  728.   asmtoken(+_CMDORG);
  729.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  730.   IF (tokexpr()) {asmtoken(+_FMTCMD);
  731.   }ELSE tokerr(+_ERREXPR); //wrong expr
  732. }
  733.  
  734. PROC tokalign()
  735. {
  736.   asmtoken(+_CMDALIGN);
  737.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  738.   IF (tokexpr()) {asmtoken(+_FMTCMD);
  739.   }ELSE tokerr(+_ERREXPR); //wrong expr
  740. }
  741. /**
  742. PROC tokpage()
  743. {
  744.   tokerrcmd();
  745. }
  746.  
  747. PROC tokif()
  748. {
  749.   asmtoken(+_CMDIF);
  750.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  751.   IF (tokexpr()) {asmtoken(+_FMTCMD);
  752.   }ELSE tokerr(+_ERREXPR); //wrong expr
  753.   //tokerrcmd();
  754. }
  755.  
  756. PROC tokelse()
  757. {
  758.   asmtoken(+_CMDELSE);
  759.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  760.   //tokerrcmd();
  761. }
  762.  
  763. PROC tokendif()
  764. {
  765.   asmtoken(+_CMDENDIF);
  766.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  767.   //tokerrcmd();
  768. }
  769.  
  770. PROC tokdup()
  771. {
  772.   tokerrcmd();
  773. }
  774.  
  775. PROC tokedup()
  776. {
  777.   tokerrcmd();
  778. }
  779.  
  780. PROC tokmacro()
  781. {
  782.   tokerrcmd();
  783. }
  784.  
  785. PROC tokendm()
  786. {
  787.   tokerrcmd();
  788. }
  789. */
  790. PROC tokexport()
  791. {
  792.   asmtoken(+_CMDEXPORT);
  793.   asmrdword_tokspc(); //ё·хфрхь call
  794.   eatlabel(+_TOKLABEL);
  795.   //asmmtoken(+_TOKTEXT);
  796.   //fputs(_tword, _fout);
  797.   //asmtoken(+_TOKENDTEXT);
  798.   //asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  799.   asmtoken(+_FMTCMD); //ўЄюс√ шёяюы№чютрЄ№ label
  800. }
  801. /**
  802. PROC toklocal()
  803. {
  804.   tokerrcmd();
  805. }
  806.  
  807. PROC tokendl()
  808. {
  809.   tokerrcmd();
  810. }
  811.  
  812. PROC tokdisp()
  813. {
  814.   asmtoken(+_CMDDISP);
  815.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  816.   IF (tokexpr()) {asmtoken(+_FMTCMD);
  817.   }ELSE tokerr(+_ERREXPR); //wrong expr
  818. }
  819.  
  820. PROC tokent()
  821. {
  822.   asmtoken(+_CMDENT);
  823.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  824.   asmtoken(+_FMTCMD);
  825. }
  826. */
  827. PROC tokinclude()
  828. {
  829.   asmtoken(+_CMDINCLUDE);
  830.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  831.   IF (matchquote()) {
  832.     //asmtoken(+_OPWRSTR);
  833.     _lentword = 0/**strclear(_tword)*/; //ўшЄрхь ё яєёЄющ ёЄЁюъш
  834.     rdquotes('\"');
  835.     toktext(); //ухэхЁшЁєхЄ <text>text<endtext>
  836.     rdch(); //яЁюяєёЄшЄ№ чръЁ√тр■∙є■ ърт√ўъє
  837.     asmtoken(+_TOKDBLQUOTESYM);
  838.     asmrdword_tokspc();
  839.   }ELSE tokerr(+_ERREXPR);
  840.   //asmtoken(+_FMTCMD); //todo?
  841. }
  842.  
  843. PROC tokincbin()
  844. {
  845.   asmtoken(+_CMDINCBIN);
  846.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  847.   IF (matchquote()) {
  848.     //asmtoken(+_OPWRSTR);
  849.     _lentword = 0/**strclear(_tword)*/; //ўшЄрхь ё яєёЄющ ёЄЁюъш
  850.     rdquotes('\"');
  851.     toktext(); //ухэхЁшЁєхЄ <text>text<endtext>
  852.     rdch(); //яЁюяєёЄшЄ№ чръЁ√тр■∙є■ ърт√ўъє
  853.     asmtoken(+_TOKDBLQUOTESYM);
  854.     asmrdword_tokspc();
  855.   }ELSE tokerr(+_ERREXPR);
  856.   //todo ярЁрьхЄЁ√ (яЁюяєёъ, фышэр)
  857.   //asmtoken(+_FMTCMD); //todo?
  858. }
  859.  
  860. PROC tokdb()
  861. {
  862.   asmtoken(+_CMDDB);
  863.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  864.   REPEAT {
  865.     IF (matchquote()) {
  866.       asmtoken(+_OPWRSTR);
  867.       _lentword = 0/**strclear(_tword)*/; //ўшЄрхь ё яєёЄющ ёЄЁюъш
  868.       rdquotes('\"');
  869.       toktext(); //ухэхЁшЁєхЄ <text>text<endtext>
  870.       rdch(); //яЁюяєёЄшЄ№ чръЁ√тр■∙є■ ърт√ўъє
  871.       asmtoken(+_TOKDBLQUOTESYM);
  872.       asmrdword_tokspc();
  873.     }ELSE IF (tokexpr()) {
  874.       asmtoken(+_OPWRVAL);
  875.     }ELSE tokerr(+_ERREXPR);
  876.   }UNTIL (!matchcomma());
  877.   asmtoken(+_FMTCMD);
  878. }
  879.  
  880. PROC tokdw()
  881. {
  882.   asmtoken(+_CMDDW);
  883.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  884.   REPEAT {
  885.     tokexpr();
  886.     asmtoken(+_OPWRVAL);
  887.   }UNTIL (!matchcomma());
  888.   asmtoken(+_FMTCMD);
  889. }
  890.  
  891. PROC tokdl()
  892. {
  893.   asmtoken(+_CMDDL);
  894.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  895.   REPEAT {
  896.     tokexpr();
  897.     asmtoken(+_OPWRVAL);
  898.   }UNTIL (!matchcomma());
  899.   asmtoken(+_FMTCMD);
  900. }
  901.  
  902. PROC tokds()
  903. {
  904.   asmtoken(+_CMDDS);
  905.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  906.   tokexpr();
  907.   WHILE (matchcomma()) {
  908.     tokexpr();
  909.   };
  910.   asmtoken(+_FMTCMD);
  911. }
  912. /**
  913. PROC tokdisplay()
  914. {
  915.   tokerrcmd();
  916. }
  917.  
  918. PROC tokrepeat()
  919. {
  920.   tokerrcmd();
  921. }
  922.  
  923. PROC tokuntil()
  924. {
  925.   tokerrcmd();
  926. }
  927.  
  928. PROC tokstruct()
  929. {
  930.   tokerrcmd();
  931. }
  932.  
  933. PROC tokendstruct()
  934. {
  935.   tokerrcmd();
  936. }
  937. */
  938. PROC tokcolon()
  939. {
  940.   asmtoken(+_TOKCOLON);
  941.   asmrdword_tokspc(); //ё·хфрхь ':'
  942. }
  943.  
  944. ///////////////////////
  945.  
  946. PROC tokcmd()
  947. {
  948.   //_asmwaseof=_waseof;
  949.   //rdword_tokspc(); //яЁюўшЄрэю т яЁхф√фє∙хщ шэёЄЁєъЎшш
  950.   //stringdecapitalize(_tword,_lentword);
  951.   IF (*(PCHAR)_tword==';') {tokcomment();
  952. /**  }ELSE IF (*(PCHAR)_tword==':') {
  953.     asmtoken(+_TOKCOLON);
  954.     asmrdword_tokspc(); //ё·хфрхь ':'
  955. */
  956.   }ELSE IF (_asmspcsize!=0) {
  957.     //tokasm(); //assembly mnemonic or directive
  958.     tokcalllbl();
  959. /**    IF (!tokcalllbl(_tword)) {
  960.       tokerrcmd(); //wrong _tword
  961.     };*/
  962.   }ELSE { //<label> шыш <label>=<expr>
  963.     //asmtoken(0xff);
  964.     eatlabel(+_CMDLABEL); //ё·хфрхь ьхЄъє
  965.     IF (matchreequ()) { //<label>=<expr>
  966.       IF (tokexpr()) {
  967.         asmtoken(+_FMTREEQU);
  968.       }ELSE tokerr(+_ERREXPR); //wrong expr
  969.     }ELSE //IF ((_asmwaseols!=0)||(_asmwaseof)||(*(PCHAR)_tword==':')||(*(PCHAR)_tword==';')){ //<label>
  970.       asmtoken(+_FMTCMD); //<label>
  971.     //}ELSE tokerrcmd(); //wrong _tword
  972.   };
  973.   //яш°хь eol ш яЁюсхы√, ъюЄюЁ√х эх чряшёрыш яЁш ўЄхэшш ъюэхўэюую ёыютр
  974.   IF (_asmwaseols!=0) {
  975.     WHILE (_asmwaseols!=0) {
  976.       asmtoken(+_TOKEOL);
  977.       DEC _asmwaseols;
  978.     };
  979.     tokspc(); //ЄюъхэшчшЁєхь яЁюсхы√ яюёых
  980.   };
  981. }
  982.  
  983. PROC tokinit()
  984. {
  985.   _tokfn = (PCHAR)_stokfn;
  986.   tokinitlblbuf();
  987.   tokpre(); //чряюыэшЄ№ ЄрсышЎє ьхЄюъ
  988. }
  989.  
  990. PROC tokenize(PCHAR fn)
  991. {
  992. VAR UINT i;
  993.   _fin = nfopen(fn, "rb");
  994.   IF (_fin != (PBYTE)0) {
  995.     _waseof = +FALSE;
  996.     _curline = 1;
  997.     initrd();
  998.  
  999.     _lentokfn = 0;
  1000.     i = 0;
  1001.     WHILE (fn[_lentokfn] != '\0') {
  1002.       _tokfn[_lentokfn] = fn[_lentokfn];
  1003.       IF (fn[_lentokfn] == '.') i = _lentokfn;
  1004.       INC _lentokfn;
  1005.     };
  1006.     //_lentokfn = strjoineol(_tokfn, 0, fn, '.'); //terminator is not copied
  1007.     //_lentokfn = stradd(_tokfn, _lentokfn, '.');
  1008.     _lentokfn = i+1; //after last dot
  1009.     _lentokfn = stradd(_tokfn, _lentokfn, (CHAR)((BYTE)fn[_lentokfn]&0xdf));
  1010.     _lentokfn = stradd(_tokfn, _lentokfn, '_');
  1011.     _tokfn[_lentokfn] = '\0';
  1012.     _fout = openwrite(_tokfn);
  1013.  
  1014.     _asmwaseols = 0;
  1015.     _asmwaseof = +FALSE;
  1016.     asmrdword_tokspc(); //ўшЄрхь яхЁтє■ ъюьрэфє
  1017.  
  1018.     WHILE (!_asmwaseof) { //todo шыш endasm ('}')
  1019.       tokcmd();
  1020.     };
  1021.  
  1022.     asmtoken(+_TOKEOF);
  1023.     fclose(_fout); //closewrite(_fout); //closefout();
  1024.  
  1025.     fclose(_fin); //closefin();
  1026.   };
  1027. }
  1028.  
  1029. PROC tokenize_end()
  1030. {
  1031. }
  1032.