Subversion Repositories NedoOS

//ЄюъхэшчрЄюЁ эх чэрхЄ ъюф√ ъюьрэф
//ЄюъхэшчрЄюЁ эх яюфуы ф√трхЄ тяхЁ╕ф ш эх юЄьрЄ√трхЄ эрчрф
//_asmwaseol ухэхЁшЁєхЄё  т asmrdword_tokspc(), р eol т√тюфшЄё  яюёых ъюьрэф√

//// imported
#include "../_sdk/str.h"
#include "../_sdk/io.h"

VAR UINT _curlnbeg; //эюьхЁ ёЄЁюъш эр ьюьхэЄ эрўрыр Єюъхэр //фы  read, emit
VAR BOOL _cmts; //фы  read, emit

CONST BOOL _isalphanum[256];
VAR CHAR txt_low[10];

EXTERN PCHAR _tword; //Єхъє∙хх ёыютю
EXTERN UINT _lentword;
//EXTERN CHAR _s0[_STRLEN]; //Єхъє∙хх ёыютю

EXTERN BOOL _waseof;
EXTERN PBYTE _fin;
EXTERN PBYTE _fout;
FUNC BYTE readfin FORWARD();

EXTERN UINT _curline; //Єхъє∙шщ эюьхЁ ёЄЁюъш
EXTERN UINT _waseols; //ўшёыю EOL ё яЁю°ыюую Ёрчр
EXTERN UINT _spcsize; //ўшёыю яЁюсхыют яюёых яЁюўшЄрээющ ъюьрэф√
EXTERN CHAR _cnext;

FUNC UINT stradd FORWARD(PCHAR s, UINT len, CHAR c);
FUNC BOOL strcplow FORWARD(PCHAR s1, PCHAR s2);

PROC rdchcmt FORWARD();
PROC rdch FORWARD();
PROC rdquotes FORWARD(CHAR eol);
PROC initrd FORWARD();

CONST BYTE _ASMMAXSPC;

PROC tokpre FORWARD(); //чряюыэшЄ№ ЄрсышЎє ьхЄюъ

////
VAR CHAR _c1small;
VAR CHAR _c2small;
VAR BOOL _asmwaseof;
VAR UINT _asmwaseols; //ўшёыю EOL ё яЁю°ыюую Ёрчр
VAR UINT _asmspcsize;

VAR CHAR _stokfn[_STRLEN]; //Єхъє∙хх ёыютю
VAR PCHAR _tokfn; //Єхъє∙хх ёыютю
VAR UINT _lentokfn;

VAR BYTE _temppar;

#define _TOKLBLBUFSIZE 0x1200
VAR UINT _toklblbuffreestart; //[1];
//VAR UINT _tokoldlblbuffreestart; //[1];
CONST UINT _TOKLBLBUFEOF = 0xffff;
//CONST UINT _TOKLBLBUFMAXSHIFT  = 0x1fb0/**(_LBLBUFSIZE-0x0100)*/; //0x3f00
#define _TOKLBLBUFMAXSHIFT (UINT)(_TOKLBLBUFSIZE-_STRLEN-10)
//todo фшэрьшўхёъш т√фхышЄ№
VAR UINT _toklblshift[0x100];
//VAR UINT _tokoldlblshift[0x100];
VAR BYTE _toklbls[_TOKLBLBUFSIZE]; //0x4000
VAR BYTE _toklblhash;

PROC rdaddwordall() //яюфъыхшЄ№ ёыхфє■∙є■ ъюьрэфє ъ Єхъє∙хщ
{
  _spcsize = 0; //ўшёыю яЁюсхыют яюёых яЁюўшЄрээющ ъюьрэф√
  _waseols = 0;
  _curlnbeg = _curline;

  IF (_isalphanum[(BYTE)_cnext] ) { //ёыютю ё ЎшЇЁюсєът√
    REPEAT { //цф╕ь эхЎшЇЁюсєътє (EOF эх ЎшЇЁюсєътр)
      IF (_lentword < _STRMAX) { //т рёьх шч ъюьяшы ЄюЁр тёх ёыютр ъюЁюўх, эю эх т Ёєўэюь рёьх
        _tword[_lentword] = _cnext;
        INC _lentword;
      };
      _cnext = (CHAR)readfin();
    }UNTIL (!_isalphanum[(BYTE)_cnext]/** || _waseof*/ );
  }ELSE { //ёыютю шч эхЎшЇЁюсєътхээюую ёшьтюыр - ўшЄрхь юфэє эхЎшЇЁюсєътє (шэрўх с√ эх ўшЄрыш)
    //rdch(); //ўшЄрхь тё■ уЁєяяє фшхЁхчшёют + ёшьтюы ъръ юфшэ ёшьтюы
    IF (_lentword < _STRMAX) { //т рёьх шч ъюьяшы ЄюЁр тёх ёыютр ъюЁюўх, эю эх т Ёєўэюь рёьх
      _tword[_lentword] = _cnext;
      INC _lentword;
    };
    _cnext = (CHAR)readfin();
  }; //эхы№ч  яюфъыхшЄ№ ¤Єю єёыютшх ъ Ўшъыє, Є.ъ. юэю фы  шчэрўры№эюую cnext ш юфшэ Ёрч

  goto loopgo;
  loop: //REPEAT { //цф╕ь эхфшхЁхчшё шыш EOF
    _cnext = (CHAR)readfin();
  loopgo:
    IF ((BYTE)_cnext < (BYTE)'!') { //єёъюЁхэшх т√їюфр
      INC _spcsize; //spaces after tword
      IF ((BYTE)_cnext == 0x0a) {
        INC _curline;
        _spcsize = 0;
        INC _waseols;
      }ELSE IF ((BYTE)_cnext == 0x09) {
        _spcsize = _spcsize + 7;
      };
      IF (!_waseof) goto loop;
    };
  //}UNTIL (_wasdieresis || _waseof );
  _tword[_lentword] = '\0';
}
/**
PROC rdwordall()
//ўшЄрхь ёыютю _tword (шч ЄхъёЄр ё фшхЁхчшёрьш тьхёЄю яЁюсхыют, хэЄхЁют, Єрсєы Ўшщ)
//ёыютю чрърэўштрхЄё , ъюуфр фшхЁхчшё шыш эхЎшЇЁюсєътхээ√щ ёшьтюы (юэ яюярф╕Є т cnext, р ъєЁёюЁ т Їрщых яюёых эхую)
{
  _lentword = 0; //strclear(_tword); //todo эрЁє°хэр ярЁэюёЄ№ clear..close
  rdaddwordall();
}
*/
//////////////////

PROC asmtoken(BYTE token)
{
  writebyte(_fout, token);
}

PROC tokspc()
{
//IF (!_waseol) { //уы■ъ эр ъюьрэфрї шч юфэюую ёыютр
  WHILE (_asmspcsize > (UINT)_ASMMAXSPC) { //ўшёыю яЁюсхыют яюёых яЁюўшЄрээющ ъюьрэф√
    asmtoken(+_TOKSPC0+_ASMMAXSPC);
    _asmspcsize = _asmspcsize - (UINT)_ASMMAXSPC;
  };
  IF (_asmspcsize!=0) asmtoken(+_TOKSPC0 + (BYTE)_asmspcsize);
//};
}

PROC asmrdword_tokspc() //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ ъюьрэф√ ш ўшЄрхЄ эютє■
//todo т√фртрЄ№ eol ъръ ъюьрэфє?
{
  _asmwaseof = _waseof;
  _asmwaseols = _waseols;
  _asmspcsize = _spcsize; //ўшёыю яЁюсхыют яюёых яЁюўшЄрээющ ъюьрэф√
  IF (_waseols==0) tokspc(); //ЄюъхэшчшЁєхь яЁюсхы√ яюёых яЁю°ыющ ъюьрэф√ (шэрўх юЄъырф√трхь эр яюёых eol)
  //rdwordall();
  _lentword = 0/**strclear(_tword)*/; //todo эрЁє°хэр ярЁэюёЄ№ clear..close
  rdaddwordall();
  _c1small = (CHAR)((BYTE)(*(PCHAR)_tword)|0x20);
  _c2small = (CHAR)((BYTE)_tword[1]|0x20);
}

PROC toktext() //ухэхЁшЁєхЄ <text>text<endtext>
{
  asmtoken(+_TOKTEXT);
  fputs(_tword, _fout);
  asmtoken(+_TOKENDTEXT);
}

//ёухэхЁшЁютрЄ№ Єюъхэ ю°шсъш ё ЄхъёЄрьш юЄё■фр фю ъюэЎр шэёЄЁєъЎшш/ёЄЁюъш (тъы■ўр  _tword)
//тъы■ўр  яюёыхфэ■■ ъюьрэфє т ёЄЁюъх, ъюЄюЁр  ё waseol шыш ъюЄюЁр  ':'
PROC tokerr(BYTE token)
{
  asmtoken(+_ERR);
  asmtoken(token);
  WHILE (+TRUE) {
    toktext(); //ухэхЁшЁєхЄ <text>text<endtext>
    IF ((_waseols!=0)||(_waseof)||(*(PCHAR)_tword==':')) BREAK;
    asmrdword_tokspc();
  }; //TODO т юфэє ёЄЁюъє
  asmtoken(+_TOKENDERR);
  asmrdword_tokspc(); //[ЄюъхэшчшЁєхЄ ъюэхўэ√х яЁюсхы√ шыш EOL,] схЁ╕Є ёыхфє■∙є■ ъюьрэфє (яюёых шэёЄЁєъЎшш)
  //todo asmfmt_err?
}

//ёухэхЁшЁютрЄ№ Єюъхэ ю°шсъш ё ЄхъёЄюь юЄё■фр фю ъюэЎр ёЄЁюъш (тъы■ўр  _tword)
//шыш фю ъюэЎр ъюьрэф√???
PROC tokerrcmd()
{
  tokerr(+_ERRCMD); //todo ёфхырЄ№ asmcmd_err...asmfmt_err тюъЁєу?
}

PROC tokinitlblbuf()
{
  _toklblhash = 0x00;
  REPEAT {
    _toklblshift[_toklblhash] = _TOKLBLBUFEOF;
    INC _toklblhash;
  }UNTIL (_toklblhash == 0x00);
  _toklblbuffreestart = 0;
};

PROC tokcalllbl()
{
VAR PBYTE plbl; //ьхЄър т ЄрсышЎх чрърэўштрхЄё  эєы╕ь
//VAR PBYTE pstr; //ьхЄър т ёЄЁюъх чрърэўштрхЄё  эєы╕ь
//VAR BYTE cstr; //ёшьтюы шч ёЄЁюъш
//VAR BYTE clbl; //ёшьтюы шч ЄрсышЎ√ ьхЄюъ
//VAR BOOL res;
VAR UINT plbl_idx;
VAR PBYTE calladdr;
  //res = +FALSE;
  _toklblhash = (BYTE)hash((PBYTE)_tword);

  plbl_idx = _toklblshift[_toklblhash];
  WHILE (plbl_idx != _TOKLBLBUFEOF) { //яюър Ўхяюўър ьхЄюъ эх чръюэўшырё№
    plbl = &_toklbls[plbl_idx];
    plbl_idx = *(PUINT)(plbl);
    plbl = &plbl[+sizeof(UINT)/**+1*/]; //skip string size
    IF (strcp((PCHAR)_tword, (PCHAR)plbl)) { //ьхЄър эрщфхэр
      plbl = &plbl[10/**_lenname+1*/];
      calladdr = (PBYTE)*(PLONG)(plbl); //todo PPOI
      plbl = &plbl[+sizeof(LONG)]; //todo POI
      _temppar = *(PBYTE)(plbl);
      //INC plbl;
      CALL (calladdr);
      //res = +TRUE;
      //BREAK;
      goto e;
    };
  };
  tokerrcmd(); //not found
  e: ; //RETURN res;
//asmtoken(0xfd);
}

PROC tokaddlbl1(PCHAR txt, PBYTE proc, BYTE data)
{
VAR PBYTE plbl;
//VAR UINT freestart_idx;
//VAR UINT plbl_idx;
  _toklblhash = (BYTE)hash((PBYTE)txt);

  //ьхЄъш эхЄ: яш°хь т эрўрыю Ўхяюўъш рфЁхё ъюэЎр ёЄЁрэшЎ√ ш ёючфр╕ь ьхЄъє Єрь ёю ёё√ыъющ эр ёЄрЁюх эрўрыю Ўхяюўъш
  //freestart_idx = _toklblbuffreestart; //[0] //эрўрыю ётюсюфэюую ьхёЄр
  //plbl_idx = _toklblbuffreestart; //[0] //freestart_idx; //єърчрЄхы№ эр эрўрыю фрээ√ї ёючфртрхьющ ьхЄъш (эрфю юс чрЄхы№эю чряюьэшЄ№!) //эрўрыю ётюсюфэюую ьхёЄр
  plbl = &_toklbls[_toklblbuffreestart]; //[0] [plbl_idx]; //єърчрЄхы№ эр эрўрыю ёючфртрхьющ ьхЄъш //эрўрыю ётюсюфэюую ьхёЄр
  //яш°хь ьхЄъє
  POKE *(PUINT)(plbl) = _toklblshift[_toklblhash]; //ёЄрЁ√щ єърчрЄхы№ эр эрўрыю Ўхяюўъш
  _toklblshift[_toklblhash] = _toklblbuffreestart; //[0] //freestart_idx; //эют√щ єърчрЄхы№ эр эрўрыю Ўхяюўъш //эрўрыю ётюсюфэюую ьхёЄр
  plbl = &plbl[+sizeof(UINT)];
  //POKE *(PBYTE)(plbl) = (BYTE)10/**(BYTE)_lenname*/;
  //INC plbl;
  strcopy(txt, 9/**_lenname*/, (PCHAR)plbl);
  plbl = &plbl[10/**_lenname+1*/];
  POKE *(PLONG)(plbl) = (LONG)proc; //todo PPOI
  plbl = &plbl[+sizeof(LONG)]; //todo POI
  POKE *(PBYTE)(plbl) = data;
  //INC plbl;
  //plbl_idx = (UINT)(plbl - _toklbls); //єърчрЄхы№ ъюэхЎ ёючфртрхьющ ьхЄъш
  //_toklblshift[_toklblhash] = freestart_idx; //эют√щ єърчрЄхы№ эр эрўрыю Ўхяюўъш
  //_toklblbuflen = _toklblbuflen + plbl_idx - freestart_idx;
  _toklblbuffreestart = (UINT)(plbl - _toklbls) + 1; //єърчрЄхы№ ъюэхЎ ёючфртрхьющ ьхЄъш //plbl_idx; /**[0]*/
  //INC _toklblcount;
}

PROC stringdecapitalize(PCHAR s1, PCHAR s2)
{
VAR CHAR c;
  loop:
    c = *(PCHAR)s1;
    IF (((BYTE)c>=(BYTE)'A') && ((BYTE)c<=(BYTE)'Z')) {
      c = (CHAR)((BYTE)c | 0x20);
    };
    POKE *(PCHAR)(s2) = c;
    INC s1;
    INC s2;
    IF (c != '\0') goto loop;
}

PROC tokaddlbl(PCHAR txt, PBYTE proc, BYTE data)
{
  tokaddlbl1(txt, proc, data);
  stringdecapitalize(txt, txt_low);
  tokaddlbl1(txt_low, proc, data);
}

//////////////////////////////////////
//хёыш match ёЁрсюЄры, Єю _tword ё·хфрхЄё  (ўшЄрхЄё  ёыхфє■∙р ) ш т√тюфшЄё  ёююЄтхЄёЄтє■∙шщ Єюъхэ
//хёыш эх ёЁрсюЄры, Єю _tword эх ё·хфрхЄё , ю°шсър эх т√фр╕Єё  (Єюы№ъю Їыру +FALSE)
//хёыш ю°шсър, Єю ю°шсър эх т√фр╕Єё  (Єюы№ъю Їыру +FALSE)

    //reg ш rp ьюуєЄ тёЄЁхЄшЄ№ё  т юфэющ яючшЎшш т inc,dec,[ld],[add],[adc],[sbc]
    //шэрўх ышсю reg (b,c,d,e,h,l,a,hx,lx,hy,ly, эю эх i,r!), ышсю rp (bc,de,hl,sp,ix,iy, эю эх af!)
    //i,r ш af юсЁрсрЄ√трЄ№ юЄфхы№эю, Є.ъ. эрфю Єюы№ъю фы  эхъюЄюЁ√ї ъюьрэф, юёЄры№э√х ъюьрэф√ эх фюыцэ√ яЁютхЁ Є№ ¤Єє ю°шсъє яЁш ёрьющ ъюьяшы Ўшш

FUNC BOOL matchdirect()
{
VAR BOOL ok;
  IF (*(PCHAR)_tword=='#') {
    asmtoken(+_TOKDIRECT);
    asmrdword_tokspc();
    ok = +TRUE;
  }ELSE ok = +FALSE;
RETURN ok;
}

FUNC BOOL matchcomma()
{
VAR BOOL ok;
  IF (*(PCHAR)_tword==',') {
    asmtoken(+_TOKCOMMA);
    asmrdword_tokspc();
    ok = +TRUE;
  }ELSE ok = +FALSE;
RETURN ok;
}

FUNC BOOL matchprime()
{
VAR BOOL ok;
  IF (*(PCHAR)_tword=='\'') {
    asmtoken(+_TOKPRIMESYM);
    asmrdword_tokspc();
    ok = +TRUE;
  }ELSE ok = +FALSE;
RETURN ok;
}

FUNC BOOL matchquote()
{
VAR BOOL ok;
  IF (*(PCHAR)_tword=='\"') {
    asmtoken(+_TOKDBLQUOTESYM);
    //asmrdword_tokspc();
    ok = +TRUE;
  }ELSE ok = +FALSE;
RETURN ok;
}

FUNC BOOL matchreequ()
{
VAR BOOL ok;
  IF ( (*(PCHAR)_tword=='=') || ((_c1small=='e')&&(_c2small=='q')) ) {
    asmtoken(+_TOKEQUAL/**'='*/);
    asmrdword_tokspc();
    ok = +TRUE;
  }ELSE ok = +FALSE;
RETURN ok;
}

FUNC BOOL matchopen()
{
VAR BOOL ok;
  IF       (*(PCHAR)_tword=='(') {asmtoken(+_TOKOPEN); asmrdword_tokspc(); ok = +TRUE;
  }ELSE IF (*(PCHAR)_tword=='[') {asmtoken(+_TOKOPENSQ); asmrdword_tokspc(); ok = +TRUE;
  }ELSE ok = +FALSE;
RETURN ok;
}

FUNC BOOL matchclose()
{
VAR BOOL ok;
  IF       (*(PCHAR)_tword==')') {asmtoken(+_TOKCLOSE); asmrdword_tokspc(); ok = +TRUE;
  }ELSE IF (*(PCHAR)_tword==']') {asmtoken(+_TOKCLOSESQ); asmrdword_tokspc(); ok = +TRUE;
  }ELSE ok = +FALSE;
RETURN ok;
}

//////////////////////////////////////
FUNC BOOL tokexpr RECURSIVE FORWARD();

PROC eatlabel(BYTE token)
{
  WHILE ((_cnext=='.')||(_cnext=='#')) {
    rdaddwordall(); //яЁшъыхшЄ№ Єюўъє
    IF (_spcsize==0)
      IF (_isalphanum[(BYTE)_cnext]) //с√ыю isalpha
        IF (_waseols==0)
          //IF (!_waseof)
            rdaddwordall(); //яЁшъыхшЄ№ ёыхфє■∙хх ёыютю
  };
  asmtoken(token/**_TOKLABEL шыш _CMDLABEL*/);
  asmtoken(+_TOKTEXT);
  fputs(_tword, _fout);
  asmtoken(+_TOKENDTEXT);
  asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  //хёыш ьхЄър с√ыр яюёыхфэшь ёыютюь т ёЄЁюъх, Єюуфр ¤Єющ ЄюъхэшчрЎшхщ ь√ чрс√ыш с√ яЁю хэЄхЁ (юэ ЄхяхЁ№ т _asmwaseol)
}

PROC eatval RECURSIVE() //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш  (ёъюсър, чря Єр , ъюэхЎ ёЄЁюъш)
//<val>::=
//(<expr>) //т√Ёрцхэшх (т√ўшёы хЄё )
//|<num> //фхё Єшўэюх ўшёыю (яхЁхфр╕Єё  Ўхышъюь)
//|<var> //ьхЄър шыш ярЁрьхЄЁ ьръЁюёр (TODO эх ёююЄтхЄёЄтєхЄ  ч√ъє: Єрь ¤Єю &<var>)
//|$
//|'CHAR' //ёшьтюы№эр  ъюэёЄрэЄр
//|-<val> //т√ўшёышЄ№ val, яюЄюь ёфхырЄ№ NEG
//|+<val> //т√ўшёышЄ№ val
//|~<val> //т√ўшёышЄ№ val, яюЄюь ёфхырЄ№ INV
//|!<val> //т√ўшёышЄ№ val, яюЄюь ёфхырЄ№ INV(BOOL)
//|*<val> //яЁюўшЄрЄ№ ярь Є№ яю рфЁхёє (т√ўшёышЄ№ val, яюЄюь ёфхырЄ№ PEEK)
{ //ъюьрэфр єцх яЁюўшЄрэр
VAR CHAR opsym;
{
  opsym = *(PCHAR)_tword;
  IF (!_asmwaseof) { //чр∙шЄр юЄ чрЎшъыштрэш  т ъюэЎх ю°шсюўэюую Їрщыр
    IF ((BYTE)((BYTE)opsym - (BYTE)'0') < 0x0a) { //<num> //т√фр╕Є <num><text>digits<endtext> //extra BYTE for C bug
      asmtoken(+_TOKNUM);
      asmtoken(+_TOKTEXT);
//for float:
      IF (_cnext=='.') {
        rdaddwordall(); //яЁшъыхшЄ№ Єюўъє
        rdaddwordall(); //яЁшъыхшЄ№ фЁюсэє■ ўрёЄ№
        IF ( (_tword[_lentword-1]=='e') && (_cnext=='-') ) {
          rdaddwordall(); //яЁшъыхшЄ№ '-' юЄЁшЎрЄхы№эющ ¤ъёяюэхэЄ√
          rdaddwordall(); //яЁшъыхшЄ№ юЄЁшЎрЄхы№эє■ ¤ъёяюэхэЄє
        };
/*        asmrdword_tokspc();
        fputs(_tword, _fout);
        asmrdword_tokspc();*/ //todo e-12
      };
      fputs(_tword, _fout);
      asmtoken(+_TOKENDTEXT);
      asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
      //хёыш ўшёыю с√ыю яюёыхфэшь ёыютюь т ёЄЁюъх, Єюуфр ¤Єющ ЄюъхэшчрЎшхщ ь√ чрс√ыш с√ яЁю хэЄхЁ (юэ ЄхяхЁ№ т _asmwaseol)
    }ELSE IF (_isalphanum[(BYTE)opsym] || (opsym=='.') ) { //todo єсЁрЄ№ '.', хёыш чряЁхЄшЄ№ эрўшэрЄ№ ьхЄъш ё Єюўъш //с√ыю isalpha
      eatlabel(+_TOKLABEL);
    }ELSE IF ( opsym=='$' ) {
      asmtoken(+_TOKDOLLAR);
      asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
    }ELSE IF ( opsym=='(' ) {
      asmtoken(+_TOKOPEN);
      asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
      tokexpr(); //ЁхъєЁёш  //эр т√їюфх шч expr єцх яЁюўшЄрэр ')', эю ёыхфє■∙шщ ёшьтюы шыш ъюьрэфр эх яЁюўшЄрэ√
      asmtoken(+_TOKCLOSE);
      asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
    }ELSE IF ( opsym=='\'' ) { //todo тёЄртшЄ№ TOK_TEXT...TOK_ENDTEXT
      asmtoken(+_TOKPRIME);
      _lentword = 0/**strclear(_tword)*/; //ўшЄрхь ё яєёЄющ ёЄЁюъш
      rdquotes('\''/**, +FALSE*/);
      toktext(); //ухэхЁшЁєхЄ <text>text<endtext>
      rdch(); //яЁюяєёЄшЄ№ чръЁ√тр■∙є■ ърт√ўъє
      asmtoken(+_TOKPRIME);
      asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
    }ELSE IF ( opsym=='-' ) {
      asmtoken(+_OPPUSH0); asmtoken(+_TOKMINUS/**'-'*/);
      asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
      eatval(); //ЁхъєЁёштэ√щ т√чют val
      asmtoken(+_OPSUB);
    }ELSE IF ( opsym=='+' ) {
      asmtoken(+_OPPUSH0); asmtoken(+_TOKPLUS/**'+'*/);
      asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
      eatval(); //ЁхъєЁёштэ√щ т√чют val
      asmtoken(+_OPADD);
    }ELSE IF ( opsym=='*' ) {
      asmtoken(+_OPPUSH0); asmtoken(+_TOKSTAR/**'*'*/);
      asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
      eatval(); //ЁхъєЁёштэ√щ т√чют val
      asmtoken(+_OPPEEK);
    }ELSE IF ( opsym=='~' ) {
      asmtoken(+_OPPUSH0); asmtoken(+_TOKTILDE);
      asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
      eatval(); //ЁхъєЁёштэ√щ т√чют val
      asmtoken(+_OPINV);
    }ELSE IF ( opsym=='!' ) {
      asmtoken(+_OPPUSH0); asmtoken(+_TOKEXCL);
      asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
      eatval(); //ЁхъєЁёштэ√щ т√чют val
      asmtoken(+_OPINV); //todo BOOL
    }ELSE { tokerr(+_ERREXPR);/**errstr( ">>>WRONG PREFIX " ); err( opsym ); enderr();*/ };
  };
}
}

PROC eatmul()
{
  /**asmtoken(_ASMOPPUSHSKIP1);*/ asmtoken(+_TOKSTAR/**'*'*/);
  asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  eatval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  asmtoken(+_OPMUL);
}

PROC eatdiv()
{
  /**asmtoken(_ASMOPPUSHSKIP1);*/ asmtoken(+_TOKSLASH/**'/'*/);
  asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  eatval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  asmtoken(+_OPDIV);
}

PROC eatand()
{
  /**asmtoken(_ASMOPPUSHSKIP1);*/ asmtoken(+_TOKAND/**'&'*/);
  asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  eatval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  asmtoken(+_OPAND);
}

PROC eatandbool()
{
  /**asmtoken(_ASMOPPUSHSKIP2);*/ asmtoken(+_TOKAND/**'&'*/); asmtoken(+_TOKAND/**'&'*/);
  asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  eatval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  asmtoken(+_OPAND);
}

PROC eatmulval RECURSIVE() //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш  (ёъюсър, чря Єр , ъюэхЎ ёЄЁюъш)
{ //ъюьрэфр єцх яЁюўшЄрэр
VAR CHAR opsym;
VAR BOOL dbl;
{
  eatval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  WHILE ((!_asmwaseof)&&(_asmwaseols==0)) { //єцх яЁюўшЄрэр юяхЁрЎш  ш яЁюсхы√-хэЄхЁ√ яюёых эх╕ (_asmwaseol - хэЄхЁ яюёых val)
    opsym=*(PCHAR)_tword;
    dbl = (opsym=='&')&&(_cnext==opsym); //C compatibility
    IF (dbl) asmrdword_tokspc(); //use '&' //C compatibility
    IF       (opsym=='*') {eatmul();
    }ELSE IF (opsym=='/') {eatdiv();
    }ELSE IF (opsym=='&') {
      IF (dbl) {eatandbool();
      }ELSE eatand();
    }ELSE BREAK;
  };
}
}

PROC eatadd()
{
  /**asmtoken(_ASMOPPUSHSKIP1);*/ asmtoken(+_TOKPLUS/**'+'*/);
  asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  asmtoken(+_OPADD);
}

PROC eatsub()
{
  /**asmtoken(_ASMOPPUSHSKIP1);*/ asmtoken(+_TOKMINUS/**'-'*/);
  asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  asmtoken(+_OPSUB);
}

PROC eator()
{
  /**asmtoken(_ASMOPPUSHSKIP1);*/ asmtoken(+_TOKPIPE/**'|'*/);
  asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  asmtoken(+_OPOR);
}

PROC eatorbool()
{
  /**asmtoken(_ASMOPPUSHSKIP2);*/ asmtoken(+_TOKPIPE/**'|'*/); asmtoken(+_TOKPIPE/**'|'*/);
  asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  asmtoken(+_OPOR);
}

PROC eatxor()
{
  /**asmtoken(_ASMOPPUSHSKIP1);*/ asmtoken(+_TOKCARON/**'^'*/);
  asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  asmtoken(+_OPXOR);
}

PROC eatxorbool()
{
  /**asmtoken(_ASMOPPUSHSKIP2);*/ asmtoken(+_TOKCARON/**'^'*/); asmtoken(+_TOKCARON/**'^'*/);
  asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  asmtoken(+_OPXOR);
}

PROC eatsumval RECURSIVE() //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш  (ёъюсър, чря Єр , ъюэхЎ ёЄЁюъш)
{ //ъюьрэфр єцх яЁюўшЄрэр
VAR CHAR opsym;
VAR BOOL dbl;
{
  eatmulval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  WHILE ((!_asmwaseof)&&(_asmwaseols==0)) { //єцх яЁюўшЄрэр юяхЁрЎш  ш яЁюсхы√-хэЄхЁ√ яюёых эх╕ (_asmwaseol - хэЄхЁ яюёых val)
    opsym=*(PCHAR)_tword;
    dbl = ( (opsym=='|')||(opsym=='^') )&&(_cnext==opsym); //C compatibility
    IF (dbl) asmrdword_tokspc(); //use '|' or '^' //C compatibility
    IF (opsym=='+') {eatadd();
    }ELSE IF (opsym=='-') {eatsub();
    }ELSE IF (opsym=='|') {
      IF (dbl) {eatorbool();
      }ELSE eator();
    }ELSE IF (opsym=='^') {
      IF (dbl) {eatxorbool();
      }ELSE eatxor();
    }ELSE BREAK;
  };
}
}

PROC eatshl()
{
  /**asmtoken(_ASMOPPUSHSKIP2);*/ asmtoken(+_TOKLESS/**'<'*/); asmtoken(+_TOKLESS/**'<'*/);
  asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  asmtoken(+_OPSHL);
}

PROC eatshr()
{
  /**asmtoken(_ASMOPPUSHSKIP2);*/ asmtoken(+_TOKMORE/**'>'*/); asmtoken(+_TOKMORE/**'>'*/);
  asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  asmtoken(+_OPSHR);
}

PROC eatless()
{
  asmtoken(+_TOKLESS);
  asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  asmtoken(+_OPLESS);
}

PROC eatlesseq()
{
  asmtoken(+_TOKLESS); asmtoken(+_TOKEQUAL);
  asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  asmtoken(+_OPLESSEQ);
}

PROC eatmore()
{
  asmtoken(+_TOKMORE);
  asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  asmtoken(+_OPMORE);
}

PROC eatmoreeq()
{
  asmtoken(+_TOKMORE); asmtoken(+_TOKEQUAL);
  asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  asmtoken(+_OPMOREEQ);
}

PROC eateq()
{
  asmtoken(+_TOKEQUAL); asmtoken(+_TOKEQUAL);
  asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  asmtoken(+_OPEQ);
}

PROC eatnoteq()
{
  asmtoken(+_TOKEXCL); asmtoken(+_TOKEQUAL);
  asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  asmtoken(+_OPNOTEQ);
}

FUNC BOOL tokexpr RECURSIVE() //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш  (ёъюсър, чря Єр , ъюэхЎ ёЄЁюъш)
{ //ъюьрэфр єцх яЁюўшЄрэр
VAR CHAR opsym;
VAR BOOL modified;
VAR BOOL dbl;
//VAR BOOL ok;
{
  //ok = +TRUE;
  matchdirect(); //яЁюяєёъ '#'
  eatsumval(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш 
  WHILE ((!_asmwaseof)&&(_asmwaseols==0)) { //єцх яЁюўшЄрэр юяхЁрЎш  ш яЁюсхы√-хэЄхЁ√ яюёых эх╕ (_asmwaseol - хэЄхЁ яюёых val)
    opsym = *(PCHAR)_tword;
    modified = (_cnext=='=');
    dbl = (_cnext==opsym);
    IF (modified||dbl) asmrdword_tokspc(); //use '=' or '>' or '<'
    IF (opsym=='<') {
      IF (dbl) {eatshl(); //ёЄрЁюх ёфтшэєЄ№ ёЄюы№ъю Ёрч, ёъюы№ъю уырёшЄ эютюх!
      }ELSE IF (modified) {eatlesseq();
      }ELSE {eatless();
      };
    }ELSE IF (opsym=='>') {
      IF (dbl) {eatshr(); //ёЄрЁюх ёфтшэєЄ№ ёЄюы№ъю Ёрч, ёъюы№ъю уырёшЄ эютюх!
      }ELSE IF (modified) {eatmoreeq();
      }ELSE {eatmore();
      };
    }ELSE IF (opsym=='=') {eateq();
    }ELSE IF (opsym=='!') {eatnoteq();
    }ELSE BREAK;
  };
  RETURN +TRUE; //ok; //todo err
}
}

FUNC BOOL tokexpr_close() //яюёых эхую эшўхую сюы№°х эхы№ч  яЁютхЁ Є№, Є.ъ. ъєЁёюЁ ьюу ёфтшэєЄ№ё 
{
VAR BOOL ok;
  ok = tokexpr();
  IF (ok) ok = matchclose();
  RETURN ok;
}

PROC asm_direct_expr_close_token(BYTE token)
{
  //if(matchdirect()) {
    IF (tokexpr()) {
      IF (matchclose()) {asmtoken(token);
      }ELSE tokerr(+_ERRCLOSE); //no closing bracket
    }ELSE tokerr(+_ERREXPR); //wrong expr
  //}else tokerr(_ERRPAR); //no direct
}

PROC tokcomment()
{
  asmtoken(+_TOKCOMMENT);
  _lentword = 0/**strclear(_tword)*/; //ўшЄрхь ё яєёЄющ ёЄЁюъш
  IF (_waseols==0) { //юсїюф эр ёыєўрщ ъюэхўэюую ; яхЁхф ъюьрэфющ
    WHILE (_spcsize != 0) { //фюсртшЄ№ ё·хфхээ√х яЁюсхы√
      _lentword = stradd(_tword, _lentword, ' ');
      DEC _spcsize;
    };
    WHILE (_waseols==0/**&&(!_waseof)*//**&&(_cnext!=_DIERESIS)*/) {
      rdchcmt(); //яЁюяєёърхЄ тёх хэЄхЁ√
    };
  };
  _tword[_lentword] = '\0';
  toktext(); //ухэхЁшЁєхЄ <text>text<endtext>
  asmtoken(+_TOKENDCOMMENT);
  IF ((BYTE)_cnext < (BYTE)'!') {
    IF (_cnext == '\t') {
      _spcsize = _spcsize + 8;
    }ELSE {
      INC _spcsize;
    };
    rdch(); //ўшЄрхь тё■ уЁєяяє фшхЁхчшёют + ёшьтюы ъръ юфшэ ёшьтюы
  };
  asmrdword_tokspc(); //[ЄюъхэшчшЁєхЄ ъюэхўэ√х яЁюсхы√ шыш EOL,] схЁ╕Є ёыхфє■∙є■ ъюьрэфє (яюёых шэёЄЁєъЎшш)
}

PROC tokorg()
{
  asmtoken(+_CMDORG);
  asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  IF (tokexpr()) {asmtoken(+_FMTCMD);
  }ELSE tokerr(+_ERREXPR); //wrong expr
}

PROC tokalign()
{
  asmtoken(+_CMDALIGN);
  asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  IF (tokexpr()) {asmtoken(+_FMTCMD);
  }ELSE tokerr(+_ERREXPR); //wrong expr
}
/**
PROC tokpage()
{
  tokerrcmd();
}

PROC tokif()
{
  asmtoken(+_CMDIF);
  asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  IF (tokexpr()) {asmtoken(+_FMTCMD);
  }ELSE tokerr(+_ERREXPR); //wrong expr
  //tokerrcmd();
}

PROC tokelse()
{
  asmtoken(+_CMDELSE);
  asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  //tokerrcmd();
}

PROC tokendif()
{
  asmtoken(+_CMDENDIF);
  asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  //tokerrcmd();
}

PROC tokdup()
{
  tokerrcmd();
}

PROC tokedup()
{
  tokerrcmd();
}

PROC tokmacro()
{
  tokerrcmd();
}

PROC tokendm()
{
  tokerrcmd();
}
*/
PROC tokexport()
{
  asmtoken(+_CMDEXPORT);
  asmrdword_tokspc(); //ё·хфрхь call
  eatlabel(+_TOKLABEL);
  //asmmtoken(+_TOKTEXT);
  //fputs(_tword, _fout);
  //asmtoken(+_TOKENDTEXT);
  //asmrdword_tokspc(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ (юсЁрсюЄрээющ) ъюьрэф√ ш ўшЄрхЄ эютє■
  asmtoken(+_FMTCMD); //ўЄюс√ шёяюы№чютрЄ№ label
}
/**
PROC toklocal()
{
  tokerrcmd();
}

PROC tokendl()
{
  tokerrcmd();
}

PROC tokdisp()
{
  asmtoken(+_CMDDISP);
  asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  IF (tokexpr()) {asmtoken(+_FMTCMD);
  }ELSE tokerr(+_ERREXPR); //wrong expr
}

PROC tokent()
{
  asmtoken(+_CMDENT);
  asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  asmtoken(+_FMTCMD);
}
*/
PROC tokinclude()
{
  asmtoken(+_CMDINCLUDE);
  asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  IF (matchquote()) {
    //asmtoken(+_OPWRSTR);
    _lentword = 0/**strclear(_tword)*/; //ўшЄрхь ё яєёЄющ ёЄЁюъш
    rdquotes('\"');
    toktext(); //ухэхЁшЁєхЄ <text>text<endtext>
    rdch(); //яЁюяєёЄшЄ№ чръЁ√тр■∙є■ ърт√ўъє
    asmtoken(+_TOKDBLQUOTESYM);
    asmrdword_tokspc();
  }ELSE tokerr(+_ERREXPR);
  //asmtoken(+_FMTCMD); //todo?
}

PROC tokincbin()
{
  asmtoken(+_CMDINCBIN);
  asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  IF (matchquote()) {
    //asmtoken(+_OPWRSTR);
    _lentword = 0/**strclear(_tword)*/; //ўшЄрхь ё яєёЄющ ёЄЁюъш
    rdquotes('\"');
    toktext(); //ухэхЁшЁєхЄ <text>text<endtext>
    rdch(); //яЁюяєёЄшЄ№ чръЁ√тр■∙є■ ърт√ўъє
    asmtoken(+_TOKDBLQUOTESYM);
    asmrdword_tokspc();
  }ELSE tokerr(+_ERREXPR);
  //todo ярЁрьхЄЁ√ (яЁюяєёъ, фышэр)
  //asmtoken(+_FMTCMD); //todo?
}

PROC tokdb()
{
  asmtoken(+_CMDDB);
  asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  REPEAT {
    IF (matchquote()) {
      asmtoken(+_OPWRSTR);
      _lentword = 0/**strclear(_tword)*/; //ўшЄрхь ё яєёЄющ ёЄЁюъш
      rdquotes('\"');
      toktext(); //ухэхЁшЁєхЄ <text>text<endtext>
      rdch(); //яЁюяєёЄшЄ№ чръЁ√тр■∙є■ ърт√ўъє
      asmtoken(+_TOKDBLQUOTESYM);
      asmrdword_tokspc();
    }ELSE IF (tokexpr()) {
      asmtoken(+_OPWRVAL);
    }ELSE tokerr(+_ERREXPR);
  }UNTIL (!matchcomma());
  asmtoken(+_FMTCMD);
}

PROC tokdw()
{
  asmtoken(+_CMDDW);
  asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  REPEAT {
    tokexpr();
    asmtoken(+_OPWRVAL);
  }UNTIL (!matchcomma());
  asmtoken(+_FMTCMD);
}

PROC tokdl()
{
  asmtoken(+_CMDDL);
  asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  REPEAT {
    tokexpr();
    asmtoken(+_OPWRVAL);
  }UNTIL (!matchcomma());
  asmtoken(+_FMTCMD);
}

PROC tokds()
{
  asmtoken(+_CMDDS);
  asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  tokexpr();
  WHILE (matchcomma()) {
    tokexpr();
  };
  asmtoken(+_FMTCMD);
}
/**
PROC tokdisplay()
{
  tokerrcmd();
}

PROC tokrepeat()
{
  tokerrcmd();
}

PROC tokuntil()
{
  tokerrcmd();
}

PROC tokstruct()
{
  tokerrcmd();
}

PROC tokendstruct()
{
  tokerrcmd();
}
*/
PROC tokcolon()
{
  asmtoken(+_TOKCOLON);
  asmrdword_tokspc(); //ё·хфрхь ':'
}

///////////////////////

PROC tokcmd()
{
  //_asmwaseof=_waseof;
  //rdword_tokspc(); //яЁюўшЄрэю т яЁхф√фє∙хщ шэёЄЁєъЎшш
  //stringdecapitalize(_tword,_lentword);
  IF (*(PCHAR)_tword==';') {tokcomment();
/**  }ELSE IF (*(PCHAR)_tword==':') {
    asmtoken(+_TOKCOLON);
    asmrdword_tokspc(); //ё·хфрхь ':'
*/
  }ELSE IF (_asmspcsize!=0) {
    //tokasm(); //assembly mnemonic or directive
    tokcalllbl();
/**    IF (!tokcalllbl(_tword)) {
      tokerrcmd(); //wrong _tword
    };*/
  }ELSE { //<label> шыш <label>=<expr>
    //asmtoken(0xff);
    eatlabel(+_CMDLABEL); //ё·хфрхь ьхЄъє
    IF (matchreequ()) { //<label>=<expr>
      IF (tokexpr()) {
        asmtoken(+_FMTREEQU);
      }ELSE tokerr(+_ERREXPR); //wrong expr
    }ELSE //IF ((_asmwaseols!=0)||(_asmwaseof)||(*(PCHAR)_tword==':')||(*(PCHAR)_tword==';')){ //<label>
      asmtoken(+_FMTCMD); //<label>
    //}ELSE tokerrcmd(); //wrong _tword
  };
  //яш°хь eol ш яЁюсхы√, ъюЄюЁ√х эх чряшёрыш яЁш ўЄхэшш ъюэхўэюую ёыютр
  IF (_asmwaseols!=0) {
    WHILE (_asmwaseols!=0) {
      asmtoken(+_TOKEOL);
      DEC _asmwaseols;
    };
    tokspc(); //ЄюъхэшчшЁєхь яЁюсхы√ яюёых
  };
}

PROC tokinit()
{
  _tokfn = (PCHAR)_stokfn;
  tokinitlblbuf();
  tokpre(); //чряюыэшЄ№ ЄрсышЎє ьхЄюъ
}

PROC tokenize(PCHAR fn)
{
VAR UINT i;
  _fin = nfopen(fn, "rb");
  IF (_fin != (PBYTE)0) {
    _waseof = +FALSE;
    _curline = 1;
    initrd();

    _lentokfn = 0;
    i = 0;
    WHILE (fn[_lentokfn] != '\0') {
      _tokfn[_lentokfn] = fn[_lentokfn];
      IF (fn[_lentokfn] == '.') i = _lentokfn;
      INC _lentokfn;
    };
    //_lentokfn = strjoineol(_tokfn, 0, fn, '.'); //terminator is not copied
    //_lentokfn = stradd(_tokfn, _lentokfn, '.');
    _lentokfn = i+1; //after last dot
    _lentokfn = stradd(_tokfn, _lentokfn, (CHAR)((BYTE)fn[_lentokfn]&0xdf));
    _lentokfn = stradd(_tokfn, _lentokfn, '_');
    _tokfn[_lentokfn] = '\0';
    _fout = openwrite(_tokfn);

    _asmwaseols = 0;
    _asmwaseof = +FALSE;
    asmrdword_tokspc(); //ўшЄрхь яхЁтє■ ъюьрэфє

    WHILE (!_asmwaseof) { //todo шыш endasm ('}')
      tokcmd();
    };

    asmtoken(+_TOKEOF);
    fclose(_fout); //closewrite(_fout); //closefout();

    fclose(_fin); //closefin();
  };
}

PROC tokenize_end()
{
}