Subversion Repositories NedoOS

Rev

Rev 2325 | 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 ((BYTE)_lentword != (BYTE)_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 ((BYTE)_lentword != (BYTE)_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;
  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(+_TOKSPC1-0x01+_ASMMAXSPC);
  128.     _asmspcsize = _asmspcsize - (UINT)_ASMMAXSPC;
  129.   };
  130.   IF (_asmspcsize!=0) asmtoken(+_TOKSPC1-0x01+(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;
  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. PROC tokaddlbl0(PCHAR txt, PBYTE proc)
  274. {
  275.   tokaddlbl(txt, proc, 0x00);
  276. }
  277.  
  278. //////////////////////////////////////
  279. //хёыш match ёЁрсюЄры, Єю _tword ё·хфрхЄё  (ўшЄрхЄё  ёыхфє■∙р ) ш т√тюфшЄё  ёююЄтхЄёЄтє■∙шщ Єюъхэ
  280. //хёыш эх ёЁрсюЄры, Єю _tword эх ё·хфрхЄё , ю°шсър эх т√фр╕Єё  (Єюы№ъю Їыру +FALSE)
  281. //хёыш ю°шсър, Єю ю°шсър эх т√фр╕Єё  (Єюы№ъю Їыру +FALSE)
  282.  
  283.     //reg ш rp ьюуєЄ тёЄЁхЄшЄ№ё  т юфэющ яючшЎшш т inc,dec,[ld],[add],[adc],[sbc]
  284.     //шэрўх ышсю reg (b,c,d,e,h,l,a,hx,lx,hy,ly, эю эх i,r!), ышсю rp (bc,de,hl,sp,ix,iy, эю эх af!)
  285.     //i,r ш af юсЁрсрЄ√трЄ№ юЄфхы№эю, Є.ъ. эрфю Єюы№ъю фы  эхъюЄюЁ√ї ъюьрэф, юёЄры№э√х ъюьрэф√ эх фюыцэ√ яЁютхЁ Є№ ¤Єє ю°шсъє яЁш ёрьющ ъюьяшы Ўшш
  286.  
  287. FUNC BOOL matchdirect()
  288. {
  289.   IF (*(PCHAR)_tword=='#') {
  290.     asmtoken((BYTE)'#');
  291.     asmrdword_tokspc();
  292.     RETURN +TRUE;
  293.   };
  294. RETURN +FALSE;
  295. }
  296.  
  297. FUNC BOOL matchcomma()
  298. {
  299.   IF (*(PCHAR)_tword==',') {
  300.     asmtoken(+_TOKCOMMA);
  301.     asmrdword_tokspc();
  302.     RETURN +TRUE;
  303.   };
  304. RETURN +FALSE;
  305. }
  306.  
  307. FUNC BOOL matchprime()
  308. {
  309.   IF (*(PCHAR)_tword=='\'') {
  310.     asmtoken(+_TOKPRIME);
  311.     asmrdword_tokspc();
  312.     RETURN +TRUE;
  313.   };
  314. RETURN +FALSE;
  315. }
  316.  
  317. FUNC BOOL matchquote()
  318. {
  319.   IF (*(PCHAR)_tword=='\"') {
  320.     asmtoken(+_TOKDBLQUOTE);
  321.     //asmrdword_tokspc();
  322.     RETURN +TRUE;
  323.   };
  324. RETURN +FALSE;
  325. }
  326.  
  327. FUNC BOOL matchreequ()
  328. {
  329.   IF ( (*(PCHAR)_tword=='=') || ((_c1small=='e')&&(_c2small=='q')) ) {
  330.     asmtoken(+_TOKEQUAL/**'='*/);
  331.     asmrdword_tokspc();
  332.     RETURN +TRUE;
  333.   };
  334. RETURN +FALSE;
  335. }
  336.  
  337. FUNC BOOL matchopen()
  338. {
  339.   IF       (*(PCHAR)_tword=='(') {asmtoken(+_TOKOPEN); asmrdword_tokspc(); RETURN +TRUE;
  340.   }ELSE IF (*(PCHAR)_tword=='[') {asmtoken(+_TOKOPENSQ); asmrdword_tokspc(); RETURN +TRUE;
  341.   };
  342. RETURN +FALSE;
  343. }
  344.  
  345. FUNC BOOL matchclose()
  346. {
  347.   IF       (*(PCHAR)_tword==')') {asmtoken(+_TOKCLOSE); asmrdword_tokspc(); RETURN +TRUE;
  348.   }ELSE IF (*(PCHAR)_tword==']') {asmtoken(+_TOKCLOSESQ); asmrdword_tokspc(); RETURN +TRUE;
  349.   };
  350. RETURN +FALSE;
  351. }
  352.  
  353. //////////////////////////////////////
  354. FUNC BOOL eatexpr RECURSIVE FORWARD();
  355.  
  356. PROC eatlabel()
  357. {
  358.   WHILE ((_cnext=='.')||(_cnext=='#')) {
  359.     rdaddwordall(); //яЁшъыхшЄ№ Єюўъє
  360.     IF (_spcsize==0)
  361.       IF (_isalphanum[(BYTE)_cnext]) //с√ыю isalpha
  362.         IF (_waseols==0)
  363.           //IF (!_waseof)
  364.             rdaddwordall(); //яЁшъыхшЄ№ ёыхфє■∙хх ёыютю
  365.   };
  366.   //asmtoken(token/**_TOKLABEL шыш _CMDLABEL*/);
  367.   //asmtoken(+_TOKTEXT);
  368.   fputs(_tword, _fout);
  369.   //asmtoken(+_TOKENDTEXT);
  370.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  371.   //хёыш ьхЄър с√ыр яюёыхфэшь ёыютюь т ёЄЁюъх, Єюуфр ¤Єющ ЄюъхэшчрЎшхщ ь√ чрс√ыш с√ яЁю хэЄхЁ (юэ ЄхяхЁ№ т _asmwaseol)
  372. }
  373.  
  374. PROC eatval RECURSIVE() //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш  (ёъюсър, чря Єр , ъюэхЎ ёЄЁюъш)
  375. //<val>::=
  376. //(<expr>) //т√Ёрцхэшх (т√ўшёы хЄё )
  377. //|<num> //фхё Єшўэюх ўшёыю (яхЁхфр╕Єё  Ўхышъюь)
  378. //|<var> //ьхЄър шыш ярЁрьхЄЁ ьръЁюёр (TODO эх ёююЄтхЄёЄтєхЄ  ч√ъє: Єрь ¤Єю &<var>)
  379. //|$
  380. //|'CHAR' //ёшьтюы№эр  ъюэёЄрэЄр
  381. //|-<val> //т√ўшёышЄ№ val, яюЄюь ёфхырЄ№ NEG
  382. //|+<val> //т√ўшёышЄ№ val
  383. //|~<val> //т√ўшёышЄ№ val, яюЄюь ёфхырЄ№ INV
  384. //|!<val> //т√ўшёышЄ№ val, яюЄюь ёфхырЄ№ INV(BOOL)
  385. //|*<val> //яЁюўшЄрЄ№ ярь Є№ яю рфЁхёє (т√ўшёышЄ№ val, яюЄюь ёфхырЄ№ PEEK)
  386. { //ъюьрэфр єцх яЁюўшЄрэр
  387. VAR CHAR opsym;
  388. {
  389.   opsym = *(PCHAR)_tword;
  390.   IF (!_asmwaseof) { //чр∙шЄр юЄ чрЎшъыштрэш  т ъюэЎх ю°шсюўэюую Їрщыр
  391.     IF ((BYTE)((BYTE)opsym - (BYTE)'0') < 0x0a) { //<num> //т√фр╕Є <num><text>digits<endtext> //extra BYTE for C bug
  392.       //asmtoken(+_TOKNUM);
  393.       //asmtoken(+_TOKTEXT);
  394. //for float:
  395.       IF (_cnext=='.') {
  396.         rdaddwordall(); //яЁшъыхшЄ№ Єюўъє
  397.         rdaddwordall(); //яЁшъыхшЄ№ фЁюсэє■ ўрёЄ№
  398.         IF ( (_tword[_lentword-1]=='e') && (_cnext=='-') ) {
  399.           rdaddwordall(); //яЁшъыхшЄ№ '-' юЄЁшЎрЄхы№эющ ¤ъёяюэхэЄ√
  400.           rdaddwordall(); //яЁшъыхшЄ№ юЄЁшЎрЄхы№эє■ ¤ъёяюэхэЄє
  401.         };
  402. /*        asmrdword_tokspc();
  403.         fputs(_tword, _fout);
  404.         asmrdword_tokspc();*/ //todo e-12
  405.       };
  406.       fputs(_tword, _fout);
  407.       //asmtoken(+_TOKENDTEXT);
  408.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  409.       //хёыш ўшёыю с√ыю яюёыхфэшь ёыютюь т ёЄЁюъх, Єюуфр ¤Єющ ЄюъхэшчрЎшхщ ь√ чрс√ыш с√ яЁю хэЄхЁ (юэ ЄхяхЁ№ т _asmwaseol)
  410.     }ELSE IF (_isalphanum[(BYTE)opsym] || (opsym=='.') ) { //todo єсЁрЄ№ '.', хёыш чряЁхЄшЄ№ эрўшэрЄ№ ьхЄъш ё Єюўъш //с√ыю isalpha
  411.       //asmtoken(+_TOKLABEL);
  412.       eatlabel();
  413.     }ELSE IF ( opsym=='$' ) {
  414.       asmtoken((BYTE)'$');
  415.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  416.     }ELSE IF ( opsym=='(' ) {
  417.       asmtoken(+_TOKOPEN);
  418.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  419.       eatexpr(); //ЁхъєЁёш  //эр т√їюфх шч expr єцх яЁюўшЄрэр ')', эю ёыхфє■∙шщ ёшьтюы шыш ъюьрэфр эх яЁюўшЄрэ√
  420.       asmtoken(+_TOKCLOSE);
  421.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  422.     }ELSE IF ( opsym=='\'' ) {
  423.       asmtoken(+_TOKPRIME);
  424.       _lentword = 0; //ўшЄрхь ё яєёЄющ ёЄЁюъш
  425.       rdquotes('\''/**, +FALSE*/);
  426.       fputs(_tword, _fout);
  427.       rdch(); //яЁюяєёЄшЄ№ чръЁ√тр■∙є■ ърт√ўъє
  428.       asmtoken(+_TOKPRIME);
  429.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  430.     }ELSE IF ( opsym=='-' ) {
  431.       asmtoken((BYTE)'-');
  432.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  433.       eatval(); //ЁхъєЁёштэ√щ т√чют val
  434.     }ELSE IF ( opsym=='+' ) {
  435.       asmtoken((BYTE)'+');
  436.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  437.       eatval(); //ЁхъєЁёштэ√щ т√чют val
  438.     }ELSE IF ( opsym=='*' ) { //TODO яюффхЁцрЄ№ PEEK т рёёхьсыхЁх
  439.       asmtoken((BYTE)'*');
  440.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  441.       eatval(); //ЁхъєЁёштэ√щ т√чют val
  442.     }ELSE IF ( opsym=='~' ) {
  443.       asmtoken((BYTE)'~');
  444.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  445.       eatval(); //ЁхъєЁёштэ√щ т√чют val
  446.     }ELSE IF ( opsym=='!' ) {
  447.       asmtoken((BYTE)'!');
  448.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  449.       eatval(); //ЁхъєЁёштэ√щ т√чют val
  450.     }ELSE { tokerr(+_ERREXPR);/**errstr( ">>>WRONG PREFIX " ); err( opsym ); enderr();*/ };
  451.   };
  452. }
  453. }
  454.  
  455. PROC eatmul()
  456. {
  457.   asmtoken((BYTE)'*');
  458.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  459.   eatval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  460. }
  461.  
  462. PROC eatdiv()
  463. {
  464.   asmtoken((BYTE)'/');
  465.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  466.   eatval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  467. }
  468.  
  469. PROC eatand()
  470. {
  471.   asmtoken((BYTE)'&');
  472.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  473.   eatval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  474. }
  475.  
  476. PROC eatandbool()
  477. {
  478.   asmtoken((BYTE)'&'); asmtoken((BYTE)'&');
  479.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  480.   eatval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  481. }
  482.  
  483. PROC eatmulval RECURSIVE() //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш  (ёъюсър, чря Єр , ъюэхЎ ёЄЁюъш)
  484. { //ъюьрэфр єцх яЁюўшЄрэр
  485. VAR CHAR opsym;
  486. VAR BOOL dbl;
  487. {
  488.   eatval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  489.   WHILE ((!_asmwaseof)&&(_asmwaseols==0)) { //єцх яЁюўшЄрэр юяхЁрЎш  ш яЁюсхы√-хэЄхЁ√ яюёых эх╕ (_asmwaseol - хэЄхЁ яюёых val)
  490.     opsym=*(PCHAR)_tword;
  491.     dbl = (opsym=='&')&&(_cnext==opsym); //C compatibility
  492.     IF (dbl) asmrdword_tokspc(); //use '&' //C compatibility
  493.     IF       (opsym=='*') {eatmul();
  494.     }ELSE IF (opsym=='/') {eatdiv();
  495.     }ELSE IF (opsym=='&') {
  496.       IF (dbl) {eatandbool();
  497.       }ELSE eatand();
  498.     }ELSE BREAK;
  499.   };
  500. }
  501. }
  502.  
  503. PROC eatadd()
  504. {
  505.   asmtoken((BYTE)'+');
  506.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  507.   eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  508. }
  509.  
  510. PROC eatsub()
  511. {
  512.   asmtoken((BYTE)'-');
  513.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  514.   eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  515. }
  516.  
  517. PROC eator()
  518. {
  519.   asmtoken((BYTE)'|');
  520.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  521.   eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  522. }
  523.  
  524. PROC eatorbool()
  525. {
  526.   asmtoken((BYTE)'|'); asmtoken((BYTE)'|');
  527.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  528.   eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  529. }
  530.  
  531. PROC eatxor()
  532. {
  533.   asmtoken((BYTE)'^');
  534.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  535.   eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  536. }
  537.  
  538. PROC eatxorbool()
  539. {
  540.   asmtoken((BYTE)'^'); asmtoken((BYTE)'^');
  541.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  542.   eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  543. }
  544.  
  545. PROC eatsumval RECURSIVE() //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш  (ёъюсър, чря Єр , ъюэхЎ ёЄЁюъш)
  546. { //ъюьрэфр єцх яЁюўшЄрэр
  547. VAR CHAR opsym;
  548. VAR BOOL dbl;
  549. {
  550.   eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  551.   WHILE ((!_asmwaseof)&&(_asmwaseols==0)) { //єцх яЁюўшЄрэр юяхЁрЎш  ш яЁюсхы√-хэЄхЁ√ яюёых эх╕ (_asmwaseol - хэЄхЁ яюёых val)
  552.     opsym=*(PCHAR)_tword;
  553.     dbl = ( (opsym=='|')||(opsym=='^') )&&(_cnext==opsym); //C compatibility
  554.     IF (dbl) asmrdword_tokspc(); //use '|' or '^' //C compatibility
  555.     IF (opsym=='+') {eatadd();
  556.     }ELSE IF (opsym=='-') {eatsub();
  557.     }ELSE IF (opsym=='|') {
  558.       IF (dbl) {eatorbool();
  559.       }ELSE eator();
  560.     }ELSE IF (opsym=='^') {
  561.       IF (dbl) {eatxorbool();
  562.       }ELSE eatxor();
  563.     }ELSE BREAK;
  564.   };
  565. }
  566. }
  567.  
  568. PROC eatshl()
  569. {
  570.   asmtoken((BYTE)'<'); asmtoken((BYTE)'<');
  571.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  572.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  573. }
  574.  
  575. PROC eatshr()
  576. {
  577.   asmtoken((BYTE)'>'); asmtoken((BYTE)'>');
  578.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  579.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  580. }
  581.  
  582. PROC eatless()
  583. {
  584.   asmtoken((BYTE)'<');
  585.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  586.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  587. }
  588.  
  589. PROC eatlesseq()
  590. {
  591.   asmtoken((BYTE)'<'); asmtoken((BYTE)'=');
  592.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  593.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  594. }
  595.  
  596. PROC eatmore()
  597. {
  598.   asmtoken((BYTE)'>');
  599.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  600.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  601. }
  602.  
  603. PROC eatmoreeq()
  604. {
  605.   asmtoken((BYTE)'>'); asmtoken((BYTE)'=');
  606.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  607.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  608. }
  609.  
  610. PROC eateq()
  611. {
  612.   asmtoken((BYTE)'='); asmtoken((BYTE)'=');
  613.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  614.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  615. }
  616.  
  617. PROC eatnoteq()
  618. {
  619.   asmtoken((BYTE)'!'); asmtoken((BYTE)'=');
  620.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  621.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  622. }
  623.  
  624. FUNC BOOL eatexpr RECURSIVE() //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш  (ёъюсър, чря Єр , ъюэхЎ ёЄЁюъш)
  625. { //ъюьрэфр єцх яЁюўшЄрэр
  626. VAR CHAR opsym;
  627. VAR BOOL modified;
  628. VAR BOOL dbl;
  629. //VAR BOOL ok;
  630. {
  631.   //ok = +TRUE;
  632.   matchdirect(); //яЁюяєёъ '#'
  633.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  634.   WHILE ((!_asmwaseof)&&(_asmwaseols==0)) { //єцх яЁюўшЄрэр юяхЁрЎш  ш яЁюсхы√-хэЄхЁ√ яюёых эх╕ (_asmwaseol - хэЄхЁ яюёых val)
  635.     opsym = *(PCHAR)_tword;
  636.     modified = (_cnext=='=');
  637.     dbl = (_cnext==opsym);
  638.     IF (modified||dbl) asmrdword_tokspc(); //use '=' or '>' or '<'
  639.     IF (opsym=='<') {
  640.       IF (dbl) {eatshl(); //ёЄрЁюх ёфтшэєЄ№ ёЄюы№ъю Ёрч, ёъюы№ъю уырёшЄ эютюх!
  641.       }ELSE IF (modified) {eatlesseq();
  642.       }ELSE {eatless();
  643.       };
  644.     }ELSE IF (opsym=='>') {
  645.       IF (dbl) {eatshr(); //ёЄрЁюх ёфтшэєЄ№ ёЄюы№ъю Ёрч, ёъюы№ъю уырёшЄ эютюх!
  646.       }ELSE IF (modified) {eatmoreeq();
  647.       }ELSE {eatmore();
  648.       };
  649.     }ELSE IF (opsym=='=') {eateq();
  650.     }ELSE IF (opsym=='!') {eatnoteq();
  651.     }ELSE BREAK;
  652.   };
  653. }
  654. RETURN +TRUE; //ok; //todo err
  655. }
  656.  
  657. FUNC BOOL tokexpr()
  658. {
  659.   asmtoken(+_TOKEXPR);
  660.   eatexpr();
  661.   asmtoken(+_TOKENDEXPR);
  662. RETURN +TRUE; //ok; //todo err
  663. }
  664.  
  665. FUNC BOOL tokexpr_close() //яюёых эхую эшўхую сюы№°х эхы№ч  яЁютхЁ Є№, Є.ъ. ъєЁёюЁ ьюу ёфтшэєЄ№ё 
  666. {
  667.   IF (tokexpr()) { RETURN matchclose(); };
  668.   RETURN +FALSE;
  669. }
  670.  
  671. PROC asm_direct_expr_close_token(BYTE token)
  672. {
  673.   //if(matchdirect()) {
  674.     IF (tokexpr()) {
  675.       IF (matchclose()) {asmtoken(token);
  676.       }ELSE tokerr(+_ERRCLOSE); //no closing bracket
  677.     }ELSE tokerr(+_ERREXPR); //wrong expr
  678.   //}else tokerr(_ERRPAR); //no direct
  679. }
  680.  
  681. PROC tokcomment()
  682. {
  683.   asmtoken(+_TOKCOMMENT);
  684.   _lentword = 0; //ўшЄрхь ё яєёЄющ ёЄЁюъш
  685.   IF (_waseols==0) { //юсїюф эр ёыєўрщ ъюэхўэюую ; яхЁхф ъюьрэфющ
  686.     WHILE (_spcsize != 0) { //фюсртшЄ№ ё·хфхээ√х яЁюсхы√
  687.       _lentword = stradd(_tword, _lentword, ' ');
  688.       DEC _spcsize;
  689.     };
  690.     WHILE (_waseols==0/**&&(!_waseof)*//**&&(_cnext!=_DIERESIS)*/) {
  691.       rdchcmt(); //яЁюяєёърхЄ тёх хэЄхЁ√
  692.     };
  693.   };
  694.   _tword[_lentword] = '\0';
  695.   fputs(_tword, _fout); //toktext(); //ухэхЁшЁєхЄ <text>text<endtext>
  696.   //asmtoken(+_TOKENDCOMMENT);
  697.   IF ((BYTE)_cnext < (BYTE)'!') {
  698.     IF (_cnext == '\t') {
  699.       _spcsize = _spcsize + 8;
  700.     }ELSE {
  701.       INC _spcsize;
  702.     };
  703.     rdch(); //ўшЄрхь тё■ уЁєяяє фшхЁхчшёют + ёшьтюы ъръ юфшэ ёшьтюы
  704.   };
  705.   asmrdword_tokspc(); //[ЄюъхэшчшЁєхЄ ъюэхўэ√х яЁюсхы√ шыш EOL,] схЁ╕Є ёыхфє■∙є■ ъюьрэфє (яюёых шэёЄЁєъЎшш)
  706. }
  707.  
  708. PROC tokorg()
  709. {
  710.   asmtoken(+_CMDORG);
  711.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  712.   IF (tokexpr()) {asmtoken(+_FMTCMD);
  713.   }ELSE tokerr(+_ERREXPR); //wrong expr
  714. }
  715.  
  716. PROC tokalign()
  717. {
  718.   asmtoken(+_CMDALIGN);
  719.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  720.   IF (tokexpr()) {asmtoken(+_FMTCMD);
  721.   }ELSE tokerr(+_ERREXPR); //wrong expr
  722. }
  723. /**
  724. PROC tokpage()
  725. {
  726.   tokerrcmd();
  727. }
  728.  
  729. PROC tokif()
  730. {
  731.   asmtoken(+_CMDIF);
  732.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  733.   IF (tokexpr()) {asmtoken(+_FMTCMD);
  734.   }ELSE tokerr(+_ERREXPR); //wrong expr
  735.   //tokerrcmd();
  736. }
  737.  
  738. PROC tokelse()
  739. {
  740.   asmtoken(+_CMDELSE);
  741.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  742.   //tokerrcmd();
  743. }
  744.  
  745. PROC tokendif()
  746. {
  747.   asmtoken(+_CMDENDIF);
  748.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  749.   //tokerrcmd();
  750. }
  751.  
  752. PROC tokdup()
  753. {
  754.   tokerrcmd();
  755. }
  756.  
  757. PROC tokedup()
  758. {
  759.   tokerrcmd();
  760. }
  761.  
  762. PROC tokmacro()
  763. {
  764.   tokerrcmd();
  765. }
  766.  
  767. PROC tokendm()
  768. {
  769.   tokerrcmd();
  770. }
  771. */
  772. PROC tokexport()
  773. {
  774.   asmtoken(+_CMDEXPORT);
  775.   asmrdword_tokspc(); //ё·хфрхь call
  776.   asmtoken(+_TOKLABEL);
  777.   eatlabel();
  778.   //asmmtoken(+_TOKTEXT);
  779.   //fputs(_tword, _fout);
  780.   //asmtoken(+_TOKENDTEXT);
  781.   //asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  782.   asmtoken(+_FMTCMD); //ўЄюс√ шёяюы№чютрЄ№ label
  783. }
  784. /**
  785. PROC toklocal()
  786. {
  787.   tokerrcmd();
  788. }
  789.  
  790. PROC tokendl()
  791. {
  792.   tokerrcmd();
  793. }
  794.  
  795. PROC tokdisp()
  796. {
  797.   asmtoken(+_CMDDISP);
  798.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  799.   IF (tokexpr()) {asmtoken(+_FMTCMD);
  800.   }ELSE tokerr(+_ERREXPR); //wrong expr
  801. }
  802.  
  803. PROC tokent()
  804. {
  805.   asmtoken(+_CMDENT);
  806.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  807.   asmtoken(+_FMTCMD);
  808. }
  809. */
  810. PROC tokinclude()
  811. {
  812.   asmtoken(+_CMDINCLUDE);
  813.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  814.   IF (matchquote()) {
  815.     //asmtoken(+_OPWRSTR);
  816.     _lentword = 0; //ўшЄрхь ё яєёЄющ ёЄЁюъш
  817.     rdquotes('\"');
  818.     toktext(); //ухэхЁшЁєхЄ <text>text<endtext>
  819.     rdch(); //яЁюяєёЄшЄ№ чръЁ√тр■∙є■ ърт√ўъє
  820.     asmtoken(+_TOKDBLQUOTE);
  821.     asmrdword_tokspc();
  822.   }ELSE tokerr(+_ERREXPR);
  823.   //asmtoken(+_FMTCMD); //todo?
  824. }
  825.  
  826. PROC tokincbin()
  827. {
  828.   asmtoken(+_CMDINCBIN);
  829.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  830.   IF (matchquote()) {
  831.     //asmtoken(+_OPWRSTR);
  832.     _lentword = 0; //ўшЄрхь ё яєёЄющ ёЄЁюъш
  833.     rdquotes('\"');
  834.     toktext(); //ухэхЁшЁєхЄ <text>text<endtext>
  835.     rdch(); //яЁюяєёЄшЄ№ чръЁ√тр■∙є■ ърт√ўъє
  836.     asmtoken(+_TOKDBLQUOTE);
  837.     asmrdword_tokspc();
  838.   }ELSE tokerr(+_ERREXPR);
  839.   //todo ярЁрьхЄЁ√ (яЁюяєёъ, фышэр)
  840.   //asmtoken(+_FMTCMD); //todo?
  841. }
  842.  
  843. PROC tokdb()
  844. {
  845.   asmtoken(+_CMDDB);
  846.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  847.   REPEAT {
  848.     IF (matchquote()) {
  849.       asmtoken(+_OPWRSTR);
  850.       _lentword = 0; //ўшЄрхь ё яєёЄющ ёЄЁюъш
  851.       rdquotes('\"');
  852.       toktext(); //ухэхЁшЁєхЄ <text>text<endtext>
  853.       rdch(); //яЁюяєёЄшЄ№ чръЁ√тр■∙є■ ърт√ўъє
  854.       asmtoken(+_TOKDBLQUOTE);
  855.       asmrdword_tokspc();
  856.     }ELSE IF (tokexpr()) {
  857.       asmtoken(+_OPWRVAL);
  858.     }ELSE tokerr(+_ERREXPR);
  859.   }UNTIL (!matchcomma());
  860.   asmtoken(+_FMTCMD);
  861. }
  862.  
  863. PROC tokdw()
  864. {
  865.   asmtoken(+_CMDDW);
  866.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  867.   REPEAT {
  868.     tokexpr();
  869.     asmtoken(+_OPWRVAL);
  870.   }UNTIL (!matchcomma());
  871.   asmtoken(+_FMTCMD);
  872. }
  873.  
  874. PROC tokdl()
  875. {
  876.   asmtoken(+_CMDDL);
  877.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  878.   REPEAT {
  879.     tokexpr();
  880.     asmtoken(+_OPWRVAL);
  881.   }UNTIL (!matchcomma());
  882.   asmtoken(+_FMTCMD);
  883. }
  884.  
  885. PROC tokds()
  886. {
  887.   asmtoken(+_CMDDS);
  888.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  889.   tokexpr();
  890.   WHILE (matchcomma()) {
  891.     tokexpr();
  892.   };
  893.   asmtoken(+_FMTCMD);
  894. }
  895. /**
  896. PROC tokdisplay()
  897. {
  898.   tokerrcmd();
  899. }
  900.  
  901. PROC tokrepeat()
  902. {
  903.   tokerrcmd();
  904. }
  905.  
  906. PROC tokuntil()
  907. {
  908.   tokerrcmd();
  909. }
  910.  
  911. PROC tokstruct()
  912. {
  913.   tokerrcmd();
  914. }
  915.  
  916. PROC tokendstruct()
  917. {
  918.   tokerrcmd();
  919. }
  920. */
  921. PROC tokcolon()
  922. {
  923.   asmtoken(+_TOKCOLON);
  924.   asmrdword_tokspc(); //ё·хфрхь ':'
  925. }
  926.  
  927. ///////////////////////
  928.  
  929. PROC tokcmd()
  930. {
  931.   //_asmwaseof=_waseof;
  932.   //rdword_tokspc(); //яЁюўшЄрэю т яЁхф√фє∙хщ шэёЄЁєъЎшш
  933.   //stringdecapitalize(_tword,_lentword);
  934.   IF (*(PCHAR)_tword==';') {tokcomment();
  935. /**  }ELSE IF (*(PCHAR)_tword==':') {
  936.     asmtoken(+_TOKCOLON);
  937.     asmrdword_tokspc(); //ё·хфрхь ':'
  938. */
  939.   }ELSE IF (_asmspcsize!=0) {
  940.     //tokasm(); //assembly mnemonic or directive
  941.     tokcalllbl();
  942. /**    IF (!tokcalllbl(_tword)) {
  943.       tokerrcmd(); //wrong _tword
  944.     };*/
  945.   }ELSE { //<label> шыш <label>=<expr>
  946.     //asmtoken(0xff);
  947.     asmtoken(+_CMDLABEL);
  948.     eatlabel(); //ё·хфрхь ьхЄъє
  949.     IF (matchreequ()) { //<label>=<expr>
  950.       IF (tokexpr()) {
  951.         asmtoken(+_FMTREEQU);
  952.       }ELSE tokerr(+_ERREXPR); //wrong expr
  953.     }ELSE //IF ((_asmwaseols!=0)||(_asmwaseof)||(*(PCHAR)_tword==':')||(*(PCHAR)_tword==';')){ //<label>
  954.       asmtoken(+_FMTCMD); //<label>
  955.     //}ELSE tokerrcmd(); //wrong _tword
  956.   };
  957.   //яш°хь eol ш яЁюсхы√, ъюЄюЁ√х эх чряшёрыш яЁш ўЄхэшш ъюэхўэюую ёыютр
  958.   IF (_asmwaseols!=0) {
  959.     WHILE (_asmwaseols!=0) {
  960.       asmtoken(+_TOKEOL);
  961.       DEC _asmwaseols;
  962.     };
  963.     tokspc(); //ЄюъхэшчшЁєхь яЁюсхы√ яюёых
  964.   };
  965. }
  966.  
  967. PROC tokinit()
  968. {
  969.   _tokfn = (PCHAR)_stokfn;
  970.   tokinitlblbuf();
  971.   tokpre(); //чряюыэшЄ№ ЄрсышЎє ьхЄюъ
  972. }
  973.  
  974. PROC tokenize(PCHAR fn)
  975. {
  976. VAR UINT i;
  977.   _fin = nfopen(fn, "rb");
  978.   IF (_fin != (PBYTE)0) {
  979.     _waseof = +FALSE;
  980.     _curline = 1;
  981.     initrd();
  982.  
  983.     _lentokfn = 0;
  984.     i = 0;
  985.     WHILE (fn[_lentokfn] != '\0') {
  986.       _tokfn[_lentokfn] = fn[_lentokfn];
  987.       IF (fn[_lentokfn] == '.') i = _lentokfn;
  988.       INC _lentokfn;
  989.     };
  990.     //_lentokfn = strjoineol(_tokfn, 0, fn, '.'); //terminator is not copied
  991.     //_lentokfn = stradd(_tokfn, _lentokfn, '.');
  992.     _lentokfn = i+1; //after last dot
  993.     _lentokfn = stradd(_tokfn, _lentokfn, (CHAR)((BYTE)fn[_lentokfn]&0xdf));
  994.     _lentokfn = stradd(_tokfn, _lentokfn, '_');
  995.     _tokfn[_lentokfn] = '\0';
  996.     _fout = openwrite(_tokfn);
  997.  
  998.     _asmwaseols = 0;
  999.     _asmwaseof = +FALSE;
  1000.     asmrdword_tokspc(); //ўшЄрхь яхЁтє■ ъюьрэфє
  1001.  
  1002.     WHILE (!_asmwaseof) { //todo шыш endasm ('}')
  1003.       tokcmd();
  1004.     };
  1005.  
  1006.     asmtoken(+_TOKEOF);
  1007.     fclose(_fout); //closewrite(_fout); //closefout();
  1008.  
  1009.     fclose(_fin); //closefin();
  1010.   };
  1011. }
  1012.  
  1013. PROC tokenize_end()
  1014. {
  1015. }
  1016.