Subversion Repositories NedoOS

Rev

Rev 8 | Rev 472 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download

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