?login_element?

Subversion Repositories NedoOS

Rev

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

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