Subversion Repositories NedoOS

Rev

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