?login_element?

Subversion Repositories NedoOS

Rev

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

  1. //// imported
  2. #include "../_sdk/str.h"
  3. #include "../_sdk/io.h"
  4. #include "../_sdk/emit.h"
  5.  
  6. PROC asmorgword FORWARD(LONG addr);
  7. PROC fsm FORWARD();
  8. PROC initmemmodel FORWARD();
  9.  
  10. FUNC UINT findlabel FORWARD(PBYTE labeltext);
  11.  
  12. ////
  13. ///////яхЁхьхээ√х, ёюїЁрэ хь√х т post (ёюёЄю эшх рёёхьсыхЁр т ёхЁхфшэх ёЄЁюъш):
  14.  
  15. EXTERN UINT _curlnbeg; //эюьхЁ ёЄЁюъш эр ьюьхэЄ эрўрыр Єюъхэр //фы  read, emit
  16.  
  17. VAR BYTE _token; //Єхъє∙шщ ёўшЄрээ√щ Єюъхэ
  18. VAR BYTE _curdir; //Єюъхэ Єхъє∙хщ юсЁрсрЄ√трхьющ фшЁхъЄшт√ рёёхьсыхЁр (эєцэю фы  яЁртшы№эющ юсЁрсюЄъш ЇюЁьрЄр)
  19.  
  20. VAR BYTE _reg; //яюёыхфэшщ ЁхушёЄЁ
  21. VAR BYTE _oldreg; //яЁхф√фє∙шщ ЁхушёЄЁ
  22. VAR BYTE _base; //срчр ъюфр ъюьрэф√
  23. VAR BYTE _base2; //срчр2 ъюфр ъюьрэф√ (фы  єёыютэ√ї яхЁхїюфют)
  24.  
  25. VAR BYTE _nvalues; //ўшёыю чэрўхэшщ т ёЄхъх
  26.  
  27. VAR UINT _curaddr; //рфЁхё, ъєфр яш°хь
  28. VAR UINT _curshift; //$=(_curaddr+curshift), curshift=(disp-_curaddr)
  29. VAR UINT _curbegin; //эрўры№э√щ рфЁхё сыюър, ъєфр яш°хь
  30. //VAR BYTE _curpage0;
  31. //VAR BYTE _curpage1;
  32. //VAR BYTE _curpage2;
  33. //VAR BYTE _curpage3;
  34.  
  35. VAR UINT _plabel_index; //яюёых findlabel ёюфхЁцшЄ єърчрЄхы№ эр эрўрыю фрээ√ї ьхЄъш
  36. VAR UINT _curplabel_index; //тЁхьхээюх їЁрэшыш∙х _plabel_index яЁш юяЁхфхыхэшш ьхЄюъ
  37. VAR UINT _hash;
  38. VAR UINT _curhash; //тЁхьхээюх їЁрэшыш∙х яЁш юяЁхфхыхэшш ьхЄюъ
  39.  
  40. VAR BYTE _isaddr; //ьрёър "т т√Ёрцхэшш шёяюы№чютрыё  рфЁхё" (юсэєы хЄё  т эрўрых ъюьрэф, ъюЄюЁ√х ухэхЁ Єё  ё чряшё№■ ёыютр шыш яш°єЄ ьхЄъє (label, =, dw, jp, call, ld))
  41. //todo яюър эхы№ч  $-label!!! эю ьюцэю 1*($-label)
  42.  
  43. ////////яхЁхьхээ√х, эх ёюїЁрэ хь√х т post:
  44.  
  45. VAR PBYTE _labelN; //єърчрЄхы№ эр Єхъє∙є■ ЄрсышЎє ьхЄюъ
  46. VAR BOOL _labelchanged; //Їыру "шчьхэшыш ьхЄъє" - эєцэю фы  ю°шсъш яю LABEL (эю эх яю REEQU)
  47. VAR UINT _passindex; //эюьхЁ яЁюїюфр
  48. VAR BYTE _prefixedtoken; //Ёрё°шЇЁютрээ√щ Єюъхэ ё єў╕Єюь \n ш Є.я.
  49.  
  50. VAR BYTE _ninclfiles; //ўшёыю юЄъЁ√Є√ї Їрщыют
  51.  
  52. //////////////////////////////////////////////////////////////////////////////
  53.  
  54. VAR PBYTE _forg;
  55. VAR PBYTE _fpost;
  56. VAR PBYTE _fincb;
  57. VAR PBYTE _fdecl;
  58. VAR BOOL _asms;
  59.  
  60. #define _MAXVALS 0x10
  61. VAR LONG _value[_MAXVALS];
  62. #define _MAXINCLUDES 0x08
  63. VAR PBYTE _inclfile[_MAXINCLUDES];
  64.  
  65. VAR UINT _nlabels;
  66. VAR UINT _lenlabels;
  67.  
  68. CONST BYTE _LABELPAGEMASK = 0x00; //0x07
  69. #ifdef BIGMEM
  70. #define _LABELPAGESIZE 0xfffffe
  71. #else
  72. #define _LABELPAGESIZE 0x6500 /**0x7300*/
  73. #endif
  74. #define _LABELPAGEMAXSHIFT (UINT)(_LABELPAGESIZE-_STRLEN-10)
  75. //CONST UINT _LABELPAGEFREESTART = 0x0200;
  76. VAR UINT _labelpagefreestart; //[1];
  77. //CONST UINT _LABELPAGEDATASHIFT = 0x0202;
  78. #ifdef BIGMEM
  79. CONST UINT _LABELPAGEEOF = 0xffffffff;
  80. #else
  81. CONST UINT _LABELPAGEEOF = 0xffff;
  82. #endif
  83.  
  84. //todo фшэрьшўхёъш т√фхышЄ№
  85. VAR BYTE _labels0[_LABELPAGESIZE]; //0x4000
  86. //VAR BYTE _labels1[0xc000]/**_LABELPAGESIZE*/;
  87. //VAR BYTE _labels2[0xc000]/**_LABELPAGESIZE*/;
  88. //VAR BYTE _labels3[0xc000]/**_LABELPAGESIZE*/;
  89. //VAR BYTE _labels4[0xc000]/**_LABELPAGESIZE*/;
  90. //VAR BYTE _labels5[0xc000]/**_LABELPAGESIZE*/;
  91. //VAR BYTE _labels6[0xc000]/**_LABELPAGESIZE*/;
  92. //VAR BYTE _labels7[0xc000]/**_LABELPAGESIZE*/;
  93. VAR UINT _labelshift[0x400]; //todo 8 pages
  94. VAR PBYTE _labelpage[1]; //8
  95.  
  96. VAR BYTE _m_curlabeltext[_STRLEN]; //Єрь цх fn?
  97. VAR BYTE _m_evallabeltext[_STRLEN];
  98.  
  99. VAR PBYTE _curlabeltext;
  100. VAR PBYTE _evallabeltext;
  101. VAR UINT _labellen; //фышэр ьхЄъш фы  findlabel //тъы■ўр  0
  102.  
  103. //0x0000..0x01ff - рфЁхёр эрўрыр Ўхяюўхъ
  104. //0x0200..0x0201 - рфЁхё эрўрыр ётюсюфэюую ьхёЄр (freestart)
  105. //фры№°х ёрьш Ўхяюўъш
  106. //ЇюЁьрЄ Ўхяюўъш:
  107. //2 срщЄр - рфЁхё ёыхфє■∙хщ ьхЄъш
  108. //N срщЄ - ЄхъёЄ ьхЄъш
  109. //1 срщЄ - '\0'
  110. //1 срщЄ - Їыруш ьхЄъш (defined, accessed, macro)
  111. //4 срщЄр - чэрўхэшх ьхЄъш
  112.  
  113. CONST BYTE _ASMLABEL_DEFINED = 0x01;
  114. CONST BYTE _ASMLABEL_ACCESSED= 0x02;
  115. CONST BYTE _ASMLABEL_MACRO   = 0x04;
  116. CONST BYTE _ASMLABEL_ISADDR  = 0x08;
  117.  
  118. FUNC LONG getlabel FORWARD();
  119.  
  120. //ъръ ёюїЁрэ Є№ post labels?
  121. //todo сєфхь ёюїЁрэ Є№ тё╕ ёюёЄю эшх рёёхьсыхЁр ш ёЄЁюъє фю ъюэЎр, р яюёЄ√ ъюьяшышЁютрЄ№ Єръ цх, ъръ юс√ўэ√щ ЄюъхэшчшЁютрээ√щ ЄхъёЄ
  122. //р яюър яЁюёЄю фтр яЁюїюфр ё чрЄшЁрэшхь Ёхчєы№ЄрЄр яхЁтюую
  123.  
  124. PROC decltoken(BYTE bb)
  125. {
  126.   writebyte(_fdecl,bb);
  127. }
  128.  
  129. PROC asmpushvalue(LONG value)
  130. {
  131. /**  IF ((value & 0xffffL) != value) {
  132.     errstr("val>65536"); enderr();
  133.   };*/
  134.   IF (_nvalues != _MAXVALS) {
  135.     _value[_nvalues] = value;
  136.     INC _nvalues;
  137.   }ELSE {errstr("maxvals"); enderr(); };
  138. }
  139.  
  140. PROC asmpushbool(BOOL b)
  141. {
  142.   //IF (b) {asmpushvalue(1L);
  143.   //}ELSE asmpushvalue(0L);
  144.   asmpushvalue((LONG)(BYTE)b);
  145. }
  146.  
  147. FUNC LONG asmpopvalue()
  148. {
  149. //VAR LONG tempvalue;
  150. //  IF (_nvalues!=0x00) {
  151.     DEC _nvalues;
  152.     //tempvalue = _value[_nvalues];
  153. //  }ELSE {
  154.     //tempvalue = 0xDEADBEEFL;
  155. //    errstr("no data"); enderr(); //debug (can't be error after tokenizer)
  156. //  };
  157.   RETURN _value[_nvalues]; //tempvalue;
  158. }
  159. /**
  160. PROC asmwritestate()
  161. {
  162.   writebyte(_fpost, +_DIR_READSTATE);
  163.  
  164.   writebyte(_fpost, _token);
  165.   writebyte(_fpost, _curdir);
  166.  
  167.   writebyte(_fpost, _reg);
  168.   writebyte(_fpost, _oldreg);
  169.   writebyte(_fpost, _base);
  170.   writebyte(_fpost, _base2);
  171.  
  172.   writebyte(_fpost, _nvalues);
  173.   WHILE (_nvalues!=0x00) {
  174.     writelong(_fpost, asmpopvalue());
  175.   };
  176.  
  177.   writeuint(_fpost, _curaddr);
  178.   writeuint(_fpost, _curshift);
  179.   writeuint(_fpost, _curbegin);
  180.  
  181.   writebyte(_fpost, _curpage0); //ьюфхы№ ярь Єш
  182.   writebyte(_fpost, _curpage1);
  183.   writebyte(_fpost, _curpage2);
  184.   writebyte(_fpost, _curpage3);
  185.  
  186.   //writepointer(_fpost, _labelN);
  187.   //writeuint(_fpost, plabelqueuestart_index);
  188.   writeuint(_fpost, _plabel_index);
  189.   writeuint(_fpost, _curplabel_index);
  190.   writeuint(_fpost, _hash);
  191.   writeuint(_fpost, _curhash);
  192.  
  193.   writeuint(_fpost, _curlnbeg);
  194.  
  195.   writebyte(_fpost, _isaddr);
  196. }
  197. */
  198. /**
  199. PROC asmreadstate()
  200. {
  201. VAR BYTE i;
  202.   _token = readfin();
  203.   _curdir = readfin();
  204.  
  205.   _reg = readfin();
  206.   _oldreg = readfin();
  207.   _base = readfin();
  208.   _base2 = readfin();
  209.  
  210.   i = readfinbyte();
  211.   WHILE (_nvalues!=i) {
  212.     asmpushvalue(readfinlong());
  213.   };
  214.  
  215.   _curaddr = readfinuint();
  216.   _curshift = readfinuint();
  217.   _curbegin = readfinuint();
  218.  
  219.   _curpage0 = readfin(); //ьюфхы№ ярь Єш
  220.   _curpage1 = readfin();
  221.   _curpage2 = readfin();
  222.   _curpage3 = readfin();
  223.  
  224.   //_labelN = readfinpointer();
  225.   //plabelqueuestart_index = readfinuint();
  226.   _curplabel_index = readfinuint();
  227.   _plabel_index = readfinuint();
  228.   _hash = readfinuint();
  229.   _curhash = readfinuint();
  230.  
  231.   _curlnbeg = readfinuint();
  232.  
  233.   _isaddr = readfinbyte();
  234. }
  235. */
  236.  
  237. //0x0000..0x01ff - рфЁхёр эрўрыр Ўхяюўхъ
  238. //фры№°х ёрьш Ўхяюўъш
  239. //ЇюЁьрЄ Ўхяюўъш:
  240. //2 срщЄр - рфЁхё ёыхфє■∙хщ ьхЄъш
  241. //N срщЄ - ЄхъёЄ ьхЄъш
  242. //1 срщЄ - '\0'
  243. //1 срщЄ - Їыруш ьхЄъш (defined, accessed, macro)
  244. //4 срщЄр - чэрўхэшх ьхЄъш
  245.  
  246. PROC clearlabels(UINT labelblock, PBYTE labelpointer)
  247. {
  248.   _labelpage[labelblock] = labelpointer;
  249.   _hash = 0x0400;
  250.   REPEAT {
  251.     DEC _hash;
  252.     _labelshift[_hash] = _LABELPAGEEOF;
  253.   }UNTIL (_hash == 0);
  254.   _labelpagefreestart = 0;
  255. }
  256.  
  257. PROC readlabel()
  258. {
  259. VAR PBYTE pevalstr; //ьхЄър т ёЄЁюъх чрърэўштрхЄё  TOK_ENDTEXT
  260. VAR BYTE cstr; //ёшьтюы шч ёЄЁюъш
  261. VAR UINT labellen;
  262.   _token = readfin(); //TOK_TEXT
  263.   labellen = 0;
  264.   REPEAT {
  265.     cstr = readfin();
  266.     IF ((CHAR)cstr == '#') { //evallabelname=123:labelname#evallabelname фюыцэю фртрЄ№ labelname123
  267.       //ё яюёЄрьш ЁрсюЄрЄ№ эх сєфхЄ!!!
  268.       //яЁюўшЄрЄ№ evallabel т _evallabeltext - TODO fgets
  269.       pevalstr = (PBYTE)_evallabeltext;
  270.       REPEAT {
  271.         cstr = readfin();
  272.         POKE *(PBYTE)(pevalstr) = cstr; //ьхЄър т ёЄЁюъх чрърэўштрхЄё  TOK_ENDTEXT
  273.         INC pevalstr;
  274.       }UNTIL (cstr == +_TOKENDTEXT);
  275.       ;;_labellen = (UINT)(pevalstr - _evallabeltext); //тъы■ўр  0
  276.       //т√ўшёышЄ№ evallabel
  277.       //errstr("readevallabel "); errstr(_evallabeltext); enderr();
  278.       _plabel_index = findlabel(_evallabeltext);
  279.       emitn((UINT)getlabel());
  280.       labellen = strjoin((PCHAR)_curlabeltext, labellen, _nbuf); //уыюсры№эр 
  281.       //cstr == +_TOKENDTEXT
  282.     };
  283.     _curlabeltext[labellen] = cstr;
  284.     INC labellen; //TODO яЁютхЁ Є№ яхЁхяюыэхэшх фышэ√
  285.   }UNTIL (cstr == +_TOKENDTEXT);
  286.   _labellen = labellen; //тъы■ўр  +_TOKENDTEXT
  287.   //errstr("readlabel "); errstr(_curlabeltext); enderr();
  288. }
  289. /**
  290. FUNC UINT findlabel(PBYTE labeltext)
  291. {
  292. //VAR PBYTE _labelN; //єърчрЄхы№ эр Єхъє∙є■ ЄрсышЎє ьхЄюъ
  293. VAR PBYTE plabel; //ьхЄър т ЄрсышЎх чрърэўштрхЄё  эєы╕ь
  294. //VAR PBYTE pstr; //ьхЄър т ёЄЁюъх чрърэўштрхЄё  TOK_ENDTEXT
  295. //VAR BYTE cstr; //ёшьтюы шч ёЄЁюъш
  296. //VAR BYTE clabel; //ёшьтюы шч ЄрсышЎ√ ьхЄюъ
  297. //VAR UINT pnext_index; //рфЁхё ёыхфє■∙хщ ьхЄъш т ЄрсышЎх
  298. //VAR UINT plabelqueuestart_index; //т (_labelN+plabelqueuestart_index) їЁрэшЄё  рфЁхё эрўрыр Ўхяюўъш фы  ьхЄъш
  299.   _hash = hash(labeltext)&0x3ff;
  300.  
  301.   _labelN = _labels0; //_labelpage[(UINT)(_hashhigh&_LABELPAGEMASK)]; //set page (todo ъръ юяЁхфхышЄ№? ёшёЄхьэ√щ ьръЁюё?)
  302.   //plabelqueuestart_index = ((UINT)(_hash))<<1; //todo Ёрчэр  ЁрчЁ фэюёЄ№ UINT
  303.   _plabel_index = _labelshift[_hash];
  304.   //todo ъръ ёфхырЄ№ эрсюЁ ьрёёштют т Ёрчэ√ї ёЄЁрэшўърї? ёфтшу шэфхъёр т юфэюь ьрёёштх тэшчє?
  305.   //_labelflag = 0x00; //"label not found"
  306.   WHILE (_plabel_index != _LABELPAGEEOF) { //яюър Ўхяюўър ьхЄюъ эх чръюэўшырё№
  307.     plabel = &_labelN[_plabel_index]; //(PBYTE)((POINTER)_labelN + (POINTER)_plabel_index);
  308.     _plabel_index = *(PUINT)(plabel);
  309.     plabel = &plabel[+sizeof(UINT)]; //(PBYTE)((POINTER)plabel + (POINTER)2);
  310.     IF (strcp((PCHAR)labeltext, (PCHAR)plabel)) { //ьхЄър эрщфхэр
  311.       //plabel = (PBYTE)((POINTER)plabel + (POINTER)_labellen); //тъы■ўр  0
  312.         //errstr("found label "); errstr(labeltext); enderr();
  313.       _plabel_index = (UINT)(plabel - _labelN) + _labellen; //тъы■ўр  0 //єърчрЄхы№ эр эрўрыю фрээ√ї ёючфртрхьющ ьхЄъш (эрфю юс чрЄхы№эю чряюьэшЄ№!)
  314.       //_labelflag = *(PBYTE)(plabel);
  315.       //_labelvalue = *(PLONG)((POINTER)plabel + (POINTER)1);
  316.       BREAK; //яюьэшЄ _plabel_index эрўрыр фрээ√ї эрщфхээющ ьхЄъш
  317.     };
  318.     //_plabel_index = pnext_index;
  319.   }; //хёыш эх эрщфхэю, Єю _plabel_index==_LABELPAGEEOF
  320. RETURN _plabel_index;
  321. }
  322. */
  323. PROC addlabel(LONG labelvalue) //т√ч√трЄ№ эхяюёЁхфёЄтхээю яюёых findlabel!!!
  324. {
  325. //VAR PBYTE _labelN; //єърчрЄхы№ эр Єхъє∙є■ ЄрсышЎє ьхЄюъ
  326. VAR PBYTE plabel;
  327. //VAR PBYTE pstr; //ьхЄър т ёЄЁюъх чрърэўштрхЄё  TOK_ENDTEXT
  328. //VAR BYTE cstr;
  329. //VAR UINT plabelqueuestart_index; //т (_labelN+plabelqueuestart_index) їЁрэшЄё  рфЁхё эрўрыр Ўхяюўъш фы  ьхЄъш
  330. //VAR UINT oldqueuestart_index; //ёЄрЁ√щ єърчрЄхы№ эр эрўрыю Ўхяюўъш
  331. VAR UINT freestart_index;
  332. VAR BYTE labelflag;
  333. //VAR LONG oldlabelvalue;
  334.   _labelchanged = +FALSE;
  335.   _labelN = _labels0; //_labelpage[(UINT)(_hashhigh&_LABELPAGEMASK)]; //set page (todo ъръ юяЁхфхышЄ№? ёшёЄхьэ√щ ьръЁюё?)
  336.   //IF (_labelflag!=0x00) { //ьхЄър хёЄ№
  337.   IF (_plabel_index!=_LABELPAGEEOF) { //ьхЄър хёЄ№
  338.     plabel = &_labelN[_plabel_index]; //(PBYTE)((POINTER)_labelN + (POINTER)_plabel_index); //єърчрЄхы№ эр эрўрыю фрээ√ї ьхЄъш
  339.     labelflag = *(PBYTE)(plabel); //findlabel();
  340.     IF ((labelflag&_ASMLABEL_MACRO)!=0x00) {
  341.       errstr("redefmacro"); /**errstr((PCHAR)_curlabeltext);*/ enderr();
  342.     }ELSE IF ((labelflag&_ASMLABEL_DEFINED)!=0x00) {
  343.       IF (*(PLONG)&plabel[1] != labelvalue) { //хёыш ьхЄър юяЁхфхыхэр ш чэрўхэшх эх ёююЄтхЄёЄтєхЄ
  344.         _labelchanged = +TRUE;
  345.         //;;errstr("old "); erruint(*(PUINT)&plabel[1]); enderr();
  346.         //;;errstr("new "); erruint((UINT)labelvalue); enderr();
  347.       };
  348.     }ELSE { //шэрўх (эх юяЁхфхыхэр) юяЁхфхы хь
  349.       POKE *(PBYTE)(plabel) = labelflag|_isaddr|_ASMLABEL_DEFINED;
  350.       POKE *(PLONG)(&plabel[1]) = labelvalue;
  351.     };
  352.   }ELSE {//ьхЄъш эхЄ: яш°хь т эрўрыю Ўхяюўъш рфЁхё ъюэЎр ёЄЁрэшЎ√ ш ёючфр╕ь ьхЄъє Єрь ёю ёё√ыъющ эр ёЄрЁюх эрўрыю Ўхяюўъш
  353.     //plabelqueuestart_index = (UINT)_hash + (UINT)_hash; //todo Ёрчэр  ЁрчЁ фэюёЄ№ UINT
  354.     //oldqueuestart_index = *(PUINT)((POINTER)_labelN + (POINTER)plabelqueuestart_index); //ёЄрЁ√щ єърчрЄхы№ эр эрўрыю Ўхяюўъш
  355.     freestart_index = _labelpagefreestart; //[0] //эрўрыю ётюсюфэюую ьхёЄр
  356.     _plabel_index = freestart_index; //єърчрЄхы№ эр эрўрыю фрээ√ї ёючфртрхьющ ьхЄъш (эрфю юс чрЄхы№эю чряюьэшЄ№!)
  357.     IF (freestart_index < _LABELPAGEMAXSHIFT) { //хёЄ№ ьхёЄю яюф ьхЄъє
  358.       plabel = &_labelN[_plabel_index]; //єърчрЄхы№ эр эрўрыю ёючфртрхьющ ьхЄъш
  359.       //яш°хь ьхЄъє
  360.       POKE *(PUINT)(plabel) = _labelshift[_hash]; //oldqueuestart_index; //ёЄрЁ√щ єърчрЄхы№ эр эрўрыю Ўхяюўъш
  361.       plabel = &plabel[+sizeof(UINT)];
  362.       strcopy((PCHAR)_curlabeltext, _labellen /**-1*/, (PCHAR)plabel); //_labellen тъы■ўр  0
  363.       plabel = &plabel[_labellen]; //тъы■ўр  0
  364.       POKE *(PBYTE)(plabel) = _ASMLABEL_DEFINED;
  365.       _plabel_index = (UINT)(plabel - _labelN); //єърчрЄхы№ эр эрўрыю фрээ√ї ёючфртрхьющ ьхЄъш
  366.       INC plabel;
  367.       POKE *(PLONG)(plabel) = labelvalue;
  368.       plabel = &plabel[+sizeof(LONG)];
  369.       _labelshift[_hash] = freestart_index; //эют√щ єърчрЄхы№ эр эрўрыю Ўхяюўъш
  370.       _labelpagefreestart = (UINT)(plabel - _labelN); //єърчрЄхы№ эр ъюэхЎ ёючфртрхьющ ьхЄъш
  371.       _lenlabels = _lenlabels + _labelpagefreestart - freestart_index;
  372.       INC _nlabels;
  373.       //_plabel_index фюыцхэ єърч√трЄ№ эр эрўрыю фрээ√ї ьхЄъш!
  374.     }ELSE {errstr("mem"); enderr();
  375.     };
  376.   };
  377. }
  378.  
  379. PROC changelabel(LONG labelvalue) //т√ч√трхЄё  яю фрээ√ь ёЄрЁюую findlabel (Єюы№ъю т reequ - TODO тэхфЁшЄ№)
  380. { //_plabel_index єърч√трхЄ эр эрўрыю фрээ√ї ьхЄъш
  381. //VAR PBYTE _labelN; //єърчрЄхы№ эр Єхъє∙є■ ЄрсышЎє ьхЄюъ
  382. VAR PBYTE plabel;
  383. //VAR BYTE labelflag;
  384.   _labelN = _labels0; //_labelpage[(UINT)(_hashhigh&_LABELPAGEMASK)]; //set page (todo ъръ юяЁхфхышЄ№? ёшёЄхьэ√щ ьръЁюё?)
  385.   plabel = &_labelN[_plabel_index];
  386.   //labelflag = *(PBYTE)(plabel);
  387.   POKE *(PBYTE)(plabel) = (*(PBYTE)(plabel)&~_ASMLABEL_ISADDR)|_isaddr|_ASMLABEL_DEFINED;
  388.   POKE *(PLONG)(&plabel[1]) = labelvalue;
  389. }
  390.  
  391. FUNC LONG getlabel() //т√ч√трЄ№ эхяюёЁхфёЄтхээю яюёых findlabel!!!
  392. { //_plabel_index єърч√трхЄ эр эрўрыю фрээ√ї ьхЄъш
  393. //VAR PBYTE _labelN; //єърчрЄхы№ эр Єхъє∙є■ ЄрсышЎє ьхЄюъ
  394. VAR PBYTE plabel;
  395. VAR BYTE labelflag;
  396. VAR LONG labelvalue; //=0L; //= 0xDEADBEEFL;
  397.   _labelN = _labels0; //_labelpage[(UINT)(_hashhigh&_LABELPAGEMASK)]; //set page (todo ъръ юяЁхфхышЄ№? ёшёЄхьэ√щ ьръЁюё?)
  398.   IF (_plabel_index!=_LABELPAGEEOF) { //ьхЄър хёЄ№
  399.     plabel = &_labelN[_plabel_index];
  400.     labelflag = *(PBYTE)(plabel);
  401. //    IF ((labelflag&_ASMLABEL_MACRO)!=0x00) {
  402. //      errstr("label=macro"); enderr();
  403. //    }ELSE {
  404.       POKE *(PBYTE)(plabel) = labelflag|_ASMLABEL_ACCESSED;
  405.       labelvalue = *(PLONG)(&plabel[1]);
  406.       _isaddr = labelflag&_ASMLABEL_ISADDR;
  407. //    };
  408.   }ELSE {//ьхЄъш эхЄ: ю°шсър //todo post
  409.     //asmwritestate();
  410.     //todo чряшёрЄ№ т яюёЄ тхё№ ЄхъёЄ фю ъюэЎр ъюьрэф√
  411.  
  412.     //todo яю ЇюЁьрЄє ъюьрэф√ юяЁхфхышЄ№, ёъюы№ъю срщЄ яЁюяєёЄшЄ№
  413.  
  414.     errstr("nolbl "); errstr((PCHAR)_curlabeltext); enderr();
  415.   };
  416.   RETURN labelvalue;
  417. }
  418.  
  419. PROC asmdir_label() //эхшчтхёЄэю, яЁюёЄю ьхЄър шыш reequ
  420. {
  421.   readlabel();
  422.   _plabel_index = findlabel(_curlabeltext);
  423.   //эхы№ч  ёхщўрё яхЁхюяЁхфхы Є№! шэрўх эхы№ч  label=label+1
  424.   addlabel((LONG)(_curaddr+_curshift)); //■чрхЄ _plabel_index //єёЄрэютшЄ _labelchanged, хёыш шчьхэшыш
  425.   _curplabel_index = _plabel_index; //чряюьэшЄ№ єърчрЄхы№ фрээ√ї ьхЄъш фы  REEQU
  426.   _curhash = _hash;
  427. }
  428.  
  429. PROC asmfmt_reequ()
  430. {
  431.   _plabel_index = _curplabel_index; //фюёЄрЄюўэю юфэющ тыюцхээюёЄш эр ўЄхэшх ьхЄюъ т т√Ёрцхэшш
  432.   _hash = _curhash;
  433.   IF (_plabel_index!=_LABELPAGEEOF) { //ьхЄър хёЄ№
  434.     changelabel(asmpopvalue()); /**тёяюьэшЄ№ єърчрЄхы№ ьхЄъш ш яЁшётюшЄ№/яхЁхяЁшётюшЄ№ хщ value*/
  435.   };
  436. }
  437. /**
  438. PROC asmfmt_dir_label()
  439. {
  440.   //_plabel_index=_curplabel_index; //фюёЄрЄюўэю юфэющ тыюцхээюёЄш эр ўЄхэшх ьхЄюъ т т√Ёрцхэшш
  441.   //_hash=_curhash;
  442.   //addlabel((_curaddr+curshift)); //эхы№ч  схч findlabel эхяюёЁхфёЄтхээю фю!!!
  443.  
  444.   IF (_labelchanged) {
  445.     errstr("redef "); errstr((PCHAR)_curlabeltext); enderr();
  446.   };
  447. }
  448. */
  449. //////////////
  450.  
  451. PROC errwrongreg()
  452. {
  453.   errstr("badreg"); enderr();
  454. }
  455.  
  456. PROC errwrongpar()
  457. {
  458.   errstr("badpar"); enderr();
  459. }
  460.  
  461. PROC asmerrtext()
  462. {
  463.   loop:
  464.   {
  465.     _token = readfin();
  466.     IF ((_token == +_TOKENDERR)||_waseof) goto end; //BREAK;
  467.     //IF (_waseof) goto end; //BREAK; //эр тё ъшщ ёыєўрщ
  468.     IF (_token == +_TOKTEXT) {
  469.       txtloop:
  470.       {
  471.         _token = readfin();
  472.         IF ((_token == +_TOKENDTEXT)||_waseof) goto loop; //BREAK;
  473.         //IF (_waseof) goto loop; //BREAK; //эр тё ъшщ ёыєўрщ
  474.         err((CHAR)_token);
  475.         goto txtloop;
  476.       };
  477.     }ELSE err(' ');
  478.     goto loop;
  479.   };
  480.   end:
  481.   err('\"'); enderr();
  482. }
  483.  
  484. PROC asmbyte(BYTE token)
  485. {
  486.   IF (_asms) writefout(token);
  487.   INC _curaddr;
  488. }
  489.  
  490. PROC asmemitblock() //чряшёрЄ№ рфЁхёр сыюър org
  491. {
  492.   IF (_curaddr != _curbegin) {
  493.     asmorgword((LONG)_curbegin);
  494.     asmorgword((LONG)(_curaddr-_curbegin));
  495.   };
  496. }
  497.  
  498. PROC asmreadprefixed()
  499. {
  500.   _token=readfin();
  501.   IF ((CHAR)_token=='\\') { //todo тёЄртшЄ№ TOK_TEXT...TOK_ENDTEXT
  502.     _token=readfin();
  503.     IF       ((CHAR)_token=='n') {_prefixedtoken=0x0a;
  504.     }ELSE IF ((CHAR)_token=='r') {_prefixedtoken=0x0d;
  505.     }ELSE IF ((CHAR)_token=='t') {_prefixedtoken=0x09;
  506.     }ELSE IF ((CHAR)_token=='0') {_prefixedtoken=0x00;
  507.     }ELSE _prefixedtoken=_token; //юёЄры№э√х яЁхЇшъёэ√х ёшьтюы√ юёЄрты хь ъръ хёЄ№
  508.   }ELSE _prefixedtoken=_token;
  509. }
  510.  
  511. PROC asmpass(PCHAR fn)
  512. {
  513.   initmemmodel();
  514.   _curbegin = _curaddr;
  515.   _curshift = 0;
  516.  
  517.   _nvalues = 0x00;
  518.   _ninclfiles = 0x00;
  519.  
  520.   //;;errstr("pass "); erruint(_passindex); enderr();
  521.   //setfin("tok.f");
  522.   _fin = nfopen(fn, "rb");
  523.   IF (_fin != (PBYTE)0) {
  524.     _waseof = +FALSE;
  525.     _curlnbeg = 1; //todo яЁш include ш яюЄюь тюёёЄрэртыштрЄ№
  526.  
  527.     fsm();
  528.  
  529.     fclose(_fin); //closefin();
  530.   }ELSE {
  531.     errstr("no "); errstr(fn); enderr();
  532.   };
  533.   asmemitblock(); //чряшёрЄ№ рфЁхёр сыюър org
  534.   INC _passindex;
  535. }
  536.  
  537. FUNC UINT findlast(PCHAR s, CHAR eol)
  538. {
  539. VAR UINT len;
  540. VAR UINT last;
  541. VAR CHAR c;
  542.   len = 0;
  543.   last = 0; //яюёых яюёыхфэхую ЄхЁьшэрЄюЁр
  544.   loop: //REPEAT {
  545.     c = *(PCHAR)s;
  546.     IF (c == '\0') goto endloop; //BREAK; //ЄхЁьшэрЄюЁ эх ъюяшЁєхЄё 
  547.     IF (c == eol) last = len;
  548.     INC s;
  549.     INC len;
  550.   goto loop; //}UNTIL ( (c==eol) || (len>=_STRMAX) ); //ЄхЁьшэрЄюЁ эх ъюяшЁєхЄё 
  551.   endloop:
  552. RETURN last; //яюёых яюёыхфэхую ЄхЁьшэрЄюЁр
  553. }
  554.  
  555. FUNC PBYTE openext(PCHAR ext)
  556. {
  557.   _lenfn = findlast(_fn, '.');
  558.   _lenfn = strjoin(_fn, _lenfn, ext);
  559.   _fn[_lenfn] = '\0'; //strclose
  560. RETURN openwrite(_fn);
  561. }
  562.  
  563. PROC asmcompile(PCHAR fn)
  564. {
  565.   _curlabeltext = (PBYTE)_m_curlabeltext;
  566.   _evallabeltext = (PBYTE)_m_evallabeltext;
  567.  
  568.   _fn = _m_fn;
  569.   _lenfn = 0;
  570.  
  571.   _nlabels = 0;
  572.   _lenlabels = 0;
  573.   clearlabels(0, (PBYTE)_labels0);
  574.   //clearlabels(1, (PBYTE)_labels1);
  575.   //clearlabels(2, (PBYTE)_labels2);
  576.   //clearlabels(3, (PBYTE)_labels3);
  577.   //clearlabels(4, (PBYTE)_labels4);
  578.   //clearlabels(5, (PBYTE)_labels5);
  579.   //clearlabels(6, (PBYTE)_labels6);
  580.   //clearlabels(7, (PBYTE)_labels7);
  581.  
  582.   _passindex = 1;
  583.  
  584.   _errs = +FALSE;
  585.   _asms = +FALSE;
  586.   asmpass(fn);
  587.  
  588.   _lenfn = strjoineol(_fn, 0, fn, '\0'); //фышэр схч ЄхЁьшэрЄюЁр!
  589.   _fn[_lenfn] = '\0'; //strclose
  590.   _fout = openext(".bin");
  591.   _forg = openext(".org");
  592.   //_fpost = openext(".pst");
  593.   _fdecl = openext(".D_");
  594.   //_fout = openwrite( "bin.f" );
  595.   //_forg = openwrite( "org.f" );
  596.   //_fpost = openwrite( "post.f" );
  597.   //_fdecl = openwrite( "decl.f" );
  598.   //setferr("asmerr.f");
  599.   _errs = +TRUE;
  600.   _asms = +TRUE;
  601.   asmpass(fn);
  602.   errstr("lbls "); erruint(_nlabels); errstr(" buf "); erruint(_lenlabels); enderr();
  603.   //closeferr();
  604.   decltoken(+_TOKEOF);
  605.   fclose(_fdecl);
  606.   //fclose(_fpost);
  607.   fclose(_forg);
  608.   fclose(_fout);
  609. }
  610.