Subversion Repositories NedoOS

Rev

Rev 2325 | Blame | Compare with Previous | Last modification | View Log | Download

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