?login_element?

Subversion Repositories NedoOS

Rev

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

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