?login_element?

Subversion Repositories NedoOS

Rev

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

  1. //// imported
  2. #ifdef TARGET_THUMB
  3. #include "sizesarm.h"
  4. #else
  5. #ifdef TARGET_SCRIPT
  6. #include "sizesspt.h"
  7. #else
  8. #include "sizesz80.h"
  9. #endif
  10. #endif
  11.  
  12. //#ifdef DOUBLES
  13. //CONST BYTE _NRGS; //ўшёыю ЁхушёЄЁют
  14.  
  15.   //яЁшюЁшЄхЄ√ ЁхушёЄЁют:
  16. CONST BYTE _RMAIN; //ЁхушёЄЁ Ёхчєы№ЄрЄр ш 1-ую ярЁрьхЄЁр ёЄрэфрЁЄэ√ї ЇєэъЎшщ
  17. CONST BYTE _RMAIN2; //ЁхушёЄЁ тЄюЁюую ёыютр Ёхчєы№ЄрЄр ш 2-ую ярЁрьхЄЁр ёЄрэфрЁЄэ√ї ЇєэъЎшщ
  18. CONST BYTE _RMAIN3;
  19. CONST BYTE _RMAIN4;
  20. //#endif
  21.  
  22. PROC emitpoprg FORWARD(BYTE rnew);
  23. PROC emitpushrg FORWARD(BYTE rnew);
  24. PROC emitmovrg FORWARD(BYTE rsrc, BYTE rdest); //эх чрърч√трхЄ ш эх юётюсюцфрхЄ (ёь. moverg)
  25.  
  26. //#ifdef USE_COMMENTS
  27. //;;PROC cmt FORWARD(CHAR c);
  28. //;;PROC cmtstr FORWARD(PCHAR s);
  29. //;;PROC cmtuint FORWARD(UINT i);
  30. //;;PROC endcmt FORWARD();
  31. //#endif
  32. #ifdef USE_HINTS
  33. ;;PROC hint FORWARD(CHAR c);
  34. ;;PROC hintstr FORWARD(PCHAR s);
  35. ;;PROC hintuint FORWARD(UINT i);
  36. ;;PROC endhint FORWARD();
  37. #endif
  38. PROC err FORWARD(CHAR c);
  39. PROC errstr FORWARD(PCHAR s);
  40. PROC erruint FORWARD(UINT i);
  41. PROC enderr FORWARD();
  42.  
  43. ////
  44. VAR BYTE _usedrg[16]/**_NRGS*/;
  45. VAR BYTE _usedrgs;
  46. VAR BOOL _usedr1; //todo ьрёёшт
  47. VAR BOOL _usedr2;
  48. VAR BOOL _usedr3;
  49. VAR BOOL _usedr4;
  50.  
  51. VAR BYTE _rnew;
  52. VAR BYTE _rold;
  53. VAR BYTE _rold2;
  54. VAR BYTE _rold3;
  55.  
  56. #ifdef USE_HINTS
  57. ;;PROC hintrg(PCHAR text, BYTE data) {
  58. ;;  hintstr("//"); hintstr(text); hintuint(+(UINT)data);
  59. ;;}
  60.  
  61. ;;PROC hintrgstate() {
  62. ;;  hintrg("_fastrg4used=", +(BYTE)_usedr4); //bool!
  63. ;;  hintrg("_fastrg3used=", +(BYTE)_usedr3); //bool!
  64. ;;  hintrg("_fastrg2used=", +(BYTE)_usedr2); //bool!
  65. ;;  hintrg("_fastrgused=" , +(BYTE)_usedr1); //bool!
  66. ;;  endhint();
  67. ;;  hintrg("[0]=", _usedrg[0]); //#!
  68. ;;  hintrg("[1]=", _usedrg[1]); //#!
  69. ;;  hintrg("[2]=", _usedrg[2]); //#!
  70. ;;  hintrg("[3]=", _usedrg[3]); //#!
  71. ;;  endhint();
  72. ;;  hintrg("_usedrgs=", _usedrgs); //byte!
  73. ;;  endhint();
  74. ;;}
  75. #endif
  76.  
  77. //////////////////////////////////////////////////////////////////////////////////////////
  78. //rg pool
  79. //(т ЁхушёЄЁрї ьюцхЄ с√Є№ яєёЄю, тё╕ т ёЄхъх)
  80. //яЁюЎхфєЁ√, эхфюёЄєяэ√х шч commands
  81.  
  82. PROC nouserg FORWARD(BYTE rnew);  //Єюы№ъю ёсЁрё√трхЄ Їыру шёяюы№чютрэш  ЁхушёЄЁр ш фтшурхЄ ёў╕Єўшъ!
  83. FUNC BYTE userg FORWARD(BYTE rnew);  //Єюы№ъю єёЄрэртыштрхЄ Їыру шёяюы№чютрэш  ЁхушёЄЁр ш фтшурхЄ ёў╕Єўшъ!
  84. PROC popgetrg FORWARD(BYTE rnew);  //userg + фюсртыхэшх т юўхЁхф№ _usedrg ёэшчє + pop
  85.  
  86. //////////////////////////////////////////
  87. //схч ьр°шээюую ъюфр
  88.  
  89. //яхЁхьхёЄшЄ№ фрээ√х т чрфрээ√щ ЁхушёЄЁ rdest
  90. PROC moverg(BYTE rsrcindex, BYTE rdest) //чрюфэю чрърч√трхЄ ш юётюсюцфрхЄ ЁхушёЄЁ√
  91. {
  92. VAR BYTE rsrc;
  93.   rsrc = _usedrg[rsrcindex];
  94.   emitmovrg(rsrc,rdest); //todo шыш ёЁртэштрЄ№ rsrc!=rdest ЄєЄ?
  95.   _usedrg[rsrcindex] = rdest; //Єрь с√ыю rsrc
  96.   nouserg( rsrc ); //Єюы№ъю ёсЁрё√трхЄ Їыру шёяюы№чютрэш  ЁхушёЄЁр ш фтшурхЄ ёў╕Єўшъ!
  97.   userg( rdest ); //Єюы№ъю єёЄрэртыштрхЄ Їыру шёяюы№чютрэш  ЁхушёЄЁр ш фтшурхЄ ёў╕Єўшъ!
  98. }
  99.  
  100. PROC pushtailrg()
  101. {
  102. VAR BYTE rnew;
  103. VAR BYTE i;
  104. #ifdef USE_HINTS
  105. ;;  hintstr( "//pusholdestrg" ); endhint();
  106. #endif
  107. ;;  IF (_usedrgs<0x01) { errstr( "pusholdestrg _usedrgs=" ); erruint(+(UINT)_usedrgs); enderr();
  108. ;;  }ELSE
  109.   {
  110.     rnew = _usedrg[ 0 ];
  111.     emitpushrg( rnew );
  112.     i = 0x01;
  113.     WHILE (i < _usedrgs/**_NRGS*/) { //ёў╕Єўшъ х∙╕ эх ёфтшэєЄ
  114.       _usedrg[i-0x01] = _usedrg[i];
  115.       INC i;
  116.     };
  117.     nouserg( rnew ); //Єюы№ъю ёсЁрё√трхЄ Їыру шёяюы№чютрэш  ЁхушёЄЁр ш фтшурхЄ ёў╕Єўшъ!
  118.   };
  119. #ifdef USE_HINTS
  120. ;;  hintrgstate();
  121. #endif
  122. }
  123.  
  124. FUNC BYTE findrfree() //эрщЄш ётюсюфэ√щ (ъръ ьюцэю сюыхх с√ёЄЁ√щ) ЁхушёЄЁ ш тхЁэєЄ№ хую ъюф
  125. {
  126. VAR BYTE result;
  127.   IF (_usedrgs==_NRGS) pushtailrg();
  128.   IF       (!_usedr1) {result = 0x01;
  129.   }ELSE IF (!_usedr2) {result = 0x02;
  130.   }ELSE IF (!_usedr3) {result = 0x03;
  131.   }ELSE result = 0x04;
  132.   RETURN result;
  133. }
  134.  
  135. PROC nouserg(BYTE rnew) //Єюы№ъю ёсЁрё√трхЄ Їыру шёяюы№чютрэш  ЁхушёЄЁр ш фтшурхЄ ёў╕Єўшъ!
  136. {
  137. ;;  IF (_usedrgs==0x00) { errstr( "nouserg _usedrgs=" ); erruint(+(UINT)_usedrgs); enderr();
  138. ;;  }ELSE
  139.   {
  140.     IF       (rnew==0x01) {_usedr1 = +FALSE;
  141.     }ELSE IF (rnew==0x02) {_usedr2 = +FALSE;
  142.     }ELSE IF (rnew==0x03) {_usedr3 = +FALSE;
  143.     }ELSE _usedr4 = +FALSE;
  144.     DEC _usedrgs;
  145.   };
  146. }
  147.  
  148. FUNC BYTE userg(BYTE rnew) //Єюы№ъю єёЄрэртыштрхЄ Їыру шёяюы№чютрэш  ЁхушёЄЁр ш фтшурхЄ ёў╕Єўшъ!
  149. {
  150. ;;  IF (_usedrgs>=_NRGS) { errstr( "userg _usedrgs=" ); erruint(+(UINT)_usedrgs); enderr();
  151. ;;  }ELSE
  152.   {
  153.     IF       (rnew==0x01) {_usedr1 = +TRUE;
  154.     }ELSE IF (rnew==0x02) {_usedr2 = +TRUE;
  155.     }ELSE IF (rnew==0x03) {_usedr3 = +TRUE;
  156.     }ELSE _usedr4 = +FALSE;
  157.     INC _usedrgs;
  158.   };
  159.   RETURN rnew;
  160. }
  161.  
  162. FUNC BYTE getrg(BYTE rnew) //userg + фюсртыхэшх т юўхЁхф№ _usedrg
  163. {
  164. #ifdef USE_HINTS
  165. ;;  hintrg("getrg ",rnew); endhint();
  166. ;;  hintrgstate();
  167. #endif
  168.   _usedrg[_usedrgs] = rnew;
  169.   userg( rnew ); //Єюы№ъю єёЄрэртыштрхЄ Їыру шёяюы№чютрэш  ЁхушёЄЁр ш фтшурхЄ ёў╕Єўшъ!
  170. #ifdef USE_HINTS
  171. ;;  hintrgstate();
  172. #endif
  173.   RETURN rnew;
  174. }
  175.  
  176. PROC popgetrg(BYTE rnew) //userg + фюсртыхэшх т юўхЁхф№ _usedrg ёэшчє + pop
  177. {
  178. VAR BYTE i;
  179. #ifdef USE_HINTS
  180. ;;  hintstr( "//getoldestrg" ); endhint();
  181. #endif
  182.   i = _usedrgs; //ёў╕Єўшъ х∙╕ эх ёфтшэєЄ //_NRGS-0x01;
  183.   WHILE (i>0x00) {
  184.     _usedrg[i] =_usedrg[i-0x01];
  185.     DEC i;
  186.   };
  187.   _usedrg[ 0 ] =rnew;
  188.   userg( rnew ); //Єюы№ъю єёЄрэртыштрхЄ Їыру шёяюы№чютрэш  ЁхушёЄЁр ш фтшурхЄ ёў╕Єўшъ!
  189. #ifdef USE_HINTS
  190. ;;  hintrgstate();
  191. #endif
  192.   emitpoprg(rnew);
  193. }
  194.  
  195. //яюьхэ Є№ ьхёЄрьш фтр ЁхушёЄЁр эр тхЁ°шэх "ёЄхър" (ўшёЄю ыюушўхёъш)
  196. PROC swaptop()
  197. {
  198. VAR BYTE rtmp;
  199.   IF ( _usedrgs==0x00 ) popgetrg(0x02);
  200.   IF ( _usedrgs==0x01 ) popgetrg( findrfree() );
  201.   rtmp = _usedrg[_usedrgs-0x02]; //old
  202.   _usedrg[_usedrgs-0x02] = _usedrg[_usedrgs-0x01]; //new => old
  203.   _usedrg[_usedrgs-0x01] = rtmp; //=> new
  204. }
  205.  
  206. ////////////////////////////////////////////////////////////////////////////////
  207. //эхфюёЄєяэ√ шч ъюьяшы ЄюЁр, фюёЄєяэ√ шч commands
  208. //схч ьр°шээюую ъюфр
  209. //эх яш°єЄ т ...used (ъЁюьх initrgs)
  210.  
  211. //rg pool
  212.  
  213. PROC rgs_initrgs()
  214. {
  215.   _usedr1 = +FALSE;
  216.   _usedr2 = +FALSE;
  217.   _usedr3 = +FALSE;
  218.   _usedr4 = +FALSE;
  219.   _usedrgs = 0x00;
  220. }
  221.  
  222. PROC getrnew() //ёЄрЁрхЄё  сЁрЄ№ new=FASTRG
  223. //чфхё№ эхы№ч  фхырЄ№ getnothing (шч-чр bytetoint, inttobyte)
  224. {
  225. #ifdef USE_HINTS
  226. ;;  hintstr( "//getrnew" ); endhint();
  227. #endif
  228.   IF ( _usedrgs==0x00 ) popgetrg(0x01);
  229.   _rnew = _usedrg[_usedrgs-0x01];
  230. }
  231.  
  232. PROC getrold() //ёЄрЁрхЄё  сЁрЄ№ old=FASTRG (т√уюфэю т√ч√трЄ№ фю getrnew фы  +,-)
  233. {
  234. #ifdef USE_HINTS
  235. ;;  hintstr( "//getrold" ); endhint();
  236. #endif
  237.   IF ( _usedrgs==0x00 ) popgetrg(0x02);
  238.   IF ( _usedrgs==0x01 ) popgetrg( findrfree() );
  239.   _rold = _usedrg[_usedrgs-0x02];
  240. }
  241.  
  242. PROC getrold2() //ёЄрЁрхЄё  сЁрЄ№ old2=FASTRG (т√уюфэю т√ч√трЄ№ фю getrnew фы  +,-)
  243. {
  244. #ifdef USE_HINTS
  245. ;;  hintstr( "//getrold2" ); endhint();
  246. #endif
  247.   IF ( _usedrgs==0x00 ) popgetrg(0x03);
  248.   IF ( _usedrgs==0x01 ) { //я√Єрхьё  тч Є№ old=_RFAST2
  249.     IF ( _usedrg[0]!=0x02 ) {popgetrg(0x02);
  250.     }ELSE popgetrg( findrfree() );
  251.   };
  252.   IF ( _usedrgs==0x02 ) popgetrg( findrfree() );
  253.   _rold = _usedrg[_usedrgs-0x03];
  254. }
  255.  
  256. PROC getrold3()
  257. {
  258. #ifdef USE_HINTS
  259. ;;  hintstr( "//getrold3" ); endhint();
  260. #endif
  261.   IF ( _usedrgs==0x00 ) popgetrg(0x03);
  262.   IF ( _usedrgs==0x01 ) popgetrg( findrfree() );
  263.   IF ( _usedrgs==0x02 ) popgetrg( findrfree() );
  264.   IF ( _usedrgs==0x03 ) popgetrg( findrfree() );
  265.   _rold = _usedrg[_usedrgs-0x04];
  266. }
  267.  
  268. PROC freernew() //юётюсюфшЄ№ ЁхушёЄЁ ё тхЁ°шэ√ ёЄхър
  269. {
  270. #ifdef USE_HINTS
  271. ;;  hintstr( "//freernew" ); endhint();
  272. ;;  hintrgstate();
  273. #endif
  274.   getrnew(); //р Єю тфЁєу эхЄ т ЁхушёЄЁрї
  275.   //юўхЁхф№ usedrgs ьюцэю эх ЄЁюурЄ№, яЁюёЄю ёфтшэєЄ№ уюыютє юўхЁхфш (ёў╕Єўшъ)
  276.   nouserg( _usedrg[_usedrgs-0x01] ); //Єюы№ъю ёсЁрё√трхЄ Їыру шёяюы№чютрэш  ЁхушёЄЁр ш фтшурхЄ ёў╕Єўшъ!
  277. #ifdef USE_HINTS
  278. ;;  hintrgstate();
  279. ;;  hintstr( "//end freernew" ); endhint();
  280. #endif
  281. }
  282.  
  283. //
  284. //ёыхфє■∙шх яЁюЎхфєЁ√ эх юсЁр∙р■Єё   тэю ъ ...used
  285. //
  286. PROC getnothing() //ёюїЁрэшЄ№ ЁхушёЄЁ√ ш срщЄ√ т ёЄхъх ш юётюсюфшЄ№
  287. {
  288.   WHILE (_usedrgs>0x00) pushtailrg();
  289. }
  290.  
  291. PROC getrfree() //чрэ Є№ ётюсюфэ√щ ЁхушёЄЁ ш тхЁэєЄ№ хую ъюф
  292. //чфхё№ эхы№ч  фхырЄ№ getnothing (шч-чр bytetoint, inttobyte)
  293. {
  294. #ifdef USE_HINTS
  295. ;;  hintstr( "//getrfree" ); endhint();
  296. #endif
  297.   _rnew = getrg(findrfree());
  298. }
  299.  
  300. PROC getmainrg() //тч Є№ RMAIN=new ш юётюсюфшЄ№ юёЄры№э√х ЁхушёЄЁ√ (todo хёыш тё╕ т ЁхушёЄЁрї, Єю тёЄртшЄ№ RMAIN т oldestrg)
  301. {
  302. #ifdef USE_HINTS
  303. ;;  hintstr( "//getmainrg" ); endhint();
  304. #endif
  305.   IF ( _usedrgs==0x00 ) popgetrg( _RMAIN ); //emitpopoldestrg(RMAIN);
  306.   WHILE ( _usedrgs>0x01 ) pushtailrg();
  307.   //ЄхяхЁ№ чрэ Є Ёютэю 1 ЁхушёЄЁ
  308.   moverg( (0x00), _RMAIN ); //todo юяЄшьшчшЁютрЄ№ ўхЁхч ex de,hl
  309. #ifdef USE_HINTS
  310. ;;  hintstr( "//end getmainrg" ); endhint();
  311. #endif
  312. }
  313.  
  314. PROC getmain2rgs() //тч Є№ RMAIN=old, RMAIN2=new ш юётюсюфшЄ№ юёЄры№э√х ЁхушёЄЁ√ (todo хёыш тё╕ т ЁхушёЄЁрї, Єю тёЄртшЄ№ RMAIN, RMAIN2 т oldestrg)
  315. {
  316. #ifdef USE_HINTS
  317. ;;  hintstr( "//getmain2rgs" ); endhint();
  318. #endif
  319.   IF ( _usedrgs==0x00 ) popgetrg( _RMAIN2 );
  320.   IF ( _usedrgs==0x01 ) {
  321.     moverg( (0x00), _RMAIN2 ); //todo юяЄшьшчшЁютрЄ№ ўхЁхч ex de,hl
  322.     popgetrg( _RMAIN );
  323.   };
  324.   WHILE ( _usedrgs>0x02 ) pushtailrg();
  325.   //ЄхяхЁ№ чрэ Єю Ёютэю 2 ЁхушёЄЁр
  326.   //RMAIN, XXX: moverg((1),RMAIN2);
  327.   IF (_usedrg[0]==_RMAIN) {moverg( (0x01), _RMAIN2 );
  328.   }ELSE IF (_usedrg[1]==_RMAIN ) {
  329.     //RMAIN2, RMAIN: pusholdestrg;moverg((0),RMAIN2);popoldestrg(RMAIN);
  330.     IF (_usedrg[0]==_RMAIN2) {
  331.       pushtailrg();
  332.       moverg( (0x00), _RMAIN2 ); //todo юяЄшьшчшЁютрЄ№ ўхЁхч ex de,hl
  333.       popgetrg( _RMAIN );
  334.     }ELSE { //XXX, RMAIN: moverg((1),RMAIN2);moverg((0),RMAIN);
  335.      moverg( (0x01), _RMAIN2 ); //todo юяЄшьшчшЁютрЄ№ ўхЁхч ex de,hl //moverg((0),RMAIN) ёь. эшцх
  336.     };
  337.   };
  338.   //XXX, YYY: moverg((0),RMAIN);moverg((1),RMAIN2);
  339.   moverg( (0x00), _RMAIN ); //todo юяЄшьшчшЁютрЄ№ ўхЁхч ex de,hl
  340.   moverg( (0x01), _RMAIN2 ); //todo юяЄшьшчшЁютрЄ№ ўхЁхч ex de,hl
  341. #ifdef USE_HINTS
  342. ;;  hintstr( "//end getmain2rgs" ); endhint();
  343. #endif
  344. }
  345. /**
  346. PROC getmain3rgs()
  347. {
  348. #ifdef USE_HINTS
  349. ;;  hintstr( "//getmain3rgs" ); endhint();
  350. #endif
  351.   getmain2rgs();
  352.   getrold2();
  353. #ifdef USE_HINTS
  354. ;;  hintstr( "//end getmain3rgs" ); endhint();
  355. #endif
  356. }
  357. */
  358. PROC getmain4rgs()
  359. {
  360. #ifdef USE_HINTS
  361. ;;  hintstr( "//getmain4rgs" ); endhint();
  362. #endif
  363.   IF ( (_usedrgs!=0x04)
  364.     || (_usedrg[0]!=_RMAIN)
  365.     || (_usedrg[1]!=_RMAIN2)
  366.     || (_usedrg[2]!=_RMAIN3)
  367.     || (_usedrg[3]!=_RMAIN4)
  368.      ) {
  369.     getnothing(); //todo яю юфэюьє, ё яЁютхЁъющ эр ёююЄтхЄёЄтшх
  370.     popgetrg(_RMAIN4);
  371.     popgetrg(_RMAIN3);
  372.     popgetrg(_RMAIN2);
  373.     popgetrg(_RMAIN);
  374.   };
  375. #ifdef USE_HINTS
  376. ;;  hintstr( "//end getmain4rgs" ); endhint();
  377. #endif
  378. }
  379.  
  380. PROC setmainrg() //єёЄрэютшЄ№ яЁшчэръш, ъръ сєфЄю ь√ яюыєўшыш Ёхчєы№ЄрЄ т ЁхушёЄЁх
  381. { //ёхщўрё тёх ЁхушёЄЁ√ ёўшЄр■Єё  ётюсюфэ√ьш
  382.   getrg( _RMAIN );
  383. }
  384.  
  385. PROC setmain2rgs() //єёЄрэютшЄ№ яЁшчэръш, ъръ сєфЄю ь√ яюыєўшыш Ёхчєы№ЄрЄ т ЁхушёЄЁрї
  386. { //ёхщўрё тёх ЁхушёЄЁ√ ёўшЄр■Єё  ётюсюфэ√ьш
  387.   getrg( _RMAIN );
  388.   getrg( _RMAIN2 );
  389. }
  390.  
  391.