Subversion Repositories NedoOS

Rev

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

  1. //// imported
  2. PROC tokaddlbl FORWARD(PCHAR txt, PBYTE proc, BYTE data);
  3.  
  4. EXTERN PCHAR _tword; //Єхъє∙хх ёыютю
  5. EXTERN UINT _lentword;
  6.  
  7. EXTERN BYTE _temppar;
  8.  
  9. PROC asmtoken FORWARD(BYTE token);
  10.  
  11. PROC tokorg FORWARD();
  12. PROC tokalign FORWARD();
  13. PROC tokpage FORWARD();
  14. PROC tokif FORWARD();
  15. PROC tokelse FORWARD();
  16. PROC tokendif FORWARD();
  17. PROC tokdup FORWARD();
  18. PROC tokedup FORWARD();
  19. PROC tokmacro FORWARD();
  20. PROC tokendm FORWARD();
  21. //PROC tokusemacro FORWARD();
  22. PROC tokexport FORWARD();
  23. PROC toklocal FORWARD();
  24. PROC tokendl FORWARD();
  25. PROC tokdisp FORWARD();
  26. PROC tokent FORWARD();
  27. PROC tokinclude FORWARD();
  28. PROC tokincbin FORWARD();
  29. PROC tokdb FORWARD();
  30. PROC tokdw FORWARD();
  31. PROC tokdl FORWARD();
  32. PROC tokds FORWARD();
  33. PROC tokdisplay FORWARD();
  34. PROC tokrepeat FORWARD();
  35. PROC tokuntil FORWARD();
  36. PROC tokstruct FORWARD();
  37. PROC tokendstruct FORWARD();
  38. PROC tokcomment FORWARD();
  39. PROC tokcolon FORWARD();
  40.  
  41. EXTERN CHAR _c1small;
  42. EXTERN CHAR _c2small;
  43. EXTERN BOOL _asmwaseof;
  44. EXTERN UINT _asmwaseols;
  45.  
  46. PROC tokeol FORWARD();
  47. PROC asmrdword_tokspc FORWARD(); //ЄюъхэшчшЁєхЄ яЁюсхы√ яюёых яЁю°ыющ ъюьрэф√ ш ўшЄрхЄ эютє■
  48. PROC toktext FORWARD(); //ухэхЁшЁєхЄ <text>text<endtext>
  49. PROC tokerr FORWARD(BYTE token);
  50. PROC tokerrcmd FORWARD();
  51. FUNC BOOL matchcomma FORWARD();
  52. FUNC BOOL matchprime FORWARD();
  53. FUNC BOOL matchquote FORWARD();
  54. FUNC BOOL matchreequ FORWARD();
  55. FUNC BOOL matchopen FORWARD();
  56. FUNC BOOL matchclose FORWARD();
  57. FUNC BOOL tokexpr FORWARD(); //фюыцхэ ўшЄрЄ№, эю эх ё·хфрЄ№ ёшьтюы ъюэЎр т√Ёрцхэш  (ёъюсър, чря Єр , ъюэхЎ ёЄЁюъш)
  58. FUNC BOOL tokexpr_close FORWARD(); //яюёых эхую эшўхую сюы№°х эхы№ч  яЁютхЁ Є№, Є.ъ. ъєЁёюЁ ьюу ёфтшэєЄ№ё 
  59. PROC asm_direct_expr_close_token FORWARD(BYTE token);
  60.  
  61. ////
  62.  
  63. FUNC BOOL matchopenbrace()
  64. {
  65. VAR BOOL ok;
  66.   IF (*(PCHAR)_tword=='{') {asmtoken(+_TOKOPENBRACE); asmrdword_tokspc(); ok = +TRUE;
  67.   }ELSE ok = +FALSE;
  68. RETURN ok;
  69. }
  70.  
  71. FUNC BOOL matchclosebrace()
  72. {
  73. VAR BOOL ok;
  74.   IF (*(PCHAR)_tword=='}') {asmtoken(+_TOKCLOSEBRACE); asmrdword_tokspc(); ok = +TRUE;
  75.   }ELSE ok = +FALSE;
  76. RETURN ok;
  77. }
  78.  
  79. FUNC BOOL matchpc()
  80. {
  81. VAR BOOL ok;
  82.   IF ((_c1small=='p')&&(_c2small=='c')&&(_lentword==2)) {
  83.     asmtoken(+_RG_PC); asmrdword_tokspc(); ok = +TRUE;
  84.   }ELSE ok = +FALSE;
  85.   RETURN ok;
  86. }
  87.  
  88. FUNC BOOL matchlr()
  89. {
  90. VAR BOOL ok;
  91.   IF ((_c1small=='l')&&(_c2small=='r')&&(_lentword==2)) {
  92.     asmtoken(+_RG_LR); asmrdword_tokspc(); ok = +TRUE;
  93.   }ELSE ok = +FALSE;
  94.   RETURN ok;
  95. }
  96.  
  97. FUNC BOOL matchsp()
  98. {
  99. VAR BOOL ok;
  100.   IF ((_c1small=='s')&&(_c2small=='p')&&(_lentword==2)) {
  101.     asmtoken(+_RG_SP); asmrdword_tokspc(); ok = +TRUE;
  102.   }ELSE ok = +FALSE;
  103.   RETURN ok;
  104. }
  105.  
  106. FUNC BOOL matchrp()
  107. {
  108. VAR BOOL ok;
  109. VAR BYTE n;
  110.   ok = +FALSE;
  111.   IF (_c1small=='r') {
  112.       IF ((_c2small=='p') && (_lentword==2)) { //rp ьхЄър
  113.         asmrdword_tokspc();
  114.         asmtoken(+_RG_RPBYNAME);
  115.         toktext(); //ухэхЁшЁєхЄ <text>text<endtext>
  116.         asmrdword_tokspc();
  117.         ok = +TRUE;
  118.       }ELSE { //r0..r12, rp
  119.         IF (((BYTE)_c2small>=(BYTE)'0') && ((BYTE)_c2small<=(BYTE)'9')) {
  120.           n = (BYTE)_c2small - 0x30;
  121.           IF (_lentword==2) { //r0..r9
  122.             goto rnok;
  123.           }ELSE IF ((_lentword==3) && (n==0x01) && ((BYTE)_tword[2]>=(BYTE)'0') && ((BYTE)_tword[2]<=(BYTE)'2')) {
  124.             n = 0x0a + (BYTE)_tword[2] - 0x30;
  125.             rnok:
  126.             asmtoken(+_RG_R0 + n); asmrdword_tokspc(); ok = +TRUE;
  127.           };
  128.         };
  129.       };
  130.   }ELSE IF (_lentword==2) {
  131.     IF       ((_c1small=='s')&&(_c2small=='p')) {asmtoken(+_RG_SP); asmrdword_tokspc(); ok = +TRUE;
  132.     }ELSE IF ((_c1small=='l')&&(_c2small=='r')) {asmtoken(+_RG_LR); asmrdword_tokspc(); ok = +TRUE;
  133.     }ELSE IF ((_c1small=='p')&&(_c2small=='c')) {asmtoken(+_RG_PC); asmrdword_tokspc(); ok = +TRUE;
  134.     };
  135.   };
  136. RETURN ok;
  137. }
  138.  
  139. ////////////// ьр°шээючртшёшь√х уЁєяя√ ёЁртэхэшщ фы  ярЁёшэур ўрёЄ√ї ярЁрьхЄЁют
  140.  
  141. PROC asm_rp_close_token(BYTE mrtoken)
  142. {
  143.   IF (matchrp()) {
  144.     IF (matchclose()) {asmtoken(mrtoken);
  145.     }ELSE tokerr(+_ERRCLOSE); //no closing bracket
  146.   }ELSE tokerr(+_ERRREG); //wrong register
  147. }
  148.  
  149. ///////////////////////////////////////////////////
  150.  
  151. PROC tokmov()
  152. {
  153.   asmtoken(_temppar);
  154.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  155.   IF (matchrp()) {
  156.     IF (matchcomma()) {
  157.       IF (matchrp()) {
  158.         asmtoken(+_FMTR8R8);
  159. //      }ELSE IF (tokexpr()) {
  160. //        asmtoken(+_FMTRN);
  161.       }ELSE tokerr(+_ERREXPR); //wrong expr
  162.     }ELSE tokerr(+_ERRCOMMA); //no comma
  163.   }ELSE tokerr(+_ERRREG); //wrong register
  164. }
  165.  
  166. PROC tokmovs()
  167. {
  168.   asmtoken(_temppar);
  169.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  170.   IF (matchrp()) {
  171.     IF (matchcomma()) {
  172.       IF (matchrp()) {
  173.         asmtoken(+_FMTR0R0);
  174.       }ELSE IF (tokexpr()) {
  175.         asmtoken(+_FMTR0N);
  176.       }ELSE tokerr(+_ERREXPR); //wrong expr
  177.     }ELSE tokerr(+_ERRCOMMA); //no comma
  178.   }ELSE tokerr(+_ERRREG); //wrong register
  179. }
  180.  
  181. PROC tokmvns()
  182. {
  183.   asmtoken(_temppar);
  184.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  185.   IF (matchrp()) {
  186.     IF (matchcomma()) {
  187.       IF (matchrp()) {
  188.         asmtoken(+_FMTR0R0);
  189.       }ELSE IF (tokexpr()) {
  190.         asmtoken(+_FMTR0N);
  191.       }ELSE tokerr(+_ERREXPR); //wrong expr
  192.     }ELSE tokerr(+_ERRCOMMA); //no comma
  193.   }ELSE tokerr(+_ERRREG); //wrong register
  194. }
  195.  
  196. PROC tokaddsubN()
  197. {
  198.   asmtoken(_temppar);
  199.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  200.   IF (matchrp()) {
  201.     IF (matchcomma()) {
  202.       IF (matchrp()) {
  203.         IF (matchcomma()) { //adds r0,r1,r2/N
  204.           IF (matchrp()) {
  205.             asmtoken(+_FMTR0R0R0);
  206.           }ELSE IF (tokexpr()) {
  207.             asmtoken(+_FMTR0R0N7);
  208.           }ELSE tokerr(+_ERREXPR); //wrong expr
  209.         }ELSE asmtoken(+_FMTR0R0SAME);
  210.       }ELSE IF (tokexpr()) {
  211.         asmtoken(+_FMTR0N);
  212.       }ELSE tokerr(+_ERREXPR); //wrong expr
  213.     }ELSE tokerr(+_ERRCOMMA); //no comma
  214.   }ELSE tokerr(+_ERRREG); //wrong register
  215. }
  216.  
  217. PROC tokcmp()
  218. {
  219.   asmtoken(_temppar);
  220.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  221.   IF (matchrp()) {
  222.     IF (matchcomma()) {
  223.       IF (matchrp()) {
  224.         asmtoken(+_FMTR0R0);
  225.       }ELSE IF (tokexpr()) {
  226.         asmtoken(+_FMTR0N);
  227.       }ELSE tokerr(+_ERREXPR); //wrong expr
  228.     }ELSE tokerr(+_ERRCOMMA); //no comma
  229.   }ELSE tokerr(+_ERRREG); //wrong register
  230. }
  231.  
  232. PROC tokalucmdN()
  233. {
  234.   asmtoken(_temppar);
  235.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  236.   IF (matchrp()) {
  237.     IF (matchcomma()) {
  238.       IF (matchrp()) {
  239.         asmtoken(+_FMTR0R0);
  240.       }ELSE tokerr(+_ERRREG); //wrong register
  241.     }ELSE tokerr(+_ERRCOMMA); //no comma
  242.   }ELSE tokerr(+_ERRREG); //wrong register
  243. }
  244.  
  245. PROC tokrsbs()
  246. {
  247.   asmtoken(_temppar);
  248.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  249.   IF (matchrp()) {
  250.     IF (matchcomma()) {
  251.       IF (matchrp()) {
  252.         IF (matchcomma()) {
  253.           IF (tokexpr()) {
  254.             asmtoken(+_FMTR0R0ZERO);
  255.           }ELSE tokerr(+_ERREXPR); //wrong expr
  256.         }ELSE tokerr(+_ERRCOMMA); //no comma
  257.       }ELSE tokerr(+_ERRREG); //wrong register
  258.     }ELSE tokerr(+_ERRCOMMA); //no comma
  259.   }ELSE tokerr(+_ERRREG); //wrong register
  260. }
  261.  
  262. PROC tokshiftN()
  263. {
  264.   asmtoken(_temppar);
  265.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  266.   IF (matchrp()) {
  267.     IF (matchcomma()) {
  268.       IF (matchrp()) {
  269.         IF (matchcomma()) {
  270.           IF (tokexpr()) {
  271.             asmtoken(+_FMTR0R0N31);
  272.           }ELSE tokerr(+_ERREXPR); //wrong expr
  273.         }ELSE asmtoken(+_FMTR0R0);
  274.       }ELSE tokerr(+_ERRREG); //wrong register
  275.     }ELSE tokerr(+_ERRCOMMA); //no comma
  276.   }ELSE tokerr(+_ERRREG); //wrong register
  277. }
  278.  
  279. PROC tokrors()
  280. {
  281.   asmtoken(_temppar);
  282.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  283.   IF (matchrp()) {
  284.     IF (matchcomma()) {
  285.       IF (matchrp()) {
  286.         asmtoken(+_FMTR0R0);
  287.       }ELSE tokerr(+_ERRREG); //wrong register
  288.     }ELSE tokerr(+_ERRCOMMA); //no comma
  289.   }ELSE tokerr(+_ERRREG); //wrong register
  290. }
  291.  
  292. PROC tokpushpop()
  293. {
  294.   asmtoken(_temppar);
  295.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  296.   IF (matchopenbrace()) {
  297.     rloop:
  298.     IF (matchrp()) {
  299.       IF (matchcomma()) goto rloop; //ёяшёюъ ЁхушёЄЁют
  300.       IF (matchclosebrace()) {
  301.         asmtoken(+_FMTPUSHPOP);
  302.       }ELSE tokerr(+_ERRCLOSE); //no closing bracket
  303.     }ELSE tokerr(+_ERRREG); //wrong register
  304.   }ELSE tokerr(+_ERROPEN); //no opening bracket
  305. }
  306.  
  307. PROC tokldr()
  308. {
  309.   asmtoken(_temppar);
  310.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  311.   IF (matchrp()) {
  312.     IF (matchcomma()) {
  313.       IF (matchopen()) {
  314.         IF (matchrp()) {
  315.           IF (matchclose()) { //ldr r0,[r1]
  316.             asmtoken(+_FMTR0R0);
  317.           }ELSE IF (matchcomma()) { //ldr r0,[r1,N*4]
  318.             asmtoken(+_FMTR0R0NX4);
  319.           }ELSE tokerr(+_ERRCLOSE); //no closing bracket
  320.         }ELSE tokerr(+_ERRREG); //wrong register
  321.       }ELSE IF (tokexpr()) { //ldr r0,mem
  322.         asmtoken(+_FMTRADDR);
  323.       }ELSE tokerr(+_ERREXPR); //wrong expr
  324.     }ELSE tokerr(+_ERRCOMMA); //no comma
  325.   }ELSE tokerr(+_ERRREG); //wrong register
  326. }
  327.  
  328. PROC tokstr() //todo = tokldr
  329. {
  330.   asmtoken(_temppar);
  331.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  332.   IF (matchrp()) {
  333.     IF (matchcomma()) {
  334.       IF (matchopen()) {
  335.         IF (matchrp()) {
  336.           IF (matchclose()) { //str r0,[r1]
  337.             asmtoken(+_FMTR0R0);
  338.           }ELSE IF (matchcomma()) { //str r0,[r1,N*4]
  339.             asmtoken(+_FMTR0R0NX4);
  340.           }ELSE tokerr(+_ERRCLOSE); //no closing bracket
  341.         }ELSE tokerr(+_ERRREG); //wrong register
  342.       }ELSE IF (tokexpr()) { //str r0,mem
  343.         asmtoken(+_FMTRADDR);
  344.       }ELSE tokerr(+_ERREXPR); //wrong expr
  345.     }ELSE tokerr(+_ERRCOMMA); //no comma
  346.   }ELSE tokerr(+_ERRREG); //wrong register
  347. }
  348.  
  349. PROC tokjp()
  350. {
  351.   asmtoken(_temppar);
  352.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  353.   IF (tokexpr()) {asmtoken(+_FMTBADDR);
  354.   }ELSE tokerr(+_ERREXPR); //wrong expr
  355. }
  356.  
  357. PROC tokjpccN()
  358. {
  359.   asmtoken(_temppar);
  360.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  361.   IF (tokexpr()) {asmtoken(+_FMTBSHORTADDR);
  362.   }ELSE tokerr(+_ERREXPR); //wrong expr
  363. }
  364.  
  365. PROC tokbl()
  366. {
  367.   asmtoken(_temppar);
  368.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  369.   IF (tokexpr()) {asmtoken(+_FMTBLONGADDR);
  370.   }ELSE tokerr(+_ERREXPR); //wrong expr
  371. }
  372.  
  373. PROC tokbx()
  374. {
  375.   asmtoken(_temppar);
  376.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  377.   IF (matchrp()) {asmtoken(+_FMTR);
  378.   }ELSE tokerr(+_ERREXPR); //wrong expr
  379. }
  380.  
  381. PROC tokblx()
  382. {
  383.   asmtoken(_temppar);
  384.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  385.   IF (matchrp()) {asmtoken(+_FMTR);
  386.   }ELSE tokerr(+_ERREXPR); //wrong expr
  387. }
  388.  
  389. PROC tokxxN()
  390. {
  391.   asmtoken(_temppar);
  392.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  393.   asmtoken(+_FMTXX);
  394. }
  395.  
  396. PROC tokend()
  397. {
  398.   asmrdword_tokspc(); //ё·хфрхь ъюьрэфє
  399. }
  400.  
  401. PROC tokpre()
  402. {
  403.   tokaddlbl("NOP"  , (PBYTE)&tokxxN    , +_ASMNOP);
  404. //_ASMADR, //???
  405.  
  406.   tokaddlbl("ADCS" , (PBYTE)&tokalucmdN, +_ASMADCS);
  407.   tokaddlbl("ADDS" , (PBYTE)&tokaddsubN, +_ASMADDS);
  408.   tokaddlbl("SBCS" , (PBYTE)&tokalucmdN, +_ASMSBCS);
  409.   tokaddlbl("SUBS" , (PBYTE)&tokaddsubN, +_ASMSUBS);
  410.   tokaddlbl("RSBS" , (PBYTE)&tokrsbs,    +_ASMRSBS);
  411.   tokaddlbl("CMN"  , (PBYTE)&tokalucmdN, +_ASMCMN);
  412.   tokaddlbl("CMP"  , (PBYTE)&tokcmp    , +_ASMCMP);
  413.   tokaddlbl("TST"  , (PBYTE)&tokalucmdN, +_ASMTST);
  414.   tokaddlbl("MULS" , (PBYTE)&tokalucmdN, +_ASMMULS);
  415.   tokaddlbl("BICS" , (PBYTE)&tokalucmdN, +_ASMBICS);
  416. //_ASMNEG,
  417.  
  418.   tokaddlbl("ANDS" , (PBYTE)&tokalucmdN, +_ASMANDS);
  419.   tokaddlbl("ORRS" , (PBYTE)&tokalucmdN, +_ASMORRS);
  420.   tokaddlbl("EORS" , (PBYTE)&tokalucmdN, +_ASMEORS);
  421.  
  422.   tokaddlbl("ASRS" , (PBYTE)&tokshiftN , +_ASMASRS);
  423.   tokaddlbl("LSLS" , (PBYTE)&tokshiftN , +_ASMLSLS);
  424.   tokaddlbl("LSRS" , (PBYTE)&tokshiftN , +_ASMLSRS);
  425.   tokaddlbl("RORS" , (PBYTE)&tokrors   , +_ASMRORS);
  426.  
  427.   tokaddlbl("B"    , (PBYTE)&tokjp     , +_ASMB);
  428.   tokaddlbl("BEQ"  , (PBYTE)&tokjpccN  , +_ASMBEQ);
  429.   tokaddlbl("BNE"  , (PBYTE)&tokjpccN  , +_ASMBNE);
  430.   tokaddlbl("BCS"  , (PBYTE)&tokjpccN  , +_ASMBCS); //HS?
  431.   tokaddlbl("BCC"  , (PBYTE)&tokjpccN  , +_ASMBCC); //LO?
  432.   tokaddlbl("BMI"  , (PBYTE)&tokjpccN  , +_ASMBMI);
  433.   tokaddlbl("BPL"  , (PBYTE)&tokjpccN  , +_ASMBPL);
  434.   tokaddlbl("BVS"  , (PBYTE)&tokjpccN  , +_ASMBVS);
  435.   tokaddlbl("BVC"  , (PBYTE)&tokjpccN  , +_ASMBVC);
  436.   tokaddlbl("BHI"  , (PBYTE)&tokjpccN  , +_ASMBHI);
  437.   tokaddlbl("BLS"  , (PBYTE)&tokjpccN  , +_ASMBLS);
  438.   tokaddlbl("BGE"  , (PBYTE)&tokjpccN  , +_ASMBGE);
  439.   tokaddlbl("BLT"  , (PBYTE)&tokjpccN  , +_ASMBLT);
  440.   tokaddlbl("BGT"  , (PBYTE)&tokjpccN  , +_ASMBGT);
  441.   tokaddlbl("BLE"  , (PBYTE)&tokjpccN  , +_ASMBLE);
  442.   tokaddlbl("BAL"  , (PBYTE)&tokjpccN  , +_ASMBAL);
  443.  
  444.   tokaddlbl("BL"   , (PBYTE)&tokbl     , +_ASMBL);
  445.   tokaddlbl("BLX"  , (PBYTE)&tokblx    , +_ASMBLX);
  446.   tokaddlbl("BX"   , (PBYTE)&tokbx     , +_ASMBX);
  447.  
  448. //_ASMBKPT, //???
  449.  
  450. //_ASMDMB,
  451. //_ASMDSB,
  452. //_ASMISB,
  453. //_ASMCPSID,
  454. //_ASMCPSIE,
  455. //_ASMSEV,
  456. //_ASMSVC,
  457. //_ASMYIELD,
  458.  
  459.   tokaddlbl("LDR"  , (PBYTE)&tokldr    , +_ASMLDR);
  460.   tokaddlbl("LDRB" , (PBYTE)&tokldr    , +_ASMLDRB);
  461.   tokaddlbl("LDRH" , (PBYTE)&tokldr    , +_ASMLDRH);
  462.   tokaddlbl("LDRSB", (PBYTE)&tokldr    , +_ASMLDRSB);
  463.   tokaddlbl("LDRSH", (PBYTE)&tokldr    , +_ASMLDRSH);
  464. //_ASMLDM, //???
  465. //_ASMLDMFD, //???
  466. //_ASMLDMIA, //???
  467.   tokaddlbl("STR"  , (PBYTE)&tokstr    , +_ASMSTR);
  468.   tokaddlbl("STRB" , (PBYTE)&tokstr    , +_ASMSTRB);
  469.   tokaddlbl("STRH" , (PBYTE)&tokstr    , +_ASMSTRH);
  470. //_ASMSTM, //???
  471. //_ASMSTMEA, //???
  472. //_ASMSTMIA, //???
  473.  
  474.   tokaddlbl("MOV"  , (PBYTE)&tokmov    , +_ASMMOV);
  475.   tokaddlbl("MOVS" , (PBYTE)&tokmovs   , +_ASMMOVS);
  476.   tokaddlbl("MVNS" , (PBYTE)&tokmvns   , +_ASMMVNS);
  477. //_ASMMRS,
  478. //_ASMMSR,
  479. //_ASMCPY, //???
  480.  
  481.   tokaddlbl("POP"  , (PBYTE)&tokpushpop, +_ASMPOP);
  482.   tokaddlbl("PUSH" , (PBYTE)&tokpushpop, +_ASMPUSH);
  483.  
  484. //_ASMREV,
  485. //_ASMREV16,
  486. //_ASMREVSH,
  487. //_ASMSXTB,
  488. //_ASMSXTH,
  489. //_ASMUXTB,
  490. //_ASMUXTH,
  491.  
  492.   tokaddlbl("DCB"  , (PBYTE)&tokdb  , 0x00); //db ..., тьхёЄю defb - эрфю яюёых ърцфюую т√Ёрцхэш  ЇюЁьрЄ writeN, ЁрчсшЁрЄ№ тЁєўэє■ эх яюыєўшЄё  шч-чр т√Ёрцхэш 
  493.   tokaddlbl("DCD"  , (PBYTE)&tokdw  , 0x00); //dw ..., тьхёЄю defw - эрфю яюёых ърцфюую т√Ёрцхэш  ЇюЁьрЄ writeNN
  494.   tokaddlbl("DCQ"  , (PBYTE)&tokdl  , 0x00); //dl ..., тьхёЄю defl - эрфю яюёых ърцфюую т√Ёрцхэш  ЇюЁьрЄ writeNNNN
  495.   tokaddlbl("SPACE", (PBYTE)&tokds  , 0x00); //ds ..., тьхёЄю defs - эрфю ЇюЁьрЄ writeds
  496.  
  497.   tokaddlbl("ORG"  , (PBYTE)&tokorg , 0x00); /**org nn - эрфю ЇюЁьрЄ writeorg, ЁрчсшЁрЄ№ тЁєўэє■ эх яюыєўшЄё  шч-чр т√Ёрцхэш */
  498.  
  499.   tokaddlbl("ALIGN",(PBYTE)&tokalign,0x00); /**align nn - эрфю ЇюЁьрЄ writealign, ЁрчсшЁрЄ№ тЁєўэє■ эх яюыєўшЄё  шч-чр т√Ёрцхэш */
  500. //  tokaddlbl("PAGE", (PBYTE)&tokpage, 0x00); /**page n - эрфю ЇюЁьрЄ writepage, ЁрчсшЁрЄ№ тЁєўэє■ эх яюыєўшЄё  шч-чр т√Ёрцхэш */
  501. //  tokaddlbl("IF"  , (PBYTE)&tokif  , 0x00); /**if nn - эрфю ЇюЁьрЄ writeif, ЁрчсшЁрЄ№ тЁєўэє■ эх яюыєўшЄё  шч-чр т√Ёрцхэш */
  502. //  tokaddlbl("ELSE", (PBYTE)&tokelse, 0x00); /**else*/
  503. //  tokaddlbl("ENDIF",(PBYTE)&tokendif,0x00); /**endif*/
  504. //  tokaddlbl("DUP" , (PBYTE)&tokdup , 0x00); /**dup nn - эрфю ЇюЁьрЄ writedup, ЁрчсшЁрЄ№ тЁєўэє■ эх яюыєўшЄё  шч-чр т√Ёрцхэш */
  505. //  tokaddlbl("EDUP", (PBYTE)&tokedup, 0x00); /**edup*/
  506. //  tokaddlbl("MACRO",(PBYTE)&tokmacro,0x00); /**macro name - ЁрчсшЁрЄ№ тЁєўэє■?*/
  507. //  tokaddlbl("ENDM", (PBYTE)&tokendm, 0x00); /**endm*/
  508.   //tokaddlbl("USEMACRO",(PBYTE)&tokusemacro, 0x00); /**usemacro name ... - ЁрчсшЁрЄ№ тЁєўэє■?*/
  509.   tokaddlbl("EXPORT",(PBYTE)&tokexport, 0x00); /**export name - ЁрчсшЁрЄ№ тЁєўэє■?*/
  510. //  tokaddlbl("LOCAL",(PBYTE)&toklocal,0x00); /**local name - ЁрчсшЁрЄ№ тЁєўэє■?*/
  511. //  tokaddlbl("ENDL", (PBYTE)&tokendl, 0x00); /**endl*/
  512. //  tokaddlbl("DISP", (PBYTE)&tokdisp, 0x00); /**disp nn - эрфю ЇюЁьрЄ writedisp*/
  513. //  tokaddlbl("ENT" , (PBYTE)&tokent , 0x00); /**ent*/
  514.   tokaddlbl("INCLUDE",(PBYTE)&tokinclude, 0x00); /**include "filename" - ЁрчсшЁрЄ№ тЁєўэє■?*/
  515.   tokaddlbl("INCBIN",(PBYTE)&tokincbin, 0x00); /**incbin "filename" - ЁрчсшЁрЄ№ тЁєўэє■?*/
  516. //  tokaddlbl("DISPLAY",(PBYTE)&tokdisplay, 0x00); /**display nn - ЇюЁьрЄ√ displaynum, displaystring - ЁрчсшЁрЄ№ тЁєўэє■ эх яюыєўшЄё  шч-чр т√Ёрцхэшщ*/
  517. //  tokaddlbl("REPEAT",(PBYTE)&tokrepeat, 0x00); /**repeat*/
  518. //  tokaddlbl("UNTIL",(PBYTE)&tokuntil, 0x00); /**until nn - эрфю ЇюЁьрЄ writeuntil*/
  519. //  tokaddlbl("STRUCT",(PBYTE)&tokstruct, 0x00); /**struct name - ЁрчсшЁрЄ№ тЁєўэє■?*/
  520. //  tokaddlbl("ENDSTRUCT",(PBYTE)&tokendstruct, 0x00); /**endstruct*/
  521.  
  522.   tokaddlbl("END"  , (PBYTE)&tokend  , 0x00); //ds ..., тьхёЄю defs - эрфю ЇюЁьрЄ writeds
  523.  
  524.   tokaddlbl(":",(PBYTE)&tokcolon, 0x00);
  525. //  tokaddlbl(";",(PBYTE)&tokcomment, 0x00); //яЁютхЁ хЄё  юЄфхы№эю
  526. }
  527.