?login_element?

Subversion Repositories NedoOS

Rev

Rev 477 | Rev 634 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /// imported
  2. #include "../_sdk/typecode.h"
  3. #include "../_sdk/str.h"
  4. #include "../_sdk/io.h"
  5. #include "../_sdk/emit.h"
  6. //EXTERN UINT _curlnbeg; //эюьхЁ ёЄЁюъш эр ьюьхэЄ эрўрыр Єюъхэр //фы  read, emit
  7. //EXTERN BOOL _cmts; //фы  read, emit
  8.  
  9. CONST BYTE _typesz[32];
  10.  
  11. #ifdef TARGET_THUMB
  12. #include "sizesarm.h"
  13. #else
  14. #ifdef TARGET_SCRIPT
  15. #include "sizesspt.h"
  16. #else
  17. #include "sizesz80.h"
  18. #endif
  19. #endif
  20.  
  21. CONST BOOL _isalphanum[256];
  22.  
  23. EXTERN BOOL _doskip; //яЁюяєёърЄ№ ёЄЁюъш, ъЁюьх эрўшэр■∙шїё  ё #
  24.  
  25. EXTERN PCHAR _tword; //Єхъє∙хх ёыютю
  26. EXTERN UINT  _lentword;
  27. VAR PCHAR _prefix; //яЁхЇшъё Єхъє∙хую ёыютр (юёЄрЄюъ - т _tword)
  28. VAR UINT  _lenprefix;
  29. VAR PCHAR _title; //эрчтрэшх Єхъє∙хщ яЁюЎхфєЁ√ (ё єў╕Єюь ьюфєы )
  30. VAR UINT  _lentitle;
  31. EXTERN PCHAR _callee; //эрчтрэшх т√ч√трхьющ яЁюЎхфєЁ√ (ё єў╕Єюь ьюфєы )
  32. EXTERN UINT  _lencallee;
  33. EXTERN PCHAR _name; //ьхЄър схч яЁхЇшъёр (фы  ЄрсышЎ√ ьхЄюъ)
  34. EXTERN UINT  _lenname;
  35. EXTERN PCHAR _joined; //ртЄюьхЄър
  36. EXTERN UINT  _lenjoined;
  37. VAR PCHAR _ncells; //т addlbl эхы№ч  юс·хфшэшЄ№ ncells ё callee //Єрь цх тЁхьхээю яЁю°ыр  ьхЄър фы  enum
  38. VAR UINT  _lenncells;
  39. VAR CHAR  _s1[_STRLEN]; //яЁхЇшъё Єхъє∙хую ёыютр (юёЄрЄюъ - т _tword)
  40. VAR CHAR  _s2[_STRLEN]; //эрчтрэшх Єхъє∙хщ яЁюЎхфєЁ√ (ё єў╕Єюь ьюфєы )
  41. VAR CHAR  _s3[_STRLEN]; //эрчтрэшх т√ч√трхьющ яЁюЎхфєЁ√ (ё єў╕Єюь ьюфєы )
  42. VAR CHAR  _s4[_STRLEN]; //ьхЄър схч яЁхЇшъёр (фы  ЄрсышЎ√ ьхЄюъ)
  43. VAR CHAR  _s5[_STRLEN]; //ртЄюьхЄър
  44. VAR CHAR  _s6[_STRLEN]; //ўшёыю ¤ыхьхэЄют
  45.  
  46. EXTERN CHAR _cnext;
  47. EXTERN UINT _spcsize; //ўшёыю яЁюсхыют яюёых яЁюўшЄрээющ ъюьрэф√
  48.  
  49. EXTERN UINT _curline; //Єхъє∙шщ эюьхЁ ёЄЁюъш
  50.  
  51. EXTERN UINT _waseols; //ёъюы№ъю с√ыю EOL ё яЁю°ыюую Ёрчр
  52.  
  53. EXTERN UINT _typeaddr;
  54.  
  55. PROC rdch FORWARD();
  56. PROC rdchcmt FORWARD();
  57. PROC rdquotes FORWARD(CHAR eol);
  58. PROC rdaddword FORWARD();
  59. PROC rdword FORWARD();
  60. PROC initrd FORWARD();
  61.  
  62. PROC strpush FORWARD(PCHAR s, UINT len); //joined шыш callee
  63. FUNC UINT strpop FORWARD(PCHAR s);
  64. EXTERN UINT _lenstrstk;
  65.  
  66. PROC initlblbuf FORWARD();
  67.  
  68. //math (схч ьр°шээюую ъюфр)
  69. PROC cmdneg FORWARD();
  70. PROC cmdinv FORWARD();
  71. PROC cmdpoke FORWARD();
  72. PROC cmdpeek FORWARD();
  73. PROC cmdpushvar FORWARD();
  74. PROC cmdpopvar FORWARD();
  75. PROC cmdpushnum FORWARD();
  76. PROC cmdmul FORWARD();
  77. PROC cmddiv FORWARD();
  78. //PROC cmdshl1 FORWARD();
  79. //PROC cmdshr1 FORWARD();
  80. PROC cmdshl FORWARD();
  81. PROC cmdshr FORWARD();
  82. PROC cmdadd FORWARD();
  83. PROC cmdsub FORWARD();
  84. PROC cmdaddpoi FORWARD(); //ёфтшурхЄ ёююЄтхЄёЄтхээю Єшяє ш яЁшсрты хЄ
  85. PROC cmdand FORWARD();
  86. PROC cmdor FORWARD();
  87. PROC cmdxor FORWARD();
  88. PROC cmdinc FORWARD();
  89. PROC cmddec FORWARD();
  90. PROC cmdincbyaddr FORWARD();
  91. PROC cmddecbyaddr FORWARD();
  92.  
  93. //ёЁртэхэш  (схч ьр°шээюую ъюфр)
  94. PROC cmdless FORWARD();
  95. PROC cmdmore FORWARD();
  96. PROC cmdlesseq FORWARD();
  97. PROC cmdmoreeq FORWARD();
  98. PROC cmdeq FORWARD();
  99. PROC cmdnoteq FORWARD();
  100.  
  101. //ухэхЁрЎш  т√чютют ш яхЁхїюфют (схч ьр°шээюую ъюфр)
  102. PROC cmdjpval FORWARD();
  103. PROC cmdcallval FORWARD();
  104. PROC cmdjp FORWARD();
  105. PROC cmdjpiffalse FORWARD();
  106. PROC cmdcall FORWARD();
  107. PROC cmdfunc FORWARD();
  108. PROC cmdpushpar FORWARD(); //фы  ЁхъєЁёштэ√ї яЁюЎхфєЁ (ёюїЁрэхэшх ярЁрьхЄЁют тэєЄЁш шыш ёэрЁєцш)
  109. PROC cmdstorergs FORWARD(); //яюёых ёюїЁрэхэш  ыюъры№эющ яхЁхьхээющ ЁхъєЁёштэющ яЁюЎхфєЁ√
  110. PROC cmdpoppar FORWARD(); //фы  ЁхъєЁёштэ√ї яЁюЎхфєЁ (тюёёЄрэютыхэшх ярЁрьхЄЁют тэєЄЁш шыш ёэрЁєцш)
  111. PROC cmdresult FORWARD();
  112. PROC cmdret FORWARD(BOOL isfunc); //тюёёЄрэютыхэшх Ёхчєы№ЄрЄр яюёых ёэ Єш  ыюърыют ёю ёЄхър ш т√їюф
  113.  
  114. PROC cmdcastto FORWARD(TYPE t2);
  115. PROC cmdlabel FORWARD();
  116. PROC var_alignwsz_label FORWARD(TYPE t);
  117. PROC var_def FORWARD(TYPE t, PCHAR s);
  118.  
  119. PROC initcmd FORWARD();
  120.  
  121. PROC initcode FORWARD();
  122. PROC endcode FORWARD();
  123. PROC emitasmlabel FORWARD(PCHAR s);
  124. PROC emitfunclabel FORWARD(PCHAR s);
  125. PROC emitvarlabel FORWARD(PCHAR s);
  126. PROC emitexport FORWARD(PCHAR s);
  127. PROC emitvarpreequ FORWARD(PCHAR s);
  128. PROC emitvarpostequ FORWARD();
  129. PROC varequ FORWARD(PCHAR s);
  130. PROC asm_db FORWARD(); //ъюёЄ√ы№ фы  ъюэёЄрэЄэ√ї ьрёёштют ёЄЁюъ TODO
  131. PROC var_db FORWARD();
  132. PROC var_dw FORWARD();
  133. //PROC var_dl FORWARD();
  134. PROC var_ds FORWARD();
  135. FUNC UINT varshift FORWARD(UINT shift, UINT sz);
  136.  
  137. FUNC UINT gettypename FORWARD(PCHAR s); //тч Є№ эрчтрэшх Єшяр ёЄЁєъЄєЁ√ т s (ёЁрчє яюёых lbltype)
  138. PROC setvarsz FORWARD(UINT addr, UINT shift);
  139. FUNC TYPE lbltype FORWARD(); //тхЁэєЄ№ Єшя ьхЄъш _name
  140. PROC dellbl FORWARD(); //єфрышЄ№ ьхЄъє _name
  141. PROC addlbl FORWARD(TYPE t, BOOL isloc, UINT varsz/**, PCHAR size, UINT lensize*/); //(_name)
  142. PROC keepvars FORWARD(); //яхЁхф эрўрыюь ыюъры№э√ї ьхЄюъ
  143. PROC undovars FORWARD(); //яюёых ыюъры№э√ї ьхЄюъ (чрс√Є№ шї)
  144. EXTERN UINT _varszaddr;
  145. EXTERN UINT _varsz;
  146.  
  147. EXTERN BYTE _exprlvl; //уыєсшэр т√Ёрцхэш  (тхЁїэшщ єЁютхэ№ == 1)
  148. EXTERN TYPE _t; //Єхъє∙шщ Єшя
  149. EXTERN BOOL _isloc; //ыюъры№эр  ыш яЁюўшЄрээр  яхЁхьхээр 
  150.  
  151. ////
  152. CONST UINT _MAXPARS = 16; /**ьръёшьры№эюх ўшёыю ярЁрьхЄЁют т т√чютх ЇєэъЎшш*/
  153. //todo юуЁрэшўшЄ№ уыєсшэє ЁхъєЁёшш f(g(h(...()...)
  154.  
  155. //ёюёЄю эшх ъюьяшы ЄюЁр (яы■ё х∙╕ ёюёЄю эш  commands ш codetg):
  156. VAR UINT _curlbl; //эюьхЁ ртЄюьхЄъш
  157. VAR UINT _tmpendlbl; //эюьхЁ ртЄюьхЄъш фы  т√їюфр шч Ўшъыр while/repeat
  158.  
  159. VAR BYTE _namespclvl; //уыєсшэр тыюцхээюёЄш яЁюёЄЁрэёЄтр шь╕э (ўшёыю Єюўхъ т яЁхЇшъёх)
  160.  
  161. VAR BOOL _isrecursive; //Єхъє∙р  юс· ты хьр  яЁюЎхфєЁр ЁхъєЁёштэр 
  162. VAR BOOL _wasreturn; //с√ыр ъюьрэфр return (яюёых эх╕ эхы№ч  ъюьрэф√ т ЁхъєЁёштэющ ЇєэъЎшш) //ёюїЁрэ ■Єё  т func
  163. VAR TYPE _curfunct; //Єшя ЇєэъЎшш (фы  return) //ёюїЁрэ ■Єё  т func
  164. VAR BOOL _isexp; //Єхъє∙р  юс· ты хьр  яхЁхьхээр , ъюэёЄрэЄэ√щ ьрёёшт/ёЄЁєъЄєЁр, яЁюЎхфєЁр/ЇєэъЎш  ¤ъёяюЁЄшЁєхЄё  (эю эх ъюэёЄрэЄр, Є.ъ. ¤Єю эх рфЁхё ш эх эєцэю)
  165.  
  166. VAR CHAR _c0;
  167. VAR CHAR _c2;
  168.  
  169. VAR UINT _parnum;
  170.  
  171. VAR UINT _doskipcond;
  172. //_doskipcond т сшЄютюь тшфх яюьэшЄ, ёъюы№ъю єЁютэхщ ръЄштэ√ї ifdef ш ёъюы№ъю єЁютэхщ эхръЄштэ√ї (ъЁюьх Єхъє∙хую)
  173. //(тэєЄЁш эхръЄштэюую ьюуєЄ с√Є№ Єюы№ъю эхръЄштэ√х)
  174. //хёыш (_doskipcond&1) == 0 (Є.х. ь√ т эхръЄштэющ тхЄъх), Єю Єхъє∙шщ ifdef шуэюЁшЁєхЄё  ёю тёхьш тїюф ∙шьш (Є.х. else эх ЁрсюЄрхЄ)
  175. //эхръЄштэюёЄ№ Єхъє∙хщ тхЄъш ifdef ыхцшЄ т _doskip
  176. //эр тхЁїэхь єЁютэх _doskipcond = 1, _doskip = +FALSE
  177.  
  178. VAR BOOL _morecmd; //Їыру "сыюъ эх юъюэўхэ" т eatcmd
  179.  
  180. VAR CHAR _opsym;
  181.  
  182. VAR BOOL _addrexpr; //т√Ёрцхэшх ё & фы  &(<structname>-><field>) (TODO тыюцхээю???)
  183.  
  184. #define _MAXHINCLUDES 0x08
  185. VAR PBYTE _hinclfile[_MAXHINCLUDES];
  186. VAR UINT _hnline[_MAXHINCLUDES];
  187. VAR BYTE _nhinclfiles; //ўшёыю юЄъЁ√Є√ї Їрщыют
  188. //
  189.  
  190. #ifdef USE_HINTS
  191. ;;PROC hint_tword() {
  192. ;;  hintstr("//_tword=\""); hintstr(_tword); hintstr("\", cnext=\""); hint(_cnext); hint('\"'); endhint();
  193. ;;}
  194. #endif
  195.  
  196. PROC err_tword(PCHAR s)
  197. {
  198.   errstr(s); errstr(" expected, but we have \'"); errstr(_tword); err('\''); enderr();
  199. }
  200.  
  201. PROC doexp() //тёхуфр _joined
  202. {
  203.   IF (_isexp) emitexport(_joined);
  204. }
  205.  
  206. PROC eat(CHAR c)
  207. {
  208.   IF (*(PCHAR)_tword!=c) {
  209.     err(c); errstr(" expected, but we have \'"); errstr(_tword); err('\''); enderr();
  210.   };
  211.   rdword();
  212. }
  213.  
  214. PROC jdot()
  215. {
  216.   _lenjoined = stradd(_joined, _lenjoined,'.');
  217.   _joined[_lenjoined] = '\0'; //strclose(_joined, _lenjoined);
  218. }
  219.  
  220. VAR UINT _genn;
  221.  
  222. PROC gendig(UINT d)
  223. {
  224. VAR BYTE dig;
  225.   dig = +(BYTE)'A';
  226.   WHILE (_genn >= d) {
  227.     _genn = _genn - d;
  228.     INC dig;
  229.     _wasdig = +TRUE;
  230.   };
  231.   IF (_wasdig) {
  232.     _lenjoined = stradd(_joined, _lenjoined, +(CHAR)dig);
  233.   };
  234. }
  235.  
  236. PROC jautonum(UINT n)
  237. {
  238.   _genn = n;
  239.   _wasdig = +TRUE;
  240.   IF (n != 0) {
  241.     _wasdig = +FALSE;
  242.     gendig(676);
  243.     gendig(26);
  244.   };
  245.   gendig(1);
  246.   jdot();
  247. }
  248.  
  249. PROC genjplbl(UINT n)
  250. {
  251.   _lenjoined = strcopy(_title, _lentitle, _joined);
  252.   jautonum(n);
  253. }
  254.  
  255. PROC jtitletword()
  256. {
  257.   _lenjoined = strcopy(_title, _lentitle, _joined); //_lenjoined = strjoin(/**to=*/_joined, 0/**strclear(_joined)*/, _title);
  258.   _lenjoined = strjoin(/**to=*/_joined, _lenjoined, _tword);
  259.   _joined[_lenjoined] = '\0'; //strclose(_joined, _lenjoined);
  260. }
  261.  
  262. PROC do_type()
  263. {
  264. loop:
  265.   _lenname = strcopy(_tword, _lentword, _name);
  266.   _t = lbltype();
  267.   IF ((_t&_T_TYPE)!=(TYPE)0x00) { //хёыш ¤Єю эх яхЁхьхээр , р Єшя
  268.     IF (_t == (_T_TYPE+_T_STRUCTWORD)) {
  269.       rdword(); //use STRUCT
  270.       goto loop;
  271.     };
  272.     IF (_cnext == '*') {
  273.       _t = _t|_T_POI;
  274.       _varsz = (UINT)_SZ_REG;
  275.       rdword(); //use *
  276.     };
  277.   };
  278. }
  279.  
  280. PROC eattype()
  281. {
  282.   do_type();
  283.   _t = _t&~_T_TYPE;
  284.   rdword();
  285. }
  286.  
  287. PROC doprefix(BYTE nb) //ёъыхшЄ№ n ёыют Єшяр 'word.' шч title т prefix (name схч яЁхЇшъёр)
  288. {
  289.   _lenprefix = 0; //strclear(_prefix)
  290.   WHILE (nb > 0x00) { //яхЁхсшЁрхь ёыютр
  291.     _lenprefix = strjoineol(/**to=*/_prefix, _lenprefix, &_title[_lenprefix], '.');
  292.     _lenprefix = stradd(_prefix, _lenprefix, '.');
  293.     DEC nb;
  294.   };
  295.   _prefix[_lenprefix] = '\0'; //strclose(_prefix, _lenprefix);
  296.   _lenjoined = strcopy(_prefix, _lenprefix, _joined);
  297.   _lenjoined = strjoin(/**to=*/_joined, _lenjoined, _tword/**, _lentword*/);
  298.   _joined[_lenjoined] = '\0'; //strclose(_joined, _lenjoined);
  299. }
  300.  
  301. PROC adddots()
  302. {
  303. /**  WHILE (_cnext == '.') {
  304.     rdaddword(); //яЁшъыхшЄ№ Єюўъє
  305.     rdaddword(); //яЁшъыхшЄ№ ёыхфє■∙хх ёыютю
  306.   };*/
  307. }
  308.  
  309. PROC joinvarname(BOOL iscall) //тючтЁр∙рхЄ _t = Єшя(_name)
  310. { //шфхэЄшЇшърЄюЁ єцх яЁюўшЄрэ
  311. VAR BYTE lvl;
  312.   do_type();
  313.   IF (!_isloc) {
  314.     _lenjoined = strcopy(_tword, _lentword, _joined);
  315.   }ELSE {
  316.     lvl = _namespclvl;
  317.     IF (iscall && (lvl != 0x00)) {
  318.       DEC lvl; //proc()
  319.     };
  320.     doprefix(lvl); //ёъыхшЄ№ n ёыют Єшяр 'word.' шч title т prefix (name схч яЁхЇшъёр)
  321.     //todo яЁютхЁшЄ№ ш ¤ЄюЄ Єшя (фы  ьюфєы№эюёЄш)?
  322.     //шыш todo яЁхтЁрЄшЄ№ stru1->f1.f2 т tstru1.f1+tstru2.f2
  323.   };
  324. }
  325.  
  326. PROC eatvarname() //фы  ёючфрэш  ьхЄюъ
  327. {
  328.   eattype(); //t = _t; //Єшя с√ы єцх яЁюўшЄрэ
  329.   adddots();
  330.   _lenname = strcopy(_tword, _lentword, _name);
  331.   doprefix(_namespclvl); //ёъыхшЄ№ n ёыют Єшяр 'word.' шч title т prefix (name схч яЁхЇшъёр)
  332.   rdword(); //'['
  333.   IF (*(PCHAR)_tword == '[') {
  334.     _t = _t|_T_ARRAY;
  335.   };
  336. }
  337.  
  338. PROC getstructfield() //тючтЁр∙рхЄ _t = Єшя яюы 
  339. { //ёЄЁєъЄєЁр єцх яЁюўшЄрэр ш рфЁхёютрэр _typeaddr (т lbltype шыш addlbl), Єшя _t = эхъшщ єърчрЄхы№???
  340. //errstr("------------"); erruint(_typeaddr); enderr();
  341.   _lenjoined = gettypename(_joined); //тч Є№ эрчтрэшх Єшяр ёЄЁєъЄєЁ√ т joined
  342.   eat('>'); //rdword(); //use '>'
  343.   jdot();
  344.   _lenjoined = strjoin(/**to=*/_joined, _lenjoined, _tword); //structname.structfield
  345.   _joined[_lenjoined] = '\0'; //strclose(_joined, _lenjoined);
  346.   //_t = _T_POI|_T_BYTE; //Єшя єцх - эхъшщ єърчрЄхы№
  347.   cmdpushnum(); //structname.structfield
  348.   cmdadd();
  349.   _lenname = strcopy(_joined, _lenjoined, _name); //structname.structfield
  350.   _t = lbltype(); //(_name)
  351. }
  352.  
  353. //////////////////////////////////////////
  354. // compiler
  355.  
  356. //call т√ч√трхЄ _tword ш expr
  357. PROC eatexpr RECURSIVE FORWARD();  //т√ч√трхЄ call
  358. FUNC BOOL eatcmd RECURSIVE FORWARD();  //т√ч√трхЄ call
  359. FUNC TYPE do_call RECURSIVE FORWARD(BOOL isfunc); //тючтЁр∙рхЄ Єшя ЇєэъЎшш
  360. PROC compfile RECURSIVE FORWARD(PCHAR fn);
  361.  
  362. PROC varstrz() //фы  ёЄЁюъют√ї ъюэёЄрэЄ т т√Ёрцхэш ї
  363. {
  364.   emitvarlabel(_joined); //varstr(_joined); endvar();
  365.   WHILE (+TRUE) {
  366.     rdquotes('\"');
  367.     rdch(); //фюсрты хь чръЁ√тр■∙є■ ърт√ўъє
  368.     _tword[_lentword] = '\0'; //strclose(_tword, _lentword);
  369.     var_db(); varstr(_tword); endvar();
  370.     IF (_cnext != '\"') BREAK;
  371.     rdword(); //юЄъЁ√тр■∙р  ърт√ўър яЁшъыххээющ ёЄЁюъш
  372.   };
  373.   var_db(); varc('0'); endvar();
  374. }
  375.  
  376. PROC asmstrz() //тёх CONST ёЄЁюъш ЄхяхЁ№ т ъюфх (Ёрэ№°х с√ыю Єюы№ъю фы  ъюэёЄрэЄэ√ї ьрёёштют ёЄЁюъ)
  377. {
  378.   emitasmlabel(_joined); //asmstr(_joined); endasm();
  379.   WHILE (+TRUE) {
  380.     rdquotes('\"');
  381.     rdch(); //фюсрты хь чръЁ√тр■∙є■ ърт√ўъє
  382.     _tword[_lentword] = '\0'; //strclose(_tword, _lentword);
  383.     asm_db(); asmstr(_tword); endasm();
  384.     IF (_cnext != '\"') BREAK;
  385.     rdword(); //юЄъЁ√тр■∙р  ърт√ўър яЁшъыххээющ ёЄЁюъш
  386.   };
  387.   asm_db(); asmc('0'); endasm();
  388. }
  389.  
  390. PROC eatidx() //фы  idxarray ш switch
  391. {
  392.   INC _exprlvl; //no jump optimization
  393.   eatexpr(); //ёЁртэхэш  эхы№ч  схч ёъюсюъ!!!
  394.   DEC _exprlvl;
  395.   IF (_t==_T_BYTE) cmdcastto(_T_UINT);
  396.   IF (_t!=_T_UINT) {errstr("idx bad type "); erruint(+(UINT)_t); enderr(); };
  397. }
  398.  
  399. FUNC TYPE idxarray RECURSIVE(TYPE t)
  400. {
  401.   rdword(); //яхЁтюх ёыютю expr
  402.   IF ((t&_T_ARRAY) != (TYPE)0x00) { //ьрёёшт
  403.     t = t&_TYPEMASK; //&(~(_T_ARRAY|_T_CONST)); //ьюцхЄ с√Є№ _T_POI (хёыш ьрёёшт ёЄЁюъ)
  404.     _t = _T_POI|_T_BYTE; cmdpushnum(); //шёяюы№чютрэшх юс√ўэюую ьрёёштр - схЁ╕ь хую рфЁхё
  405.   }ELSE IF ((t&_T_POI) != (TYPE)0x00) { //єърчрЄхы№
  406.     _t = t; cmdpushvar(); //шёяюы№чютрэшх єърчрЄхы  т ърўхёЄтх ьрёёштр - ўшЄрхь хую чэрўхэшх
  407.     t = t&(~_T_POI);
  408.   }ELSE {errstr("[] not in array "); erruint(+(UINT)t); enderr(); };
  409.   eatidx();
  410.   _t = t; //Єшя ¤ыхьхэЄр ьрёёштр
  411.   cmdaddpoi();
  412. RETURN t; //Єшя ¤ыхьхэЄр ьрёёштр
  413. }
  414.  
  415. PROC numtype()
  416. {
  417.   IF (_cnext == '.') { //фЁюсэюх ўшёыю (эхы№ч  эрўшэрЄ№ ё Єюўъш шыш чрърэўштрЄ№ Єюўъющ)
  418.     rdaddword(); //яЁшъыхшЄ№ Єюўъє
  419.     rdaddword(); //яЁшъыхшЄ№ фЁюсэє■ ўрёЄ№
  420.     IF ( (_tword[_lentword-1]=='e') && (_cnext=='-') ) {
  421.       rdaddword(); //яЁшъыхшЄ№ '-' юЄЁшЎрЄхы№эющ ¤ъёяюэхэЄ√
  422.       rdaddword(); //яЁшъыхшЄ№ юЄЁшЎрЄхы№эє■ ¤ъёяюэхэЄє
  423.     };
  424.     _t = _T_FLOAT;
  425.   }ELSE IF (*(PCHAR)_tword == '-') { //т val єцх хёЄ№, эрфю фы  define
  426.     _t = _T_INT;
  427.   }ELSE IF (_tword[_lentword-1]=='L') {
  428.     _t = _T_LONG;
  429.   }ELSE IF (+(BYTE)_tword[1] > +(BYTE)'9') { //єёъюЁхэшх яЁютхЁъш ўшёыютюую ЇюЁьрЄр
  430.     IF ((_lentword<=4)&&(_tword[1]=='x')) {
  431.       _t = _T_BYTE;
  432.     }ELSE IF ((_lentword<=10)&&(_tword[1]=='b')) {
  433.       _t = _T_BYTE;
  434.     }ELSE {
  435.       _t = _T_UINT;
  436.     };
  437.   }ELSE {
  438.     _t = _T_UINT;
  439.   };
  440. }
  441.  
  442. PROC val RECURSIVE()
  443. {
  444. VAR TYPE t; //фы  cast,peek
  445. VAR UINT typeaddr; //фы  cast
  446. {
  447. //<val>::=
  448. //(<expr>) //т√Ёрцхэшх (т√ўшёы хЄё )
  449. //|<num> //фхё Єшўэюх ўшёыю (яхЁхфр╕Єё  Ўхышъюь) INT/UINT/LONG
  450. //|<num>.<num>[e-<num>] //float ўшёыю (яхЁхфр╕Єё  Ўхышъюь)
  451. //|<var> //яхЁхьхээр 
  452. //|'CHAR' //ёшьтюы№эр  ъюэёЄрэЄр (яхЁхфр╕Єё  Ўхышъюь)
  453. //|"str" //ёЄЁюъютр  ъюэёЄрэЄр (яхЁхфр╕Єё  Ўхышъюь)
  454. //|+(<type>)<val> //т√ўшёышЄ№ val, яюЄюь ёфхырЄ№ яхЁхтюф т <type>
  455. //|+<boolconst>
  456. //|+_<enumconst> BYTE
  457. //|<lbl>([<val>,...]) //call
  458. //|-<val> //т√ўшёышЄ№ val, яюЄюь ёфхырЄ№ NEG
  459. //|~<val> //т√ўшёышЄ№ val, яюЄюь ёфхырЄ№ INV
  460. //|!<val> //т√ўшёышЄ№ val, яюЄюь ёфхырЄ№ INV(BOOL)
  461. ////|<<val> //т√ўшёышЄ№ val, яюЄюь ёфхырЄ№ SHL1
  462. ////|><val> //т√ўшёышЄ№ val, яюЄюь ёфхырЄ№ SHR1
  463. //|*(<ptype>)<val> //яЁюўшЄрЄ№ ярь Є№ яю рфЁхёє (т√ўшёышЄ№ val, яюЄюь ёфхырЄ№ PEEK)
  464. //|&<var> //рфЁхё яхЁхьхээющ
  465.  //ъюьрэфр єцх яЁюўшЄрэр
  466. #ifdef USE_HINTS
  467. ;;  hintstr("//val: word=\""); hintstr(_tword); hintstr("\", cnext=\""); hint(_cnext); hint('\"'); endhint();
  468. #endif
  469.   //_t = _T_UNKNOWN; //debug (шэрўх ьюцхЄ т√ыхЄхЄ№ чр ЄрсышЎє typesz яЁш юсЁ√тх Їрщыр)
  470.   //IF ( !_waseof )
  471.   { //чр∙шЄр юЄ чрЎшъыштрэш  т ъюэЎх ю°шсюўэюую Їрщыр (ЄхяхЁ№ т ЁхъєЁёштэ√ї т√чютрї)
  472.     _opsym = *(PCHAR)_tword;
  473.     IF (_opsym == '\'') {
  474.       rdquotes('\'');
  475.       rdch(); //фюсрты хь чръЁ√тр■∙є■ ърт√ўъє
  476.       _tword[_lentword] = '\0'; //strclose(_tword, _lentword);
  477.       _lenjoined = strcopy(_tword, _lentword, _joined);
  478.       _t = _T_CHAR; cmdpushnum();
  479.     }ELSE IF (_opsym == '\"') {
  480.       _lenjoined = strcopy(_title, _lentitle, _joined);
  481.       jautonum(_curlbl);
  482.       INC _curlbl;
  483.       //_joined[_lenjoined] = '\0'; //strclose(_joined, _lenjoined);
  484.       _t = _T_POI|_T_CHAR; cmdpushnum();
  485.       varstrz(); //ё ьхЄъющ joined
  486.     }ELSE IF (_opsym == '+') {
  487.       rdword(); //'(' of type or +TRUE/+FALSE (BOOL) or +_CONSTANT or +__CONSTANT (BYTE)
  488.       _opsym = *(PCHAR)_tword;//|+(CHAR)0x20;
  489.       IF (_opsym=='_') { //+_CONSTANT or +__CONSTANT (BYTE)
  490.         //эрўры№эр  ўрёЄ№ шьхэш ъюэёЄрэЄ√ єцх яЁюўшЄрэр
  491.         adddots();
  492.         joinvarname(/**iscall*/+FALSE);
  493.         _lenjoined = strcopy(_name, _lenname, _joined); //уыюсры№эр 
  494.         _t = _T_BYTE; cmdpushnum();
  495.       }ELSE IF (+(BYTE)(+(BYTE)_opsym - +(BYTE)'0') < 0x0a) { //+num
  496.         IF (!_waseof) val(); //ЁхъєЁёштэ√щ т√чют val
  497.         IF (_t == _T_UINT) cmdcastto(_T_INT); //фы  чэръют√ї ъюэёЄрэЄ Єшяр +15
  498.       }ELSE IF (_opsym!='(') { //+TRUE/+FALSE (BOOL) //+sizeof
  499.         IF (_opsym=='s') { //+sizeof //TODO uppercase?
  500.           rdword(); //шёяюы№чютрыш sizeof
  501.           eat('('/**, "\'(\'"*/);
  502.           eattype();
  503.           //eatexpr(); //эр т√їюфх шч expr єцх яЁюўшЄрэр ')', эю ёыхфє■∙шщ ёшьтюы шыш ъюьрэфр эх яЁюўшЄрэ√
  504.           //eat(')', "\')\'");
  505. //          IF ((_t&_T_TYPE)!=0x00) {
  506.             emitn(_varsz); //gettypesz();
  507.             _lenjoined = strcopy(_nbuf, _lennbuf, _joined); //уыюсры№эр 
  508. //          }ELSE { //эх Єшя
  509.             //- шч яхЁхьхээющ срчютюую Єшяр - сєфхЄ ю°шсър, Є.ъ. яє° чэрўхэш  яхЁхьхээющ TODO (ёфхырЄ№ ёюёЄю эшх _issizeof)
  510.             //- шч яхЁхьхээющ ьрёёштр - сєфхЄ ю°шсър, Є.ъ. яє° рфЁхёр ьрёёштр TODO
  511.             //- шч яхЁхьхээющ ёЄЁєъЄєЁ√ - сєфхЄ ю°шсър, Є.ъ. яє° рфЁхёр ёЄЁєъЄєЁ√ TODO
  512.             //- шч т√Ёрцхэш  - сєфхЄ ю°шсър, Є.ъ. ёухэхЁшЁє■Єё  юяхЁрЎшш TODO
  513. //          };
  514.           _t = _T_UINT; cmdpushnum(); //(_joined)
  515.         }ELSE { //+TRUE/+FALSE (BOOL)
  516.           _lenjoined = strcopy(_tword, _lentword, _joined); //_lenjoined = strjoin(/**to=*/_joined, 0/**strclear(_joined)*/, _tword/**, _lentword*/);
  517.           //strclose(_joined, _lenjoined);
  518.           _t = _T_BOOL; cmdpushnum(); //(_joined)
  519.         };
  520.       }ELSE { //'(': с√ы typecast
  521. /**        rdword(); //type
  522.         t = eattype();
  523.         eat(')', "\')\'");
  524.         IF (!_waseof) val(); //ЁхъєЁёштэ√щ т√чют val
  525.         cmdcastto(t);*/
  526.         //rdword(); //яхЁтюх ёыютю expr
  527.         //eatexpr(); //эр т√їюфх шч expr єцх яЁюўшЄрэр ')', эю ёыхфє■∙шщ ёшьтюы шыш ъюьрэфр эх яЁюўшЄрэ√
  528.         IF (!_waseof) val(); //ЁхъєЁёштэ√щ т√чют val
  529.         //IF (_t == _T_UINT) cmdcastto(_T_INT); //фы  чэръют√ї ъюэёЄрэЄ Єшяр +15 (ьх°рхЄ фхырЄ№ +(type)val)
  530.       };
  531.     }ELSE IF ((BYTE)((BYTE)_opsym - (BYTE)'0') < 0x0a) { //num
  532.       numtype(); //_t
  533.       _lenjoined = strcopy(_tword, _lentword, _joined);
  534.       cmdpushnum();
  535.     }ELSE IF (_isalphanum[(BYTE)_opsym] /**|| (_opsym=='.')*/) { //<var> //с√ыю isalpha
  536.       adddots();
  537.      //хёыш т√чют ЇєэъЎшш, Єю do_variable эрфю фхырЄ№ ё namespclvl-1!!!
  538.       IF (_cnext == '(') { //call
  539.         _t = do_call(+TRUE); //isfunc
  540.       }ELSE {
  541.         joinvarname(+FALSE); //iscall
  542.         IF (_cnext == '[') { //<varname>[<idx>]
  543.           rdword(); //'['
  544.           _t = idxarray(_t);
  545.           cmdpeek();
  546.         }ELSE { //<varname>
  547.           IF ((_t&_T_TYPE)==(TYPE)0x00) {
  548.             /**IF (_t==_T_STRUCT) {
  549.               _t = _T_POI|_T_BYTE;
  550.               cmdpushnum(); //схЁ╕ь рфЁхё ёЄЁєъЄєЁ√ (фы  .)
  551.             }ELSE*/ IF ((_t&_T_ARRAY)!=(TYPE)0x00) { //array without [] as a pointer
  552.               _t = _t&(~(_T_ARRAY|_T_CONST))|_T_POI;
  553.               cmdpushnum(); //шёяюы№чютрэшх юс√ўэюую ьрёёштр - схЁ╕ь хую рфЁхё
  554.             }ELSE IF ((_t&_T_CONST)==(TYPE)0x00) {
  555.               cmdpushvar(); //єърчрЄхы№ (т Єюь ўшёых эр ёЄЁєъЄєЁє) шыш юс√ўэр  яхЁхьхээр 
  556.             }ELSE { //ъюэёЄрэЄр (equ)
  557.               _t = _t&_TYPEMASK; //&(~_T_CONST);
  558.               cmdpushnum();
  559.             };
  560.           };
  561.         };
  562.       };
  563.     }ELSE IF (_opsym == '(') {
  564.       rdword(); //яхЁтюх ёыютю expr
  565.       eatexpr(); //эр т√їюфх шч expr єцх яЁюўшЄрэр ')'???, эю ёыхфє■∙шщ ёшьтюы шыш ъюьрэфр эх яЁюўшЄрэ√
  566. typeaddr = _typeaddr; //errstr("((((("); erruint(_typeaddr); enderr();
  567.       IF ((_t&_T_TYPE)!=(TYPE)0x00) { //(type)val typecast//эхы№ч  т sizeof(expr)
  568.         t = _t&~_T_TYPE;
  569.         _t = t;
  570.         rdword();
  571.         val();
  572. _typeaddr = typeaddr; //errstr(")))))"); erruint(_typeaddr); enderr();
  573.         cmdcastto(t);
  574.       };
  575.     }ELSE IF (_opsym == '-') {
  576.       IF ((BYTE)((BYTE)_cnext - (BYTE)'0') < 0x0a) { //-<const>
  577.         rdaddword();
  578.         //todo float
  579.         _t = _T_INT;
  580.         _lenjoined = strcopy(_tword, _lentword, _joined);
  581.         cmdpushnum();
  582.       }ELSE { //-<var>
  583.         rdword(); //яхЁтюх ёыютю val
  584.         IF (!_waseof) val(); //ЁхъєЁёштэ√щ т√чют val
  585.         cmdneg();
  586.       };
  587.     }ELSE IF (_opsym == '!') {
  588.       rdword(); //яхЁтюх ёыютю val
  589.       IF (!_waseof) val(); //ЁхъєЁёштэ√щ т√чют val
  590.       cmdinv(); //TODO invBOOL
  591.     }ELSE IF (_opsym == '~') {
  592.       rdword(); //яхЁтюх ёыютю val
  593.       IF (!_waseof) val(); //ЁхъєЁёштэ√щ т√чют val
  594.       cmdinv();
  595.     }ELSE IF (_opsym == '*') {
  596.       rdword(); //'(' of type
  597.       //eat('(');
  598.       //eattype(); t = _t/**|_T_POI*/; //tpoi //todo PPOINTER
  599.       //eat(')');
  600.       IF (!_waseof) val(); //чфхё№ Єшя єърчрЄхы  эх трцхэ //ЁхъєЁёштэ√щ т√чют val
  601.       _t = _t&~_T_POI; //&~_T_CONST;
  602.       cmdpeek();
  603.     }ELSE IF (_opsym == '&') {
  604.       IF (_cnext == '(') { //&(<structname>-><field>)
  605.         _addrexpr = +TRUE;
  606.         rdword(); //'('
  607.         val();
  608.         _t = _t|_T_POI;
  609.       }ELSE {
  610.         rdword();
  611.         adddots();
  612.         joinvarname(/**iscall*/+FALSE);
  613.         IF (_cnext == '[') { //&<varname>[<idx>]
  614.           rdword(); //'['
  615.           _t = idxarray(_t)/**Єшя ¤ыхьхэЄр ьрёёштр*/|_T_POI;
  616.         }ELSE { //&<varname>
  617.           //IF ((_t&_T_ARRAY)!=0x00) { //&<arrayname> - error
  618.           //}ELSE IF ((_t&_T_CONST)!=0x00) { //&<constname> - error
  619.           //}ELSE { //&<varname>
  620.             _t = _t&_TYPEMASK|_T_POI;
  621.             cmdpushnum();
  622.           //};
  623.         };
  624.       };
  625.     }ELSE {
  626.       errstr("WRONG PREFIX "); err(_opsym); enderr();
  627.       _t = _T_UNKNOWN; //debug (шэрўх ьюцхЄ т√ыхЄхЄ№ чр ЄрсышЎє typesz яЁш юсЁ√тх Їрщыр)
  628.     };
  629.   };
  630. #ifdef USE_HINTS
  631. ;;  hinttype("end val",_t);
  632. #endif
  633. }
  634. }
  635.  
  636. PROC eatmulval RECURSIVE()
  637. {
  638. VAR CHAR opsym;
  639. VAR TYPE t1;
  640. {
  641. //<val>[<*|/><val>...] => push[push<*|/>...]
  642. //чрърэўштрхЄё  яю ёшьтюыє ы■сющ эхюяшёрээющ юяхЁрЎшш (эряЁшьхЁ, ')' шыш ';')
  643.  //ъюьрэфр єцх яЁюўшЄрэр
  644. #ifdef USE_HINTS
  645. ;;  hintstr("//mulval"); endhint();
  646. #endif
  647.   val();
  648.   rdword();
  649. #ifdef USE_HINTS
  650. ;;  hintstr("//mulval after val"); hint_tword();
  651. #endif
  652.   REPEAT {
  653.     opsym = *(PCHAR)_tword;
  654.     //IF (opsym==')') BREAK; //fast exit
  655.     IF (opsym!='*')
  656.       IF (opsym!='/')
  657.         IF (opsym!='&')
  658.           BREAK;
  659.     t1 = _t;
  660.     rdword();
  661.     IF (opsym=='&')
  662.       IF (*(PCHAR)_tword==opsym)
  663.         rdword(); //use '&' //C compatibility
  664.     val();
  665.     _t = _t&_TYPEMASK; //&(~_T_CONST);
  666.     rdword();
  667. #ifdef USE_HINTS
  668. ;;    hintstr("//mulval after val2"); hint_tword();
  669. #endif
  670.     IF (t1 != _t) {errstr("opsym "); err(opsym); errstr(" type "); erruint(+(UINT)t1); errstr("!="); erruint(+(UINT)_t); enderr(); };
  671.     IF       (opsym=='&') {cmdand();
  672.     }ELSE IF (opsym=='*') {cmdmul();
  673.     }ELSE /**IF (opsym=='/')*/ {cmddiv();
  674.     };
  675.   }UNTIL (_waseof);
  676. #ifdef USE_HINTS
  677. ;;  hinttype("end mulval",_t);
  678. #endif
  679. }
  680. }
  681.  
  682. PROC eatsumval RECURSIVE()
  683. {
  684. VAR CHAR opsym;
  685. VAR TYPE t1;
  686. {
  687. //<mulval>[<+|-><mulval>...] => push[push<+|->...]
  688.  //ъюьрэфр єцх яЁюўшЄрэр
  689. #ifdef USE_HINTS
  690. ;;  hintstr("//sumval"); endhint();
  691. #endif
  692.   eatmulval();
  693.   REPEAT {
  694.     opsym = *(PCHAR)_tword;
  695.     //IF (opsym==')') BREAK; //fast exit
  696.     IF (opsym!='+')
  697.       IF (opsym!='-')
  698.         IF (opsym!='|')
  699.           IF (opsym!='^')
  700.             BREAK;
  701.     t1 = _t;
  702.     rdword();
  703.     IF (*(PCHAR)_tword=='>') { //structinstancepointer->structfield
  704.       //ёЄЁєъЄєЁр єцх яЁюўшЄрэр ш рфЁхёютрэр _typeaddr, Єшя _t = эхъшщ єърчрЄхы№
  705.       getstructfield(); //_t = Єшя яюы 
  706.       IF (!_addrexpr) cmdpeek(); //peek
  707.       rdword(); //шёяюы№чютрыш structfield
  708.     }ELSE {
  709.       IF (opsym=='|') //||(opsym=='^')
  710.         IF (*(PCHAR)_tword==opsym)
  711.           rdword(); //use '|' or '^' //C compatibility
  712.       eatmulval();
  713.       _t = _t&_TYPEMASK; //&(~_T_CONST);
  714.       IF (t1 != _t) /**&& ((t&_T_POI)!=0x00)*/ {errstr("opsym "); err(opsym); errstr(" type "); erruint(+(UINT)t1); errstr("!="); erruint(+(UINT)_t); enderr(); };
  715.       //todo addpointer
  716.       IF       (opsym == '+') {cmdadd();
  717.       }ELSE IF (opsym == '-') {cmdsub(); //шч ёЄрЁюую т√ўхёЄ№ эютюх!
  718.       }ELSE IF (opsym == '|') {cmdor();
  719.       }ELSE /**IF (opsym == '^')*/ {cmdxor();
  720.       };
  721.     };
  722.   }UNTIL (_waseof);
  723. #ifdef USE_HINTS
  724. ;;  hinttype("end sumval",_t);
  725. #endif
  726. }
  727. }
  728.  
  729. PROC eatexpr RECURSIVE()
  730. {
  731. VAR CHAR opsym;
  732. VAR TYPE t1;
  733. VAR BOOL modified;
  734. VAR BOOL dbl;
  735. {
  736. //<sumval>[<=><sumval>...]
  737.  //ъюьрэфр єцх яЁюўшЄрэр (эєцэю фы  do_call_par)
  738. #ifdef USE_HINTS
  739. ;;  hintstr("//expr"); endhint();
  740. #endif
  741.   INC _exprlvl;
  742.   eatsumval();
  743.   REPEAT {
  744.     opsym = *(PCHAR)_tword;
  745.     //IF (opsym==')') BREAK; //fast exit
  746.     IF (opsym!='<')
  747.       IF (opsym!='>')
  748.         IF (opsym!='=')
  749.           IF (opsym!='!')
  750.             BREAK;
  751.     t1 = _t;
  752.     rdword();
  753.     modified = (*(PCHAR)_tword=='=');
  754.     dbl = (*(PCHAR)_tword==opsym);
  755.     IF ( modified||dbl ) rdword(); //use '=' or '>' or '<'
  756.     eatsumval();
  757.     _t = _t&_TYPEMASK; //&(~_T_CONST);
  758.     IF (t1 != _t) {errstr("opsym "); err(opsym); errstr(" type "); erruint(+(UINT)t1); errstr("!="); erruint(+(UINT)_t); enderr(); };
  759.     IF (opsym == '=') {
  760.       IF (!dbl) {errstr( "assign in expr" ); enderr(); };
  761.       cmdeq(); //фхырхЄ _t = _T_BOOL
  762.     }ELSE IF (opsym == '!') {
  763.       cmdnoteq(); //фхырхЄ _t = _T_BOOL
  764.     }ELSE IF (opsym == '<') {
  765.       IF (dbl) {
  766.         cmdshl(); //ёЄрЁюх ёфтшэєЄ№ ёЄюы№ъю Ёрч, ёъюы№ъю уырёшЄ эютюх!
  767.       }ELSE IF (modified) {
  768.         cmdlesseq(); //фхырхЄ _t = _T_BOOL
  769.       }ELSE cmdless(); //фхырхЄ _t = _T_BOOL
  770.     }ELSE /**IF (opsym == '>')*/ {
  771.       IF (dbl) {
  772.         cmdshr(); //ёЄрЁюх ёфтшэєЄ№ ёЄюы№ъю Ёрч, ёъюы№ъю уырёшЄ эютюх!
  773.       }ELSE IF (modified) {
  774.         cmdmoreeq(); //фхырхЄ _t = _T_BOOL
  775.       }ELSE cmdmore(); //фхырхЄ _t = _T_BOOL
  776.     };
  777.   }UNTIL (_waseof);
  778.   //ЄєЄ юцшфрхЄё  (т _tword) ')' шыш фЁєующ эхёююЄтхЄёЄтє■∙шщ ёшьтюы
  779.   DEC _exprlvl;
  780.   _addrexpr = +FALSE; //эх т√Ёрцхэшх ё &
  781. #ifdef USE_HINTS
  782. ;;  hinttype("end expr",_t);
  783. ;;  hint_tword();
  784. #endif
  785. }
  786. }
  787.  
  788. PROC eatpoke()
  789. //poke*(<ptype>)(<pointerexpr>)=<expr>
  790. {
  791. VAR TYPE t;
  792. #ifdef USE_HINTS
  793. ;;  hintstr("//poke"); endhint();
  794. #endif
  795.   _exprlvl = 0x01; //no jump optimization
  796.   eat('*');
  797. /**
  798.   eat('(');
  799.   eattype(); t = _t&~_T_POI;
  800.   eat(')');
  801.   eat('('); //'=' ьюцхЄ с√Є№ т т√Ёрцхэшш
  802.   eatexpr(); //todo ъръ-Єю ЁрёёўшЄрЄ№ т√Ёрцхэшх єърчрЄхы  яюёых т√Ёрцхэш  =, ўЄюс√ ё¤ъюэюьшЄ№ ЁхушёЄЁ
  803.   //todo яЁютхЁшЄ№ pointer
  804.   eat(')'); //'=' ьюцхЄ с√Є№ т т√Ёрцхэшш
  805. */
  806.   val(); t = _t&~_T_POI;
  807.   rdword();
  808.   eat('=');
  809.   eatexpr();
  810.   IF (t != _t) {errstr("poke variable type="); erruint(+(UINT)t); errstr(", but expr type="); erruint(+(UINT)_t); enderr(); };
  811.   cmdpoke();
  812. #ifdef USE_HINTS
  813. ;;  hintstr("//end poke"); endhint();
  814. #endif
  815. }
  816.  
  817. PROC eatlet()
  818. //<var>[<[><expr><]>]=<expr>
  819. //<var>-><field>=<expr>
  820. {
  821. VAR TYPE t;
  822. VAR BOOL ispoke;
  823. #ifdef USE_HINTS
  824. ;;  hintstr("//let"); endhint();
  825. #endif
  826.   _exprlvl = 0x01; //no jump optimization
  827.   joinvarname(/**iscall*/+FALSE); t = _t; //t!!!
  828.   rdword(); //'['
  829.   ispoke = +FALSE;
  830.   IF (*(PCHAR)_tword/**_cnext*/ == '[') {
  831.     t = idxarray(t); //t = t&(~(_T_ARRAY|_T_POI));
  832.     eat(']');
  833.     ispoke = +TRUE;
  834.   }ELSE {
  835.     WHILE (*(PCHAR)_tword/**_cnext*/ == '-') {
  836.       _t = t;
  837.       IF (ispoke) { //эх яхЁт√щ ->
  838.         cmdpeek();
  839.       }ELSE { //яхЁт√щ ->
  840.         cmdpushvar(); //єърчрЄхы№ (т Єюь ўшёых эр ёЄЁєъЄєЁє) шыш юс√ўэр  яхЁхьхээр 
  841.       };
  842.       eat('-');
  843.       //ёЄЁєъЄєЁр єцх яЁюўшЄрэр ш рфЁхёютрэр _typeaddr, Єшя _t = эхъшщ єърчрЄхы№
  844.       getstructfield(); //_t = Єшя яюы 
  845.       t = _t; //todo
  846.       rdword(); //шёяюы№чютрыш structfield
  847.       ispoke = +TRUE;
  848.     };
  849.   };
  850.   eat('=');
  851.  strpush(_joined,_lenjoined);
  852.   eatexpr(); //яюыєўрхЄ Єшя _t
  853.  _lenjoined = strpop(_joined);
  854.   IF (t!=_t) {
  855.     errstr("let variable type="); erruint(+(UINT)t); errstr(", but expr type="); erruint(+(UINT)_t); enderr();
  856.   };
  857.   IF (ispoke) {
  858.     cmdpoke();
  859.   }ELSE {
  860.     cmdpopvar();
  861.   };
  862. #ifdef USE_HINTS
  863. ;;  hintstr("//end let"); hint_tword();
  864. #endif
  865. }
  866.  
  867. PROC eatwhile RECURSIVE()
  868. //while<expr><cmd>[;]
  869. //; яЁюЄшт ю°шсъш "WHILE (expr);cmd"
  870. /**
  871. LOCAL ;ухэхЁшЁєхЄ єэшъры№э√щ_шфхэЄшЇшърЄюЁ
  872. TEMPWHILE: ;¤ътштрыхэЄэю єэшъры№э√щ_шфхэЄшЇшърЄюЁ.TEMPWHILE
  873.  <єёыютшх>
  874.  jp cc,TEMPEND ;¤ътштрыхэЄэю єэшъры№э√щ_шфхэЄшЇшърЄюЁ.TEMPEND
  875.  <Єхыю>
  876.  jp TEMPWHILE ;¤ътштрыхэЄэю єэшъры№э√щ_шфхэЄшЇшърЄюЁ.TEMPWHILE
  877. TEMPEND: ;¤ътштрыхэЄэю єэшъры№э√щ_шфхэЄшЇшърЄюЁ.TEMPEND ;х∙╕ фы  break
  878. ENDL
  879. */
  880. {
  881. VAR UINT beglbl;
  882. VAR UINT wasendlbl;
  883. {
  884. #ifdef USE_HINTS
  885. ;;  hintstr("//while"); endhint();
  886. #endif
  887.   _exprlvl = 0x00; //jump optimization possible
  888.   wasendlbl = _tmpendlbl;
  889.   beglbl = _curlbl; INC _curlbl;
  890.   _tmpendlbl = _curlbl; INC _curlbl;
  891.   genjplbl(beglbl); cmdlabel();
  892.   eat('(');
  893.   eatexpr(); //parentheses not included
  894.   genjplbl(_tmpendlbl); cmdjpiffalse();
  895.   eat(')');
  896.   eatcmd(); //Єхыю while
  897.   genjplbl(beglbl); cmdjp();
  898.   genjplbl(_tmpendlbl); cmdlabel();
  899.   _tmpendlbl = wasendlbl;
  900.   //IF (*(PCHAR)_tword/**_cnext*/ != ';') {errstr("\';\' expected, but we have \'"); err(*(PCHAR)_tword/**_cnext*/); err('\''); enderr();};
  901. #ifdef USE_HINTS
  902. ;;  hintstr("//end while"); endhint();
  903. #endif
  904. }
  905. }
  906.  
  907. PROC eatrepeat RECURSIVE()
  908. //repeat<cmd>until<expr>
  909. /**
  910. LOCAL ;ухэхЁшЁєхЄ єэшъры№э√щ_шфхэЄшЇшърЄюЁ
  911. TEMPREPEAT: ;¤ътштрыхэЄэю єэшъры№э√щ_шфхэЄшЇшърЄюЁ.TEMPREPEAT
  912.  <Єхыю>
  913.  <єёыютшх>
  914.  jp cc,TEMPREPEAT ;¤ътштрыхэЄэю єэшъры№э√щ_шфхэЄшЇшърЄюЁ.TEMPREPEAT
  915. TEMPEND: ;фы  break
  916. ENDL
  917. */
  918. {
  919. VAR UINT beglbl;
  920. VAR UINT wasendlbl;
  921. {
  922. #ifdef USE_HINTS
  923. ;;  hintstr("//repeat"); endhint();
  924. #endif
  925.   wasendlbl = _tmpendlbl;
  926.   beglbl = _curlbl; INC _curlbl;
  927.   _tmpendlbl = _curlbl; INC _curlbl;
  928.   genjplbl(beglbl); cmdlabel();
  929.   eatcmd(); //Єхыю repeat
  930.   IF ( +(CHAR)(+(BYTE)(*(PCHAR)_tword)|0x20)!='u'/**"until"*/ ) err_tword("UNTIL");
  931.   rdword();
  932.   eat('(');
  933.   _exprlvl = 0x00; //jump optimization possible
  934.   eatexpr(); //parentheses not included
  935.   eat(')');
  936.   genjplbl(beglbl); cmdjpiffalse();
  937.   genjplbl(_tmpendlbl); cmdlabel();
  938.   _tmpendlbl = wasendlbl;
  939. #ifdef USE_HINTS
  940. ;;  hintstr("//end repeat"); endhint();
  941. #endif
  942. }
  943. }
  944.  
  945. PROC eatbreak() //todo inline
  946. //break
  947. {
  948.   genjplbl(_tmpendlbl);
  949.   cmdjp();
  950. }
  951.  
  952. PROC eatif RECURSIVE()
  953. //if <expr> <cmd>[else<cmd>];
  954. //(; яЁюЄшт ю°шсъш "IF (expr);cmd" ш ю°шсъш тыюцхээюую if)
  955. /**
  956. <єёыютшх>
  957. LOCAL ;ухэхЁшЁєхЄ єэшъры№э√щ_шфхэЄшЇшърЄюЁ
  958.  jp cc,TEMPELSE;¤ътштрыхэЄэю єэшъры№э√щ_шфхэЄшЇшърЄюЁ.TEMPELSE
  959.  <Єхыю then>
  960. [ jp TEMPENDIF ;¤ътштрыхэЄэю єэшъры№э√щ_шфхэЄшЇшърЄюЁ.TEMPENDIF]
  961. TEMPELSE: ;¤ътштрыхэЄэю єэшъры№э√щ_шфхэЄшЇшърЄюЁ.TEMPELSE
  962.  <Єхыю else>
  963. TEMPENDIF: ;¤ътштрыхэЄэю єэшъры№э√щ_шфхэЄшЇшърЄюЁ.TEMPENDIF
  964. ENDL
  965. */
  966. {
  967. VAR UINT elselbl;
  968. VAR UINT endiflbl;
  969. {
  970. #ifdef USE_HINTS
  971. ;;  hintstr("//if"); endhint();
  972. #endif
  973.   _exprlvl = 0x00; //jump optimization possible
  974.   elselbl = _curlbl; INC _curlbl;
  975.   endiflbl = _curlbl; INC _curlbl;
  976.   eat('(');
  977.   eatexpr(); //parentheses not included
  978.   genjplbl(elselbl); cmdjpiffalse();
  979.   eat(')'); //rdword();
  980.   eatcmd(); //Єхыю then
  981.   IF (*(PCHAR)_tword/**_cnext*/ != ';'/**"endif"*/) {
  982.     IF ( +(CHAR)(+(BYTE)(*(PCHAR)_tword)|0x20)!='e'/**"else"*/ ) err_tword("ELSE or \';\'");
  983.     genjplbl(endiflbl); cmdjp();
  984.     genjplbl(elselbl); cmdlabel();
  985.     rdword();
  986.     eatcmd(); //Єхыю else
  987.     genjplbl(endiflbl); cmdlabel();
  988.     IF (*(PCHAR)_tword/**_cnext*/ != ';'/**"endif"*/) { errstr( "\';\' expected, but we have \'"); err(*(PCHAR)_tword/**_cnext*/); err('\''); enderr(); };
  989.     //эхы№ч  ё·хфрЄ№ ';', юэ эєцхэ фы  тыюцхээ√ї if
  990.   }ELSE { //юцшфрхь 'endif' (хёыш IF схч ELSE)
  991.     genjplbl(elselbl); cmdlabel();
  992.   };
  993. #ifdef USE_HINTS
  994. ;;  hintstr("//end if"); endhint();
  995. #endif
  996. }
  997. }
  998. /**
  999. PROC eatmodule RECURSIVE()
  1000. //module<lbl><cmd>
  1001. {
  1002.   _lentitle = strjoin(_title, _lentitle, _tword);
  1003.   _lentitle = stradd(_title, _lentitle, '.');
  1004.   INC _namespclvl; //фюсрты хь ёыютю ъ title
  1005.  
  1006.   rdword();
  1007.   eatcmd();
  1008.  
  1009.   DEC _namespclvl;
  1010.   doprefix(_namespclvl); //to prefix
  1011.   _lentitle = strcopy(_prefix, _lenprefix, _title); //title = prefix //юЄЁхчрхь фюсртыхээюх ёыютю
  1012. }
  1013. */
  1014. PROC eatreturn() //todo inline
  1015. {
  1016. //todo яЁютхЁшЄ№ isfunc (ўЄю ь√ т ЇєэъЎшш) фы  т√тюфр ю°шсъш
  1017. #ifdef USE_HINTS
  1018. ;;  hintstr("//return"); endhint();
  1019. #endif
  1020.   _exprlvl = 0x01; //no jump optimization
  1021.   eatexpr(); //ёЁртэхэш  эхы№ч  схч ёъюсюъ!!!
  1022.   IF ( _t != (_curfunct&(~_T_RECURSIVE)) ) {errstr("return type="); erruint(+(UINT)_curfunct); errstr(", but expr type="); erruint(+(UINT)_t); enderr(); };
  1023.   cmdresult();
  1024. #ifdef USE_HINTS
  1025. ;;  hintstr("//end return"); endhint();
  1026. #endif
  1027.   _wasreturn = +TRUE; //єёЄрэютшЄ№ яЁютхЁъє "юяхЁрЄюЁ яюёых return"
  1028. }
  1029.  
  1030. PROC eatinc()
  1031. {
  1032. #ifdef USE_HINTS
  1033. ;;  hintstr("//inc"); endhint();
  1034. #endif
  1035.   IF (*(PCHAR)_tword == '*') {
  1036.     rdword(); //'('
  1037.     eatexpr();
  1038.     _t = _t&~_T_POI;
  1039.     cmdincbyaddr();
  1040.   }ELSE {
  1041.     //эрўры№эр  ўрёЄ№ шьхэш яхЁхьхээющ єцх яЁюўшЄрэр
  1042.     adddots(); //фюўшЄрЄ№ шь 
  1043.     joinvarname(/**iscall*/+FALSE); //doprefix(_namespclvl); //prefix:=title[FIRST to...];
  1044.     cmdinc();
  1045.     rdword();
  1046.   };
  1047. }
  1048.  
  1049. PROC eatdec()
  1050. {
  1051. #ifdef USE_HINTS
  1052. ;;  hintstr("//dec"); endhint();
  1053. #endif
  1054.   IF (*(PCHAR)_tword == '*') {
  1055.     rdword(); //'('
  1056.     eatexpr();
  1057.     _t = _t&~_T_POI;
  1058.     cmddecbyaddr();
  1059.   }ELSE {
  1060.     //эрўры№эр  ўрёЄ№ шьхэш яхЁхьхээющ єцх яЁюўшЄрэр
  1061.     adddots(); //фюўшЄрЄ№ шь 
  1062.     joinvarname(/**iscall*/+FALSE); //doprefix(_namespclvl); //prefix:=title[FIRST to...];
  1063.     cmddec();
  1064.     rdword();
  1065.   };
  1066. }
  1067.  
  1068. PROC var_num(TYPE t, PCHAR s)
  1069. {
  1070. VAR TYPE tmasked = t&(~_T_ARRAY);
  1071. /**  IF ( (t&_T_POI)!=(TYPE)0x00 ) { //шёяюы№чєхЄё  фы  ёЄЁюъ (эхы№ч  equ)
  1072.     varstr_tword(); //DB "str"
  1073.   }ELSE*/ IF ( (t&_T_CONST)!=(TYPE)0x00 ) {
  1074.     varequ(_title); /**varstr(_title); varc( '=' );*/ varstr(s); endvar();
  1075.   }ELSE {
  1076.     IF (t==tmasked/**(t&_T_ARRAY)==(TYPE)0x00*/) {
  1077.       var_alignwsz_label(t);
  1078.       //emitvarlabel(_joined); //varstr(_joined); /**varc( ':' );*/ endvar();
  1079.     };
  1080.     var_def(tmasked, s);
  1081.   };
  1082. }
  1083.  
  1084. //TODO т√Ёрцхэш (юЄфрЄ№ рёьє?) + ЄрсышЎє ъюэёЄрэЄ т ъюьяшы ЄюЁх?
  1085. PROC do_const_num(TYPE t)
  1086. {
  1087.   IF ((*(PCHAR)_tword == '-') || (*(PCHAR)_tword == '+')) {
  1088.     rdaddword(); //яЁшъыхшЄ№ ўшёыю
  1089.     var_num(t, _tword);
  1090.   }ELSE IF (*(PCHAR)_tword == '\'') {
  1091.     rdquotes('\'');
  1092.     rdch(); //фюсрты хь чръЁ√тр■∙є■ ърт√ўъє
  1093.     _tword[_lentword] = '\0'; //strclose(_tword, _lentword);
  1094.     var_num(t, _tword);
  1095.   }ELSE IF (*(PCHAR)_tword == '&') { //&<var>, &<func>, &<structinstance>
  1096.     rdword(); //шёяюы№чютрЄ№ &, яЁюўшЄрЄ№ эрўрыю шьхэш
  1097.     adddots(); //фюўшЄрЄ№ шь 
  1098.     var_num(_T_ARRAY|_T_UINT, _tword); //_T_ARRAY эх фр╕Є ёючфрЄ№ ьхЄъє
  1099.   }ELSE IF (*(PCHAR)_tword == '\"') {
  1100.     _lenjoined = strcopy(_title, _lentitle, _joined);
  1101.     IF ((t&_T_ARRAY)!=(TYPE)0x00) { //ёЄЁюър тэєЄЁш ьрёёштр
  1102.       jdot();
  1103.       jautonum(_curlbl);
  1104.       INC _curlbl;
  1105.       //_joined[_lenjoined] = '\0'; //strclose(_joined, _lenjoined);
  1106.       var_num(_T_ARRAY|_T_UINT, _joined); //_T_ARRAY эх фр╕Є ёючфрЄ№ ьхЄъє
  1107.       asmstrz(); //ё ьхЄъющ _joined //ъюёЄ√ы№ тьхёЄю varstrz //todo Ўхышъюь чряюыэшЄ№ єърчрЄхыш, яюЄюь ухэхЁшЁютрЄ№ ёЄЁюъш? (эхы№ч  сєфхЄ &str т const pchar arr[]?)
  1108.     }ELSE {
  1109.       asmstrz(); //varstrz(); //ё ьхЄъющ joined
  1110.     };
  1111.   }ELSE var_num(t, _tword);
  1112. }
  1113.  
  1114. PROC eatextern()
  1115. //extern<type><variable>[<[><expr><]>]
  1116. {
  1117. VAR TYPE t;
  1118. #ifdef USE_HINTS
  1119. ;;  hintstr("//extern"); endhint();
  1120. #endif
  1121.   _exprlvl = 0x01; //no jump optimization
  1122.   eatvarname(); t = _t; //схч ёЁєсрэш  тыюцхээюёЄхщ яю _ (ёючфр╕Є _name)
  1123.   IF (*(PCHAR)_tword == '[') {
  1124.     //t = t|_T_ARRAY; //єцх т eatvarname
  1125.     //rdbrackets(); //_tword='[' //TODO evaluate expr (т э╕ь эхы№ч  яхЁхьхээ√х ш т√чют√, Є.х. эх чрярЁ√трхЄё  joined?)
  1126.     _lentword = 0; //strclear(_tword); //ўшЄрхь ё яєёЄющ ёЄЁюъш
  1127.     rdquotes(']');
  1128.     rdch(); //яЁюяєёЄшЄ№ ']'
  1129.     //_lenncells = strcopy(_tword, _lentword, _ncells); //n = _tword;
  1130.   //}ELSE {
  1131.     //n ="1";
  1132.     //_lenncells = stradd(_ncells, strclear(_ncells), '1'); //n = n + '1';
  1133.     //strclose(_ncells, _lenncells);
  1134.     rdword();
  1135.   };
  1136.   addlbl(t, /**isloc*/+FALSE, (UINT)_typesz[t&_TYPEMASK]/**, _ncells, _lenncells*/); //(_name) //TODO ЁрчьхЁ ьрёёштр (ёЄЁєъЄєЁ√ эх с√тр■Є extern?)!
  1137. #ifdef USE_HINTS
  1138. ;;  hintstr("//end extern"); endhint();
  1139. #endif
  1140. }
  1141.  
  1142. PROC eatvar RECURSIVE(BOOL ispar, BOOL body) //хёыш var, Єю body==+TRUE, шэрўх body==!forward
  1143. //var<type><variable>[<[><expr><]>][=<expr>]
  1144. //шыш т ярЁрьхЄЁрї яЁш юс· тыхэшш ЇєэъЎшш <type><variable>
  1145. {
  1146. VAR TYPE t;
  1147. {
  1148. #ifdef USE_HINTS
  1149. ;;  hintstr("//var"); endhint();
  1150. #endif
  1151.   _exprlvl = 0x01; //no jump optimization
  1152.   eatvarname(); t = _t; //схч ёЁєсрэш  тыюцхээюёЄхщ яю _ (ёючфр╕Є _name)
  1153.   IF (*(PCHAR)_tword == '[') {
  1154.     //t = t|_T_ARRAY; //єцх т eatvarname
  1155.    //strpush(_joined,_lenjoined);
  1156.     //TODO evaluate expr (т э╕ь эхы№ч  яхЁхьхээ√х ш т√чют√, Є.х. эх чрярЁ√трхЄё  joined?)
  1157.     _lentword = 0; //strclear(_tword); //ўшЄрхь ё яєёЄющ ёЄЁюъш
  1158.     rdquotes(']');
  1159.    //_lenjoined = strpop(_joined);
  1160.     _lenncells = strcopy(_tword, _lentword, _ncells); //n = _tword;
  1161.     rdch(); //яЁюяєёЄшЄ№ ']'
  1162.     rdword();
  1163.   }ELSE { //n = "1"
  1164.     _lenncells = stradd(_ncells, 0/**strclear(_ncells)*/, '1'); //n = n + '1';
  1165.     _ncells[_lenncells] = '\0'; //strclose(_ncells, _lenncells);
  1166.   };
  1167.   IF (body) addlbl(t, /**isloc*/(_namespclvl!=0x00), (UINT)_typesz[t&_TYPEMASK]/**, _ncells, _lenncells*/); //(_name) //TODO ЁрчьхЁ ьрёёштр шыш ёЄЁєъЄєЁ√!
  1168.   IF (ispar) { //parameter of func/proc
  1169.     IF (body) {
  1170.       var_alignwsz_label(t);
  1171.       //emitvarlabel(_joined); //varstr(_joined); /**varc( ':' );*/ endvar();
  1172.     };
  1173.     _lenjoined = strcopy(_prefix, _lenprefix, _joined); //_lenjoined = strjoin(/**to=*/_joined, 0/**strclear(_joined)*/, _prefix/**, _lenprefix*/); //prefix юёЄрыё  юЄ doprefix/eatvarname т√°х
  1174.     jautonum(_parnum);
  1175.     INC _parnum; //!!! todo эряшёрЄ№ яюўхьє
  1176.     INC _curlbl; //!!! todo эряшёрЄ№ яюўхьє
  1177.     //_joined[_lenjoined] = '\0'; //strclose(_joined, _lenjoined);
  1178.     _lenname = strcopy(_joined, _lenjoined, _name);
  1179.     addlbl(t, /**isloc*/+FALSE, (UINT)_typesz[t&_TYPEMASK]/**, "0", _lenncells*/); //юЄьхЄшыш т ЄрсышЎх, ўЄю эх т√фхы Є№ ярь Є№ //(_name) //TODO ЁрчьхЁ ьрёёштр шыш ёЄЁєъЄєЁ√!
  1180.   };
  1181.   //printf("%s \n",_joined);
  1182.   IF (body) {
  1183.     IF ((t&_T_ARRAY)!=(TYPE)0x00) {
  1184.       var_alignwsz_label(t);
  1185.       //emitvarlabel(_joined); //varstr(_joined); /**varc( ':' );*/ endvar();
  1186.       var_ds(); /**varstr( "\tDS " );*/ varuint(+(UINT)_typesz[t&_TYPEMASK]); varc('*'); varstr(_ncells); endvar(); //todo ЁрёёўшЄрЄ№ ЁрчьхЁ єцх т addlbl, Єюуфр ьюцэю сєфхЄ фхырЄ№ +sizeof(<array>)
  1187.       //printf("%s ds \n",_joined);
  1188.     }ELSE {
  1189.       var_num(t, "0");
  1190.     };
  1191.     doexp(); //_joined
  1192.   };
  1193.   IF (*(PCHAR)_tword == '=') { //TODO яЁютхЁшЄ№, ўЄю ь√ тэєЄЁш ЇєэъЎшш (эхЁхъєЁёштэющ!)
  1194.     rdword(); //'='
  1195.    strpush(_joined,_lenjoined);
  1196.     eatexpr();
  1197.    _lenjoined = strpop(_joined);
  1198.     //IF ( (t!=_t) && !( ((t&_T_POI)!=(TYPE)0x00) && (/**(texpr==_T_UINT)||*/((_t&_T_POI)!=(TYPE)0x00)) ) ) {errstr("let variable="); errstr(_joined); errstr(" type="); erruint(+(UINT)t); errstr(", but expr type="); erruint(+(UINT)_t); enderr(); };
  1199.     IF (t!=_t) {errstr("let variable="); errstr(_joined); errstr(" type="); erruint(+(UINT)t); errstr(", but expr type="); erruint(+(UINT)_t); enderr(); };
  1200.     cmdpopvar();
  1201.   };
  1202.   IF (_isrecursive && !ispar) { //local variable of recursive func/proc
  1203.     _t = t;
  1204.     cmdpushpar(); //todo ўЄю фхырЄ№ ё ьрёёштрьш?
  1205.    strpush(_joined,_lenjoined);
  1206.     WHILE (*(PCHAR)_tword==';') {
  1207.       rdword();
  1208.     }; //C compatibility
  1209.     eatcmd(); //recursive function body must be in {} after vars!
  1210.    _lenjoined = strpop(_joined);
  1211.     _t = t;
  1212.     cmdpoppar(); //todo ўЄю фхырЄ№ ё ьрёёштрьш?
  1213.   };
  1214. #ifdef USE_HINTS
  1215. ;;  hintstr("//end var"); endhint();
  1216. #endif
  1217. }
  1218. }
  1219.  
  1220. //TODO т√Ёрцхэш (юЄфрЄ№ рёьє?) + ЄрсышЎє ъюэёЄрэЄ?
  1221. PROC eatconst()
  1222. //<constnum>::=[-]<num>|'<char>'|"<str>"["<str>"...]
  1223. //const<type><variable>[=<constnum>]
  1224. //|const<type><variable><[><expr><]>[<[><expr><]>...][={<constnum>[,<constnum>...]}] - тыюцхээ√х {} чряЁх∙хэ√ (todo ёфхырЄ№ шыш шуэюЁшЁютрЄ№ ё ртЄюяхЁхёў╕Єюь ьэюуюьхЁэ√ї ьрёёштют т юфэюьхЁэ√х)
  1225. //|const pchar<variable><[><expr><]><[><expr><]>={"<str>"[,"<str>"...]}
  1226. {
  1227. VAR TYPE t;
  1228. VAR UINT i = 0;
  1229. #ifdef USE_HINTS
  1230. ;;  hintstr("//const"); endhint();
  1231. #endif
  1232.   _exprlvl = 0x01; //no jump optimization
  1233.   eattype(); t = _t|_T_CONST; //Єшя с√ы єцх яЁюўшЄрэ
  1234.   adddots();
  1235.   doprefix(_namespclvl); //ёъыхшЄ№ n ёыют Єшяр 'word.' шч title т prefix (name схч яЁхЇшъёр)
  1236.   rdword(); //'['
  1237.   IF (*(PCHAR)_tword == '[') {
  1238.     t = t|_T_ARRAY;
  1239.   };
  1240.   //_joined ёюфхЁцшЄ шь  ъюэёЄрэЄ√
  1241.   //_name ёюфхЁцшЄ Єшя
  1242.   _lentitle = strcopy(_joined, _lenjoined, _title); //фы  єэшъры№эюёЄш шь╕э ёЄЁюъют√ї ъюэёЄрэЄ
  1243.   INC _namespclvl; //фюсрты хь ёыютю ъ title
  1244.  
  1245.   //эрь эєцэю яюыєўшЄ№ шь  Єшяр
  1246.   lbltype();
  1247.   _lenname = strcopy(_joined, _lenjoined, _name); //шь  ъюэёЄрэЄ√
  1248.   _lencallee = gettypename(_callee); //тч Є№ эрчтрэшх Єшяр ёЄЁєъЄєЁ√ т callee (ёЁрчє яюёых lbltype)
  1249.  
  1250.   //title ёюфхЁцшЄ шь  ъюэёЄрэЄ√ (эєцэю фы  єэшъры№эюёЄш шь╕э ёЄЁюъют√ї ъюэёЄрэЄ т ьрёёштх т do_const_num)
  1251.   //_joined Єюцх ёюфхЁцшЄ шь  ъюэёЄрэЄ√
  1252.   addlbl(t, /**isloc*/+FALSE, (UINT)_typesz[t&_TYPEMASK]/**, _ncells, _lenncells*/); //(_name) //TODO ЁрчьхЁ ьрёёштр шыш ёЄЁєъЄєЁ√!
  1253.   WHILE (*(PCHAR)_tword == '[') { //[size]
  1254.     _lentword = 0; //strclear(_tword); //ўшЄрхь ё яєёЄющ ёЄЁюъш
  1255.     rdquotes(']');
  1256.     rdch(); //яЁюяєёЄшЄ№ ']'
  1257.     rdword();
  1258.   };
  1259.   IF (*(PCHAR)_tword == '=') {
  1260.     rdword(); //num or '{'
  1261.     IF (*(PCHAR)_tword == '{') { //array or struct
  1262.       var_alignwsz_label(t);
  1263.       doexp(); //_joined //эрфю ыш ¤ъёяюЁЄшЁютрЄ№ ъюэёЄрэЄ√? Єюы№ъю ъюэёЄрэЄэ√х ьрёёшт√/ёЄЁєъЄєЁ√
  1264.       REPEAT{ //¤ЄюЄ Ўшъы чряюЁЄшЄ _joined, эю шёяюы№чєхЄ _title
  1265.         rdword(); //num
  1266.  
  1267.         IF (t == (_T_STRUCT|_T_CONST)) { //ёЄЁєъЄєЁр (є эх╕ эхЄ рЄюьрЁэюую Єшяр)
  1268.           _lenjoined = strcopy(_callee, _lencallee, _joined); //callee ёюфхЁцшЄ шь  Єшяр ъюэёЄрэЄ√
  1269.           _lenjoined = stradd(_joined, _lenjoined, '.');
  1270.           jautonum(i);
  1271.           _lenname = strcopy(_joined, _lenjoined, _name);
  1272.           _t = lbltype();
  1273.           do_const_num(lbltype()&(~_T_TYPE)|_T_ARRAY); //_T_ARRAY эх фр╕Є ёючфрЄ№ ьхЄъє
  1274.           INC i;
  1275.         }ELSE { //эх ёЄЁєъЄєЁр
  1276.           do_const_num(t&(~_T_CONST)); //_T_ARRAY эх фр╕Є ёючфрЄ№ ьхЄъє
  1277.         };
  1278.  
  1279.         rdword(); //',' or '}'
  1280.       }UNTIL (*(PCHAR)_tword == '}');
  1281.     }ELSE { //not array
  1282.       do_const_num(t);
  1283.     };
  1284.     rdword();
  1285.   };
  1286.  
  1287.   DEC _namespclvl; doprefix(_namespclvl); _lentitle=strcopy(_prefix,_lenprefix,_title);/**title =prefix;*/ //юЄЁхчрхь фюсртыхээюх ёыютю
  1288.  
  1289.   //_isexp = +FALSE; //эрфю ыш ¤ъёяюЁЄшЁютрЄ№ ъюэёЄрэЄ√? Єюы№ъю ъюэёЄрэЄэ√х ьрёёшт√/ёЄЁєъЄєЁ√
  1290.  
  1291. #ifdef USE_HINTS
  1292. ;;  hintstr("//end const"); endhint();
  1293. #endif
  1294. }
  1295.  
  1296. PROC eatfunc(BOOL isfunc, TYPE oldfunct, BOOL oldwasreturn)
  1297. //proc<procname>[recursive][forward](<type><par>,...])[<cmd>]
  1298. //|func<type><funcname>[recursive][forward]([<type><par>,...])[<cmd>]
  1299. {
  1300. VAR BOOL isforward;
  1301.   _curlbl = 0; //ёсЁрё√трхь эєьхЁрЎш■ ртЄюьхЄюъ, Є.ъ. є эшї яЁхЇшъё ЇєэъЎшш
  1302.   IF ( isfunc ) {
  1303.     eattype(); _curfunct = _t;
  1304.   }ELSE _curfunct = _T_PROC;
  1305. #ifdef USE_HINTS
  1306. ;;    hintstr("//func "); hinttype(_title,_curfunct);
  1307. #endif
  1308.   _lenname = strcopy(_tword, _lentword, _name);
  1309.   jtitletword();
  1310.   rdword(); //'(' or "recursive" or "forward"
  1311.   IF (+(CHAR)(+(BYTE)(*(PCHAR)_tword)|0x20) == 'r') {
  1312.     _curfunct = _curfunct|_T_RECURSIVE;
  1313.     _isrecursive = +TRUE;
  1314.     rdword(); //'('
  1315.   }ELSE _isrecursive = +FALSE;
  1316.   IF (+(CHAR)(+(BYTE)(*(PCHAR)_tword)|0x20) == 'f') {
  1317.     isforward = +TRUE;
  1318.     rdword(); //'('
  1319.   }ELSE isforward = +FALSE;
  1320.   addlbl(_curfunct, /**isloc*/+FALSE, 0/**, _ncells"0", 1*/); //(_name) //эхы№ч  if (!isforward), яюЄюьє ўЄю эрфю чряюьэшЄ№ Єшя ЇєэъЎшш т forward
  1321.   IF (!isforward) {
  1322.     cmdlabel(); //_joined
  1323.     cmdfunc(); //фхырхЄ initrgs
  1324.     doexp(); //_joined
  1325.   };
  1326.   jdot();
  1327.   _lentitle = strcopy(_joined, _lenjoined, _title);
  1328.   INC _namespclvl; //фюсрты хь ёыютю ъ title
  1329.  
  1330.   eat('(');
  1331.   _parnum = 0;
  1332.   WHILE (!_waseof) {
  1333.     IF (*(PCHAR)_tword == ')') BREAK;
  1334.     eatvar(/**ispar*/+TRUE, /**body*/!isforward); //ьхЄър ярЁрьхЄЁр ёючфр╕Єё  схч яЁхЇшъёр ш ё Їыруюь isloc, х∙╕ ёючфр╕Єё  f.A.
  1335.     IF (*(PCHAR)_tword == ')') BREAK; //шэрўх ','
  1336.     rdword(); //type or ')'
  1337.   };
  1338.   rdword();
  1339.  
  1340.   keepvars(); //эхы№ч  яхЁхф ярЁрьхЄЁрьш, Є.ъ. f.A. эрфю яюьэшЄ№ яюёых Єхыр ЇєэъЎшш
  1341.  
  1342.   IF (!isforward) {
  1343.     eatcmd(); //Єхыю ЇєэъЎшш
  1344.     _t = _curfunct&(~_T_RECURSIVE);
  1345.     cmdret(isfunc);
  1346.     IF (isfunc && !_wasreturn) {errstr("return expected"); enderr(); };
  1347. #ifdef USE_HINTS
  1348. ;;    hintstr("/////end func"); endhint();
  1349. #endif
  1350.   };
  1351.  
  1352.   undovars(); //TODO єэшўЄюцшЄ№ ъюЁюЄъшх ьхЄъш ярЁрьхЄЁют, шэрўх юэш чрЄЁєЄ уыюсры√ эртхўэю. ═рфю їЁрэшЄ№ рфЁхёр Єръшї ьхЄюъ т ЄрсышЎх
  1353.  
  1354.   DEC _namespclvl; doprefix(_namespclvl); _lentitle=strcopy(_prefix,_lenprefix,_title);/**title =prefix;*/ //юЄЁхчрхь фюсртыхээюх ёыютю
  1355.   _curfunct = oldfunct; //тючтЁрЄшЄ№ тэх°эшщ Єшя ЇєэъЎшш
  1356.   _wasreturn = oldwasreturn; //ёсЁюёшЄ№ яЁютхЁъє "юяхЁрЄюЁ яюёых return"
  1357.   _isexp = +FALSE;
  1358. }
  1359.  
  1360. PROC do_callpar RECURSIVE(TYPE funct, UINT parnum)
  1361. {
  1362. VAR TYPE t;
  1363. {
  1364. #ifdef USE_HINTS
  1365. ;;  hintstr("//call_par"); endhint();
  1366. #endif
  1367.   IF ( (*(PCHAR)_tword!=')') && !_waseof ) {
  1368.     _lenjoined = strcopy(_callee, _lencallee, _joined);
  1369.     jdot();
  1370.     jautonum(parnum);
  1371.     //INC _curlbl; //эх эєцэю, Є.ъ. ¤Єю т√чют (Є.х. фЁєующ яЁхЇшъё)
  1372.     //_joined[_lenjoined] = '\0'; //strclose(_joined, _lenjoined);
  1373. ;;    cmtstr(";accesspar="); cmtstr(_joined); endcmt();
  1374.     _lenname = strcopy(_joined, _lenjoined, _name);
  1375.     t = lbltype(); //(_name)
  1376.     IF ((funct&_T_RECURSIVE)!=(TYPE)0x00/**isstacked*/) {
  1377.       _t = t;
  1378.       cmdpushpar(); //(_joined)
  1379.     };
  1380.     strpush(_joined,_lenjoined);
  1381.     INC _exprlvl; //no jump optimization
  1382.     eatexpr(); //ьюцхЄ ЁхъєЁёштэю т√чтрЄ№ do_call ш чрЄхЁхЄ№ callee (хёыш юэ уыюсры№э√щ)! //ёЁртэхэш  эхы№ч  схч ёъюсюъ!!!
  1383.     DEC _exprlvl;
  1384.     IF (t != _t) {errstr("callpar type="); erruint(+(UINT)t); errstr(", but expr type="); erruint(+(UINT)_t); enderr(); };
  1385.     _lenjoined = strpop(_joined);
  1386.     cmdpopvar(); //(_joined)
  1387.     IF (*(PCHAR)_tword == ',') rdword(); //parameter or ')'
  1388.     IF (parnum < _MAXPARS) {
  1389.       strpush(_joined,_lenjoined);
  1390.       do_callpar(/**isfunc,*/ funct, /**isstacked,*/ parnum+1); //ЁхъєЁёштэю
  1391.       _lenjoined = strpop(_joined);
  1392.     }/**ELSE {errstr("too many parameters"); enderr(); }*/;
  1393.     IF ((funct&_T_RECURSIVE)!=(TYPE)0x00/**isstacked*/) {
  1394.       _t = t;
  1395.       cmdpoppar(); //(_joined)
  1396.     };
  1397.   }ELSE {
  1398.     _t = funct&(~_T_RECURSIVE);
  1399.     cmdcall();
  1400.   };
  1401. #ifdef USE_HINTS
  1402. ;;  hintstr("//end call_par"); endhint();
  1403. #endif
  1404. }
  1405. }
  1406.  
  1407. FUNC TYPE do_call RECURSIVE(BOOL isfunc)
  1408. //<lbl>([recursive][(<type>)<val>,...])
  1409. {
  1410. VAR TYPE t;
  1411. {
  1412.   INC _exprlvl; //no jump optimization
  1413.   joinvarname(/**iscall*/+TRUE); t = _t; //t!!!
  1414.   IF (t == _T_UNKNOWN) {errstr("unknown function "); errstr(_joined); enderr(); };
  1415. #ifdef USE_HINTS
  1416. ;;    hinttype("call",t);
  1417. #endif
  1418.   IF (!isfunc) t = (t&_T_RECURSIVE)|_T_PROC; //ўЄюс√ ьюцэю с√ыю т√ч√трЄ№ ЇєэъЎшш ъръ яЁюЎхфєЁ√
  1419.   strpush(_callee,_lencallee); //эр ёыєўрщ тыюцхээ√ї т√чютют
  1420.   _lencallee = strcopy(_joined, _lenjoined, _callee); //схч Єюўъш
  1421.   jdot();
  1422.   rdword(); //'('
  1423.   eat('(');
  1424.   do_callpar(t, /**parnum*/0); //ёюїЁрэхэшх [call]title, [ёюїЁрэхэшх яхЁхьхээющ], яЁшётрштрэшх, ЁхъєЁёш , [тюёёЄрэютыхэшх яхЁхьхээющ], тюёёЄрэютыхэшх [call]title
  1425.   _lencallee = strpop(_callee); //эр ёыєўрщ тыюцхээ√ї т√чютют
  1426.   DEC _exprlvl; //no jump optimization
  1427. RETURN t&(~_T_RECURSIVE);
  1428. }
  1429. }
  1430.  
  1431. PROC eatcallpoi()
  1432. //call(<poi>)
  1433. {
  1434.  //эрўры№эр  ўрёЄ№ шьхэш яхЁхьхээющ єцх яЁюўшЄрэр
  1435.   adddots(); //фюўшЄрЄ№ шь 
  1436.   joinvarname(/**iscall*/+FALSE); //doprefix(_namespclvl); //prefix:=title[FIRST to...];
  1437.   eat('(');
  1438.   eatexpr();
  1439.   //todo яЁютхЁшЄ№ pointer
  1440.   eat(')');
  1441.   cmdcallval();
  1442.   rdword();
  1443. }
  1444.  
  1445. PROC eatlbl() //todo inline
  1446. //_lbl<lblname><:>
  1447. {
  1448.   jtitletword();
  1449.   cmdlabel();
  1450.   rdword(); //skip ':' for C compatibility
  1451.   rdword(); //эєцэю!
  1452. }
  1453.  
  1454. PROC eatgoto() //яхЁхїюф Єюы№ъю тэєЄЁш Єхъє∙хщ яЁюЎхфєЁ√ //todo inline
  1455. //goto<lblname>
  1456. {
  1457.   //rdword(); //lbl
  1458.   jtitletword();
  1459.   cmdjp();
  1460.   rdword();
  1461. }
  1462.  
  1463. PROC eatasm()
  1464. //asm("asmtext")
  1465. {
  1466.   //rdword(); //'('
  1467.   rdword(); //'\"'
  1468.   WHILE (!_waseof) {
  1469.     _lentword = 0/**strclear(_tword)*/; //ўшЄрхь ё яєёЄющ ёЄЁюъш
  1470.     rdquotes('\"'/**, +FALSE*/);
  1471.     asmstr(_tword); endasm();
  1472.     rdch(); //яЁюяєёЄшЄ№ чръЁ√тр■∙є■ ърт√ўъє
  1473.     IF (_cnext != '\"') BREAK;
  1474.     rdword(); //'\"' юЄъЁ√тр■∙р  ърт√ўър яЁшъыххээющ ёЄЁюъш
  1475.   };
  1476.   rdword(); //')'
  1477.   rdword();
  1478. }
  1479.  
  1480. PROC eatenum()
  1481. //enum{<constname0>[=<num>],<constname1>...[,]}
  1482. {
  1483. //VAR UINT i = 0;
  1484.   //rdword(); //'{'
  1485. _lenncells = strcopy("-1", 2, _ncells);
  1486.   WHILE (!_waseof) {
  1487.     rdword(); //ьхЄър
  1488.     IF (*(PCHAR)_tword=='}') BREAK; //BREAK ЁрсюЄрхЄ, р goto qqq эх ЁрсюЄрхЄ ('}' эх ё·хфхэр)
  1489.     varequ(_tword); /**varstr(_tword); varc('=');*/
  1490.  
  1491. //ъюёЄ√ы№ фы  script: ёючфр╕ь яхЁхьхээє■ UINT ё рфЁхёюь, ъръ Єхъє∙хх ўшёыю т enum:
  1492.     _lenname = strcopy(_tword, _lentword, _name);
  1493.     addlbl(_T_UINT, /**isloc*/+FALSE, /**varsz*/0/**, "0", _lenncells*/); //юЄьхЄшыш т ЄрсышЎх, ўЄю эх т√фхы Є№ ярь Є№
  1494. //    rdword(); //',' шыш '}'
  1495. //    IF (*(PCHAR)_tword=='=') {
  1496.     IF (_cnext=='=') {
  1497.       rdword(); //ё·хыш =
  1498.       rdword(); //яхЁтюх ёыютю expr
  1499.       //eatexpr(); //parentheses not included
  1500.       //rdword(); //',' шыш '}'
  1501.       varstr(_tword);
  1502.     }ELSE {
  1503.       varstr(_ncells); varc('+'); varc('1'); /**varuint(i);*/
  1504.     };
  1505. _lenncells = strcopy(_tword, _lentword, _ncells);
  1506.     endvar();
  1507.     rdword(); //',' шыш '}'
  1508.     IF (*(PCHAR)_tword!=',') BREAK; //}
  1509.     //INC i;
  1510.   };
  1511.   rdword(); //ёыютю яюёых }
  1512. }
  1513.  
  1514. PROC eatstruct()
  1515. //struct<name>{<type1><field1>[;]<type2><field2>[;]...}
  1516. {
  1517. VAR UINT shift = 0;
  1518. VAR UINT varszaddr;
  1519. VAR UINT i = 0;
  1520. VAR UINT sz;
  1521.   _lentitle = strjoin(/**to=*/_title, _lentitle, _tword/**, _lentword*/);
  1522.   _title[_lentitle] = '\0'; //strclose(_title, _lentitle);
  1523.   //strpush(_title,_lentitle); //схч Єюўъш
  1524.   _lenname = strcopy(_title, _lentitle, _name); //схч Єюўъш
  1525.   addlbl(_T_STRUCT|_T_TYPE, /**isloc*/+FALSE, 0/**, "0", _lenncells*/); //(_name) //яЁхфтрЁшЄхы№эю ёючфрыш, ўЄюс√ ёё√ырЄ№ё 
  1526.   varszaddr = _varszaddr;
  1527.  
  1528.   _lentitle = stradd(_title, _lentitle, '.');
  1529.   _title[_lentitle] = '\0'; //strclose(_title, _lentitle);
  1530.   INC _namespclvl; //фюсрты хь ёыютю ъ title
  1531.   rdword(); //шёяюы№чютрыш шь 
  1532.   eat('{');
  1533.  
  1534.   WHILE (!_waseof) {
  1535.     eattype(); //шёяюы№чютрыш Єшя
  1536.     sz = (UINT)_typesz[_t&_TYPEMASK];
  1537.     //rdword(); //ьхЄър
  1538.     jtitletword();
  1539.     shift = varshift(shift, sz);
  1540.  
  1541.     _lenname = strcopy(_joined, _lenjoined, _name);
  1542.     addlbl(_t, /**isloc*/+FALSE, sz/**, "0", _lenncells*/); //(_name)
  1543.  
  1544.     genjplbl(i);
  1545.     _lenname = strcopy(_joined, _lenjoined, _name);
  1546.     addlbl(_t, /**isloc*/+FALSE, sz/**, "0", _lenncells*/); //ртЄюэєьхЁютрээр  (_name)
  1547.     INC i;
  1548.  
  1549.     shift = shift + sz;
  1550.     rdword(); //Єшя шыш ';' шыш '}' //шёяюы№чютрыш ьхЄъє
  1551.     IF (*(PCHAR)_tword==';') rdword(); //Єшя
  1552.     IF (*(PCHAR)_tword=='}') BREAK;
  1553.   };
  1554.  
  1555.   //_lenname = strpop(_name);
  1556.   //addlbl(_T_STRUCT|_T_TYPE, /**isloc*/+FALSE/**, "0", _lenncells*/); //юЄьхЄшыш т ЄрсышЎх, ўЄю эх т√фхы Є№ ярь Є№ //(_name)
  1557.   //Єрь цх ёюїЁрэшЄ№ sizeof_structname (=shift)
  1558.   //яЁш ¤Єюь тё╕ х∙╕ ЁрчЁх°шЄ№ ёё√ырЄ№ё  эр ¤Єє цх ёЄЁєъЄєЁє (Є.х. юяЁхфхышЄ№ х╕ Ёрэ№°х, р чряюыэшЄ№ фрээ√х яюЄюь; ёючфрЄ№ чрэютю эхы№ч  - фЁєующ рфЁхё)
  1559.   setvarsz(varszaddr, shift);
  1560.  
  1561.   DEC _namespclvl;
  1562.   doprefix(_namespclvl); //to prefix
  1563.   _lentitle = strcopy(_prefix, _lenprefix, _title); //title = prefix //юЄЁхчрхь фюсртыхээюх ёыютю
  1564.   rdword();
  1565. }
  1566.  
  1567. PROC eatswitch() //яЁюЎхфєЁр ЄхюЁхЄшўхёъш ЁхъєЁёштэр , эю яЁръЄшўхёъш тыюцхээюёЄ№ switch чряЁх∙хэр
  1568. //'J' т эєьхЁютрээ√ї ьхЄърї ьюцэю єсЁрЄ№, Є.ъ. ртЄюьхЄъш ЄхяхЁ№ схч ЎшЇЁ ш эх яхЁхёхъєЄё  (ьюцэю ёъыхштрЄ№ '.' ё ўшёыюь)
  1569. //switch (<byteexpr>){...};
  1570. //case <byteconst>: //ухэхЁшЁєхЄё  ртЄюьхЄър ё ўшёыюь (эх яхЁхёхў╕Єё  эш ё ўхь)
  1571. //default: //ухэхЁшЁєхЄё  ртЄюьхЄър ё Єюўъющ (эх яхЁхёхў╕Єё  эш ё ўхь)
  1572. {
  1573. VAR BYTE ib;
  1574. VAR UINT wastmpendlbl;
  1575.   //rdword(); //'('
  1576.   wastmpendlbl = _tmpendlbl;
  1577.   _tmpendlbl = _curlbl; INC _curlbl;
  1578.  
  1579.   //pushvar <title>.J
  1580.   _lenjoined = strcopy(_title, _lentitle, _joined);
  1581.   _lenjoined = stradd(_joined, _lenjoined, 'J');
  1582.   _joined[_lenjoined] = '\0'; //strclose(_joined , _lenjoined);
  1583.   _t = _T_UINT|_T_POI;
  1584.   cmdpushnum(); //шёяюы№чютрэшх єърчрЄхы  т ърўхёЄтх ьрёёштр - ўшЄрхь хую чэрўхэшх
  1585.  
  1586.   eatidx();
  1587.   _t = _T_UINT; //Єшя ¤ыхьхэЄр ьрёёштр
  1588.   cmdaddpoi();
  1589.   cmdpeek();
  1590.  
  1591.   cmdjpval();
  1592.  
  1593.   //ухэхЁшЁютрЄ№ ёяшёюъ эрўры№э√ї чэрўхэшщ эєьхЁютрээ√ї ьхЄюъ яхЁхїюфр
  1594.   //procname.aab.<num> = procname.aab.default (яюър схч aab TODO)
  1595.   //ухэхЁшЁютрЄ№ ЄрсышЎє яхЁхїюфют, чряюыэхээє■ эєьхЁютрээ√ьш ьхЄърьш яхЁхїюфр
  1596.   //DW procname.aab.1 (яюър схч aab TODO)
  1597.   varstr(_title); varc('J'); endvar();
  1598.   ib = 0x00;
  1599.   REPEAT {
  1600.     asmstr(_title); asmuint(+(UINT)ib); asmc('='); asmstr(_title); asmstr("default"); endasm(); //фю ъюфр! яю¤Єюьє asm
  1601.     var_dw(); varstr(_title); varuint(+(UINT)ib); endvar(); //TODO "DP", Є.х. эр °шЁшэє POINTER?
  1602.     INC ib;
  1603.   }UNTIL (ib == 0x00);
  1604.  
  1605.   eatcmd(); //{...}
  1606.  
  1607.   genjplbl(_tmpendlbl); cmdlabel();
  1608.   _tmpendlbl = wastmpendlbl;
  1609. }
  1610.  
  1611. PROC eatcase()
  1612. //case <byteconst>:
  1613. {
  1614.   //rdword(); //byteconst
  1615.  
  1616.   //чряюыэшЄ№ эєьхЁютрээє■ ьхЄъє яхЁхїюфр
  1617.   //procname.aab.#<_tword> = $ (яюър схч aab TODO)
  1618.   asmstr(_title); asmc('#'); asmstr(_tword); asmc('='); asmc('$'); endasm();
  1619.  
  1620.   rdword(); //skip ':' for C compatibility
  1621.   rdword(); //эєцэю!
  1622. }
  1623.  
  1624. FUNC BOOL eatcmd RECURSIVE() //тючтЁр∙рхЄ +FALSE, хёыш ъюэхЎ сыюър
  1625. {
  1626. {
  1627.  //эрўры№эр  ўрёЄ№ шьхэш яхЁхьхээющ єцх яЁюўшЄрэр
  1628.   adddots(); //фюўшЄрЄ№ шь 
  1629.   _c0 = *(PCHAR)_tword;
  1630.   IF ((_c0=='}') || _waseof) {
  1631.     rdword();
  1632.     _morecmd = +FALSE;
  1633.   }ELSE {
  1634. //    IF (_wasreturn) {
  1635. //      IF (_c0!=';') {errstr("cmd after return!"); enderr(); };
  1636. //    };
  1637.     IF (_cnext=='=') { //let
  1638.       eatlet();
  1639.     }ELSE IF (_cnext=='[') { //let []
  1640.       eatlet();
  1641.     }ELSE IF (_cnext=='-') { //let ->
  1642.       eatlet();
  1643.     }ELSE IF ( (_cnext=='(') && (_spcsize==0) ) { //call
  1644.       do_call(/**isfunc*/+FALSE); rdword();
  1645.     }ELSE IF ( _cnext==':' ) { //lbl
  1646.       eatlbl();
  1647.     }ELSE {
  1648.       IF (_c0==';') {
  1649.         rdword(); //C compatibility
  1650.       }ELSE IF (_c0=='{') {
  1651.         rdword(); WHILE (eatcmd()) {};
  1652.       }ELSE {
  1653.         _c0 = +(CHAR)(+(BYTE)_c0|0x20);
  1654.         _c2 = +(CHAR)(+(BYTE)_tword[2]|0x20);
  1655.         IF       (_c0=='v') { //var
  1656.           rdword(); eatvar(/**ispar*/+FALSE, /**body*/+TRUE);
  1657.           _isexp = +FALSE; //эхы№ч  тэєЄЁ№, шэрўх эх ¤ъёяюЁЄшЁє■Єё  ярЁрьхЄЁ√ яЁюЎхфєЁ√
  1658.         }ELSE IF (_c0=='e') { //enum //extern //export
  1659.           IF (_c2=='t') { //extern
  1660.             rdword(); eatextern();
  1661.           }ELSE IF (_c2=='p') { //export
  1662.             rdword(); _isexp = +TRUE;
  1663.           }ELSE { //enum
  1664.             rdword(); eatenum();
  1665.           };
  1666.         }ELSE IF (_c0=='c') { //const //case //call
  1667.           IF (_c2=='n') { //const
  1668.             rdword(); eatconst();
  1669.           }ELSE IF (_c2=='l') { //call
  1670.             rdword(); eatcallpoi();
  1671.           }ELSE { //case
  1672.             rdword(); eatcase();
  1673.           };
  1674.         }ELSE IF (_c0=='f') { //func
  1675.           rdword(); eatfunc(+TRUE, _curfunct, _wasreturn);
  1676.         }ELSE IF (_c0=='p') { //proc //poke
  1677.           IF (_c2=='o') { //proc
  1678.             rdword(); eatfunc(+FALSE, _curfunct, _wasreturn);
  1679.           }ELSE { //poke
  1680.             rdword(); eatpoke();
  1681.           };
  1682.         }ELSE IF (_c0=='r') { //return //repeat
  1683.           IF (_c2=='t') { //return
  1684.             rdword(); eatreturn();
  1685.           }ELSE { //repeat
  1686.             rdword(); eatrepeat();
  1687.           };
  1688.         }ELSE IF ( _c0=='w' ) { //while
  1689.           rdword(); eatwhile();
  1690.         }ELSE IF ( _c0=='b' ) { //break
  1691.           rdword(); eatbreak(); //no parameters (rds nothing)
  1692.         }ELSE IF ( _c0=='d' ) { //dec
  1693.           rdword(); eatdec();
  1694.         }ELSE IF ( _c0=='i' ) { //inc //if
  1695.           IF ( _c2=='c' ) { //inc
  1696.             rdword(); eatinc();
  1697.           }ELSE { //if
  1698.             rdword(); eatif();
  1699.           };
  1700.         }ELSE IF ( _c0=='g' ) { //goto
  1701.           rdword(); eatgoto();
  1702.         }ELSE IF ( _c0=='a' ) { //asm
  1703.           rdword(); eatasm();
  1704.         }ELSE IF ( _c0=='s' ) { //struct //switch
  1705.           IF (_c2=='r') { //struct
  1706.             rdword(); eatstruct();
  1707.           }ELSE { //switch
  1708.             rdword(); eatswitch();
  1709.           };
  1710. //        }ELSE IF ( _c0=='m' ) { //module
  1711. //          rdword(); eatmodule();
  1712.         }ELSE IF ( _c0=='t' ) { //typedef <type> <name>
  1713.           rdword();
  1714.           eattype();
  1715.           _lenname = strcopy(_tword, _lentword, _name);
  1716.           addlbl(_T_TYPE + _t, /**isloc*/+FALSE, (UINT)_typesz[_t]);
  1717.           rdword(); //шёяюы№чютрыш шь 
  1718.         }ELSE IF ( _c0=='#' ) { //define, include... (ё■фр яюярфрхь фрцх т эхръЄштэ√ї тхЄърї єёыютэющ ъюьяшы Ўшш)
  1719.           rdword(); //define, undef, include, if, else, [elif], ifdef, ifndef, endif, [import], [line], [error], [pragma]
  1720. //тыюцхээр  єёыютэр  ъюьяшы Ўш :
  1721. //_doskipcond т сшЄютюь тшфх яюьэшЄ, ёъюы№ъю єЁютэхщ ръЄштэ√ї ifdef ш ёъюы№ъю єЁютэхщ эхръЄштэ√ї (ъЁюьх Єхъє∙хую)
  1722. //(тэєЄЁш эхръЄштэюую ьюуєЄ с√Є№ Єюы№ъю эхръЄштэ√х)
  1723. //хёыш (_doskipcond&1) == 0 (Є.х. ь√ т эхръЄштэющ тхЄъх), Єю Єхъє∙шщ ifdef шуэюЁшЁєхЄё  ёю тёхьш тїюф ∙шьш (Є.х. else эх ЁрсюЄрхЄ)
  1724. //эхръЄштэюёЄ№ Єхъє∙хщ тхЄъш ifdef ыхцшЄ т _doskip
  1725. //эр тхЁїэхь єЁютэх _doskipcond = 1, _doskip = +FALSE
  1726. //хёыш ifdef, Єю:
  1727.   //_doskipcond = _doskipcond+_doskipcond
  1728.   //хёыш !_doskip, Єю:
  1729.     //INC _doskipcond;
  1730.     //хёыш ifdef эх уюфхэ, Єю _doskip = +TRUE
  1731. //хёыш else ш ((_doskipcond&1) != 0), Єю _doskip = !_doskip
  1732. //хёыш endif, Єю _doskip = ((_doskipcond&1) == 0); _doskipcond = _doskipcond>>1
  1733.           _c2 = _tword[2];
  1734.           IF ((_c2 == 'c')&&(!_doskip)) { //include
  1735.             rdword(); //"
  1736.             _lentword = 0;
  1737.             rdquotes('\"'/**, +FALSE*/); //IF (_c0 == '\"') { rdquotes('>'); }ELSE rdquotes('\"');
  1738.             _hinclfile[_nhinclfiles] = _fin;
  1739.             _hnline[_nhinclfiles] = _curline;
  1740.             INC _nhinclfiles;
  1741.             compfile(_tword);
  1742.             DEC _nhinclfiles;
  1743.             _fin = _hinclfile[_nhinclfiles];
  1744.             _curline = _hnline[_nhinclfiles];
  1745.             _waseof = +FALSE;
  1746.             rdch(); //яЁюяєёЄшЄ№ чръЁ√тр■∙є■ ърт√ўъє
  1747.           }ELSE IF (_c2 == 'd') { //ifdef/endif/undef
  1748.             IF (*(PCHAR)_tword == 'e') { //endif
  1749.               //_doskip = +FALSE; //todo тыюцхээюёЄ№ (яюфёў╕Є ўшёыр шЇют)
  1750.               _doskip = ((_doskipcond&1) == 0);
  1751.               _doskipcond = _doskipcond>>1;
  1752. //erruint(_doskipcond); errstr("#endif "); erruint((UINT)_doskip); enderr();
  1753.             }ELSE IF (*(PCHAR)_tword == 'i') { //ifdef
  1754.               _doskipcond = _doskipcond+_doskipcond;
  1755.               rdword(); //шь 
  1756.               _lenname = strcopy(_tword, _lentword, _name);
  1757.               //_t = lbltype(); //хёыш эхЄє, Єю _T_UNKNOWN
  1758.               IF (!_doskip) {
  1759.                 INC _doskipcond; //эх шуэюЁшЁєхь ¤ЄюЄ ifdef
  1760.                 //эхЄ ьхЄъш - яЁюяєёЄшЄ№ Єхыю
  1761.                 _doskip = (lbltype() == _T_UNKNOWN); //тъы■ўшЄ№ яЁюяєёъ ёЄЁюъ, ъЁюьх эрўшэр■∙шїё  ё #, р чфхё№ юсЁрсрЄ√трЄ№ Єюы№ъю шї
  1762.               };
  1763. //erruint(_doskipcond); errstr("#ifdef "); erruint((UINT)_doskip); enderr();
  1764.             }ELSE { //undef
  1765.               rdword(); //шь 
  1766.               _lenname = strcopy(_tword, _lentword, _name);
  1767.               dellbl();
  1768.             };
  1769.           }ELSE IF (_c2 == 'n') { //ifndef
  1770.               _doskipcond = _doskipcond+_doskipcond;
  1771.               rdword(); //шь 
  1772.               _lenname = strcopy(_tword, _lentword, _name);
  1773.               //_t = lbltype(); //хёыш эхЄє, Єю _T_UNKNOWN
  1774.               IF (!_doskip) {
  1775.                 INC _doskipcond; //эх шуэюЁшЁєхь ¤ЄюЄ ifndef
  1776.                 //хёЄ№ ьхЄър - яЁюяєёЄшЄ№ Єхыю
  1777.                 _doskip = (lbltype() != _T_UNKNOWN); //тъы■ўшЄ№ яЁюяєёъ ёЄЁюъ, ъЁюьх эрўшэр■∙шїё  ё #, р чфхё№ юсЁрсрЄ√трЄ№ Єюы№ъю шї
  1778.               };
  1779.           }ELSE IF (_c2 == 's') { //else
  1780.             //_doskip = !_doskip;
  1781.             IF ((_doskipcond&1) != 0) _doskip = !_doskip; //эх шуэюЁшЁєхь ¤ЄюЄ ifdef
  1782. //erruint(_doskipcond); errstr("#else "); erruint((UINT)_doskip); enderr();
  1783.           }ELSE IF ((_c2 == 'f')&&(!_doskip)) { //define
  1784.             rdword(); //шь 
  1785.             _lenjoined = strcopy(_tword, _lentword, _joined);
  1786.             rdword(); //чэрўхэшх шыш (
  1787.             IF (*(PCHAR)_tword == '(') { //TODO ¤Єє ъюэёЄЁєъЎш■ яЁшьхэшЄ№ ш т const
  1788.               rdword(); //eat('(');
  1789.               eattype();
  1790.               eat(')');
  1791.               rdquotes(')');
  1792.               rdch(); //фюсрты хь чръЁ√тр■∙є■ ёъюсъє
  1793.               _tword[_lentword] = '\0'; //strclose(_tword, _lentword);
  1794.             }ELSE {
  1795.               numtype(); //_t
  1796.             };
  1797.             _lenname = strcopy(_joined, _lenjoined, _name);
  1798.             addlbl(_t|_T_CONST, /**isloc*/+FALSE, (UINT)_typesz[_t/**&_TYPEMASK*/]/**, _ncells, _lenncells*/); //(_name) //TODO ЁрчьхЁ ьрёёштр шыш ёЄЁєъЄєЁ√!
  1799.             emitvarpreequ(_name);
  1800.             varequ(_name); /**varstr(_name); varc( '=' );*/ varstr(_tword); endvar();
  1801.             emitvarpostequ();
  1802.           };
  1803.  
  1804.           //rdchcmt(); //rdaddword(); //шёяюы№чєхь яхЁт√щ ёшьтюы чэрър ъюььхэЄрЁш , ўшЄрхь ёыхфє■∙шщ ёшьтюы
  1805.           WHILE (_waseols==0/** && !_waseof*/ ) {
  1806.             rdchcmt(); //яЁюяєёърхЄ тёх хэЄхЁ√
  1807.           };
  1808.           _tword[_lentword] = '\0'; //strclose(_tword, _lentword); //todo эрЁє°хэр ярЁэюёЄ№ clear..close
  1809.           IF (+(BYTE)_cnext < +(BYTE)'!') {
  1810.             rdch(); //шёяюы№чєхь яюёыхфэшщ ёшьтюы ъюььхэЄрЁш , ўшЄрхь ёыхфє■∙шщ ёшьтюы (TODO єэшЇшЎшЁютрЄ№ ъръ /* */)
  1811.           };
  1812.           rdword();
  1813.         }ELSE {
  1814.           errstr("WRONG COMMAND "); errstr(_tword); enderr();
  1815.           rdword();
  1816.         };
  1817.       };
  1818.     }; //not a headless cmd
  1819.     _morecmd = +TRUE;
  1820.   }; //not '{'
  1821.   RETURN _morecmd;
  1822. }
  1823. }
  1824.  
  1825. PROC compfile RECURSIVE(PCHAR fn)
  1826. {
  1827.   _fin = nfopen(fn, "rb");
  1828.   IF (_fin != (PBYTE)0) {
  1829.     strpush(_fn,_lenfn);
  1830.     _lenfn = strjoineol(_fn, 0/**_lenfn*/, fn, '\0');
  1831.     _fn[_lenfn] = '\0';
  1832.     _waseof = +FALSE;
  1833.  
  1834.     _curline = 1;
  1835.     initrd();
  1836.     rdword();
  1837.  
  1838.     WHILE (eatcmd()) {};
  1839.  
  1840.     fclose(_fin);
  1841.     _lenfn = strpop(_fn);
  1842.   }ELSE {
  1843.     errstr("no file "); errstr(fn); enderr();
  1844.   };
  1845. }
  1846.  
  1847. FUNC UINT strjoineollast(PCHAR to, UINT tolen, PCHAR s2/**, UINT s2len*/, CHAR eol) //фышэр схч ЄхЁьшэрЄюЁр!
  1848. { //to = to + s2;
  1849. VAR UINT len;
  1850. VAR UINT last;
  1851. VAR CHAR c;
  1852.   to = &to[tolen];
  1853.   len = tolen; //фышэр схч ЄхЁьшэрЄюЁр!
  1854.   last = 0; //яюёых яюёыхфэхую ЄхЁьшэрЄюЁр
  1855.   loop:
  1856.     c = *(PCHAR)s2;
  1857.     IF ((c == '\0') || (len>=_STRMAX)) goto endloop; //ЄхЁьшэрЄюЁ эх ъюяшЁєхЄё 
  1858.     POKE *(PCHAR)(to) = c;
  1859.     INC s2;
  1860.     IF (c == eol) last = len;
  1861.     INC to;
  1862.     INC len;
  1863.   goto loop; //ЄхЁьшэрЄюЁ эх ъюяшЁєхЄё 
  1864.   endloop:
  1865. RETURN last; //яюёых яюёыхфэхую ЄхЁьшэрЄюЁр
  1866. }
  1867.  
  1868. PROC compile(PCHAR fn)
  1869. {
  1870.   _doskipcond = 1;
  1871.  
  1872.   _prefix = (PCHAR)_s1; //чряюыэ хЄё  т doprefix: module/func/const/var/extern - ыюъры№эю, joinvarname
  1873.   _title  = (PCHAR)_s2;
  1874.   _callee = (PCHAR)_s3;
  1875.   _name   = (PCHAR)_s4;
  1876.   _joined = (PCHAR)_s5;
  1877.   _ncells = (PCHAR)_s6;
  1878.  
  1879.   _fn = (PCHAR)_m_fn;
  1880.   _lenfn = 0;
  1881.  
  1882.   _tmpendlbl = 0; //ўЄюс√ эшъюуфр эх ёютярыю (break тэх ЇєэъЎшш т√фрёЄ ю°шсъє т рёьх)
  1883.   _lenstrstk = 0;
  1884.   _curlbl = 0; //ёсЁрё√трхь эєьхЁрЎш■ ртЄюьхЄюъ (фы  ьрёёштют ёЄЁюъ)
  1885.  
  1886.   initlblbuf();
  1887.  
  1888.   _lenname = strcopy("INT", 3, _name);
  1889.   addlbl(_T_TYPE + _T_INT, +FALSE, (UINT)_typesz[_T_INT]);
  1890.   _lenname = strcopy("UINT", 4, _name);
  1891.   addlbl(_T_TYPE + _T_UINT, +FALSE, (UINT)_typesz[_T_UINT]);
  1892.   _lenname = strcopy("BYTE", 4, _name);
  1893.   addlbl(_T_TYPE + _T_BYTE, +FALSE, (UINT)_typesz[_T_BYTE]);
  1894.   _lenname = strcopy("BOOL", 4, _name);
  1895.   addlbl(_T_TYPE + _T_BOOL, +FALSE, (UINT)_typesz[_T_BOOL]);
  1896.   _lenname = strcopy("LONG", 4, _name);
  1897.   addlbl(_T_TYPE + _T_LONG, +FALSE, (UINT)_typesz[_T_LONG]);
  1898.   _lenname = strcopy("CHAR", 4, _name);
  1899.   addlbl(_T_TYPE + _T_CHAR, +FALSE, (UINT)_typesz[_T_CHAR]);
  1900.   _lenname = strcopy("FLOAT", 5, _name);
  1901.   addlbl(_T_TYPE + _T_FLOAT, +FALSE, (UINT)_typesz[_T_FLOAT]);
  1902.   _lenname = strcopy("STRUCT", 6, _name);
  1903.   addlbl(_T_TYPE + _T_STRUCTWORD, +FALSE, (UINT)_typesz[_T_STRUCT]);
  1904.   _lenname = strcopy("PINT", 4, _name);
  1905.   addlbl(_T_TYPE + _T_POI + _T_INT, +FALSE, (UINT)_typesz[_T_POI]);
  1906.   _lenname = strcopy("PUINT", 5, _name);
  1907.   addlbl(_T_TYPE + _T_POI + _T_UINT, +FALSE, (UINT)_typesz[_T_POI]);
  1908.   _lenname = strcopy("PBYTE", 5, _name);
  1909.   addlbl(_T_TYPE + _T_POI + _T_BYTE, +FALSE, (UINT)_typesz[_T_POI]);
  1910.   _lenname = strcopy("PBOOL", 5, _name);
  1911.   addlbl(_T_TYPE + _T_POI + _T_BOOL, +FALSE, (UINT)_typesz[_T_POI]);
  1912.   _lenname = strcopy("PLONG", 5, _name);
  1913.   addlbl(_T_TYPE + _T_POI + _T_LONG, +FALSE, (UINT)_typesz[_T_POI]);
  1914.   _lenname = strcopy("PCHAR", 5, _name);
  1915.   addlbl(_T_TYPE + _T_POI + _T_CHAR, +FALSE, (UINT)_typesz[_T_POI]);
  1916.   _lenname = strcopy("PFLOAT", 6, _name);
  1917.   addlbl(_T_TYPE + _T_POI + _T_FLOAT, +FALSE, (UINT)_typesz[_T_POI]);
  1918.   //_lenname = strcopy("PPROC", 5, _name);
  1919.   //addlbl(_T_TYPE + _T_POI + _T_PROC, +FALSE, (UINT)_typesz[_T_POI]);
  1920.  
  1921.   _lentitle = 0/**strclear(_title)*/;
  1922.   POKE *(PCHAR)(_title) = '\0'; //strclose(_title, _lentitle);
  1923.   _namespclvl = 0x00;
  1924.   //_exprlvl = 0x00; //ёхщўрё тхчфх ЁрёёЄртыхэю 0 (ьюцэю юяЄшьшчшЁютрЄ№ ёЁртэхэш ) шыш 1 (эхы№ч ) шыш inc-dec (фы  тыюцхээ√ї т√ўшёыхэшщ Єюцх эхы№ч )
  1925.  
  1926.  _addrexpr = +FALSE;
  1927.   _isexp = +FALSE;
  1928.   _curfunct = _T_UNKNOWN; //эр тё ъшщ ёыєўрщ
  1929.   _wasreturn = +FALSE; //ёсЁюёшЄ№ яЁютхЁъє "юяхЁрЄюЁ яюёых return"
  1930.  
  1931.    _lenjoined = strjoineollast(_joined, 0, fn, '.');
  1932.    _lenjoined = strjoin(_joined, _lenjoined, ".ast");
  1933.    _joined[_lenjoined] = '\0'; //strclose(_joined, _lenjoined);
  1934.   _fout = openwrite(_joined);
  1935.  
  1936.    _lenjoined = strjoineollast(_joined, 0, fn, '.');
  1937.    _lenjoined = strjoin(_joined, _lenjoined, ".var");
  1938.    _joined[_lenjoined] = '\0'; //strclose(_joined, _lenjoined);
  1939.   _fvar = openwrite(_joined);
  1940.  
  1941.   _nhinclfiles = 0x00;
  1942.  
  1943.   initcmd();
  1944.   initcode(); //т√ч√трхЄ emitregs
  1945.   compfile(fn);
  1946.   endcode();
  1947.  
  1948.   fclose(_fvar);
  1949.   fclose(_fout);
  1950. }
  1951.