Subversion Repositories NedoOS

Rev

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

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