Subversion Repositories NedoOS

Rev

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

  1. //// ьр°шээючртшёшь√х яЁюЎхфєЁ√ ш юс· тыхэш 
  2.  
  3. //ЁхушёЄЁ яю ьрёъх 0x3f яЁштюфшЄ ix/iy ъ hl
  4. CONST BYTE _ASMRBIXADD = 0x40;
  5. CONST BYTE _ASMRBCODE_B = 0x00;
  6. CONST BYTE _ASMRBCODE_C = 0x08;
  7. CONST BYTE _ASMRBCODE_D = 0x10;
  8. CONST BYTE _ASMRBCODE_E = 0x18;
  9. CONST BYTE _ASMRBCODE_H = 0x20;
  10. CONST BYTE _ASMRBCODE_L = 0x28;
  11. CONST BYTE _ASMRBCODE_A = 0x38;
  12. CONST BYTE _ASMRBCODE_HX = 0x60;
  13. CONST BYTE _ASMRBCODE_LX = 0x68;
  14. CONST BYTE _ASMRBCODE_HY = 0xa0;
  15. CONST BYTE _ASMRBCODE_LY = 0xa8;
  16. CONST BYTE _ASMRBCODE_I = 0x00;
  17. CONST BYTE _ASMRBCODE_R = 0x08;
  18.  
  19. CONST BYTE _ASMRPIXADD = 0x40;
  20. CONST BYTE _ASMRPCODE_BC = 0x00;
  21. CONST BYTE _ASMRPCODE_DE = 0x10;
  22. CONST BYTE _ASMRPCODE_HL = 0x20;
  23. CONST BYTE _ASMRPCODE_SP = 0x30;
  24. CONST BYTE _ASMRPCODE_AF = 0x30;
  25. CONST BYTE _ASMRPCODE_IX = 0x60;
  26. CONST BYTE _ASMRPCODE_IY = 0xa0;
  27.  
  28. //CONST UINT _BASEADDR = 0x6000;
  29. //VAR UINT _baseaddr;
  30.  
  31. PROC asmbytepopvalue()
  32. {
  33.   DEC _nvalues;
  34.   IF (_asms) {
  35. #ifdef TARGET_SCRIPT
  36.     fwrite((PBYTE)&_value[_nvalues], +sizeof(LONG), 1, _fout);
  37. #else
  38.     ;;writefout((BYTE)_value[_nvalues]/**(BYTE)asmpopvalue()*/); //compatible version
  39.     /*writefout(*(PBYTE)&_value[_nvalues]);*/ //fast version (little endian)
  40. #endif
  41.   };
  42.   INC _curaddr;
  43. }
  44.  
  45. PROC asmwordpopvalue() //Ёрчэр  ЁрчЁ фэюёЄ№ UINT/DW
  46. {
  47. VAR UINT uinttempvalue;
  48.   DEC _nvalues;
  49.   IF (_asms) {
  50.     //яш°хь фрээ√х ЁхыюърЎшш яЁш эхэєыхтюь _isaddr!
  51.     IF (_isaddr!=0x00) {
  52.       uinttempvalue = _curaddr+_curshift-_curbegin; //_curaddr+_curshift-_BASEADDR;
  53.       fwrite((PBYTE)&uinttempvalue, 2, 1, _forg);
  54.     }; //
  55. #ifdef TARGET_SCRIPT
  56.     fwrite((PBYTE)&_value[_nvalues], +sizeof(LONG), 1, _fout);
  57. #else
  58.     ;;uinttempvalue = (UINT)_value[_nvalues]; //(UINT)asmpopvalue()
  59.     ;;writefout((BYTE)uinttempvalue); //compatible version (эх _SIZEOF_UINT, Є.ъ. ЄєЄ эрфю ЁрчьхЁ фы  ЄрЁухЄр!)
  60.     ;;writefout((BYTE)(uinttempvalue>>8)); //compatible version (эх _SIZEOF_UINT, Є.ъ. ЄєЄ эрфю ЁрчьхЁ фы  ЄрЁухЄр!)
  61.     /*fwrite((PBYTE)&_value[_nvalues], 2, 1, _fout);*/ //fast version (little endian) (эх _SIZEOF_UINT, Є.ъ. ЄєЄ эрфю ЁрчьхЁ фы  ЄрЁухЄр!)
  62. #endif
  63.   };
  64. #ifdef TARGET_SCRIPT
  65.   _curaddr = _curaddr + 1; //ёыютю - ¤Єю  ўхщър ёъЁшяЄр
  66. #else
  67.   _curaddr = _curaddr + 2; //эх _SIZEOF_UINT, Є.ъ. ЄєЄ эрфю ЁрчьхЁ фы  ЄрЁухЄр!
  68. #endif
  69. }
  70.  
  71. PROC asmlong(LONG value) //Ёрчэр  ЁрчЁ фэюёЄ№ LONG/DL
  72. {
  73.   ;;asmbyte((BYTE)value); //compatible version
  74.   ;;asmbyte((BYTE)((UINT)value>>8)); //compatible version
  75.   ;;asmbyte((BYTE)(value>>16L)); //compatible version
  76.   ;;asmbyte((BYTE)(value>>24L)); //compatible version
  77.   /*IF (_asms) fwrite((PBYTE)&value, 4, 1, _fout);*/ //fast version (little endian) (эх _SIZEOF_LONG, Є.ъ. ЄєЄ эрфю ЁрчьхЁ фы  ЄрЁухЄр!)
  78.   /*_curaddr = _curaddr + 4;*/ //fast version (little endian) (эх _SIZEOF_LONG, Є.ъ. ЄєЄ эрфю ЁрчьхЁ фы  ЄрЁухЄр!)
  79. }
  80.  
  81. PROC asmorgword(LONG addr) //Ёрчэр  ЁрчЁ фэюёЄ№ POINTER
  82. {
  83. //todo ORG
  84. //  IF (_asms) {
  85. //    ;;writebyte(_forg, (BYTE)addr); //compatible version
  86. //    ;;writebyte(_forg, (BYTE)((UINT)addr>>8)); //compatible version
  87. //    /*fwrite(+(PBYTE)&addr, 2, 1, _forg);*/ //fast version (little endian) (эх _SIZEOF_UINT, Є.ъ. ЄєЄ эрфю ЁрчьхЁ фы  ЄрЁухЄр!)
  88. //  };
  89. }
  90.  
  91. PROC asmdisp(INT ivalue) //фы  $+d ш ix+d
  92. {
  93.   IF ((UINT)(ivalue + (INT)0x0080) >= 0x0100) {
  94.     errstr("far +d"); enderr();
  95.   };
  96.   asmbyte((BYTE)ivalue); //юс чрЄхы№эю чряшёрЄ№, шэрўх яюхфєЄ рфЁхёр!
  97. }
  98.  
  99. PROC asmdisppopvalue() //фы  jr ш ix+d
  100. {
  101.   asmdisp((INT)asmpopvalue());
  102. }
  103.  
  104. PROC asmrb_ixiyprefix() //ёухэхЁшЁютрЄ№ яЁхЇшъё dd/fd ш яЁштхёЄш _reg ъ h/l
  105. {
  106. //  IF       (_reg==+_ASMRBCODE_HX) {asmbyte(0xdd); //_reg = +_ASMRBCODE_H;
  107. //  }ELSE IF (_reg==+_ASMRBCODE_LX) {asmbyte(0xdd); //_reg = +_ASMRBCODE_L;
  108. //  }ELSE IF (_reg==+_ASMRBCODE_HY) {asmbyte(0xfd); //_reg = +_ASMRBCODE_H;
  109. //  }ELSE /**IF (_reg==+_ASMRBCODE_LY)*/{asmbyte(0xfd); //_reg = +_ASMRBCODE_L;
  110. //  };
  111.   IF (_reg < +_ASMRBCODE_HY) {asmbyte(0xdd);
  112.   }ELSE asmbyte(0xfd);
  113.   _reg = _reg&0x3f;
  114. }
  115.  
  116. PROC asmoldrb_ixiyprefix() //ёухэхЁшЁютрЄ№ яЁхЇшъё dd/fd ш яЁштхёЄш _reg ъ h/l
  117. {
  118. //  IF       (_oldreg==+_ASMRBCODE_HX) {asmbyte(0xdd); //_oldreg = +_ASMRBCODE_H;
  119. //  }ELSE IF (_oldreg==+_ASMRBCODE_LX) {asmbyte(0xdd); //_oldreg = +_ASMRBCODE_L;
  120. //  }ELSE IF (_oldreg==+_ASMRBCODE_HY) {asmbyte(0xfd); //_oldreg = +_ASMRBCODE_H;
  121. //  }ELSE /**IF (_oldreg==+_ASMRBCODE_LY)*/{asmbyte(0xfd); //_oldreg = +_ASMRBCODE_L;
  122. //  };
  123.   IF (_oldreg < +_ASMRBCODE_HY) {asmbyte(0xdd);
  124.   }ELSE asmbyte(0xfd);
  125.   _oldreg = _oldreg&0x3f;
  126. }
  127.  
  128. PROC asmrbrb_ixiyprefix() //ёухэхЁшЁютрЄ№ яЁхЇшъё dd/fd ш яЁштхёЄш _oldreg,_reg ъ h/l
  129. //ё яЁютхЁъющ ю°шсюъ ?x,?y / ?y,?x / ?x/y,h/l / h/l,?x/y
  130. {
  131. VAR BYTE prefix1;
  132.   prefix1 = 0x00; //needed
  133.   IF (_oldreg >= +_ASMRBCODE_HY) {
  134.     prefix1=0xfd;
  135.     goto test1;
  136.   }ELSE IF (_oldreg >= +_ASMRBCODE_HX) {
  137.     prefix1=0xdd;
  138.     test1:
  139.     IF (_reg==+_ASMRBCODE_H) errwrongreg(); //?x/y, h
  140.     IF (_reg==+_ASMRBCODE_L) errwrongreg(); //?x/y, l
  141.     asmbyte(prefix1);
  142.   };
  143.   IF (_reg >= +_ASMRBCODE_HY) {
  144.     IF (prefix1!=0xfd) {
  145.       asmbyte(0xfd);
  146.       IF (prefix1==0xdd) errwrongreg();
  147.     };
  148.     goto test2;
  149.   }ELSE IF (_reg >= +_ASMRBCODE_HX) {
  150.     IF (prefix1!=0xdd) {
  151.       asmbyte(0xdd);
  152.       IF (prefix1==0xfd) errwrongreg();
  153.     };
  154.     test2:
  155.     IF (_oldreg==+_ASMRBCODE_H) errwrongreg(); //h, ?x/y
  156.     IF (_oldreg==+_ASMRBCODE_L) errwrongreg(); //l, ?x/y
  157.     _reg = _reg&0x3f;
  158.   };
  159.   _oldreg = _oldreg&0x3f;
  160. }
  161.  
  162. PROC asmrp_ixiyprefix() //ёухэхЁшЁютрЄ№ яЁхЇшъё dd/fd ш яЁштхёЄш _reg ъ hl
  163. {
  164.   IF (_reg==+_ASMRPCODE_IX) {asmbyte(0xdd); //_reg = +_ASMRPCODE_HL;
  165.   }ELSE /*IF (_reg==+_ASMRPCODE_IY)*/{asmbyte(0xfd); //_reg = +_ASMRPCODE_HL;
  166.   };
  167.   _reg = +_ASMRPCODE_HL;
  168. }
  169.  
  170. PROC asmoldrp_ixiyprefix() //ёухэхЁшЁютрЄ№ яЁхЇшъё dd/fd ш яЁштхёЄш _reg ъ hl
  171. {
  172.   IF (_oldreg==+_ASMRPCODE_IX) {asmbyte(0xdd); //_oldreg = +_ASMRPCODE_HL;
  173.   }ELSE /*IF (_oldreg==+_ASMRPCODE_IY)*/{asmbyte(0xfd); //_oldreg = +_ASMRPCODE_HL;
  174.   };
  175.   _oldreg = +_ASMRPCODE_HL;
  176. }
  177.  
  178. PROC asmrprp_ixiyprefix() //ёухэхЁшЁютрЄ№ яЁхЇшъё dd/fd ш яЁштхёЄш _oldreg,_reg ъ hl
  179. //ё яЁютхЁъющ ю°шсюъ ix,iy / iy,ix / ix/iy,hl / hl,ix/iy
  180. {
  181. VAR BYTE prefix1;
  182.   prefix1=0x00; //needed
  183.   IF (_oldreg==+_ASMRPCODE_IX) {
  184.     prefix1=0xdd;
  185.     goto test1;
  186.   }ELSE IF (_oldreg==+_ASMRPCODE_IY) {
  187.     prefix1=0xfd;
  188.     test1:
  189.     IF (_reg==+_ASMRPCODE_HL) errwrongreg(); //ix/iy, hl
  190.     asmbyte(prefix1);
  191.   };//ELSE prefix1=0x00;
  192.   IF (_reg==+_ASMRPCODE_IX) {
  193.     IF (prefix1!=0xdd) {
  194.       asmbyte(0xdd);
  195.       IF (prefix1==0xfd) errwrongreg();
  196.     };
  197.     goto test2;
  198.   }ELSE IF (_reg==+_ASMRPCODE_IY) {
  199.     IF (prefix1!=0xfd) {
  200.       asmbyte(0xfd);
  201.       IF (prefix1==0xdd) errwrongreg();
  202.     };
  203.     test2:
  204.     IF (_oldreg==+_ASMRPCODE_HL) errwrongreg(); //hl, ix/iy
  205.     _reg = +_ASMRPCODE_HL;
  206.   };//ELSE prefix2=0x00;
  207.   _oldreg = _oldreg&0x3f;
  208. }
  209.  
  210. PROC asmbyte_ed()
  211. {
  212.   asmbyte(0xed);
  213. }
  214.  
  215. PROC err_rbix()
  216. {
  217.   IF (_reg>=_ASMRBIXADD) errwrongreg();
  218. }
  219.  
  220. PROC err_oldrbix()
  221. {
  222.   IF (_oldreg>=_ASMRBIXADD) errwrongreg();
  223. }
  224.  
  225. PROC err_rpix()
  226. {
  227.   IF (_reg>=_ASMRPIXADD) errwrongreg();
  228. }
  229.  
  230. PROC asmcheckrb_ixiyprefix()
  231. {
  232.   IF (_reg>=_ASMRBIXADD) asmrb_ixiyprefix();
  233. }
  234.  
  235. PROC asmcheckrp_ixiyprefix()
  236. {
  237.   IF (_reg>=_ASMRPIXADD) asmrp_ixiyprefix();
  238. }
  239.  
  240. PROC asmcheckoldrp_ixiyprefix()
  241. {
  242.   IF (_oldreg>=_ASMRPIXADD) asmoldrp_ixiyprefix();
  243. }
  244.  
  245. PROC initmemmodel()
  246. {
  247.   //_curaddr = _BASEADDR; //0x0100;
  248.   //_curpage0 = 0x00;
  249.   //_curpage1 = 0x05;
  250.   //_curpage2 = 0x02;
  251.   //_curpage3 = 0x07;
  252. }
  253.  
  254.