Subversion Repositories NedoOS

Rev

Rev 50 | Rev 485 | 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] = (CHAR)0x00; //strclose(_tword, _lentword); //todo эрЁє°хэр ярЁэюёЄ№ clear..close
  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 != (CHAR)0x00) 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>
  394.       asmtoken(+_TOKNUM);
  395.       asmtoken(+_TOKTEXT);
  396.       fputs(_tword, _fout);
  397.       asmtoken(+_TOKENDTEXT);
  398.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  399.       //хёыш ўшёыю с√ыю яюёыхфэшь ёыютюь т ёЄЁюъх, Єюуфр ¤Єющ ЄюъхэшчрЎшхщ ь√ чрс√ыш с√ яЁю хэЄхЁ (юэ ЄхяхЁ№ т _asmwaseol)
  400.     }ELSE IF (_isalphanum[+(BYTE)opsym] || (opsym=='.') ) { //todo єсЁрЄ№ '.', хёыш чряЁхЄшЄ№ эрўшэрЄ№ ьхЄъш ё Єюўъш //с√ыю isalpha
  401.       eatlabel(+_TOKLABEL);
  402.     }ELSE IF ( opsym=='$' ) {
  403.       asmtoken(+_TOKDOLLAR);
  404.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  405.     }ELSE IF ( opsym=='(' ) {
  406.       asmtoken(+_TOKOPEN);
  407.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  408.       tokexpr(); //ЁхъєЁёш  //эр т√їюфх шч expr єцх яЁюўшЄрэр ')', эю ёыхфє■∙шщ ёшьтюы шыш ъюьрэфр эх яЁюўшЄрэ√
  409.       asmtoken(+_TOKCLOSE);
  410.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  411.     }ELSE IF ( opsym=='\'' ) { //todo тёЄртшЄ№ TOK_TEXT...TOK_ENDTEXT
  412.       asmtoken(+_TOKPRIME);
  413.       _lentword = 0/**strclear(_tword)*/; //ўшЄрхь ё яєёЄющ ёЄЁюъш
  414.       rdquotes('\''/**, +FALSE*/);
  415.       toktext(); //ухэхЁшЁєхЄ <text>text<endtext>
  416.       rdch(); //яЁюяєёЄшЄ№ чръЁ√тр■∙є■ ърт√ўъє
  417.       asmtoken(+_TOKPRIME);
  418.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  419.     }ELSE IF ( opsym=='-' ) {
  420.       asmtoken(+_OPPUSH0); asmtoken(+_TOKMINUS/**'-'*/);
  421.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  422.       eatval(); //ЁхъєЁёштэ√щ т√чют val
  423.       asmtoken(+_OPSUB);
  424.     }ELSE IF ( opsym=='+' ) {
  425.       asmtoken(+_OPPUSH0); asmtoken(+_TOKPLUS/**'+'*/);
  426.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  427.       eatval(); //ЁхъєЁёштэ√щ т√чют val
  428.       asmtoken(+_OPADD);
  429.     }ELSE IF ( opsym=='*' ) {
  430.       asmtoken(+_OPPUSH0); asmtoken(+_TOKSTAR/**'*'*/);
  431.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  432.       eatval(); //ЁхъєЁёштэ√щ т√чют val
  433.       asmtoken(+_OPPEEK);
  434. /**    }ELSE IF ( opsym=='~' ) {
  435.       asmtoken(+_OPPUSH0); asmtoken(+_TOKTILDE);
  436.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  437.       eatval(); //ЁхъєЁёштэ√щ т√чют val
  438.       asmtoken(+_OPINV);
  439.     }ELSE IF ( opsym=='!' ) {
  440.       asmtoken(+_OPPUSH0); asmtoken(+_TOKEXCL);
  441.       asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  442.       eatval(); //ЁхъєЁёштэ√щ т√чют val
  443.       asmtoken(+_OPINV); //todo BOOL
  444. */    }ELSE { tokerr(+_ERREXPR);/**errstr( ">>>WRONG PREFIX " ); err( opsym ); enderr();*/ };
  445.   };
  446. }
  447. }
  448.  
  449. PROC eatmul()
  450. {
  451.   /**asmtoken(_ASMOPPUSHSKIP1);*/ asmtoken(+_TOKSTAR/**'*'*/);
  452.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  453.   eatval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  454.   asmtoken(+_OPMUL);
  455. }
  456.  
  457. PROC eatdiv()
  458. {
  459.   /**asmtoken(_ASMOPPUSHSKIP1);*/ asmtoken(+_TOKSLASH/**'/'*/);
  460.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  461.   eatval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  462.   asmtoken(+_OPDIV);
  463. }
  464.  
  465. PROC eatand()
  466. {
  467.   /**asmtoken(_ASMOPPUSHSKIP1);*/ asmtoken(+_TOKAND/**'&'*/);
  468.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  469.   eatval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  470.   asmtoken(+_OPAND);
  471. }
  472.  
  473. PROC eatandbool()
  474. {
  475.   /**asmtoken(_ASMOPPUSHSKIP2);*/ asmtoken(+_TOKAND/**'&'*/); asmtoken(+_TOKAND/**'&'*/);
  476.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  477.   eatval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  478.   asmtoken(+_OPAND);
  479. }
  480.  
  481. PROC eatmulval RECURSIVE() //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш  (ёъюсър, чря Єр , ъюэхЎ ёЄЁюъш)
  482. { //ъюьрэфр єцх яЁюўшЄрэр
  483. VAR CHAR opsym;
  484. VAR BOOL dbl;
  485. {
  486.   eatval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  487.   WHILE ((!_asmwaseof)&&(_asmwaseols==0)) { //єцх яЁюўшЄрэр юяхЁрЎш  ш яЁюсхы√-хэЄхЁ√ яюёых эх╕ (_asmwaseol - хэЄхЁ яюёых val)
  488.     opsym=*(PCHAR)_tword;
  489.     dbl = (opsym=='&')&&(_cnext==opsym); //C compatibility
  490.     IF (dbl) asmrdword_tokspc(); //use '&' //C compatibility
  491.     IF       (opsym=='*') {eatmul();
  492.     }ELSE IF (opsym=='/') {eatdiv();
  493.     }ELSE IF (opsym=='&') {
  494.       IF (dbl) {eatandbool();
  495.       }ELSE eatand();
  496.     }ELSE BREAK;
  497.   };
  498. }
  499. }
  500.  
  501. PROC eatadd()
  502. {
  503.   /**asmtoken(_ASMOPPUSHSKIP1);*/ asmtoken(+_TOKPLUS/**'+'*/);
  504.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  505.   eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  506.   asmtoken(+_OPADD);
  507. }
  508.  
  509. PROC eatsub()
  510. {
  511.   /**asmtoken(_ASMOPPUSHSKIP1);*/ asmtoken(+_TOKMINUS/**'-'*/);
  512.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  513.   eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  514.   asmtoken(+_OPSUB);
  515. }
  516.  
  517. PROC eator()
  518. {
  519.   /**asmtoken(_ASMOPPUSHSKIP1);*/ asmtoken(+_TOKPIPE/**'|'*/);
  520.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  521.   eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  522.   asmtoken(+_OPOR);
  523. }
  524.  
  525. PROC eatorbool()
  526. {
  527.   /**asmtoken(_ASMOPPUSHSKIP2);*/ asmtoken(+_TOKPIPE/**'|'*/); asmtoken(+_TOKPIPE/**'|'*/);
  528.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  529.   eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  530.   asmtoken(+_OPOR);
  531. }
  532.  
  533. PROC eatxor()
  534. {
  535.   /**asmtoken(_ASMOPPUSHSKIP1);*/ asmtoken(+_TOKCARON/**'^'*/);
  536.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  537.   eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  538.   asmtoken(+_OPXOR);
  539. }
  540.  
  541. PROC eatxorbool()
  542. {
  543.   /**asmtoken(_ASMOPPUSHSKIP2);*/ asmtoken(+_TOKCARON/**'^'*/); asmtoken(+_TOKCARON/**'^'*/);
  544.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  545.   eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  546.   asmtoken(+_OPXOR);
  547. }
  548.  
  549. PROC eatsumval RECURSIVE() //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш  (ёъюсър, чря Єр , ъюэхЎ ёЄЁюъш)
  550. { //ъюьрэфр єцх яЁюўшЄрэр
  551. VAR CHAR opsym;
  552. VAR BOOL dbl;
  553. {
  554.   eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  555.   WHILE ((!_asmwaseof)&&(_asmwaseols==0)) { //єцх яЁюўшЄрэр юяхЁрЎш  ш яЁюсхы√-хэЄхЁ√ яюёых эх╕ (_asmwaseol - хэЄхЁ яюёых val)
  556.     opsym=*(PCHAR)_tword;
  557.     dbl = ( (opsym=='|')||(opsym=='^') )&&(_cnext==opsym); //C compatibility
  558.     IF (dbl) asmrdword_tokspc(); //use '|' or '^' //C compatibility
  559.     IF (opsym=='+') {eatadd();
  560.     }ELSE IF (opsym=='-') {eatsub();
  561.     }ELSE IF (opsym=='|') {
  562.       IF (dbl) {eatorbool();
  563.       }ELSE eator();
  564.     }ELSE IF (opsym=='^') {
  565.       IF (dbl) {eatxorbool();
  566.       }ELSE eatxor();
  567.     }ELSE BREAK;
  568.   };
  569. }
  570. }
  571.  
  572. PROC eatshl()
  573. {
  574.   /**asmtoken(_ASMOPPUSHSKIP2);*/ asmtoken(+_TOKLESS/**'<'*/); asmtoken(+_TOKLESS/**'<'*/);
  575.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  576.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  577.   asmtoken(+_OPSHL);
  578. }
  579.  
  580. PROC eatshr()
  581. {
  582.   /**asmtoken(_ASMOPPUSHSKIP2);*/ asmtoken(+_TOKMORE/**'>'*/); asmtoken(+_TOKMORE/**'>'*/);
  583.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  584.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  585.   asmtoken(+_OPSHR);
  586. }
  587.  
  588. PROC eatless()
  589. {
  590.   asmtoken(+_TOKLESS);
  591.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  592.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  593.   asmtoken(+_OPLESS);
  594. }
  595.  
  596. PROC eatlesseq()
  597. {
  598.   asmtoken(+_TOKLESS); asmtoken(+_TOKEQUAL);
  599.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  600.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  601.   asmtoken(+_OPLESSEQ);
  602. }
  603.  
  604. PROC eatmore()
  605. {
  606.   asmtoken(+_TOKMORE);
  607.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  608.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  609.   asmtoken(+_OPMORE);
  610. }
  611.  
  612. PROC eatmoreeq()
  613. {
  614.   asmtoken(+_TOKMORE); asmtoken(+_TOKEQUAL);
  615.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  616.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  617.   asmtoken(+_OPMOREEQ);
  618. }
  619.  
  620. PROC eateq()
  621. {
  622.   asmtoken(+_TOKEQUAL); asmtoken(+_TOKEQUAL);
  623.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  624.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  625.   asmtoken(+_OPEQ);
  626. }
  627.  
  628. PROC eatnoteq()
  629. {
  630.   asmtoken(+_TOKEXCL); asmtoken(+_TOKEQUAL);
  631.   asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  632.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  633.   asmtoken(+_OPNOTEQ);
  634. }
  635.  
  636. FUNC BOOL tokexpr RECURSIVE() //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш  (ёъюсър, чря Єр , ъюэхЎ ёЄЁюъш)
  637. { //ъюьрэфр єцх яЁюўшЄрэр
  638. VAR CHAR opsym;
  639. VAR BOOL modified;
  640. VAR BOOL dbl;
  641. //VAR BOOL ok;
  642. {
  643.   //ok = +TRUE;
  644.   matchdirect(); //яЁюяєёъ '#'
  645.   eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  646.   WHILE ((!_asmwaseof)&&(_asmwaseols==0)) { //єцх яЁюўшЄрэр юяхЁрЎш  ш яЁюсхы√-хэЄхЁ√ яюёых эх╕ (_asmwaseol - хэЄхЁ яюёых val)
  647.     opsym = *(PCHAR)_tword;
  648.     modified = (_cnext=='=');
  649.     dbl = (_cnext==opsym);
  650.     IF (modified||dbl) asmrdword_tokspc(); //use '=' or '>' or '<'
  651.     IF (opsym=='<') {
  652.       IF (dbl) {eatshl(); //ёЄрЁюх ёфтшэєЄ№ ёЄюы№ъю Ёрч, ёъюы№ъю уырёшЄ эютюх!
  653.       }ELSE IF (modified) {eatlesseq();
  654.       }ELSE {eatless();
  655.       };
  656.     }ELSE IF (opsym=='>') {
  657.       IF (dbl) {eatshr(); //ёЄрЁюх ёфтшэєЄ№ ёЄюы№ъю Ёрч, ёъюы№ъю уырёшЄ эютюх!
  658.       }ELSE IF (modified) {eatmoreeq();
  659.       }ELSE {eatmore();
  660.       };
  661.     }ELSE IF (opsym=='=') {eateq();
  662.     }ELSE IF (opsym=='!') {eatnoteq();
  663.     }ELSE BREAK;
  664.   };
  665.   RETURN +TRUE; //ok; //todo err
  666. }
  667. }
  668.  
  669. FUNC BOOL tokexpr_close() //яюёых эхую эшўхую сюы№°х эхы№ч  яЁютхЁ Є№, Є.ъ. ъєЁёюЁ ьюу ёфтшэєЄ№ё 
  670. {
  671. VAR BOOL ok;
  672.   ok =             tokexpr();
  673.   IF (ok) ok = matchclose();
  674.   RETURN ok;
  675. }
  676.  
  677. PROC asm_direct_expr_close_token(BYTE token)
  678. {
  679.   //if(matchdirect()) {
  680.     IF (tokexpr()) {
  681.       IF (matchclose()) {asmtoken(token);
  682.       }ELSE tokerr(+_ERRCLOSE); //no closing bracket
  683.     }ELSE tokerr(+_ERREXPR); //wrong expr
  684.   //}else tokerr(_ERRPAR); //no direct
  685. }
  686.  
  687. PROC tokcomment()
  688. {
  689.   asmtoken(+_TOKCOMMENT);
  690.   _lentword = 0/**strclear(_tword)*/; //ўшЄрхь ё яєёЄющ ёЄЁюъш
  691.   IF (_waseols==0) { //юсїюф эр ёыєўрщ ъюэхўэюую ; яхЁхф ъюьрэфющ
  692.     WHILE (_spcsize != 0) { //фюсртшЄ№ ё·хфхээ√х яЁюсхы√
  693.       _lentword = stradd(_tword, _lentword, ' ');
  694.       DEC _spcsize;
  695.     };
  696.     WHILE (_waseols==0/**&&(!_waseof)*//**&&(_cnext!=_DIERESIS)*/) {
  697.       rdchcmt(); //яЁюяєёърхЄ тёх хэЄхЁ√
  698.     };
  699.   };
  700.   _tword[_lentword] = (CHAR)0x00; //strclose(_tword, _lentword); //todo эрЁє°хэр ярЁэюёЄ№ clear..close
  701.   toktext(); //ухэхЁшЁєхЄ <text>text<endtext>
  702.   asmtoken(+_TOKENDCOMMENT);
  703.   IF (+(BYTE)_cnext < +(BYTE)'!') {
  704.     IF (_cnext == '\t') {
  705.       _spcsize = _spcsize + 8;
  706.     }ELSE {
  707.       INC _spcsize;
  708.     };
  709.     rdch(); //ўшЄрхь тё■ уЁєяяє фшхЁхчшёют + ёшьтюы ъръ юфшэ ёшьтюы
  710.   };
  711.   asmrdword_tokspc(); //[ЄюъхэшчшЁєхЄ ъюэхўэ√х яЁюсхы√ шыш EOL,] схЁ╕Є ёыхфє■∙є■ ъюьрэфє (яюёых шэёЄЁєъЎшш)
  712. }
  713.  
  714. PROC tokorg()
  715. {
  716.   asmtoken(+_CMDORG);
  717.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  718.   IF (tokexpr()) {asmtoken(+_FMTCMD);
  719.   }ELSE tokerr(+_ERREXPR); //wrong expr
  720. }
  721.  
  722. PROC tokalign()
  723. {
  724.   asmtoken(+_CMDALIGN);
  725.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  726.   IF (tokexpr()) {asmtoken(+_FMTCMD);
  727.   }ELSE tokerr(+_ERREXPR); //wrong expr
  728. }
  729. /**
  730. PROC tokpage()
  731. {
  732.   tokerrcmd();
  733. }
  734.  
  735. PROC tokif()
  736. {
  737.   asmtoken(+_CMDIF);
  738.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  739.   IF (tokexpr()) {asmtoken(+_FMTCMD);
  740.   }ELSE tokerr(+_ERREXPR); //wrong expr
  741.   //tokerrcmd();
  742. }
  743.  
  744. PROC tokelse()
  745. {
  746.   asmtoken(+_CMDELSE);
  747.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  748.   //tokerrcmd();
  749. }
  750.  
  751. PROC tokendif()
  752. {
  753.   asmtoken(+_CMDENDIF);
  754.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  755.   //tokerrcmd();
  756. }
  757.  
  758. PROC tokdup()
  759. {
  760.   tokerrcmd();
  761. }
  762.  
  763. PROC tokedup()
  764. {
  765.   tokerrcmd();
  766. }
  767.  
  768. PROC tokmacro()
  769. {
  770.   tokerrcmd();
  771. }
  772.  
  773. PROC tokendm()
  774. {
  775.   tokerrcmd();
  776. }
  777. */
  778. PROC tokexport()
  779. {
  780.   asmtoken(+_CMDEXPORT);
  781.   asmrdword_tokspc(); //ё·хфрхь call
  782.   eatlabel(+_TOKLABEL);
  783.   //asmmtoken(+_TOKTEXT);
  784.   //fputs(_tword, _fout);
  785.   //asmtoken(+_TOKENDTEXT);
  786.   //asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  787.   asmtoken(+_FMTCMD); //ўЄюс√ шёяюы№чютрЄ№ label
  788. }
  789. /**
  790. PROC toklocal()
  791. {
  792.   tokerrcmd();
  793. }
  794.  
  795. PROC tokendl()
  796. {
  797.   tokerrcmd();
  798. }
  799.  
  800. PROC tokdisp()
  801. {
  802.   asmtoken(+_CMDDISP);
  803.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  804.   IF (tokexpr()) {asmtoken(+_FMTCMD);
  805.   }ELSE tokerr(+_ERREXPR); //wrong expr
  806. }
  807.  
  808. PROC tokent()
  809. {
  810.   asmtoken(+_CMDENT);
  811.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  812.   asmtoken(+_FMTCMD);
  813. }
  814. */
  815. PROC tokinclude()
  816. {
  817.   asmtoken(+_CMDINCLUDE);
  818.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  819.   IF (matchquote()) {
  820.     //asmtoken(+_OPWRSTR);
  821.     _lentword = 0/**strclear(_tword)*/; //ўшЄрхь ё яєёЄющ ёЄЁюъш
  822.     rdquotes('\"');
  823.     toktext(); //ухэхЁшЁєхЄ <text>text<endtext>
  824.     rdch(); //яЁюяєёЄшЄ№ чръЁ√тр■∙є■ ърт√ўъє
  825.     asmtoken(+_TOKDBLQUOTESYM);
  826.     asmrdword_tokspc();
  827.   }ELSE tokerr(+_ERREXPR);
  828.   //asmtoken(+_FMTCMD); //todo?
  829. }
  830.  
  831. PROC tokincbin()
  832. {
  833.   asmtoken(+_CMDINCBIN);
  834.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  835.   IF (matchquote()) {
  836.     //asmtoken(+_OPWRSTR);
  837.     _lentword = 0/**strclear(_tword)*/; //ўшЄрхь ё яєёЄющ ёЄЁюъш
  838.     rdquotes('\"');
  839.     toktext(); //ухэхЁшЁєхЄ <text>text<endtext>
  840.     rdch(); //яЁюяєёЄшЄ№ чръЁ√тр■∙є■ ърт√ўъє
  841.     asmtoken(+_TOKDBLQUOTESYM);
  842.     asmrdword_tokspc();
  843.   }ELSE tokerr(+_ERREXPR);
  844.   //todo ярЁрьхЄЁ√ (яЁюяєёъ, фышэр)
  845.   //asmtoken(+_FMTCMD); //todo?
  846. }
  847.  
  848. PROC tokdb()
  849. {
  850.   asmtoken(+_CMDDB);
  851.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  852.   REPEAT {
  853.     IF (matchquote()) {
  854.       asmtoken(+_OPWRSTR);
  855.       _lentword = 0/**strclear(_tword)*/; //ўшЄрхь ё яєёЄющ ёЄЁюъш
  856.       rdquotes('\"');
  857.       toktext(); //ухэхЁшЁєхЄ <text>text<endtext>
  858.       rdch(); //яЁюяєёЄшЄ№ чръЁ√тр■∙є■ ърт√ўъє
  859.       asmtoken(+_TOKDBLQUOTESYM);
  860.       asmrdword_tokspc();
  861.     }ELSE IF (tokexpr()) {
  862.       asmtoken(+_OPWRVAL);
  863.     }ELSE tokerr(+_ERREXPR);
  864.   }UNTIL (!matchcomma());
  865.   asmtoken(+_FMTCMD);
  866. }
  867.  
  868. PROC tokdw()
  869. {
  870.   asmtoken(+_CMDDW);
  871.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  872.   REPEAT {
  873.     tokexpr();
  874.     asmtoken(+_OPWRVAL);
  875.   }UNTIL (!matchcomma());
  876.   asmtoken(+_FMTCMD);
  877. }
  878.  
  879. PROC tokdl()
  880. {
  881.   asmtoken(+_CMDDL);
  882.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  883.   REPEAT {
  884.     tokexpr();
  885.     asmtoken(+_OPWRVAL);
  886.   }UNTIL (!matchcomma());
  887.   asmtoken(+_FMTCMD);
  888. }
  889.  
  890. PROC tokds()
  891. {
  892.   asmtoken(+_CMDDS);
  893.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  894.   tokexpr();
  895.   WHILE (matchcomma()) {
  896.     tokexpr();
  897.   };
  898.   asmtoken(+_FMTCMD);
  899. }
  900. /**
  901. PROC tokdisplay()
  902. {
  903.   tokerrcmd();
  904. }
  905.  
  906. PROC tokrepeat()
  907. {
  908.   tokerrcmd();
  909. }
  910.  
  911. PROC tokuntil()
  912. {
  913.   tokerrcmd();
  914. }
  915.  
  916. PROC tokstruct()
  917. {
  918.   tokerrcmd();
  919. }
  920.  
  921. PROC tokendstruct()
  922. {
  923.   tokerrcmd();
  924. }
  925. */
  926. PROC tokcolon()
  927. {
  928.   asmtoken(+_TOKCOLON);
  929.   asmrdword_tokspc(); //ё·хфрхь ':'
  930. }
  931.  
  932. ///////////////////////
  933.  
  934. PROC tokcmd()
  935. {
  936.   //_asmwaseof=_waseof;
  937.   //rdword_tokspc(); //яЁюўшЄрэю т яЁхф√фє∙хщ шэёЄЁєъЎшш
  938.   //stringdecapitalize(_tword,_lentword);
  939.   IF (*(PCHAR)_tword==';') {tokcomment();
  940. /**  }ELSE IF (*(PCHAR)_tword==':') {
  941.     asmtoken(+_TOKCOLON);
  942.     asmrdword_tokspc(); //ё·хфрхь ':'
  943. */
  944.   }ELSE IF (_asmspcsize!=0) {
  945.     //tokasm(); //assembly mnemonic or directive
  946.     tokcalllbl();
  947. /**    IF (!tokcalllbl(_tword)) {
  948.       tokerrcmd(); //wrong _tword
  949.     };*/
  950.   }ELSE { //<label> шыш <label>=<expr>
  951.     //asmtoken(0xff);
  952.     eatlabel(+_CMDLABEL); //ё·хфрхь ьхЄъє
  953.     IF (matchreequ()) { //<label>=<expr>
  954.       IF (tokexpr()) {
  955.         asmtoken(+_FMTREEQU);
  956.       }ELSE tokerr(+_ERREXPR); //wrong expr
  957.     }ELSE //IF ((_asmwaseols!=0)||(_asmwaseof)||(*(PCHAR)_tword==':')||(*(PCHAR)_tword==';')){ //<label>
  958.       asmtoken(+_FMTCMD); //<label>
  959.     //}ELSE tokerrcmd(); //wrong _tword
  960.   };
  961.   //яш°хь eol ш яЁюсхы√, ъюЄюЁ√х эх чряшёрыш яЁш ўЄхэшш ъюэхўэюую ёыютр
  962.   IF (_asmwaseols!=0) {
  963.     WHILE (_asmwaseols!=0) {
  964.       asmtoken(+_TOKEOL);
  965.       DEC _asmwaseols;
  966.     };
  967.     tokspc(); //ЄюъхэшчшЁєхь яЁюсхы√ яюёых
  968.   };
  969. }
  970.  
  971. PROC tokinit()
  972. {
  973.   _tokfn = (PCHAR)_stokfn;
  974.   tokinitlblbuf();
  975.   tokpre(); //чряюыэшЄ№ ЄрсышЎє ьхЄюъ
  976. }
  977.  
  978. PROC tokenize(PCHAR fn)
  979. {
  980. VAR UINT i;
  981.   _fin = nfopen(fn, "rb");
  982.   IF (_fin != (PBYTE)0) {
  983.     _waseof = +FALSE;
  984.     _curline = 1;
  985.     initrd();
  986.  
  987.     _lentokfn = 0;
  988.     i = 0;
  989.     WHILE (fn[_lentokfn] != (CHAR)0x00) {
  990.       _tokfn[_lentokfn] = fn[_lentokfn];
  991.       IF (fn[_lentokfn] == '.') i = _lentokfn;
  992.       INC _lentokfn;
  993.     };
  994.     //_lentokfn = strjoineol(_tokfn, 0, fn, '.'); //terminator is not copied
  995.     //_lentokfn = stradd(_tokfn, _lentokfn, '.');
  996.     _lentokfn = i+1; //after last dot
  997.     _lentokfn = stradd(_tokfn, _lentokfn, (CHAR)((BYTE)fn[_lentokfn]&0xdf));
  998.     _lentokfn = stradd(_tokfn, _lentokfn, '_');
  999.     _tokfn[_lentokfn] = (CHAR)0x00;
  1000.     _fout = openwrite(_tokfn);
  1001.  
  1002.     _asmwaseols = 0;
  1003.     _asmwaseof = +FALSE;
  1004.     asmrdword_tokspc(); //ўшЄрхь яхЁтє■ ъюьрэфє
  1005.  
  1006.     WHILE (!_asmwaseof) { //todo шыш endasm ('}')
  1007.       tokcmd();
  1008.     };
  1009.  
  1010.     asmtoken(+_TOKEOF);
  1011.     fclose(_fout); //closewrite(_fout); //closefout();
  1012.  
  1013.     fclose(_fin); //closefin();
  1014.   };
  1015. }
  1016.  
  1017. PROC tokenize_end()
  1018. {
  1019. }
  1020.