Subversion Repositories NedoOS

Rev

Rev 637 | Rev 2039 | Go to most recent revision | 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 asmloop 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.       };
  346.     }ELSE { //шэрўх (эх юяЁхфхыхэр) юяЁхфхы хь
  347.       POKE *(PBYTE)(plabel) = labelflag|_isaddr|_ASMLABEL_DEFINED;
  348.       POKE *(PLONG)(&plabel[1]) = labelvalue;
  349.     };
  350.   }ELSE {//ьхЄъш эхЄ: яш°хь т эрўрыю Ўхяюўъш рфЁхё ъюэЎр ёЄЁрэшЎ√ ш ёючфр╕ь ьхЄъє Єрь ёю ёё√ыъющ эр ёЄрЁюх эрўрыю Ўхяюўъш
  351.     //plabelqueuestart_index = (UINT)_hash + (UINT)_hash; //todo Ёрчэр  ЁрчЁ фэюёЄ№ UINT
  352.     //oldqueuestart_index = *(PUINT)((POINTER)_labelN + (POINTER)plabelqueuestart_index); //ёЄрЁ√щ єърчрЄхы№ эр эрўрыю Ўхяюўъш
  353.     freestart_index = _labelpagefreestart; //[0] //эрўрыю ётюсюфэюую ьхёЄр
  354.     _plabel_index = freestart_index; //єърчрЄхы№ эр эрўрыю фрээ√ї ёючфртрхьющ ьхЄъш (эрфю юс чрЄхы№эю чряюьэшЄ№!)
  355.     IF (freestart_index < _LABELPAGEMAXSHIFT) { //хёЄ№ ьхёЄю яюф ьхЄъє
  356.       plabel = &_labelN[_plabel_index]; //єърчрЄхы№ эр эрўрыю ёючфртрхьющ ьхЄъш
  357.       //яш°хь ьхЄъє
  358.       POKE *(PUINT)(plabel) = _labelshift[_hash]; //oldqueuestart_index; //ёЄрЁ√щ єърчрЄхы№ эр эрўрыю Ўхяюўъш
  359.       plabel = &plabel[+sizeof(UINT)];
  360.       strcopy((PCHAR)_curlabeltext, _labellen /**-1*/, (PCHAR)plabel); //_labellen тъы■ўр  0
  361.       plabel = &plabel[_labellen]; //тъы■ўр  0
  362.       POKE *(PBYTE)(plabel) = _ASMLABEL_DEFINED;
  363.       _plabel_index = (UINT)(plabel - _labelN); //єърчрЄхы№ эр эрўрыю фрээ√ї ёючфртрхьющ ьхЄъш
  364.       INC plabel;
  365.       POKE *(PLONG)(plabel) = labelvalue;
  366.       plabel = &plabel[+sizeof(LONG)];
  367.       _labelshift[_hash] = freestart_index; //эют√щ єърчрЄхы№ эр эрўрыю Ўхяюўъш
  368.       _labelpagefreestart = (UINT)(plabel - _labelN); //єърчрЄхы№ эр ъюэхЎ ёючфртрхьющ ьхЄъш
  369.       _lenlabels = _lenlabels + _labelpagefreestart - freestart_index;
  370.       INC _nlabels;
  371.       //_plabel_index фюыцхэ єърч√трЄ№ эр эрўрыю фрээ√ї ьхЄъш!
  372.     }ELSE {errstr("mem"); enderr();
  373.     };
  374.   };
  375. }
  376.  
  377. PROC changelabel(LONG labelvalue) //т√ч√трхЄё  яю фрээ√ь ёЄрЁюую findlabel (Єюы№ъю т reequ - TODO тэхфЁшЄ№)
  378. { //_plabel_index єърч√трхЄ эр эрўрыю фрээ√ї ьхЄъш
  379. //VAR PBYTE _labelN; //єърчрЄхы№ эр Єхъє∙є■ ЄрсышЎє ьхЄюъ
  380. VAR PBYTE plabel;
  381. //VAR BYTE labelflag;
  382.   _labelN = _labels0; //_labelpage[(UINT)(_hashhigh&_LABELPAGEMASK)]; //set page (todo ъръ юяЁхфхышЄ№? ёшёЄхьэ√щ ьръЁюё?)
  383.   plabel = &_labelN[_plabel_index];
  384.   //labelflag = *(PBYTE)(plabel);
  385.   POKE *(PBYTE)(plabel) = (*(PBYTE)(plabel)&~_ASMLABEL_ISADDR)|_isaddr|_ASMLABEL_DEFINED;
  386.   POKE *(PLONG)(&plabel[1]) = labelvalue;
  387. }
  388.  
  389. FUNC LONG getlabel() //т√ч√трЄ№ эхяюёЁхфёЄтхээю яюёых findlabel!!!
  390. { //_plabel_index єърч√трхЄ эр эрўрыю фрээ√ї ьхЄъш
  391. //VAR PBYTE _labelN; //єърчрЄхы№ эр Єхъє∙є■ ЄрсышЎє ьхЄюъ
  392. VAR PBYTE plabel;
  393. VAR BYTE labelflag;
  394. VAR LONG labelvalue; //=0L; //= 0xDEADBEEFL;
  395.   _labelN = _labels0; //_labelpage[(UINT)(_hashhigh&_LABELPAGEMASK)]; //set page (todo ъръ юяЁхфхышЄ№? ёшёЄхьэ√щ ьръЁюё?)
  396.   IF (_plabel_index!=_LABELPAGEEOF) { //ьхЄър хёЄ№
  397.     plabel = &_labelN[_plabel_index];
  398.     labelflag = *(PBYTE)(plabel);
  399. //    IF ((labelflag&_ASMLABEL_MACRO)!=0x00) {
  400. //      errstr("label=macro"); enderr();
  401. //    }ELSE {
  402.       POKE *(PBYTE)(plabel) = labelflag|_ASMLABEL_ACCESSED;
  403.       labelvalue = *(PLONG)(&plabel[1]);
  404.       _isaddr = labelflag&_ASMLABEL_ISADDR;
  405. //    };
  406.   }ELSE {//ьхЄъш эхЄ: ю°шсър //todo post
  407.     //asmwritestate();
  408.     //todo чряшёрЄ№ т яюёЄ тхё№ ЄхъёЄ фю ъюэЎр ъюьрэф√
  409.  
  410.     //todo яю ЇюЁьрЄє ъюьрэф√ юяЁхфхышЄ№, ёъюы№ъю срщЄ яЁюяєёЄшЄ№
  411.  
  412.     errstr("nolbl "); errstr((PCHAR)_curlabeltext); enderr();
  413.   };
  414.   RETURN labelvalue;
  415. }
  416.  
  417. PROC asmdir_label() //эхшчтхёЄэю, яЁюёЄю ьхЄър шыш reequ
  418. {
  419.   readlabel();
  420.   _plabel_index = findlabel(_curlabeltext);
  421.   //эхы№ч  ёхщўрё яхЁхюяЁхфхы Є№! шэрўх эхы№ч  label=label+1
  422.   addlabel((LONG)(_curaddr+_curshift)); //■чрхЄ _plabel_index //єёЄрэютшЄ _labelchanged, хёыш шчьхэшыш
  423.   _curplabel_index = _plabel_index; //чряюьэшЄ№ єърчрЄхы№ фрээ√ї ьхЄъш фы  REEQU
  424.   _curhash = _hash;
  425. }
  426.  
  427. PROC asmfmt_reequ()
  428. {
  429.   _plabel_index = _curplabel_index; //фюёЄрЄюўэю юфэющ тыюцхээюёЄш эр ўЄхэшх ьхЄюъ т т√Ёрцхэшш
  430.   _hash = _curhash;
  431.   IF (_plabel_index!=_LABELPAGEEOF) { //ьхЄър хёЄ№
  432.     changelabel(asmpopvalue()); /**тёяюьэшЄ№ єърчрЄхы№ ьхЄъш ш яЁшётюшЄ№/яхЁхяЁшётюшЄ№ хщ value*/
  433.   };
  434. }
  435. /**
  436. PROC asmfmt_dir_label()
  437. {
  438.   //_plabel_index=_curplabel_index; //фюёЄрЄюўэю юфэющ тыюцхээюёЄш эр ўЄхэшх ьхЄюъ т т√Ёрцхэшш
  439.   //_hash=_curhash;
  440.   //addlabel((_curaddr+curshift)); //эхы№ч  схч findlabel эхяюёЁхфёЄтхээю фю!!!
  441.  
  442.   IF (_labelchanged) {
  443.     errstr("redef "); errstr((PCHAR)_curlabeltext); enderr();
  444.   };
  445. }
  446. */
  447. //////////////
  448.  
  449. PROC errwrongreg()
  450. {
  451.   errstr("badreg"); enderr();
  452. }
  453.  
  454. PROC errwrongpar()
  455. {
  456.   errstr("badpar"); enderr();
  457. }
  458.  
  459. PROC asmerrtext()
  460. {
  461.   loop:
  462.   {
  463.     _token = readfin();
  464.     IF ((_token == +_TOKENDERR)||_waseof) goto end; //BREAK;
  465.     //IF (_waseof) goto end; //BREAK; //эр тё ъшщ ёыєўрщ
  466.     IF (_token == +_TOKTEXT) {
  467.       txtloop:
  468.       {
  469.         _token = readfin();
  470.         IF ((_token == +_TOKENDTEXT)||_waseof) goto loop; //BREAK;
  471.         //IF (_waseof) goto loop; //BREAK; //эр тё ъшщ ёыєўрщ
  472.         err((CHAR)_token);
  473.         goto txtloop;
  474.       };
  475.     }ELSE err(' ');
  476.     goto loop;
  477.   };
  478.   end:
  479.   err('\"'); enderr();
  480. }
  481.  
  482. PROC asmbyte(BYTE token)
  483. {
  484.   IF (_asms) writefout(token);
  485.   INC _curaddr;
  486. }
  487.  
  488. PROC asmemitblock() //чряшёрЄ№ рфЁхёр сыюър org
  489. {
  490.   IF (_curaddr != _curbegin) {
  491.     asmorgword((LONG)_curbegin);
  492.     asmorgword((LONG)(_curaddr-_curbegin));
  493.   };
  494. }
  495.  
  496. PROC asmreadprefixed()
  497. {
  498.   _token=readfin();
  499.   IF ((CHAR)_token=='\\') { //todo тёЄртшЄ№ TOK_TEXT...TOK_ENDTEXT
  500.     _token=readfin();
  501.     IF       ((CHAR)_token=='n') {_prefixedtoken=0x0a;
  502.     }ELSE IF ((CHAR)_token=='r') {_prefixedtoken=0x0d;
  503.     }ELSE IF ((CHAR)_token=='t') {_prefixedtoken=0x09;
  504.     }ELSE IF ((CHAR)_token=='0') {_prefixedtoken=0x00;
  505.     }ELSE _prefixedtoken=_token; //юёЄры№э√х яЁхЇшъёэ√х ёшьтюы√ юёЄрты хь ъръ хёЄ№
  506.   }ELSE _prefixedtoken=_token;
  507. }
  508.  
  509. PROC asmpass(PCHAR fn)
  510. {
  511.   initmemmodel();
  512.   _curbegin = _curaddr;
  513.   _curshift = 0;
  514.  
  515.   _nvalues = 0x00;
  516.   _ninclfiles = 0x00;
  517.  
  518.   //setfin("tok.f");
  519.   _fin = nfopen(fn, "rb");
  520.   IF (_fin != (PBYTE)0) {
  521.     _waseof = +FALSE;
  522.     _curlnbeg = 1; //todo яЁш include ш яюЄюь тюёёЄрэртыштрЄ№
  523.  
  524.     asmloop();
  525.  
  526.     fclose(_fin); //closefin();
  527.   }ELSE {
  528.     errstr("no "); errstr(fn); enderr();
  529.   };
  530.   asmemitblock(); //чряшёрЄ№ рфЁхёр сыюър org
  531.   INC _passindex;
  532. }
  533.  
  534. FUNC UINT findlast(PCHAR s, CHAR eol)
  535. {
  536. VAR UINT len;
  537. VAR UINT last;
  538. VAR CHAR c;
  539.   len = 0;
  540.   last = 0; //яюёых яюёыхфэхую ЄхЁьшэрЄюЁр
  541.   loop: //REPEAT {
  542.     c = *(PCHAR)s;
  543.     IF (c == '\0') goto endloop; //BREAK; //ЄхЁьшэрЄюЁ эх ъюяшЁєхЄё 
  544.     IF (c == eol) last = len;
  545.     INC s;
  546.     INC len;
  547.   goto loop; //}UNTIL ( (c==eol) || (len>=_STRMAX) ); //ЄхЁьшэрЄюЁ эх ъюяшЁєхЄё 
  548.   endloop:
  549. RETURN last; //яюёых яюёыхфэхую ЄхЁьшэрЄюЁр
  550. }
  551.  
  552. FUNC PBYTE openext(PCHAR ext)
  553. {
  554.   _lenfn = findlast(_fn, '.');
  555.   _lenfn = strjoin(_fn, _lenfn, ext);
  556.   _fn[_lenfn] = '\0'; //strclose
  557. RETURN openwrite(_fn);
  558. }
  559.  
  560. PROC asmcompile(PCHAR fn)
  561. {
  562.   _curlabeltext = (PBYTE)_m_curlabeltext;
  563.   _evallabeltext = (PBYTE)_m_evallabeltext;
  564.  
  565.   _fn = _m_fn;
  566.   _lenfn = 0;
  567.  
  568.   _nlabels = 0;
  569.   _lenlabels = 0;
  570.   clearlabels(0, (PBYTE)_labels0);
  571.   //clearlabels(1, (PBYTE)_labels1);
  572.   //clearlabels(2, (PBYTE)_labels2);
  573.   //clearlabels(3, (PBYTE)_labels3);
  574.   //clearlabels(4, (PBYTE)_labels4);
  575.   //clearlabels(5, (PBYTE)_labels5);
  576.   //clearlabels(6, (PBYTE)_labels6);
  577.   //clearlabels(7, (PBYTE)_labels7);
  578.  
  579.   _passindex = 1;
  580.  
  581.   _errs = +FALSE;
  582.   _asms = +FALSE;
  583.   asmpass(fn);
  584.  
  585.   _lenfn = strjoineol(_fn, 0, fn, '\0'); //фышэр схч ЄхЁьшэрЄюЁр!
  586.   _fn[_lenfn] = '\0'; //strclose
  587.   _fout = openext(".bin");
  588.   _forg = openext(".org");
  589.   //_fpost = openext(".pst");
  590.   _fdecl = openext(".D_");
  591.   //_fout = openwrite( "bin.f" );
  592.   //_forg = openwrite( "org.f" );
  593.   //_fpost = openwrite( "post.f" );
  594.   //_fdecl = openwrite( "decl.f" );
  595.   //setferr("asmerr.f");
  596.   _errs = +TRUE;
  597.   _asms = +TRUE;
  598.   asmpass(fn);
  599.   errstr("lbls "); erruint(_nlabels); errstr(" buf "); erruint(_lenlabels); enderr();
  600.   //closeferr();
  601.   decltoken(+_TOKEOF);
  602.   fclose(_fdecl);
  603.   //fclose(_fpost);
  604.   fclose(_forg);
  605.   fclose(_fout);
  606. }
  607.