Subversion Repositories Kolibri OS

Rev

Rev 7626 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. #define _TOKB_
  2.  
  3. #include "tok.h"
  4.  
  5.  
  6.  
  7. char badadr[]="Bad outrm value in outaddress();";
  8.  
  9. char CXandDX[]="CX and DX";
  10.  
  11. char ECXandEDX[]="ECX and EDX";
  12.  
  13. char BXandFS[]="BX and FS";
  14.  
  15. int divexpand=FALSE;
  16.  
  17. int optnumber=FALSE;
  18.  
  19. ITOK itok,itok2,ptok;
  20.  
  21. char *pbuf;
  22.  
  23. SINFO pstr;
  24.  
  25.  
  26.  
  27. LISTFLOAT *floatnum=NULL;       //ᯨ᮪ float ª®­áâ ­â
  28.  
  29. unsigned int numfloatconst=0;
  30.  
  31. unsigned int maxnumfloatconst;
  32.  
  33. #define STEPFLOATCONST 16
  34.  
  35. unsigned int ofsfloatlist=0;
  36.  
  37. unsigned char idxregs[5]={ESI,EDI,EBX,EDX,255};
  38.  
  39.  
  40.  
  41. int expandvar();
  42.  
  43. int speedmul(unsigned long num, int razr);
  44.  
  45. int leamul32(unsigned long num,int reg,int razr);
  46.  
  47. void Float2reg32(int reg,int addop=0,int reg1=idxregs[0],int reg2=idxregs[1]);
  48.  
  49. void NegReg(int razr,int reg);
  50.  
  51. int RshiftReg(int razr,int reg,int sign);
  52.  
  53. void do_e_axmath2(int sign,int razr,int expand);
  54.  
  55. int MulReg(int reg,int razr);
  56.  
  57. void DivMod(int vop,int sign,int razr,int expand);
  58.  
  59. void DivNum2(unsigned long num,int razr,int sign);
  60.  
  61. void DivNum(unsigned long num,int razr,int sign);
  62.  
  63. void ClearDX(int razr,int sign);
  64.  
  65. void  doalmath2(int sign);
  66.  
  67. void num2bits(ITOK *gtok,unsigned long num,int razr);
  68.  
  69. void reg2bits(ITOK *gtok,int razr);
  70.  
  71. void cwpointr(ITOK *wtok,char *&wbuf,SINFO *wstr,int *otok,int npointr,int ureg);
  72.  
  73. int CheckAddOnly();
  74.  
  75. void optnumadd64(unsigned long long num,int r1,int r2,int vop);
  76.  
  77. void CallExternProc(char *name);
  78.  
  79. void getinto_reg(int gtok,ITOK *gstok,char *&gbuf,SINFO *gstr,int razr,int reg);
  80.  
  81. void intinstack(int addop);
  82.  
  83.  
  84.  
  85. extern void warningoptnum();
  86.  
  87. extern void segoperror();
  88.  
  89. extern void segbyteerror();
  90.  
  91. extern void regmathoperror();
  92.  
  93. extern void begmathoperror();
  94.  
  95. extern void negregerror();
  96.  
  97. extern void regbyteerror();
  98.  
  99. extern void begworderror();
  100.  
  101. extern void regshifterror();
  102.  
  103. extern void regmatherror();
  104.  
  105. extern void DevideZero();
  106.  
  107. extern void wordnotoper();
  108.  
  109.  
  110.  
  111. unsigned long long li[]={0x1,0x2,0x4,0x8,0x10,0x20,0x40,0x80,0x100,0x200,0x400,
  112.  
  113. 0x800,0x1000,0x2000,0x4000,0x8000,0x10000,0x20000,0x40000,0x80000,0x100000,
  114.  
  115. 0x200000,0x400000,0x800000,0x1000000,0x2000000,0x4000000,0x8000000,0x10000000,
  116.  
  117. 0x20000000,0x40000000,0x80000000,0x100000000LL,0x200000000LL,0x400000000LL
  118.  
  119. ,0x800000000LL,0x1000000000LL,0x2000000000LL,0x4000000000LL,0x8000000000LL
  120.  
  121. ,0x10000000000LL,0x20000000000LL,0x40000000000LL,0x80000000000LL
  122.  
  123. ,0x100000000000LL,0x200000000000LL,0x400000000000LL,0x800000000000LL
  124.  
  125. ,0x1000000000000LL,0x2000000000000LL,0x4000000000000LL,0x8000000000000LL
  126.  
  127. ,0x10000000000000LL,0x20000000000000LL,0x40000000000000LL,0x80000000000000LL
  128.  
  129. ,0x100000000000000LL,0x200000000000000LL,0x400000000000000LL,0x800000000000000LL
  130.  
  131. ,0x1000000000000000LL,0x2000000000000000LL,0x4000000000000000LL,0x8000000000000000LL};
  132.  
  133.  
  134.  
  135. unsigned long leanum[24]={3,5,9,15,25,27,45,81,75,125,135,225,243,405,729,
  136.  
  137.                 375,675,1215,2187,625,1125,2025,3645,6561};
  138.  
  139.  
  140.  
  141. unsigned int numleamul[24][4]={
  142.  
  143.         {3,0,0,0},{5,0,0,0},{9,0,0,0},{3,5,0,0},{5,5,0,0},{3,9,0,0},{5,9,0,0},
  144.  
  145.         {9,9,0,0},{5,5,3,0},{5,5,5,0},{9,5,3,0},{9,5,5,0},{9,9,3,0},{9,9,5,0},
  146.  
  147.         {9,9,9,0},{5,5,5,3},{5,5,9,3},{9,9,5,3},{9,9,9,3},{5,5,5,5},{9,5,5,5},
  148.  
  149.         {9,9,5,5},{9,9,9,5},{9,9,9,9}};
  150.  
  151.  
  152.  
  153. int RmEqualReg(int reg,int rm,int sib)
  154.  
  155. {
  156.  
  157. int rm0;
  158.  
  159. int reg1=-1,reg2=-1;
  160.  
  161.         rm0=rm&0x7;
  162.  
  163.         if(sib==CODE16){
  164.  
  165.                 switch(rm0){
  166.  
  167.                         case 0:
  168.  
  169.                                 reg1=BX;
  170.  
  171.                                 reg2=SI;
  172.  
  173.                                 break;
  174.  
  175.                         case 1:
  176.  
  177.                                 reg1=BX;
  178.  
  179.                                 reg2=DI;
  180.  
  181.                                 break;
  182.  
  183.                         case 2:
  184.  
  185.                                 reg1=BP;
  186.  
  187.                                 reg2=SI;
  188.  
  189.                                 break;
  190.  
  191.                         case 3:
  192.  
  193.                                 reg1=BP;
  194.  
  195.                                 reg2=DI;
  196.  
  197.                                 break;
  198.  
  199.                         case 4:
  200.  
  201.                                 reg1=SI;
  202.  
  203.                                 break;
  204.  
  205.                         case 5:
  206.  
  207.                                 reg1=DI;
  208.  
  209.                                 break;
  210.  
  211.                         case 6:
  212.  
  213.                                 if((rm&0xC0)!=0)reg1=BP;
  214.  
  215.                                 break;
  216.  
  217.                         case 7:
  218.  
  219.                                 reg1=BX;
  220.  
  221.                                 break;
  222.  
  223.                 }
  224.  
  225.         }
  226.  
  227.         else{
  228.  
  229.                 if(rm0==4){
  230.  
  231.                         reg1=sib&7;
  232.  
  233.                         reg2=(sib>>3)&7;
  234.  
  235.                         if(reg1==5&&(rm&0xc0)==0)reg1=-1;
  236.  
  237.                         if(reg2==4)reg2=-1;
  238.  
  239.                 }
  240.  
  241.                 else{
  242.  
  243.                         reg1=rm0;
  244.  
  245.                         if(reg1==5&&(rm&0xc0)==0)reg1=-1;
  246.  
  247.                 }
  248.  
  249.         }
  250.  
  251.         if(reg==reg1||reg==reg2)return TRUE;
  252.  
  253.         return FALSE;
  254.  
  255. }
  256.  
  257.  
  258.  
  259. void startmul(int razr)
  260.  
  261. {
  262.  
  263.         if(razr==r8)outword(0xE08A);    //mov ah,al
  264.  
  265.         else{
  266.  
  267.                 op66(razr);
  268.  
  269.                 outword(0xD08B);        //mov dx,ax
  270.  
  271.                 warningreg(regs[razr/2-1][2]);
  272.  
  273.         }
  274.  
  275. }
  276.  
  277.  
  278.  
  279. void lshiftmul(int num,int razr,int reg=AX)
  280.  
  281. {
  282.  
  283.         if(razr==r8){
  284.  
  285.                 if(num==1)outword(0xC002);      //add al,al
  286.  
  287.                 else{
  288.  
  289.                         if(chip==0){
  290.  
  291.                                 op(0xB1);       //mov cl,num
  292.  
  293.                                 op(num);
  294.  
  295.                                 outword(0xE0D2);        //shl al,cl
  296.  
  297.                                 warningreg(begs[1]);
  298.  
  299.                         }
  300.  
  301.                         else{
  302.  
  303.                                 outword(0xE0C0);        //shl al,num
  304.  
  305.                                 op(num);
  306.  
  307.                         }
  308.  
  309.                 }
  310.  
  311.         }
  312.  
  313.         else{
  314.  
  315.                 if(num==1){
  316.  
  317.                         op66(razr);
  318.  
  319.                         op(1);
  320.  
  321.                         op(0xC0+reg*9); //add reg,reg
  322.  
  323.                 }
  324.  
  325.                 else{
  326.  
  327.                         if(chip==0){
  328.  
  329.                                 op(0xB1);       //mov cl,num
  330.  
  331.                                 op(num);
  332.  
  333.                                 op(0xD3);
  334.  
  335.                                 op(0xE0+reg);   //shl ax,cl
  336.  
  337.                                 warningreg(begs[1]);
  338.  
  339.                         }
  340.  
  341.                         else{
  342.  
  343.                                 if(chip>2&&optimizespeed&&leamul32(li[num],reg,razr))return;
  344.  
  345.                                 op66(razr);
  346.  
  347.                                 op(0xC1);
  348.  
  349.                                 op(0xE0+reg);   //shl ax,num
  350.  
  351.                                 op(num);
  352.  
  353.                         }
  354.  
  355.                 }
  356.  
  357.         }
  358.  
  359. }
  360.  
  361.  
  362.  
  363. void submul(int razr)
  364.  
  365. {
  366.  
  367.         if(razr==r8)outword(0xC42A);    //sub al,ah
  368.  
  369.         else{
  370.  
  371.                 op66(razr);
  372.  
  373.                 outword(0xC22B);        //sub ax,dx
  374.  
  375.         }
  376.  
  377. }
  378.  
  379.  
  380.  
  381. void addmul(int razr)
  382.  
  383. {
  384.  
  385.         if(razr==r8)outword(0xC402);    //add al,ah
  386.  
  387.         else{
  388.  
  389.                 op66(razr);
  390.  
  391.                 outword(0xC203);        //add ax,dx
  392.  
  393.         }
  394.  
  395. }
  396.  
  397.  
  398.  
  399. int leamul32(unsigned long num,int reg,int razr)
  400.  
  401. {
  402.  
  403.         if(num==0)return FALSE;
  404.  
  405. int vop=0,i=8*reg+4;
  406.  
  407.         switch(num){
  408.  
  409.                 case 9: vop+=0x40;
  410.  
  411.                 case 5: vop+=0x40;
  412.  
  413.                 case 3: vop+=0x40;
  414.  
  415.                         op66(razr);
  416.  
  417.                         op67(r32);      // AX * n = LEA AX,[EAX*n+?EAX]
  418.  
  419.                         op(0x8d);
  420.  
  421.                         op(reg==BP?i|rm_mod01:i);
  422.  
  423.                         op(vop+9*reg);
  424.  
  425.                         if(reg==BP)op(0);
  426.  
  427.                         return TRUE;
  428.  
  429.         }
  430.  
  431. //                      if(chip>3&&chip<7)return FALSE; //¨§¡¥¦ âì AGI ¤«ï 486,p5,p5mmx
  432.  
  433.         switch(num){
  434.  
  435.                 case 2: vop=reg; break;
  436.  
  437.                 case 4: vop=0x85; break;
  438.  
  439.                 case 8: vop=0xc5; break;
  440.  
  441.                 default: return FALSE;
  442.  
  443.         }
  444.  
  445.         op66(razr);
  446.  
  447.         op67(r32);      // AX * n = LEA AX,[EAX*n+?EAX]
  448.  
  449.         op(0x8d);
  450.  
  451.         if(vop!=0x85&&vop!=0xc5&&reg==BP)i|=rm_mod01;
  452.  
  453.         op(i);
  454.  
  455.         op(vop+8*reg);
  456.  
  457.         if(vop==0x85||vop==0xc5)outdword(0L);
  458.  
  459.         else if(reg==BP)op(0);
  460.  
  461.         return TRUE;
  462.  
  463. }
  464.  
  465.  
  466.  
  467. int speedmul32(unsigned long num,int reg,int razr)
  468.  
  469. {
  470.  
  471. int i;
  472.  
  473.         for(i=3;i<24;i++){
  474.  
  475.                 if(leanum[i]==num){
  476.  
  477.                         leamul32(numleamul[i][0],reg,razr);
  478.  
  479.                         leamul32(numleamul[i][1],reg,razr);
  480.  
  481.                         leamul32(numleamul[i][2],reg,razr);
  482.  
  483.                         leamul32(numleamul[i][3],reg,razr);
  484.  
  485.                         return TRUE;
  486.  
  487.                 }
  488.  
  489.         }
  490.  
  491.         for(unsigned int j=1;j<NUMNUM;j++){
  492.  
  493.                 unsigned long v=li[j];
  494.  
  495.                 if((v*3)>num)break;
  496.  
  497.                 for(i=0;i<15;i++){
  498.  
  499.                         unsigned long lm=leanum[i]*v;
  500.  
  501.                         if(lm==num){
  502.  
  503.                                 leamul32(numleamul[i][0],reg,razr);
  504.  
  505.                                 lshiftmul(j,razr,reg);
  506.  
  507.                                 leamul32(numleamul[i][1],reg,razr);
  508.  
  509.                                 leamul32(numleamul[i][2],reg,razr);
  510.  
  511.                                 return TRUE;
  512.  
  513.                         }
  514.  
  515.                 }
  516.  
  517.         }
  518.  
  519.         if(reg==EAX)return speedmul(num,r32);
  520.  
  521.         return FALSE;
  522.  
  523. }
  524.  
  525.  
  526.  
  527. int speedmul(unsigned long num, int razr)       //¯®¨áª ¢®§¬®¦­®á⨠§ ¬¥­ë 㬭®¦¥­¨ï ­ 
  528.  
  529. //ᤢ¨£¨ ¨ á«®¦¥­¨ï
  530.  
  531. {
  532.  
  533. int first,second;
  534.  
  535.         for(unsigned int j=1;j<NUMNUM;j++){
  536.  
  537.                 unsigned long v=li[j];
  538.  
  539.                 if((v-1)>num)break;
  540.  
  541.                 if((num%(v-1))==0){
  542.  
  543.                         second=caselong(num/(v-1));
  544.  
  545.                         if(second!=NUMNUM){
  546.  
  547.                                 first=caselong(v);
  548.  
  549.                                 if(first!=1){
  550.  
  551.                                         startmul(razr);
  552.  
  553.                                         lshiftmul(first,razr);
  554.  
  555.                                         submul(razr);
  556.  
  557.                                         if(second!=0)lshiftmul(second,razr);
  558.  
  559.                                         setzeroflag=TRUE;
  560.  
  561.                                         return TRUE;
  562.  
  563.                                 }
  564.  
  565.                         }
  566.  
  567.                 }
  568.  
  569.                 if((v+1)>num)break;
  570.  
  571.                 if((num%(v+1))==0){
  572.  
  573.                         second=caselong(num/(v+1));
  574.  
  575.                         if(second!=NUMNUM){
  576.  
  577.                                 first=caselong(v);
  578.  
  579.                                 startmul(razr);
  580.  
  581.                                 lshiftmul(first,razr);
  582.  
  583.                                 addmul(razr);
  584.  
  585.                                 if(second!=0)lshiftmul(second,razr);
  586.  
  587.                                 setzeroflag=TRUE;
  588.  
  589.                                 return TRUE;
  590.  
  591.                         }
  592.  
  593.                 }
  594.  
  595.                 if(num>10){
  596.  
  597.                         if((v-1)>(num-1))break;
  598.  
  599.                         if(((num-1)%(v-1))==0){
  600.  
  601.                                 second=caselong((num-1)/(v-1));
  602.  
  603.                                 if(second!=NUMNUM&&second!=1){
  604.  
  605.                                         first=caselong(v);
  606.  
  607.                                         if(first!=1){
  608.  
  609.                                                 startmul(razr);
  610.  
  611.                                                 lshiftmul(first,razr);
  612.  
  613.                                                 submul(razr);
  614.  
  615.                                                 lshiftmul(second,razr);
  616.  
  617.                                                 addmul(razr);
  618.  
  619.                                                 setzeroflag=TRUE;
  620.  
  621.                                                 return TRUE;
  622.  
  623.                                         }
  624.  
  625.                                 }
  626.  
  627.                         }
  628.  
  629.                         if((v+1)>(num-1))break;
  630.  
  631.                         if(((num-1)%(v+1))==0){
  632.  
  633.                                 second=caselong((num-1)/(v+1));
  634.  
  635.                                 if(second!=NUMNUM){
  636.  
  637.                                         first=caselong(v);
  638.  
  639.                                         startmul(razr);
  640.  
  641.                                         lshiftmul(first,razr);
  642.  
  643.                                         addmul(razr);
  644.  
  645.                                         lshiftmul(second,razr);
  646.  
  647.                                         addmul(razr);
  648.  
  649.                                         setzeroflag=TRUE;
  650.  
  651.                                         return TRUE;
  652.  
  653.                                 }
  654.  
  655.                         }
  656.  
  657.                         if((v-1)>(num+1))break;
  658.  
  659.                         if(((num+1)%(v-1))==0){
  660.  
  661.                                 second=caselong((num+1)/(v-1));
  662.  
  663.                                 if(second!=NUMNUM){
  664.  
  665.                                         first=caselong(v);
  666.  
  667.                                         if(first!=1){
  668.  
  669.                                                 startmul(razr);
  670.  
  671.                                                 lshiftmul(first,razr);
  672.  
  673.                                                 submul(razr);
  674.  
  675.                                                 lshiftmul(second,razr);
  676.  
  677.                                                 submul(razr);
  678.  
  679.                                                 setzeroflag=TRUE;
  680.  
  681.                                                 return TRUE;
  682.  
  683.                                         }
  684.  
  685.                                 }
  686.  
  687.                         }
  688.  
  689.                         if((v+1)>(num+1))break;
  690.  
  691.                         if(((num+1)%(v+1))==0){
  692.  
  693.                                 second=caselong((num+1)/(v+1));
  694.  
  695.                                 if(second!=NUMNUM&&second!=1){
  696.  
  697.                                         first=caselong(v);
  698.  
  699.                                         startmul(razr);
  700.  
  701.                                         lshiftmul(first,razr);
  702.  
  703.                                         addmul(razr);
  704.  
  705.                                         lshiftmul(second,razr);
  706.  
  707.                                         submul(razr);
  708.  
  709.                                         setzeroflag=TRUE;
  710.  
  711.                                         return TRUE;
  712.  
  713.                                 }
  714.  
  715.                         }
  716.  
  717.                 }
  718.  
  719.         }
  720.  
  721.         return FALSE;
  722.  
  723. }
  724.  
  725.  
  726.  
  727. void CheckRegForLea(int reg,int *idx,int *base, int *zoom,unsigned long *val,
  728.  
  729.         unsigned int *rflag,ITOK *posttok)
  730.  
  731. {
  732.  
  733. //      printf("in:reg=%02X base=%02X idx=%02X zoom=%02X\n",reg,*base,*idx,*zoom);
  734.  
  735.         for(;;){
  736.  
  737. //              printf("tok=%d flag=%08X %s\n",tok2,itok2.flag,itok2.name);
  738.  
  739. //              printf("tok=%d tok2=%d %s\n",tok,tok2,itok2.name);
  740.  
  741.                 if((tok==tk_plus||tok==tk_minus)&&(tok2==tk_minus||
  742.  
  743.                                 (tok2==tk_number&&itok2.rm!=tk_float&&itok2.rm!=tk_double)||
  744.  
  745.                                 (tok2==tk_postnumber&&posttok->post==0)||(tok==tk_plus&&tok2==tk_rmnumber&&(itok2.flag&f_useidx)==0))){
  746.  
  747.                         goto con1;
  748.  
  749.                 }
  750.  
  751.                 if((tok!=tk_plus&&(!(tok2==tk_number&&itok2.rm!=tk_float&&itok2.rm!=tk_double)))
  752.  
  753.                                 ||(tok2!=tk_reg32&&tok2!=tk_number)||tok2==tk_rmnumber){
  754.  
  755.                         break;
  756.  
  757.                 }
  758.  
  759.                 if(tok==tk_plus&&tok2==tk_reg32&&(itok2.number==reg||(*idx!=-1&&*base!=-1))){
  760.  
  761.                         break;
  762.  
  763.                 }
  764.  
  765.                 if(tok==tk_mult&&(tok2!=tk_number||*zoom!=-1||*val!=0||*idx!=-1))break;
  766.  
  767. con1:
  768.  
  769.                 if(tok==tk_minus){
  770.  
  771.                         if(tok2==tk_postnumber||(tok2==tk_number&&(itok2.flag&f_reloc)))break;
  772.  
  773.                         nexttok();
  774.  
  775.                         if(tok==tk_minus){
  776.  
  777.                                 if(tok2!=tk_number)break;
  778.  
  779.                                 nexttok();
  780.  
  781.                                 *val+=itok.number;
  782.  
  783.                         }
  784.  
  785.                         else *val-=itok.number;
  786.  
  787.                         if(tok==tk_number)*rflag^=itok.flag;
  788.  
  789.                         else *posttok=itok;
  790.  
  791.                 }
  792.  
  793.                 else if(tok==tk_plus){
  794.  
  795.                         nexttok();
  796.  
  797.                         if(tok==tk_number){
  798.  
  799.                                 *val+=itok.number;
  800.  
  801.                                 *rflag^=itok.flag;
  802.  
  803.                         }
  804.  
  805.                         else if(tok==tk_postnumber){
  806.  
  807.                                 *val+=itok.number;
  808.  
  809.                                 *posttok=itok;
  810.  
  811.                         }
  812.  
  813.                         else if(tok==tk_rmnumber){
  814.  
  815.                                 int r1,r2,z;
  816.  
  817.                                 ExpandRm(itok.rm,itok.sib,&z,&r1,&r2);
  818.  
  819.                                 if(z&&*zoom>0)break;
  820.  
  821.                                 if(r1>=0&&r2>=0&&(*idx>=0||*base>=0))break;
  822.  
  823.                                 *val+=itok.number;
  824.  
  825.                                 if(*zoom<=0)*zoom=z;
  826.  
  827.                                 if(*base==-1){
  828.  
  829.                                         if(r1>=0){
  830.  
  831.                                                 *base=r1;
  832.  
  833.                                                 r1=-1;
  834.  
  835.                                         }
  836.  
  837.                                         else{
  838.  
  839.                                                 *base=r2;
  840.  
  841.                                                 r2=-1;
  842.  
  843.                                         }
  844.  
  845.                                 }
  846.  
  847.                                 if(*idx==-1){
  848.  
  849.                                         if(r1>=0)*idx=r1;
  850.  
  851.                                         else if(r2>=0)*idx=r2;
  852.  
  853.                                 }
  854.  
  855.                         }
  856.  
  857.                         else{
  858.  
  859.                                 if(*base==-1)*base=itok.number;
  860.  
  861.                                 else *idx=itok.number;
  862.  
  863.                         }
  864.  
  865.                 }
  866.  
  867.                 else if(tok==tk_mult){
  868.  
  869.                         *zoom=0;
  870.  
  871.                         switch(itok2.number){
  872.  
  873.                                 case 8: *zoom=*zoom+1;
  874.  
  875.                                 case 4: *zoom=*zoom+1;
  876.  
  877.                                 case 2: *zoom=*zoom+1;
  878.  
  879.                                 case 1:
  880.  
  881.                                         *idx=*base;
  882.  
  883.                                         *base=-1;
  884.  
  885.                                         break;
  886.  
  887.                                 case 9: *zoom=*zoom+1;
  888.  
  889.                                 case 5: *zoom=*zoom+1;
  890.  
  891.                                 case 3:
  892.  
  893.                                         *zoom=*zoom+1;
  894.  
  895.                                         *idx=*base;
  896.  
  897.                                         break;
  898.  
  899.                                 default: *zoom=-1;
  900.  
  901.                         }
  902.  
  903.                         if(*zoom==-1)break;
  904.  
  905.                         nexttok();
  906.  
  907.                 }
  908.  
  909.                 else break;
  910.  
  911.                 nexttok();
  912.  
  913.                 if(*base!=-1&&*idx!=-1&&tok2!=tk_number)break;
  914.  
  915.         }
  916.  
  917.         if(*zoom==-1&&*base==-1){
  918.  
  919.                 *base=*idx;
  920.  
  921.                 *idx=-1;
  922.  
  923.         }
  924.  
  925. //      printf("out:reg=%02X base=%02X idx=%02X zoom=%02X\n",reg,*base,*idx,*zoom);
  926.  
  927. }
  928.  
  929.  
  930.  
  931. int OutLea(int reg,int idx,int base, int zoom,unsigned long val,
  932.  
  933.         unsigned int rflag,ITOK *posttok)
  934.  
  935. {
  936.  
  937. int mod=rm_mod00;
  938.  
  939. int q;
  940.  
  941.         if(zoom==-1)zoom=0;
  942.  
  943.         if(val!=0){
  944.  
  945.                 if(short_ok(val,TRUE)!=0)mod=rm_mod01;
  946.  
  947.                 else mod=rm_mod10;
  948.  
  949.         }
  950.  
  951.         if((rflag&f_reloc)!=0||posttok->post)mod=rm_mod10;
  952.  
  953.         if(idx==-1){
  954.  
  955.                 idx=base;
  956.  
  957.                 base=-1;
  958.  
  959.         }
  960.  
  961.         if(base==-1){
  962.  
  963.                 if(zoom==0){
  964.  
  965.                         op66(r32);
  966.  
  967.                         op67(r32);
  968.  
  969.                         op(0x8d);
  970.  
  971.                         if(idx==5&&mod==rm_mod00)mod=rm_mod01;
  972.  
  973.                         op((reg*8+idx)|mod);
  974.  
  975.                         if(idx==4)op(idx*9);
  976.  
  977.                 }
  978.  
  979.                 else{
  980.  
  981.                         if(idx==4)return FALSE;
  982.  
  983.                         mod=rm_mod10;
  984.  
  985.                         op66(r32);
  986.  
  987.                         op67(r32);
  988.  
  989.                         op(0x8d);
  990.  
  991.                         op(reg*8+4);
  992.  
  993.                         op(idx*8+5+(zoom<<6));
  994.  
  995.                 }
  996.  
  997.         }
  998.  
  999.         else{
  1000.  
  1001.                 if(idx==4){
  1002.  
  1003.                         if(base==-1){ idx=-1; base=4;}
  1004.  
  1005.                         else if(zoom==0){
  1006.  
  1007.                                 q=base;
  1008.  
  1009.                                 base=idx;
  1010.  
  1011.                                 idx=q;
  1012.  
  1013.                         }
  1014.  
  1015.                         else return FALSE;
  1016.  
  1017.                 }
  1018.  
  1019.                 if(base==5&&mod==rm_mod00){
  1020.  
  1021.                         if(idx!=-1&&idx!=5){
  1022.  
  1023.                                 if(zoom==0){
  1024.  
  1025.                                         q=base;
  1026.  
  1027.                                         base=idx;
  1028.  
  1029.                                         idx=q;
  1030.  
  1031.                                 }
  1032.  
  1033.                                 else mod=rm_mod01;
  1034.  
  1035.                         }
  1036.  
  1037.                         else mod=rm_mod01;
  1038.  
  1039.                 }
  1040.  
  1041.                 op66(r32);
  1042.  
  1043.                 op67(r32);
  1044.  
  1045.                 op(0x8d);
  1046.  
  1047.                 op((reg*8+4)|mod);      //sib
  1048.  
  1049.                 op((zoom<<6)+(idx<<3)+base);
  1050.  
  1051.         }
  1052.  
  1053.         if(mod==rm_mod01)op(val);
  1054.  
  1055.         else if(mod==rm_mod10){
  1056.  
  1057.                 if(posttok->post)setwordpost(posttok);
  1058.  
  1059.                 else if((rflag&f_reloc)!=0)AddReloc();
  1060.  
  1061.                 outdword(val);
  1062.  
  1063.         }
  1064.  
  1065.         else if(mod==rm_mod00&&base==5)outdword(val);
  1066.  
  1067.         return TRUE;
  1068.  
  1069. }
  1070.  
  1071.  
  1072.  
  1073. int Reg32ToLea2(int reg)        //®¯â¨¬¨§ æ¨ï á«®¦¥­¨ï 32-¡¨â­ëå ॣ¨áâ஢ ¢ LEA
  1074.  
  1075. {
  1076.  
  1077. int idx,base,zoom;
  1078.  
  1079. unsigned long val;
  1080.  
  1081. int otok,otok2,otype2;
  1082.  
  1083. unsigned char ocha,next;
  1084.  
  1085. unsigned int oinptr,rflag;
  1086.  
  1087. int oline;
  1088.  
  1089. ITOK oitok;
  1090.  
  1091. ITOK posttok;
  1092.  
  1093.         if(tok!=tk_minus&&tok!=tk_plus&&tok!=tk_mult)return FALSE;
  1094.  
  1095.         if(tok==tk_minus&&(!((tok2==tk_number&&itok2.rm!=tk_float&&itok2.rm!=tk_double)||tok2==tk_postnumber)))return FALSE;
  1096.  
  1097.         if(tok==tk_mult&&(!(tok2==tk_number&&itok2.rm!=tk_float&&itok2.rm!=tk_double&&(itok2.flag&f_reloc)==0)))return FALSE;
  1098.  
  1099.         if(tok==tk_plus&&tok2!=tk_reg32&&tok2!=tk_number&&tok2!=tk_postnumber&&(!(tok2==tk_rmnumber&&(itok2.flag&f_useidx)==0)))return FALSE;
  1100.  
  1101.         if(cur_mod)return FALSE;
  1102.  
  1103.         posttok.post=0;
  1104.  
  1105.         idx=zoom=-1;
  1106.  
  1107.         base=reg;
  1108.  
  1109.         if(tok==tk_mult){
  1110.  
  1111.                 zoom=0;
  1112.  
  1113.                 switch(itok2.number){
  1114.  
  1115.                         case 8: zoom++;
  1116.  
  1117.                         case 4: zoom++;
  1118.  
  1119.                         case 2: zoom++;
  1120.  
  1121.                         case 1:
  1122.  
  1123.                                 idx=reg;
  1124.  
  1125.                                 base=-1;
  1126.  
  1127.                                 break;
  1128.  
  1129. //new!
  1130.  
  1131.                         case 9: zoom++;
  1132.  
  1133.                         case 5: zoom++;
  1134.  
  1135.                         case 3:
  1136.  
  1137. //                              if(!(am32==FALSE&&tok!=tk_plus&&(!(tok2==tk_minus||tok2==tk_number)))){
  1138.  
  1139.                                 if(am32){
  1140.  
  1141.                                         zoom++;
  1142.  
  1143.                                         idx=base=reg;
  1144.  
  1145.                                         break;
  1146.  
  1147.                                 }
  1148.  
  1149. // end new!!
  1150.  
  1151.                         default: return FALSE;
  1152.  
  1153.                 }
  1154.  
  1155.                 if(zoom==0){
  1156.  
  1157.                         zoom=-1;
  1158.  
  1159.                         base=reg;
  1160.  
  1161.                         idx=-1;
  1162.  
  1163.                 }
  1164.  
  1165.         }
  1166.  
  1167.         val=0;
  1168.  
  1169.         rflag=0;
  1170.  
  1171.         oinptr=inptr2;
  1172.  
  1173.         ocha=cha2;
  1174.  
  1175.         otok=tok;
  1176.  
  1177.         oitok=itok;
  1178.  
  1179.         otok2=tok2;
  1180.  
  1181.         otype2=itok2.type;
  1182.  
  1183.         oline=linenumber;
  1184.  
  1185.         if(tok==tk_mult){
  1186.  
  1187.                 nexttok();
  1188.  
  1189.                 nexttok();
  1190.  
  1191.         }
  1192.  
  1193.         CheckRegForLea(reg,&idx,&base,&zoom,&val,&rflag,&posttok);
  1194.  
  1195.         next=0;
  1196.  
  1197.         if(idx==-1)next=1;
  1198.  
  1199.         if(base==-1)next|=2;
  1200.  
  1201.         if(zoom==-1)next|=4;
  1202.  
  1203.         if(val==0&&rflag==0&&posttok.post==0)next|=8;
  1204.  
  1205. //      printf("next=%d\n",next);
  1206.  
  1207.         switch(next){
  1208.  
  1209.                 case 1:         // idx=-1                  Rb+N
  1210.  
  1211.                         if(base==ESP&&val==1)goto retfalse;
  1212.  
  1213.                 case 4:         // zoom=-1                 Rb+Ri+N
  1214.  
  1215.                         if(val<2||val>127)goto retfalse;
  1216.  
  1217.                         break;
  1218.  
  1219.                 case 2:         // base=-1                 Ri*Z+N
  1220.  
  1221.                         if(zoom<3){
  1222.  
  1223.                                 if(zoom==2&&val>2){
  1224.  
  1225.                                         if(val<128)goto retfalse;
  1226.  
  1227.                                         break;
  1228.  
  1229.                                 }
  1230.  
  1231.                                 goto retfalse;
  1232.  
  1233.                         }
  1234.  
  1235.                 case 0:
  1236.  
  1237.                 case 8:         // val=0                   Rb+Ri*Z
  1238.  
  1239.                         break;
  1240.  
  1241.                 default:
  1242.  
  1243. //              case 12:        // val=0   zoom=-1         Rb+Ri
  1244.  
  1245. //              case 10:        // val=0   base=-1         Ri*Z
  1246.  
  1247. //              case 13:        // val=0   idx=-1  zoom=-1 Rb
  1248.  
  1249. //              case 5:         // idx=-1  zoom=-1         Rb+N
  1250.  
  1251. //              case 3:         // idx=-1  base=-1         N
  1252.  
  1253. //              case 6:         // base=-1 zoom=-1         Ri+N
  1254.  
  1255. //              case 11:        // val=0   base=-1 idx=-1  -
  1256.  
  1257. //              case 9:         // val=0   idx=-1          Rb
  1258.  
  1259. //              case 14:        // val=0   base=-1 zoom=-1 Ri
  1260.  
  1261. //              case 7:         // idx=-1  base=-1 zoom=-1 N
  1262.  
  1263. //              case 15:        // val=0   base=-1 idx=-1  zoom=-1
  1264.  
  1265. retfalse:
  1266.  
  1267.                         inptr2=oinptr;
  1268.  
  1269.                         cha2=ocha;
  1270.  
  1271.                         tok=otok;
  1272.  
  1273.                         itok=oitok;
  1274.  
  1275.                         tok2=otok2;
  1276.  
  1277.                         itok2.type=(unsigned short)otype2;
  1278.  
  1279.                         if(bufrm){
  1280.  
  1281.                                 free(bufrm);
  1282.  
  1283.                                 bufrm=NULL;
  1284.  
  1285.                         }
  1286.  
  1287.                         if(strinf.bufstr){
  1288.  
  1289.                                 free(strinf.bufstr);
  1290.  
  1291.                                 strinf.bufstr=NULL;
  1292.  
  1293.                         }
  1294.  
  1295.                         endoffile=0;
  1296.  
  1297.                         linenum2=linenumber=oline;
  1298.  
  1299.                         return FALSE;
  1300.  
  1301.         }
  1302.  
  1303.         if(OutLea(reg,idx,base,zoom,val,rflag,&posttok)==FALSE)goto retfalse;
  1304.  
  1305.         ClearReg(reg);
  1306.  
  1307. //      printf("%s (%u) Combination %d\n",(startfileinfo+currentfileinfo)->filename,linenumber,next);
  1308.  
  1309.         return TRUE;
  1310.  
  1311. }
  1312.  
  1313.  
  1314.  
  1315. int RegEqualToLea(int reg)
  1316.  
  1317. {
  1318.  
  1319. int idx,base,zoom;
  1320.  
  1321. unsigned long val;
  1322.  
  1323. int otok,otok2;
  1324.  
  1325. unsigned char ocha,next;
  1326.  
  1327. unsigned int oinptr,rflag;
  1328.  
  1329. ITOK oitok;
  1330.  
  1331. ITOK oitok2;
  1332.  
  1333. ITOK posttok;
  1334.  
  1335.         if(cur_mod)return FALSE;
  1336.  
  1337.         oinptr=inptr2;
  1338.  
  1339.         ocha=cha2;
  1340.  
  1341.         otok=tok;
  1342.  
  1343.         oitok=itok;
  1344.  
  1345.         otok2=tok2;
  1346.  
  1347.         oitok2=oitok;
  1348.  
  1349.         base=idx=zoom=-1;
  1350.  
  1351.         val=0;
  1352.  
  1353.         rflag=0;
  1354.  
  1355.         posttok.post=0;
  1356.  
  1357.         tok=tk_plus;
  1358.  
  1359.         CheckRegForLea(reg,&idx,&base,&zoom,&val,&rflag,&posttok);
  1360.  
  1361.         if(tok!=tk_semicolon)goto retfalse;
  1362.  
  1363.         if(base==-1)base=reg;
  1364.  
  1365.         else if(idx==-1)idx=reg;
  1366.  
  1367.         else goto retfalse;
  1368.  
  1369.         next=0;
  1370.  
  1371.         if(idx==-1)next=1;
  1372.  
  1373.         if(base==-1)next|=2;
  1374.  
  1375.         if(zoom==-1)next|=4;
  1376.  
  1377.         if(val==0&&rflag==0&&posttok.post==0)next|=8;
  1378.  
  1379. //      printf("base=%d idx=%d zoom=%d val=%d next=%d\n",base,idx,zoom,val,next);
  1380.  
  1381.         if(val==0&&rflag==0&&posttok.post==0)next|=8;
  1382.  
  1383.         switch(next){
  1384.  
  1385.                 case 5:         // idx=-1  zoom=-1         Rb+N
  1386.  
  1387.                         if(reg==EAX&&(val>127||val<0xffffff80))goto retfalse;
  1388.  
  1389.                         if(val<3||val>0xfffffffd)goto retfalse;
  1390.  
  1391.                         if(base==ESP)goto retfalse;
  1392.  
  1393.                         break;
  1394.  
  1395.                 case 4:         // zoom=-1                 Rb+Ri+N
  1396.  
  1397.                         if(val==1||val==0xffffffff)goto retfalse;
  1398.  
  1399.                         break;
  1400.  
  1401.                 case 0:
  1402.  
  1403.                 case 8:         // val=0                   Rb+Ri*Z
  1404.  
  1405.                         break;
  1406.  
  1407.                 default:
  1408.  
  1409. //              case 13:        // val=0   idx=-1  zoom=-1 Rb
  1410.  
  1411. //              case 3:         // idx=-1  base=-1         N
  1412.  
  1413. //              case 6:         // base=-1 zoom=-1         Ri+N
  1414.  
  1415. //              case 11:        // val=0   base=-1 idx=-1  -
  1416.  
  1417. //              case 9:         // val=0   idx=-1          Rb
  1418.  
  1419. //              case 14:        // val=0   base=-1 zoom=-1 Ri
  1420.  
  1421. //              case 7:         // idx=-1  base=-1 zoom=-1 N
  1422.  
  1423. //              case 15:        // val=0   base=-1 idx=-1  zoom=-1
  1424.  
  1425. retfalse:
  1426.  
  1427.                         inptr2=oinptr;
  1428.  
  1429.                         cha2=ocha;
  1430.  
  1431.                         tok=otok;
  1432.  
  1433.                         itok=oitok;
  1434.  
  1435.                         tok2=otok2;
  1436.  
  1437.                         itok2=oitok2;
  1438.  
  1439.                         endoffile=0;
  1440.  
  1441.                         if(bufrm){
  1442.  
  1443.                                 free(bufrm);
  1444.  
  1445.                                 bufrm=NULL;
  1446.  
  1447.                         }
  1448.  
  1449.                         if(strinf.bufstr){
  1450.  
  1451.                                 free(strinf.bufstr);
  1452.  
  1453.                                 strinf.bufstr=NULL;
  1454.  
  1455.                         }
  1456.  
  1457. //      printf("return input=%08X inptr=%08X\n",input,inptr2);
  1458.  
  1459.                         return FALSE;
  1460.  
  1461.         }
  1462.  
  1463. //      printf("next=%d\n",next);
  1464.  
  1465.         if(OutLea(reg,idx,base,zoom,val,rflag,&posttok)==FALSE)goto retfalse;
  1466.  
  1467.         return TRUE;
  1468.  
  1469. }
  1470.  
  1471.  
  1472.  
  1473. int Reg32ToLea(int reg) //®¯â¨¬¨§ æ¨ï á«®¦¥­¨ï 32-¡¨â­ëå ॣ¨áâ஢ ¢ LEA
  1474.  
  1475. {
  1476.  
  1477. int idx,base,zoom;
  1478.  
  1479. unsigned long val;
  1480.  
  1481. int otok,otok2,otype2;
  1482.  
  1483. unsigned char ocha,next;
  1484.  
  1485. unsigned int oinptr,rflag;
  1486.  
  1487. int oline;
  1488.  
  1489. ITOK oitok;
  1490.  
  1491. ITOK posttok;
  1492.  
  1493.         if(tok!=tk_reg32&&tok!=tk_number&&tok!=tk_postnumber&&(!(tok==tk_rmnumber&&(itok.flag&f_useidx)==0)))return FALSE;
  1494.  
  1495.         if(cur_mod)return FALSE;
  1496.  
  1497.         posttok.post=0;
  1498.  
  1499.         idx=base=zoom=-1;
  1500.  
  1501.         val=0;
  1502.  
  1503.         rflag=0;
  1504.  
  1505. //      printf("input=%08X inptr=%08X\n",input,inptr2);
  1506.  
  1507.         oinptr=inptr2;
  1508.  
  1509.         ocha=cha2;
  1510.  
  1511.         otok=tok;
  1512.  
  1513.         oitok=itok;
  1514.  
  1515.         otok2=tok2;
  1516.  
  1517.         otype2=itok2.type;
  1518.  
  1519.         oline=linenumber;
  1520.  
  1521. //      printf("tok=%d type=%d %s\n",tok,itok.type,itok.name);
  1522.  
  1523.         if(tok==tk_number){
  1524.  
  1525.                 if(itok.rm==tk_float||itok.rm==tk_double||itok.rm==tk_qword)return FALSE;
  1526.  
  1527.                 val=doconstdwordmath();
  1528.  
  1529.                 rflag=postnumflag;
  1530.  
  1531.                 if((rflag&f_reloc)&&tok==tk_mult)goto retfalse;
  1532.  
  1533.         }
  1534.  
  1535.         else if(tok==tk_postnumber){
  1536.  
  1537.                 posttok=itok;
  1538.  
  1539.                 tok=tk_number;
  1540.  
  1541.                 val=doconstdwordmath();
  1542.  
  1543.                 if(tok==tk_mult)goto retfalse;
  1544.  
  1545.         }
  1546.  
  1547.         else if(tok==tk_rmnumber){
  1548.  
  1549.                 ExpandRm(itok.rm,itok.sib,&zoom,&base,&idx);
  1550.  
  1551.                 val=itok.number;
  1552.  
  1553.                 nexttok();
  1554.  
  1555.         }
  1556.  
  1557.         else{
  1558.  
  1559.                 base=itok.number;
  1560.  
  1561.                 nexttok();
  1562.  
  1563.         }
  1564.  
  1565.         if(tok==tk_mult){
  1566.  
  1567.                 nexttok();
  1568.  
  1569.                 if(base==-1&&tok==tk_reg32){
  1570.  
  1571.                         if(itok.number==reg)goto retfalse;
  1572.  
  1573.                         idx=itok.number;
  1574.  
  1575.                 }
  1576.  
  1577.                 else if(base!=-1&&tok==tk_number){
  1578.  
  1579.                         if((itok.flag&f_reloc)&&(itok.rm==tk_float||itok.rm==tk_double||itok.rm==tk_qword))goto retfalse;
  1580.  
  1581.                         idx=base;
  1582.  
  1583.                         base=-1;
  1584.  
  1585.                         val=itok.number;
  1586.  
  1587.                 }
  1588.  
  1589.                 else goto retfalse;
  1590.  
  1591.                 nexttok();
  1592.  
  1593.                 zoom=0;
  1594.  
  1595.                 switch(val){
  1596.  
  1597.                         case 8: zoom++;
  1598.  
  1599.                         case 4: zoom++;
  1600.  
  1601.                         case 2: zoom++;
  1602.  
  1603.                         case 1: break;
  1604.  
  1605. //new!
  1606.  
  1607.                         case 9: zoom++;
  1608.  
  1609.                         case 5: zoom++;
  1610.  
  1611.                         case 3:
  1612.  
  1613. //                              if(!(am32==FALSE&&tok!=tk_plus&&(!(tok2==tk_minus||tok2==tk_number)))){
  1614.  
  1615.                                 if(am32||((tok==tk_plus||tok==tk_minus)&&(tok2==tk_number||tok2==tk_minus))){
  1616.  
  1617.                                         zoom++;
  1618.  
  1619.                                         base=idx;
  1620.  
  1621.                                         break;
  1622.  
  1623.                                 }
  1624.  
  1625. // end new!!
  1626.  
  1627.                         default:
  1628.  
  1629.                                 goto retfalse;
  1630.  
  1631.                 }
  1632.  
  1633.                 if(zoom==0){
  1634.  
  1635.                         zoom=-1;
  1636.  
  1637.                         base=idx;
  1638.  
  1639.                         idx=-1;
  1640.  
  1641.                 }
  1642.  
  1643.                 val=0;
  1644.  
  1645.         }
  1646.  
  1647.         CheckRegForLea(reg,&idx,&base,&zoom,&val,&rflag,&posttok);
  1648.  
  1649.         next=0;
  1650.  
  1651.         if(idx==-1)next=1;
  1652.  
  1653.         if(base==-1)next|=2;
  1654.  
  1655.         if(zoom==-1)next|=4;
  1656.  
  1657.         if(val==0&&rflag==0&&posttok.post==0)next|=8;
  1658.  
  1659.         switch(next){
  1660.  
  1661.                 case 5:         // idx=-1  zoom=-1         Rb+N
  1662.  
  1663.                 case 1:         // idx=-1                  Rb+N
  1664.  
  1665.                         if(base==ESP&&val==1)goto retfalse;
  1666.  
  1667.                 case 12:        // val=0   zoom=-1         Rb+Ri
  1668.  
  1669.                         if(base==reg)goto retfalse;
  1670.  
  1671.                         break;
  1672.  
  1673.                 case 10:        // val=0   base=-1         Ri*Z
  1674.  
  1675.                         if(optimizespeed==FALSE||idx==reg)goto retfalse;
  1676.  
  1677.                         break;
  1678.  
  1679.                 case 2:         // base=-1                 Ri*Z+N
  1680.  
  1681.                         if(optimizespeed)break;
  1682.  
  1683.                         if(zoom<3){
  1684.  
  1685.                                 if(zoom==2&&val>2){
  1686.  
  1687.                                         if(val<128){
  1688.  
  1689.                                                 if(idx!=reg)break;
  1690.  
  1691.                                                 goto retfalse;
  1692.  
  1693.                                         }
  1694.  
  1695.                                         break;
  1696.  
  1697.                                 }
  1698.  
  1699.                                 if(zoom==1&&val>3&&idx!=reg)break;
  1700.  
  1701.                                 goto retfalse;
  1702.  
  1703.                         }
  1704.  
  1705.                 case 0:
  1706.  
  1707.                 case 4:         // zoom=-1                 Rb+Ri+N
  1708.  
  1709.                 case 8:         // val=0                   Rb+Ri*Z
  1710.  
  1711.                         break;
  1712.  
  1713.                 default:
  1714.  
  1715. //              case 13:        // val=0   idx=-1  zoom=-1 Rb
  1716.  
  1717. //              case 3:         // idx=-1  base=-1         N
  1718.  
  1719. //              case 6:         // base=-1 zoom=-1         Ri+N
  1720.  
  1721. //              case 11:        // val=0   base=-1 idx=-1  -
  1722.  
  1723. //              case 9:         // val=0   idx=-1          Rb
  1724.  
  1725. //              case 14:        // val=0   base=-1 zoom=-1 Ri
  1726.  
  1727. //              case 7:         // idx=-1  base=-1 zoom=-1 N
  1728.  
  1729. //              case 15:        // val=0   base=-1 idx=-1  zoom=-1
  1730.  
  1731. retfalse:
  1732.  
  1733.                         inptr2=oinptr;
  1734.  
  1735.                         cha2=ocha;
  1736.  
  1737.                         tok=otok;
  1738.  
  1739.                         itok=oitok;
  1740.  
  1741.                         tok2=otok2;
  1742.  
  1743.                         itok2.type=(unsigned short)otype2;
  1744.  
  1745.                         linenum2=linenumber=oline;
  1746.  
  1747.                         endoffile=0;
  1748.  
  1749.                         if(bufrm){
  1750.  
  1751.                                 free(bufrm);
  1752.  
  1753.                                 bufrm=NULL;
  1754.  
  1755.                         }
  1756.  
  1757.                         if(strinf.bufstr){
  1758.  
  1759.                                 free(strinf.bufstr);
  1760.  
  1761.                                 strinf.bufstr=NULL;
  1762.  
  1763.                         }
  1764.  
  1765. //      printf("return input=%08X inptr=%08X\n",input,inptr2);
  1766.  
  1767.                         return FALSE;
  1768.  
  1769.         }
  1770.  
  1771. //      printf("flag=%08X\n",rflag);
  1772.  
  1773.         if(OutLea(reg,idx,base,zoom,val,rflag,&posttok)==FALSE)goto retfalse;
  1774.  
  1775.         ClearReg(reg);
  1776.  
  1777.         return TRUE;
  1778.  
  1779. }
  1780.  
  1781.  
  1782.  
  1783. void CheckRegForLea16(int reg,int *idx,int *base,unsigned long *val,unsigned int *rflag,ITOK *posttok)
  1784.  
  1785. {
  1786.  
  1787. int endloop=FALSE;
  1788.  
  1789.         for(;;){
  1790.  
  1791.                 if(tok!=tk_plus&&(!(tok==tk_minus&&((tok2==tk_number&&itok2.rm!=tk_float&&itok2.rm!=tk_qword&&itok2.rm!=tk_double)||tok2==tk_postnumber))))break;
  1792.  
  1793.                 if(tok2==tk_postnumber&&(posttok->post||tok==tk_minus))break;
  1794.  
  1795.                 if(tok2==tk_reg){
  1796.  
  1797.                         if(itok2.number==reg)endloop=TRUE;
  1798.  
  1799.                         else if(*base==-1){
  1800.  
  1801.                                 switch(itok2.number){
  1802.  
  1803.                                         case BX:
  1804.  
  1805.                                         case BP:
  1806.  
  1807.                                         case SI:
  1808.  
  1809.                                         case DI:
  1810.  
  1811.                                                 *base=itok2.number;
  1812.  
  1813.                                                 break;
  1814.  
  1815.                                         default: endloop=TRUE; break;
  1816.  
  1817.                                 }
  1818.  
  1819.                         }
  1820.  
  1821.                         else if(*idx==-1){
  1822.  
  1823.                                 switch(itok2.number){
  1824.  
  1825.                                         case BX:
  1826.  
  1827.                                         case BP:
  1828.  
  1829.                                                 if(*base==BX||*base==BP)endloop=TRUE;
  1830.  
  1831.                                                 else{
  1832.  
  1833.                                                         *idx=*base;
  1834.  
  1835.                                                         *base=itok2.number;
  1836.  
  1837.                                                 }
  1838.  
  1839.                                                 break;
  1840.  
  1841.                                         case SI:
  1842.  
  1843.                                         case DI:
  1844.  
  1845.                                                 if(*base==SI||*base==DI)endloop=TRUE;
  1846.  
  1847.                                                 else{
  1848.  
  1849.                                                         *idx=itok2.number;
  1850.  
  1851.                                                 }
  1852.  
  1853.                                                 break;
  1854.  
  1855.                                         default: endloop=TRUE; break;
  1856.  
  1857.                                 }
  1858.  
  1859.                         }
  1860.  
  1861.                         else break;
  1862.  
  1863.                         if(endloop)break;
  1864.  
  1865.                         nexttok();
  1866.  
  1867.                 }
  1868.  
  1869.                 else if(tok2==tk_number&&itok2.rm!=tk_float&&itok2.rm!=tk_qword&&itok2.rm!=tk_double){
  1870.  
  1871.                         if(tok==tk_plus)*val+=itok2.number;
  1872.  
  1873.                         else *val-=itok2.number;
  1874.  
  1875.                         nexttok();
  1876.  
  1877.                         *rflag^=itok.flag;
  1878.  
  1879.                 }
  1880.  
  1881.                 else if(tok2==tk_postnumber){
  1882.  
  1883.                         if(posttok->post)break;
  1884.  
  1885.                         if(tok==tk_plus)*val+=itok2.number;
  1886.  
  1887.                         else *val-=itok2.number;
  1888.  
  1889.                         nexttok();
  1890.  
  1891.                         *posttok=itok;
  1892.  
  1893.                 }
  1894.  
  1895.                 else break;
  1896.  
  1897.                 nexttok();
  1898.  
  1899.         }
  1900.  
  1901. }
  1902.  
  1903.  
  1904.  
  1905. void OutLea16(int reg,int idx,int base,unsigned int val,int rflag,ITOK *posttok)
  1906.  
  1907. {
  1908.  
  1909. int mod=rm_mod00;
  1910.  
  1911. int rm;
  1912.  
  1913.         if(val!=0){
  1914.  
  1915.                 if(short_ok(val,FALSE)!=0)mod=rm_mod01;
  1916.  
  1917.                 else mod=rm_mod10;
  1918.  
  1919.         }
  1920.  
  1921.         if((rflag&f_reloc)!=0||posttok->post)mod=rm_mod10;
  1922.  
  1923.         rm=CalcRm16(base,idx);
  1924.  
  1925.         op66(r16);
  1926.  
  1927.         op67(r16);
  1928.  
  1929.         op(0x8D);
  1930.  
  1931.         op((rm+reg*8)|mod);
  1932.  
  1933.         if(mod==rm_mod01)op(val);
  1934.  
  1935.         else if(mod==rm_mod10){
  1936.  
  1937.                 if(posttok->post)setwordpost(posttok);
  1938.  
  1939.                 else if((rflag&f_reloc)!=0)AddReloc();
  1940.  
  1941.                 outword(val);
  1942.  
  1943.         }
  1944.  
  1945. }
  1946.  
  1947.  
  1948.  
  1949. int Reg16ToLea(int reg) //®¯â¨¬¨§ æ¨ï á«®¦¥­¨ï 16-¡¨â­ëå ॣ¨áâ஢ ¢ LEA
  1950.  
  1951. {
  1952.  
  1953. int idx,base;
  1954.  
  1955. unsigned long val;
  1956.  
  1957. int otok,otok2,otype2;
  1958.  
  1959. unsigned char ocha,next;
  1960.  
  1961. unsigned int oinptr,rflag;
  1962.  
  1963. int oline;
  1964.  
  1965. ITOK oitok;
  1966.  
  1967. ITOK posttok;
  1968.  
  1969.         if(cur_mod)return FALSE;
  1970.  
  1971.         posttok.post=0;
  1972.  
  1973. //      if(tok!=tk_reg&&tok!=tk_number&&am32!=0&&tok2!=tk_plus)return FALSE;
  1974.  
  1975.         if(!((tok==tk_reg||(tok==tk_number&&itok.rm!=tk_float&&itok.rm!=tk_double)&&tok==tk_postnumber)&&tok2==tk_plus))return FALSE;
  1976.  
  1977.         idx=base=-1;
  1978.  
  1979.         if(tok==tk_reg){
  1980.  
  1981.                 if(itok.number==reg)return FALSE;
  1982.  
  1983.                 switch(itok.number){
  1984.  
  1985.                         case BX:
  1986.  
  1987.                         case BP:
  1988.  
  1989.                         case SI:
  1990.  
  1991.                         case DI:
  1992.  
  1993.                                 base=itok.number;
  1994.  
  1995.                                 break;
  1996.  
  1997.                         default: return FALSE;
  1998.  
  1999.                 }
  2000.  
  2001.         }
  2002.  
  2003.         val=0;
  2004.  
  2005.         rflag=0;
  2006.  
  2007.         oinptr=inptr2;
  2008.  
  2009.         ocha=cha2;
  2010.  
  2011.         otok=tok;
  2012.  
  2013.         oitok=itok;
  2014.  
  2015.         otok2=tok2;
  2016.  
  2017.         otype2=itok2.type;
  2018.  
  2019.         oline=linenumber;
  2020.  
  2021.         if(tok==tk_postnumber){
  2022.  
  2023.                 posttok=itok;
  2024.  
  2025.                 tok=tk_number;
  2026.  
  2027.         }
  2028.  
  2029.         if(tok==tk_number){
  2030.  
  2031.                 val=doconstdwordmath();
  2032.  
  2033.                 rflag=postnumflag;
  2034.  
  2035.         }
  2036.  
  2037.         else nexttok();
  2038.  
  2039.         CheckRegForLea16(reg,&idx,&base,&val,&rflag,&posttok);
  2040.  
  2041.         next=0;
  2042.  
  2043.         if(idx==-1)next=1;
  2044.  
  2045.         if(base==-1)next|=2;
  2046.  
  2047.         if(val==0&&rflag==0&&posttok.post==0)next|=4;
  2048.  
  2049.         switch(next){
  2050.  
  2051.                 case 0: //base+idx+num
  2052.  
  2053.                 case 1: //base+num
  2054.  
  2055. //              case 2: //idx+num
  2056.  
  2057. //              case 3: //num
  2058.  
  2059.                 case 4: //base+idx
  2060.  
  2061. //              case 6: //idx
  2062.  
  2063. //              case 7: //
  2064.  
  2065.                         break;
  2066.  
  2067.                 case 5: //base
  2068.  
  2069.                         if(am32==0)break;
  2070.  
  2071.                 default:
  2072.  
  2073. retfalse:
  2074.  
  2075.                         inptr2=oinptr;
  2076.  
  2077.                         cha2=ocha;
  2078.  
  2079.                         tok=otok;
  2080.  
  2081.                         itok=oitok;
  2082.  
  2083.                         tok2=otok2;
  2084.  
  2085.                         itok2.type=(unsigned short)otype2;
  2086.  
  2087.                         linenum2=linenumber=oline;
  2088.  
  2089.                         endoffile=0;
  2090.  
  2091.                         if(bufrm){
  2092.  
  2093.                                 free(bufrm);
  2094.  
  2095.                                 bufrm=NULL;
  2096.  
  2097.                         }
  2098.  
  2099.                         if(strinf.bufstr){
  2100.  
  2101.                                 free(strinf.bufstr);
  2102.  
  2103.                                 strinf.bufstr=NULL;
  2104.  
  2105.                         }
  2106.  
  2107.                         return FALSE;
  2108.  
  2109.         }
  2110.  
  2111.         OutLea16(reg,idx,base,val,rflag,&posttok);
  2112.  
  2113.         return TRUE;
  2114.  
  2115. }
  2116.  
  2117.  
  2118.  
  2119. int Reg16ToLea2(int reg)        //®¯â¨¬¨§ æ¨ï á«®¦¥­¨ï 16-¡¨â­ëå ॣ¨áâ஢ ¢ LEA
  2120.  
  2121. {
  2122.  
  2123. int idx,base;
  2124.  
  2125. unsigned long val;
  2126.  
  2127. int otok,otok2,otype2;
  2128.  
  2129. unsigned char ocha,next;
  2130.  
  2131. unsigned int oinptr,rflag;
  2132.  
  2133. int oline;
  2134.  
  2135. ITOK oitok;
  2136.  
  2137. ITOK posttok;
  2138.  
  2139.         if(cur_mod)return FALSE;
  2140.  
  2141.         posttok.post=0;
  2142.  
  2143.         if(tok==tk_plus&&((tok2==tk_reg&&itok2.number!=reg)||(tok2==tk_number&&itok2.rm!=tk_float&&itok2.rm!=tk_double))&&
  2144.  
  2145.                 (reg==BX||reg==BP||reg==SI||reg==DI)){
  2146.  
  2147.                 val=0;
  2148.  
  2149.                 rflag=0;
  2150.  
  2151.                 oinptr=inptr2;
  2152.  
  2153.                 ocha=cha2;
  2154.  
  2155.                 otok=tok;
  2156.  
  2157.                 oitok=itok;
  2158.  
  2159.                 otok2=tok2;
  2160.  
  2161.                 otype2=itok2.type;
  2162.  
  2163.                 oline=linenumber;
  2164.  
  2165.                 idx=-1;
  2166.  
  2167.                 base=reg;
  2168.  
  2169.                 CheckRegForLea16(reg,&idx,&base,&val,&rflag,&posttok);
  2170.  
  2171.                 next=0;
  2172.  
  2173.                 if(idx==-1)next=1;
  2174.  
  2175.                 if(base==-1)next|=2;
  2176.  
  2177.                 if(val==0&&rflag==0&&posttok.post==0)next|=4;
  2178.  
  2179.                 switch(next){
  2180.  
  2181.                         case 1: //base+num
  2182.  
  2183.                                 if(val<3&&rflag==0&&posttok.post==0)goto retfalse;
  2184.  
  2185.                         case 0: //base+idx+num
  2186.  
  2187. //              case 2: //idx+num
  2188.  
  2189. //              case 3: //num
  2190.  
  2191.                         case 4: //base+idx
  2192.  
  2193. //              case 6: //idx
  2194.  
  2195. //              case 7: //
  2196.  
  2197.                                 break;
  2198.  
  2199. //                      case 5: //base
  2200.  
  2201.                 default:
  2202.  
  2203. retfalse:
  2204.  
  2205.                         inptr2=oinptr;
  2206.  
  2207.                         cha2=ocha;
  2208.  
  2209.                         tok=otok;
  2210.  
  2211.                         itok=oitok;
  2212.  
  2213.                         tok2=otok2;
  2214.  
  2215.                         itok2.type=(unsigned short)otype2;
  2216.  
  2217.                         endoffile=0;
  2218.  
  2219.                         linenum2=linenumber=oline;
  2220.  
  2221.                         if(bufrm){
  2222.  
  2223.                                 free(bufrm);
  2224.  
  2225.                                 bufrm=NULL;
  2226.  
  2227.                         }
  2228.  
  2229.                         if(strinf.bufstr){
  2230.  
  2231.                                 free(strinf.bufstr);
  2232.  
  2233.                                 strinf.bufstr=NULL;
  2234.  
  2235.                         }
  2236.  
  2237.                         return FALSE;
  2238.  
  2239.                 }
  2240.  
  2241.                 OutLea16(reg,idx,base,val,rflag,&posttok);
  2242.  
  2243.                 return TRUE;
  2244.  
  2245.         }
  2246.  
  2247.         return FALSE;
  2248.  
  2249. }
  2250.  
  2251.  
  2252.  
  2253. int OptimNum()  //®¯â¨¬¨§ æ¨ï æ¨ä஢ëå ®¯¥à ­¤®¢
  2254.  
  2255. {
  2256.  
  2257. int otok,oinptr,deistv,negflag,starttok;
  2258.  
  2259. char ocha2;
  2260.  
  2261. long long val;
  2262.  
  2263. unsigned int flag,oflag;
  2264.  
  2265. int plusreloc=0;
  2266.  
  2267.         if(optnumber==FALSE||cur_mod)return FALSE;      //®¯â¨¬¨§ æ¨ï ®âª«î祭 
  2268.  
  2269.         if(tok==tk_minus&&(itok2.flag&f_reloc))return FALSE;
  2270.  
  2271.         deistv=0;
  2272.  
  2273.         negflag=0;
  2274.  
  2275.         starttok=otok=tok;
  2276.  
  2277.         oflag=itok.flag;
  2278.  
  2279.         oinptr=inptr2;
  2280.  
  2281.         ocha2=cha2;
  2282.  
  2283.         nexttok();
  2284.  
  2285.         flag=itok.flag;
  2286.  
  2287.         val=itok.lnumber;
  2288.  
  2289.         switch(otok){
  2290.  
  2291.                 case tk_minus:
  2292.  
  2293.                         val=-val;
  2294.  
  2295.                 case tk_plus:
  2296.  
  2297.                         for(;;){        //®¯â¨¬¨§ æ¨ï á«®¦¥­¨©-¢ëç¨â ­¨©
  2298.  
  2299.                                 nexttok();
  2300.  
  2301.                                 if((tok!=tk_plus&&tok!=tk_minus)||tok2!=tk_number||
  2302.  
  2303.                                                 (tok==tk_minus&&(itok2.flag&f_reloc)&&plusreloc==0)){//­¥ æëäà  ¨«¨ ¤à㣮¥ ¤¥©á⢨¥
  2304.  
  2305.                                         tok=otok;
  2306.  
  2307.                                         cha2=ocha2;
  2308.  
  2309.                                         inptr2=oinptr;
  2310.  
  2311.                                         endoffile=0;
  2312.  
  2313.                                         if(deistv==0)break;     //­¨ç¥£® ­¥ ¡ë«® ®¯â¨¬¨§¨à®¢ ­®
  2314.  
  2315.                                         warningoptnum();
  2316.  
  2317.                                         tok=tk_plus;
  2318.  
  2319.                                         itok.lnumber=val;
  2320.  
  2321.                                         itok.flag|=flag;
  2322.  
  2323.                                         return TRUE;
  2324.  
  2325.                                 }
  2326.  
  2327.                                 deistv=tok;
  2328.  
  2329.                                 nexttok();
  2330.  
  2331.                                 oinptr=inptr2;
  2332.  
  2333.                                 ocha2=cha2;
  2334.  
  2335.                                 if(deistv==tk_minus){
  2336.  
  2337.                                         val-=itok.lnumber;
  2338.  
  2339.                                         if(itok.flag&f_reloc)plusreloc--;
  2340.  
  2341.                                 }
  2342.  
  2343.                                 else{
  2344.  
  2345.                                         val+=itok.lnumber;
  2346.  
  2347.                                         if(itok.flag&f_reloc)plusreloc++;
  2348.  
  2349.                                 }
  2350.  
  2351.                                 flag^=itok.flag;
  2352.  
  2353.                         }
  2354.  
  2355.                         break;
  2356.  
  2357.                 case tk_divminus:
  2358.  
  2359.                         otok=tk_div;
  2360.  
  2361.                         goto LL1;
  2362.  
  2363.                 case tk_multminus:
  2364.  
  2365.                         otok=tk_mult;
  2366.  
  2367. LL1:
  2368.  
  2369.                         negflag=TRUE;
  2370.  
  2371.                 case tk_div:
  2372.  
  2373.                 case tk_mult:
  2374.  
  2375.                         for(;;){
  2376.  
  2377.                                 nexttok();
  2378.  
  2379.                                 if((tok!=tk_div&&tok!=tk_mult&&tok!=tk_divminus&&tok!=tk_multminus)||
  2380.  
  2381.                                     tok2!=tk_number||
  2382.  
  2383.                                                 (otok!=tok&&((val>itok2.lnumber&&(val%itok2.lnumber)!=0)
  2384.  
  2385.                                                 ||(val<itok2.lnumber&&(itok2.lnumber%val)!=0)))||
  2386.  
  2387.                                                 ((flag&f_reloc)&&(itok2.flag&f_reloc))){
  2388.  
  2389.                                         tok=starttok;
  2390.  
  2391.                                         cha2=ocha2;
  2392.  
  2393.                                         inptr2=oinptr;
  2394.  
  2395.                                         endoffile=0;
  2396.  
  2397.                                         if(deistv==0)break;
  2398.  
  2399.                                         warningoptnum();
  2400.  
  2401.                                         tok=otok;
  2402.  
  2403.                                         if(negflag==TRUE)val=-val;
  2404.  
  2405.                                         itok.lnumber=val;
  2406.  
  2407.                                         itok.flag|=flag;
  2408.  
  2409.                                         return TRUE;
  2410.  
  2411.                                 }
  2412.  
  2413.                                 if(tok==tk_divminus){
  2414.  
  2415.                                         tok=tk_div;
  2416.  
  2417.                                         negflag^=TRUE;
  2418.  
  2419.                                 }
  2420.  
  2421.                                 else if(tok==tk_multminus){
  2422.  
  2423.                                         tok=tk_mult;
  2424.  
  2425.                                         negflag^=TRUE;
  2426.  
  2427.                                 }
  2428.  
  2429.                                 deistv=tok;
  2430.  
  2431.                                 nexttok();
  2432.  
  2433.                                 oinptr=inptr2;
  2434.  
  2435.                                 ocha2=cha2;
  2436.  
  2437.                                 if(otok==deistv)val=val*itok.lnumber;
  2438.  
  2439.                                 else{
  2440.  
  2441.                                         if(val>itok.lnumber)val=val/itok.lnumber;
  2442.  
  2443.                                         else if(val<itok.lnumber){
  2444.  
  2445.                                                 val=itok.lnumber/val;
  2446.  
  2447.                                                 otok=deistv;
  2448.  
  2449.                                         }
  2450.  
  2451.                                         else{
  2452.  
  2453.                                                 val=1;
  2454.  
  2455.                                                 otok=tk_mult;
  2456.  
  2457.                                         }
  2458.  
  2459.                                 }
  2460.  
  2461.                                 flag|=itok.flag;
  2462.  
  2463.                         }
  2464.  
  2465.                         break;
  2466.  
  2467.                 default:
  2468.  
  2469.                         tok=starttok;
  2470.  
  2471.                         cha2=ocha2;
  2472.  
  2473.                         inptr2=oinptr;
  2474.  
  2475.                         itok.flag=oflag;
  2476.  
  2477.         }
  2478.  
  2479.         if(bufrm){
  2480.  
  2481.                 free(bufrm);
  2482.  
  2483.                 bufrm=NULL;
  2484.  
  2485.         }
  2486.  
  2487.         if(strinf.bufstr){
  2488.  
  2489.                 free(strinf.bufstr);
  2490.  
  2491.                 strinf.bufstr=NULL;
  2492.  
  2493.         }
  2494.  
  2495.         return FALSE;
  2496.  
  2497. }
  2498.  
  2499.  
  2500.  
  2501. int expandvar()
  2502.  
  2503. {
  2504.  
  2505.         if(divexpand==FALSE)return FALSE;
  2506.  
  2507.         for(int i=inptr2-1;;i++){
  2508.  
  2509.                 switch(input[i]){
  2510.  
  2511.                         case '"':
  2512.  
  2513.                         case ';':
  2514.  
  2515.                         case '*':
  2516.  
  2517.                         case '|':
  2518.  
  2519.                         case '^':
  2520.  
  2521.                         case ',':
  2522.  
  2523.                         case 0:
  2524.  
  2525.                         case '&': return FALSE;
  2526.  
  2527.                         case '/':
  2528.  
  2529.                                 i++;
  2530.  
  2531.                                 if(input[i]=='/'||input[i]=='*')return FALSE;
  2532.  
  2533.                         case '%': goto en;
  2534.  
  2535.                 }
  2536.  
  2537.         }
  2538.  
  2539. en:
  2540.  
  2541.         warningexpand();
  2542.  
  2543.         return TRUE;
  2544.  
  2545. }
  2546.  
  2547.  
  2548.  
  2549. void RegMulNum(int reg,unsigned long num,int razr,int sign,int *expand,int flag)
  2550.  
  2551. {
  2552.  
  2553. int vop,i=0;
  2554.  
  2555.         if((flag&f_reloc)!=0)goto num_imul;
  2556.  
  2557.         if(razr==r16)num&=0xffff;
  2558.  
  2559.         if(chip>2&&(*expand==FALSE)&&optimizespeed&&leamul32(num,reg,razr)){
  2560.  
  2561.                 setzeroflag=FALSE;
  2562.  
  2563.                 return;
  2564.  
  2565.         }
  2566.  
  2567.         switch(num){
  2568.  
  2569.                 case 0:
  2570.  
  2571.                         ZeroReg(reg,razr);
  2572.  
  2573.                         setzeroflag=TRUE;
  2574.  
  2575.                 case 1: *expand=FALSE; break; /* AX * 1 = AX */
  2576.  
  2577.                 case 2:  /* AX * 2 = ADD AX,AX */
  2578.  
  2579.                         if(*expand==TRUE){
  2580.  
  2581.                                 if(optimizespeed==FALSE)goto num_imul;
  2582.  
  2583.                                 if(sign)cwdq(razr);
  2584.  
  2585.                                 else{
  2586.  
  2587.                                         op66(razr);
  2588.  
  2589.                                         outword(0xD231);
  2590.  
  2591.                                 }
  2592.  
  2593.                         }
  2594.  
  2595.                         op66(razr);
  2596.  
  2597.                         op(1);
  2598.  
  2599.                         op(0xC0+9*reg); // ADD reg,reg
  2600.  
  2601.                         if(*expand==TRUE){
  2602.  
  2603.                                 op66(razr);
  2604.  
  2605.                                 outword(0xd283);        //adc dx,0
  2606.  
  2607.                                 op(0);
  2608.  
  2609.                                 ClearReg(DX);
  2610.  
  2611.                         }
  2612.  
  2613.                         setzeroflag=TRUE;
  2614.  
  2615.                         break;
  2616.  
  2617.                 default:
  2618.  
  2619.                         vop=caselong(num);
  2620.  
  2621.                         if(vop!=NUMNUM){
  2622.  
  2623.                                 if(chip<1&&razr==r16){
  2624.  
  2625.                                         if(*expand==TRUE){
  2626.  
  2627.                                                 if(optimizespeed==FALSE)goto num_imul;
  2628.  
  2629.                                                 op(0xB1);       op(vop); /* MOV CL,num */
  2630.  
  2631.                                                 op66(r16);
  2632.  
  2633.                                                 if(sign)op(0x99);
  2634.  
  2635.                                                 else outword(0xD231);
  2636.  
  2637.                                                 outdword(0xd213c001);   //ADD AX,AX ADC DX,DX
  2638.  
  2639.                                                 outword(0xfae2);  //LOOP -6
  2640.  
  2641.                                                 warningreg(regs[0][2]);
  2642.  
  2643.                                                 ClearReg(DX);
  2644.  
  2645.                                         }
  2646.  
  2647.                                         else{
  2648.  
  2649.                                                 if(reg==CX)goto num_imul;
  2650.  
  2651.                                                 if(vop>3){
  2652.  
  2653.                                                         for(;vop!=0;vop--){
  2654.  
  2655.                                                                 op66(r16);
  2656.  
  2657.                                                                 op(3);  //add
  2658.  
  2659.                                                                 op(0xc0+reg*9);
  2660.  
  2661.                                                         }
  2662.  
  2663.                                                         return;
  2664.  
  2665.                                                 }
  2666.  
  2667.                                                 op(0xB1);       op(vop); /* MOV CL,num */
  2668.  
  2669.                                                 op(0xD3);
  2670.  
  2671.                                                 op(0xE0+reg);   //SHL reg,CL
  2672.  
  2673.                                         }
  2674.  
  2675.                                         ConstToReg(vop,CL,r8);
  2676.  
  2677.                                         warningreg(begs[1]);
  2678.  
  2679.                                 }
  2680.  
  2681.                                 else{/* SHL AX,num */
  2682.  
  2683.                                         if(*expand==TRUE){
  2684.  
  2685.                                                 if(optimizespeed==FALSE)goto num_imul;
  2686.  
  2687. //                                              op66(razr);
  2688.  
  2689.                                                 ClearDX(razr,sign);
  2690.  
  2691. /*                                              if(sign)cwdq(razr);
  2692.  
  2693.                                                 else{
  2694.  
  2695.                                                         op66(razr);
  2696.  
  2697.                                                         outword(0xC031);
  2698.  
  2699.                                                 }*/
  2700.  
  2701.                                                 if(chip<3&&razr==r16){
  2702.  
  2703.                                                         op(0xB1);       op(vop); /* MOV CL,num */
  2704.  
  2705.                                                         outdword(0xd213c001);   //ADD AX,AX ADC DX,DX
  2706.  
  2707.                                                         outword(0xfae2);  //LOOP -6
  2708.  
  2709.                                                         ConstToReg(vop,CL,r8);
  2710.  
  2711.                                                         warningreg(begs[1]);
  2712.  
  2713.                                                 }
  2714.  
  2715.                                                 else{
  2716.  
  2717.                                                         op66(razr);
  2718.  
  2719.                                                         op(0x0f);
  2720.  
  2721.                                                         outword(0xC2a4);        //SHLD DX,AX,num
  2722.  
  2723.                                                         op(vop);
  2724.  
  2725.                                                         op66(razr);
  2726.  
  2727.                                                         outword(0xE0C1);        //SHL AX,num
  2728.  
  2729.                                                         op(vop);
  2730.  
  2731.                                                 }
  2732.  
  2733.                                                 ClearReg(DX);
  2734.  
  2735.                                                 warningreg(regs[razr/2-1][2]);
  2736.  
  2737.                                         }
  2738.  
  2739.                                         else{
  2740.  
  2741.                                                 op66(razr);
  2742.  
  2743.                                                 op(0xc1);
  2744.  
  2745.                                                 op(0xe0+reg); // SHL reg,imm8
  2746.  
  2747.                                                 op(vop);
  2748.  
  2749.                                                 if(cpu<2)cpu=2;
  2750.  
  2751.                                         }
  2752.  
  2753.                                 }
  2754.  
  2755.                                 setzeroflag=TRUE;
  2756.  
  2757.                                 break;
  2758.  
  2759.                         }
  2760.  
  2761.                         if(chip<7&&*expand==FALSE&&optimizespeed&&speedmul32(num,reg,razr))break;
  2762.  
  2763. num_imul:
  2764.  
  2765.                         if((razr==r16&&chip<2)||(*expand==TRUE)){
  2766.  
  2767.                                 if(reg==AX){
  2768.  
  2769.                                         op66(razr);
  2770.  
  2771.                                         op(0xB9);  /* MOV CX,# */
  2772.  
  2773.                                         if((flag&f_reloc)!=0)AddReloc();
  2774.  
  2775.                                         razr==r16?outword((unsigned int)num):outdword(num);
  2776.  
  2777.                                         op66(razr);
  2778.  
  2779.                                         if(sign)outword(0xE9F7); /* IMUL CX */
  2780.  
  2781.                                         else outword(0xE1F7); /* MUL CX */
  2782.  
  2783.                                         ConstToReg(num,CX,razr);
  2784.  
  2785.                                         warningreg(regs[razr/2-1][1]);
  2786.  
  2787.                                 }
  2788.  
  2789.                                 else{
  2790.  
  2791.                                         op66(r16);
  2792.  
  2793.                                         op(0x90+reg);   //XCHG AX,reg
  2794.  
  2795.                                         op66(r16);
  2796.  
  2797.                                         op(reg!=DX?0xBA:0xB9);
  2798.  
  2799.                                         outword(num);   //mov DX,num
  2800.  
  2801.                                         op66(r16);
  2802.  
  2803.                                         op(0xF7);
  2804.  
  2805.                                         op(reg!=DX?0xE2:0xE1);  // mul DX
  2806.  
  2807.                                         op66(r16);
  2808.  
  2809.                                         op(0x90+reg);   //XCHG AX,reg
  2810.  
  2811.                                         warningreg(regs[0][reg!=DX?2:1]);
  2812.  
  2813.                                         ClearReg(DX);
  2814.  
  2815.                                 }
  2816.  
  2817.                         }
  2818.  
  2819.                         else{
  2820.  
  2821.                                 if((flag&f_reloc)==0&&short_ok(num,razr/2-1))i=2;       //ª®à®âª ï ä®à¬ 
  2822.  
  2823.                                 op66(razr);
  2824.  
  2825.                                 op(0x69+i);     //imul
  2826.  
  2827.                                 op(0xc0+reg*9);
  2828.  
  2829.                                 if(i==2)op(num);
  2830.  
  2831.                                 else{
  2832.  
  2833.                                         if((flag&f_reloc)!=0)AddReloc();
  2834.  
  2835.                                         razr==r16?outword((unsigned int)num):outdword(num);
  2836.  
  2837.                                 }
  2838.  
  2839.                         }
  2840.  
  2841.                         setzeroflag=FALSE;
  2842.  
  2843.                         break;
  2844.  
  2845.         }
  2846.  
  2847. }
  2848.  
  2849.  
  2850.  
  2851. /* --------------- byte, char, word, int math starts ----------------- */
  2852.  
  2853.  
  2854.  
  2855. long long CalcNumber(int sign)
  2856.  
  2857. {
  2858.  
  2859. long long hold;
  2860.  
  2861.         switch(sign){
  2862.  
  2863.                 case 0:
  2864.  
  2865.                         hold=doconstdwordmath();
  2866.  
  2867.                         break;
  2868.  
  2869.                 case 1:
  2870.  
  2871.                         hold=doconstlongmath();
  2872.  
  2873.                         break;
  2874.  
  2875.                 case 2:
  2876.  
  2877.                         hold=doconstfloatmath();
  2878.  
  2879.                         break;
  2880.  
  2881.                 case 3:
  2882.  
  2883.                         hold=doconstdoublemath();
  2884.  
  2885.                         break;
  2886.  
  2887.                 default:
  2888.  
  2889.                         hold=doconstqwordmath();
  2890.  
  2891.                         break;
  2892.  
  2893.         }
  2894.  
  2895.         return hold;
  2896.  
  2897. }
  2898.  
  2899.  
  2900.  
  2901. int OnlyNumber(int sign)
  2902.  
  2903. /*-----------------11.09.00 12:44-------------------
  2904.  
  2905.  ¯à®¢¥à¨âì çâ® áâப  á®á⮨â ⮫쪮 ¨§ æ¨äà.
  2906.  
  2907. --------------------------------------------------*/
  2908.  
  2909. {
  2910.  
  2911. ITOK oitok=itok;
  2912.  
  2913. unsigned char ocha=cha2;
  2914.  
  2915. unsigned int oinptr=inptr2;
  2916.  
  2917. unsigned int otok2=tok2;
  2918.  
  2919. int otype2=itok2.type;
  2920.  
  2921.         itok.lnumber=CalcNumber(sign);
  2922.  
  2923. //      printf("tok=%d num=%d type=%d\n",tok,itok.number,itok.type);
  2924.  
  2925.         if(itok.type==tp_stopper){
  2926.  
  2927.                 return TRUE;    //⮫쪮 æ¨äàë
  2928.  
  2929.         }
  2930.  
  2931.         cha2=ocha;      //¢®áâ ­®¢¨âì ¨á室­®¥ á®áâ®ï­¨¥
  2932.  
  2933.         inptr2=oinptr;
  2934.  
  2935.         tok2=otok2;
  2936.  
  2937.         tok=tk_number;
  2938.  
  2939.         itok=oitok;
  2940.  
  2941.         itok2.type=(unsigned short)otype2;
  2942.  
  2943.         if(bufrm){
  2944.  
  2945.                 free(bufrm);
  2946.  
  2947.                 bufrm=NULL;
  2948.  
  2949.         }
  2950.  
  2951.         if(strinf.bufstr){
  2952.  
  2953.                 free(strinf.bufstr);
  2954.  
  2955.                 strinf.bufstr=NULL;
  2956.  
  2957.         }
  2958.  
  2959.         return FALSE;
  2960.  
  2961. }
  2962.  
  2963.  
  2964.  
  2965. void MultiAssignFloat(int type,int npointr=0)
  2966.  
  2967. {
  2968.  
  2969. int otok;
  2970.  
  2971. ITOK wtok;
  2972.  
  2973. char *wbuf;
  2974.  
  2975. SINFO wstr;
  2976.  
  2977. char *ofsstr=NULL;
  2978.  
  2979.         if(tok!=type)illegalfloat();
  2980.  
  2981.         wstr=strinf;
  2982.  
  2983.         strinf.bufstr=NULL;
  2984.  
  2985.         wtok=itok;
  2986.  
  2987.         wbuf=bufrm;
  2988.  
  2989.         bufrm=NULL;
  2990.  
  2991.         otok=tok;
  2992.  
  2993.         nexttok();
  2994.  
  2995. //      getoperand();
  2996.  
  2997. int numpointr=0;
  2998.  
  2999.         nexttok();
  3000.  
  3001.         if(tok==tk_float||tok==tk_double)nexttok();
  3002.  
  3003.         while(tok==tk_mult){
  3004.  
  3005.                 nexttok();
  3006.  
  3007.                 numpointr++;
  3008.  
  3009.         }
  3010.  
  3011.         if(numpointr>itok.npointr)unuseableinput();
  3012.  
  3013.         if(tok2==tk_assign)MultiAssignFloat(type,numpointr);
  3014.  
  3015.         else{
  3016.  
  3017.                 if(tok==tk_pointer)cpointr(BX,numpointr);
  3018.  
  3019.                 if(tok==tk_floatvar&&tok2==tk_semicolon){
  3020.  
  3021.                         tok=tk_dwordvar;
  3022.  
  3023.                         do_e_axmath(1,r32,&ofsstr);
  3024.  
  3025.                 }
  3026.  
  3027.                 else doeaxfloatmath(tk_reg32,AX);
  3028.  
  3029.         }
  3030.  
  3031.         if(otok==tk_pointer){
  3032.  
  3033.                 if(wtok.type==tk_proc){
  3034.  
  3035.                         wtok.rm=wtok.sib;
  3036.  
  3037.                         if(am32)wtok.sib=CODE32;
  3038.  
  3039.                         else wtok.sib=CODE16;
  3040.  
  3041.                         compressoffset(&wtok);
  3042.  
  3043.                 }
  3044.  
  3045.                 else{
  3046.  
  3047.                         int razr=typesize(itok.type);
  3048.  
  3049.                         if(npointr<=wtok.npointr)getpointeradr(&wtok,wbuf,&wstr,npointr-1,razr,BX);
  3050.  
  3051.                         else unuseableinput();
  3052.  
  3053.                         wtok=itok;
  3054.  
  3055.                 }
  3056.  
  3057.         }
  3058.  
  3059.         if((wtok.rm==rm_d16&&wtok.sib==CODE16)||(wtok.rm==rm_d32&&(wtok.sib==CODE32||wtok.sib==0))){
  3060.  
  3061.                 op66(r32);
  3062.  
  3063.                 outseg(&wtok,1);
  3064.  
  3065.                 op(0xA3); /* MOV [word],AX */
  3066.  
  3067.                 if(wtok.post==UNDEF_OFSET){
  3068.  
  3069.                         AddUndefOff(2,wtok.name);
  3070.  
  3071.                         wtok.post=0;
  3072.  
  3073.                 }
  3074.  
  3075.                 if(am32==FALSE)outword(wtok.number);    //????
  3076.  
  3077.                 else outdword(wtok.number);
  3078.  
  3079.         }
  3080.  
  3081.         else{
  3082.  
  3083.                 CheckAllMassiv(wbuf,r32,&wstr,&wtok);
  3084.  
  3085.                 op66(r32);
  3086.  
  3087.                 outseg(&wtok,2);
  3088.  
  3089.                 op(0x89); op(wtok.rm); /* MOV [rmword],reg */
  3090.  
  3091.                 outaddress(&wtok);
  3092.  
  3093.         }
  3094.  
  3095. }
  3096.  
  3097.  
  3098.  
  3099. int MultiAssign(int razr,int usereg,int npointr)
  3100.  
  3101. {
  3102.  
  3103. int otok;
  3104.  
  3105. ITOK wtok;
  3106.  
  3107. char *wbuf;
  3108.  
  3109. SINFO wstr;
  3110.  
  3111. int sign=0,rettype,nrazr,posiblret,pointr=0;
  3112.  
  3113. int hnumber=0;
  3114.  
  3115. int ureg;
  3116.  
  3117. char *ofsstr=NULL;
  3118.  
  3119.         wstr=strinf;
  3120.  
  3121.         strinf.bufstr=NULL;
  3122.  
  3123.         wtok=itok;
  3124.  
  3125.         wbuf=bufrm;
  3126.  
  3127.         bufrm=NULL;
  3128.  
  3129.         otok=tok;
  3130.  
  3131.         if(tok==tk_bits){
  3132.  
  3133.                 usereg=EAX;//USEONLY_AX;
  3134.  
  3135.                 nrazr=r32;
  3136.  
  3137.                 rettype=tk_dword;
  3138.  
  3139.                 int i=itok.bit.siz+itok.bit.ofs;
  3140.  
  3141.                 if(i<9){
  3142.  
  3143.                         nrazr=r8;
  3144.  
  3145.                         rettype=tk_byte;
  3146.  
  3147.                 }
  3148.  
  3149.                 else if(i<17){
  3150.  
  3151.                         rettype=tk_word;
  3152.  
  3153.                         nrazr=r16;
  3154.  
  3155.                 }
  3156.  
  3157.                 else if(i>32)nrazr=r64;
  3158.  
  3159.         }
  3160.  
  3161.         else{
  3162.  
  3163.                 nrazr=GetVarSize(tok);
  3164.  
  3165.                 switch(tok){
  3166.  
  3167.                         case tk_beg:
  3168.  
  3169.                                 ureg=itok.number;
  3170.  
  3171.                                 if(ureg>3)ureg-=4;
  3172.  
  3173.                                 if(usereg>ureg)usereg=ureg;
  3174.  
  3175.                                 break;
  3176.  
  3177.                         case tk_reg:
  3178.  
  3179.                         case tk_reg32:
  3180.  
  3181.                                 if(usereg>itok.number)usereg=itok.number;
  3182.  
  3183.                                 break;
  3184.  
  3185.                 }
  3186.  
  3187. //              if(tok==tk_beg)usereg|=USEFIRST4REG;
  3188.  
  3189.         }
  3190.  
  3191.         posiblret=nrazr;
  3192.  
  3193.         if(nrazr>razr&&nrazr<r64)razr=nrazr;
  3194.  
  3195.         switch ( razr ) {
  3196.  
  3197.                 case r8:
  3198.  
  3199.                         rettype=tk_byte;
  3200.  
  3201.                         break;
  3202.  
  3203.                 case r16:
  3204.  
  3205.                         rettype=tk_word;
  3206.  
  3207.                         break;
  3208.  
  3209.                 case r32:
  3210.  
  3211.                         rettype=tk_dword;
  3212.  
  3213.                         break;
  3214.  
  3215.         }
  3216.  
  3217.         nexttok();
  3218.  
  3219. int numpointr=0;
  3220.  
  3221.         ofsstr=GetLecsem(tk_assign,tk_semicolon);
  3222.  
  3223.         nexttok();
  3224.  
  3225.         convert_type(&sign,&rettype,&pointr);
  3226.  
  3227.         while(tok==tk_mult){
  3228.  
  3229.                 nexttok();
  3230.  
  3231.                 numpointr++;
  3232.  
  3233.         }
  3234.  
  3235.         if(numpointr>itok.npointr){
  3236.  
  3237.                 unuseableinput();
  3238.  
  3239.         }
  3240.  
  3241.         ureg=AX;
  3242.  
  3243.         if(tok2==tk_assign){
  3244.  
  3245.                 ureg=hnumber=MultiAssign(razr,usereg,numpointr);
  3246.  
  3247.                 if(ofsstr){
  3248.  
  3249.                         free(ofsstr);
  3250.  
  3251.                         ofsstr=NULL;
  3252.  
  3253.                 }
  3254.  
  3255.         }
  3256.  
  3257.         else{
  3258.  
  3259.                 if(tok==tk_pointer){
  3260.  
  3261.                         int reg=idxregs[2];
  3262.  
  3263.                         if(reg==ureg)reg=idxregs[1];
  3264.  
  3265.                         cpointr(reg,numpointr);
  3266.  
  3267.                 }
  3268.  
  3269.                 if(usereg==USEALLREG){
  3270.  
  3271.                         switch(tok){
  3272.  
  3273.                                 case tk_reg:
  3274.  
  3275.                                 case tk_reg32:
  3276.  
  3277.                                         usereg=itok.number;
  3278.  
  3279.                                         break;
  3280.  
  3281.                                 case tk_beg:
  3282.  
  3283.                                         usereg=(itok.number>3?itok.number-4:itok.number);
  3284.  
  3285.                                         break;
  3286.  
  3287.                                 default:
  3288.  
  3289.                                         usereg=EAX;
  3290.  
  3291.                                         break;
  3292.  
  3293.                         }
  3294.  
  3295.                 }
  3296.  
  3297.                 switch(rettype){
  3298.  
  3299.                         case tk_char:
  3300.  
  3301.                         case tk_byte:
  3302.  
  3303.                                 if(tok2==tk_semicolon&&usereg!=0&&usereg<4){
  3304.  
  3305.                                         ureg=hnumber=usereg;
  3306.  
  3307. //                                      if(tok==tk_beg&&itok.number<4)ureg=hnumber=itok.number;
  3308.  
  3309.                                         getintoreg(usereg,r16,sign,&ofsstr);
  3310.  
  3311.                                 }
  3312.  
  3313. /*                              if(tok2==tk_semicolon&&tok==tk_beg&&usereg<2){
  3314.  
  3315.                                         if((usereg==1&&itok.number<4)||usereg==0){
  3316.  
  3317.                                                 ureg=hnumber=itok.number;
  3318.  
  3319.                                                 nexttok();
  3320.  
  3321.                                                 break;
  3322.  
  3323.                                         }
  3324.  
  3325.                                 }*/
  3326.  
  3327.                                 else doalmath(sign,&ofsstr);
  3328.  
  3329.                                 if(ofsstr)IDZToReg(ofsstr,usereg,r8);
  3330.  
  3331.                                 break;
  3332.  
  3333.                         case tk_int:
  3334.  
  3335.                         case tk_word:
  3336.  
  3337.                                 if(tok2==tk_semicolon&&usereg!=0){
  3338.  
  3339.                                         ureg=hnumber=usereg;
  3340.  
  3341. //                                      if(tok==tk_reg)ureg=hnumber=itok.number;
  3342.  
  3343.                                         getintoreg(usereg,r16,sign,&ofsstr);
  3344.  
  3345.                                 }
  3346.  
  3347.                                 else do_e_axmath(sign,r16,&ofsstr);
  3348.  
  3349.                                 if(ofsstr)IDZToReg(ofsstr,usereg,r16);
  3350.  
  3351.                                 break;
  3352.  
  3353.                         case tk_float:
  3354.  
  3355.                                 doeaxfloatmath(tk_reg32,AX);
  3356.  
  3357.                                 break;
  3358.  
  3359.                         default:
  3360.  
  3361.                                 if(tok2==tk_semicolon&&usereg!=0&&tok!=tk_floatvar){
  3362.  
  3363.                                         ureg=hnumber=usereg;
  3364.  
  3365. //                                      if(tok==tk_reg32)ureg=hnumber=itok.number;
  3366.  
  3367.                                         getintoreg(usereg,r32,sign,&ofsstr);
  3368.  
  3369.                                 }
  3370.  
  3371.                                 else{
  3372.  
  3373.                                         if(tok==tk_floatvar&&tok2==tk_semicolon)tok=tk_dwordvar;
  3374.  
  3375.                                         do_e_axmath(sign,r32,&ofsstr);
  3376.  
  3377.                                 }
  3378.  
  3379.                                 if(ofsstr)IDZToReg(ofsstr,usereg,r32);
  3380.  
  3381.                                 break;
  3382.  
  3383.                 }
  3384.  
  3385.         }
  3386.  
  3387.         if(ofsstr){
  3388.  
  3389.                 free(ofsstr);
  3390.  
  3391.                 ofsstr=NULL;
  3392.  
  3393.         }
  3394.  
  3395.         switch ( nrazr ) {
  3396.  
  3397.                 case r8:
  3398.  
  3399.                         posiblret=tk_byte;
  3400.  
  3401.                         break;
  3402.  
  3403.                 case r16:
  3404.  
  3405.                         posiblret=tk_word;
  3406.  
  3407.                         break;
  3408.  
  3409.                 case r32:
  3410.  
  3411.                         posiblret=tk_dword;
  3412.  
  3413.                         break;
  3414.  
  3415.         }
  3416.  
  3417.         convert_returnvalue(posiblret,rettype);
  3418.  
  3419.         if(otok==tk_pointer)cwpointr(&wtok,wbuf,&wstr,&otok,npointr,ureg);
  3420.  
  3421.         switch ( otok ) {
  3422.  
  3423.                 case tk_intvar:
  3424.  
  3425.                 case tk_wordvar:
  3426.  
  3427.                 case tk_longvar:
  3428.  
  3429.                 case tk_dwordvar:
  3430.  
  3431.                 case tk_floatvar:
  3432.  
  3433. #ifdef OPTVARCONST
  3434.  
  3435.                         CheckRegToConst(hnumber,&wtok,otok>tk_wordvar?r32:r16);
  3436.  
  3437. #endif
  3438.  
  3439.                         KillVar(wtok.name);
  3440.  
  3441.                         AddRegVar(hnumber,razr,&wtok);
  3442.  
  3443.                         if(hnumber==0&&((wtok.rm==rm_d16&&wtok.sib==CODE16)||(wtok.rm==rm_d32&&(wtok.sib==CODE32||wtok.sib==0)))){
  3444.  
  3445.                                 op66(nrazr);
  3446.  
  3447.                                 outseg(&wtok,1);
  3448.  
  3449.                                 op(0xA3); /* MOV [word],AX */
  3450.  
  3451.                                 if(wtok.post==UNDEF_OFSET){
  3452.  
  3453.                                         AddUndefOff(2,wtok.name);
  3454.  
  3455.                                         wtok.post=0;
  3456.  
  3457.                                 }
  3458.  
  3459.                                 if(am32==FALSE)outword(wtok.number);    //????
  3460.  
  3461.                                 else outdword(wtok.number);
  3462.  
  3463.                         }
  3464.  
  3465.                         else{
  3466.  
  3467.                                 CheckAllMassiv(wbuf,nrazr,&wstr,&wtok);
  3468.  
  3469.                                 op66(nrazr);
  3470.  
  3471.                                 outseg(&wtok,2);
  3472.  
  3473.                                 op(0x89); op(wtok.rm+hnumber*8); /* MOV [rmword],reg */
  3474.  
  3475.                                 outaddress(&wtok);
  3476.  
  3477.                         }
  3478.  
  3479.                         break;
  3480.  
  3481.                 case tk_charvar:
  3482.  
  3483.                 case tk_bytevar:
  3484.  
  3485. #ifdef OPTVARCONST
  3486.  
  3487.                         CheckRegToConst(hnumber,&wtok,r8);
  3488.  
  3489. #endif
  3490.  
  3491.                         KillVar(wtok.name);
  3492.  
  3493.                         AddRegVar(hnumber,r8,&wtok);
  3494.  
  3495.                         if(hnumber==0&&((wtok.rm==rm_d16&&wtok.sib==CODE16)||(wtok.rm==rm_d32&&(wtok.sib==CODE32||wtok.sib==0)))){
  3496.  
  3497.                                 outseg(&wtok,1);
  3498.  
  3499.                                 op(0xA2);               /* MOV [byte],AL */
  3500.  
  3501.                                 if(wtok.post==UNDEF_OFSET){
  3502.  
  3503.                                         AddUndefOff(2,wtok.name);
  3504.  
  3505.                                         wtok.post=0;
  3506.  
  3507.                                 }
  3508.  
  3509.                                 if(am32==FALSE)outword(wtok.number);
  3510.  
  3511.                                 else outdword(wtok.number);
  3512.  
  3513.                         }
  3514.  
  3515.                         else{
  3516.  
  3517.                                 CheckAllMassiv(wbuf,1,&wstr,&wtok);
  3518.  
  3519.                                 outseg(&wtok,2);  /* MOV [rmbyte],AL */
  3520.  
  3521.                                 op(0x88);
  3522.  
  3523.                                 op(wtok.rm+hnumber*8);
  3524.  
  3525.                                 outaddress(&wtok);
  3526.  
  3527.                         }
  3528.  
  3529.                         break;
  3530.  
  3531.                 case tk_bits:
  3532.  
  3533.                         if(razr!=r64){
  3534.  
  3535.                                 op66(nrazr==r32?r32:r16);
  3536.  
  3537.                                 op(0x50);       //push eax
  3538.  
  3539.                                 if(ESPloc&&am32&&wtok.segm==SS)wtok.number+=4;
  3540.  
  3541.                                 reg2bits(&wtok,razr);
  3542.  
  3543.                                 op66(nrazr==r32?r32:r16);
  3544.  
  3545.                                 op(0x58);       //pop eax
  3546.  
  3547.                         }
  3548.  
  3549.                         else{
  3550.  
  3551.                                 op66(r32);
  3552.  
  3553.                                 op(0x50);       //push eax
  3554.  
  3555.                                 int siz=wtok.bit.siz;
  3556.  
  3557.                                 op66(r32);
  3558.  
  3559.                                 op(0x50);       //push eax
  3560.  
  3561.                                 wtok.bit.siz=32-wtok.bit.ofs;
  3562.  
  3563.                                 if(ESPloc&&am32&&wtok.segm==SS)wtok.number+=8;
  3564.  
  3565.                                 reg2bits(&wtok,r32);
  3566.  
  3567.                                 op66(r32);
  3568.  
  3569.                                 op(0x58);       //pop eax
  3570.  
  3571.                                 op66(r32);      //shr eax,size
  3572.  
  3573.                                 outword(0xE8C1);
  3574.  
  3575.                                 op(wtok.bit.siz);
  3576.  
  3577.                                 wtok.bit.siz=siz+wtok.bit.ofs-32;
  3578.  
  3579.                                 wtok.bit.ofs=0;
  3580.  
  3581.                                 wtok.number+=4;
  3582.  
  3583.                                 reg2bits(&wtok,r8);
  3584.  
  3585.                                 op66(r32);
  3586.  
  3587.                                 op(0x58);       //pop eax
  3588.  
  3589.                         }
  3590.  
  3591.                         break;
  3592.  
  3593.                 case tk_reg:
  3594.  
  3595.                 case tk_reg32:
  3596.  
  3597.                         if(wtok.number!=hnumber){
  3598.  
  3599.                                 if(RegToReg(hnumber,wtok.number,nrazr)==NOINREG){
  3600.  
  3601.                                         op66(nrazr);
  3602.  
  3603.                                         op(0x89);
  3604.  
  3605.                                         op(0xC0+wtok.number+hnumber*8); //mov reg,AX
  3606.  
  3607.                                 }
  3608.  
  3609.                                 else waralreadinitreg(regs[nrazr/4][wtok.number],regs[nrazr/4][hnumber]);
  3610.  
  3611.                         }
  3612.  
  3613.                         break;
  3614.  
  3615.                 case tk_beg:
  3616.  
  3617.                         if(razr>r8&&wtok.number>3&&(wtok.number%4)==hnumber)preerror("register AH,BH,CH,DH should be first");
  3618.  
  3619.                         if(wtok.number!=hnumber){
  3620.  
  3621.                                 if(RegToReg(hnumber,wtok.number,r8)==NOINREG){
  3622.  
  3623.                                         op(0x88);
  3624.  
  3625.                                         op(0xC0+wtok.number+hnumber*8); //mov beg,AL
  3626.  
  3627.                                 }
  3628.  
  3629.                                 else waralreadinitreg(begs[wtok.number],begs[hnumber]);
  3630.  
  3631.                         }
  3632.  
  3633.                         break;
  3634.  
  3635.                 case tk_seg:
  3636.  
  3637.                         op(0x8E);       /* MOV SEG,AX */
  3638.  
  3639.                         op(0xC0+wtok.number*8+hnumber);
  3640.  
  3641.                         break;
  3642.  
  3643.                 default:
  3644.  
  3645.                         thisundefined(wtok.name);
  3646.  
  3647.         }
  3648.  
  3649.         return hnumber;
  3650.  
  3651. }
  3652.  
  3653.  
  3654.  
  3655. int do_d_wordvar(int sign,int razr,int terminater)      //signed or unsigned 16 or 32 bit memory variable
  3656.  
  3657. {
  3658.  
  3659. unsigned char next=1,getfromAX=0;
  3660.  
  3661. unsigned int vop=0,otok,rettype,posiblret;
  3662.  
  3663. ITOK wtok;
  3664.  
  3665. char *wbuf,*rbuf;
  3666.  
  3667. SINFO wstr;
  3668.  
  3669. int retrez=0,pointr=0,hnumber=EAX;
  3670.  
  3671. int numpointr=0;
  3672.  
  3673. char *ofsstr=NULL;
  3674.  
  3675. int reg1=idxregs[0],reg2=idxregs[1];
  3676.  
  3677. #ifdef OPTVARCONST
  3678.  
  3679. int initconst=FALSE;
  3680.  
  3681. int operand;
  3682.  
  3683. #endif
  3684.  
  3685. unsigned int oaddESP=addESP;
  3686.  
  3687. //      sign==0?rettype=(razr==r16?tk_word:tk_dword):rettype=(razr==r16?tk_int:tk_long);
  3688.  
  3689.         posiblret=rettype=(sign==0?(razr==r16?tk_word:tk_dword):(razr==r16?tk_int:tk_long));
  3690.  
  3691.         wstr=strinf;
  3692.  
  3693.         strinf.bufstr=NULL;
  3694.  
  3695.         wtok=itok;
  3696.  
  3697.         wbuf=bufrm;
  3698.  
  3699.         bufrm=NULL;
  3700.  
  3701.         otok=tok;
  3702.  
  3703.         while(RmEqualReg(hnumber,itok.rm,itok.sib))hnumber++;
  3704.  
  3705.         nexttok();
  3706.  
  3707. #ifdef OPTVARCONST
  3708.  
  3709.         operand=tok;
  3710.  
  3711. #endif
  3712.  
  3713.         switch(tok){
  3714.  
  3715.                 case tk_assign: //=
  3716.  
  3717.                         if(!((tok2==tk_reg||tok2==tk_reg32)&&ScanTok3()==terminater)){
  3718.  
  3719.                                 ofsstr=GetLecsem(terminater);
  3720.  
  3721.                         }
  3722.  
  3723.                         if(ofsstr){
  3724.  
  3725.                                 int retreg;
  3726.  
  3727.                                 if((retreg=CheckIDZReg(ofsstr,AX,razr))!=NOINREG){
  3728.  
  3729.                                         GetEndLex(terminater);
  3730.  
  3731.                                         if(retreg==SKIPREG)retreg=AX;
  3732.  
  3733.                                         if((GetRegVar(&wtok)&(1<<retreg))!=0){
  3734.  
  3735.                                                 free(ofsstr);
  3736.  
  3737.                                                 if(wbuf)free(wbuf);
  3738.  
  3739.                                                 if(wstr.bufstr)free(wstr.bufstr);
  3740.  
  3741.                                                 break;
  3742.  
  3743.                                         }
  3744.  
  3745.                                         if(razr==r16)tok=tk_reg;
  3746.  
  3747.                                         else tok=tk_reg32;
  3748.  
  3749.                                         itok.number=retreg;
  3750.  
  3751.                                         if(reg1==itok.number){
  3752.  
  3753.                                                 reg1=idxregs[1]; reg2=idxregs[2];
  3754.  
  3755.                                         }
  3756.  
  3757.                                         if(reg2==itok.number){
  3758.  
  3759.                                                 reg2=idxregs[2];
  3760.  
  3761.                                         }
  3762.  
  3763.                                         goto regtovar;
  3764.  
  3765.                                 }
  3766.  
  3767.                         }
  3768.  
  3769.                         nexttok();
  3770.  
  3771. //                      printf("tok=%d %s\n",tok,itok.name);
  3772.  
  3773.                         convert_type(&sign,(int *)&rettype,&pointr);
  3774.  
  3775.                         while(tok==tk_mult){
  3776.  
  3777.                                 nexttok();
  3778.  
  3779.                                 numpointr++;
  3780.  
  3781.                         }
  3782.  
  3783.                         if(numpointr>itok.npointr){
  3784.  
  3785.                                 unuseableinput();
  3786.  
  3787.                         }
  3788.  
  3789.                         if(tok2==tk_assign){
  3790.  
  3791.                                 hnumber=MultiAssign(razr,USEALLREG,numpointr);
  3792.  
  3793.                                 if(ofsstr){
  3794.  
  3795.                                         free(ofsstr);
  3796.  
  3797.                                         ofsstr=NULL;
  3798.  
  3799.                                 }
  3800.  
  3801.                                 next=0;
  3802.  
  3803.                                 goto getfromax;
  3804.  
  3805.                         }
  3806.  
  3807.                         if(tok==tk_pointer)cpointr(am32==TRUE?EAX:BX,numpointr);
  3808.  
  3809.                         CheckMinusNum();
  3810.  
  3811. //                      printf("tok=%d tok2=%d\n",tok,tok2);
  3812.  
  3813.                         if(itok2.type==tp_opperand){    //á«®¦­®¥ ¢ëà ¦¥­¨¥
  3814.  
  3815.                                 if(tok==tk_number){     //¯à®¢¥àª  ¨ á㬬¨à®¢ ­¨¥ ç¨á¥«
  3816.  
  3817.                                         if(OnlyNumber(rettype==tk_float?2:sign)){
  3818.  
  3819.                                                 next=0;
  3820.  
  3821.                                                 itok.flag=(unsigned char)postnumflag;
  3822.  
  3823.                                                 if(postnumflag==0)goto loadconst;
  3824.  
  3825.                                                 goto numbertovar;
  3826.  
  3827.                                         }
  3828.  
  3829.                                 }
  3830.  
  3831.                                 goto labl1;
  3832.  
  3833.                         }
  3834.  
  3835.                         else{
  3836.  
  3837. //                              if(hnumber!=EAX&&(tok==tk_reg||tok==tk_reg32)&&itok.number==EAX)goto labl1;
  3838.  
  3839. #ifdef OPTVARCONST
  3840.  
  3841.                                 CheckConstVar3(&tok,&itok,razr);
  3842.  
  3843. #endif
  3844.  
  3845.                                 switch(tok){
  3846.  
  3847.                                         case tk_number:
  3848.  
  3849. loadconst:
  3850.  
  3851.                                                 if((itok.flag&f_reloc)==0){
  3852.  
  3853. #ifdef OPTVARCONST
  3854.  
  3855.                                                         if(razr==r16)itok.lnumber&=0xffff;
  3856.  
  3857.                                                         else itok.lnumber&=0xffffffff;
  3858.  
  3859.                                                         if((initconst=Const2Var(&wtok,itok.lnumber,itok.rm))==FALSE){
  3860.  
  3861.                                                                 waralreadinitvar(wtok.name,itok.number);
  3862.  
  3863.                                                                 initconst=TRUE;
  3864.  
  3865.                                                                 break;
  3866.  
  3867.                                                         }
  3868.  
  3869. #endif
  3870.  
  3871.                                                         if(itok.number==0){
  3872.  
  3873.                                                                 CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  3874.  
  3875.                                                                 op66(razr);
  3876.  
  3877.                                                                 outseg(&wtok,2);
  3878.  
  3879.                                                                 op(0x83);
  3880.  
  3881.                                                                 op(wtok.rm+0x20);
  3882.  
  3883.                                                                 outaddress(&wtok);
  3884.  
  3885.                                                                 op(0);
  3886.  
  3887.                                                                 break;
  3888.  
  3889.                                                         }
  3890.  
  3891.                                                         if((razr==r32&&itok.number==0xFFFFFFFF)||(razr==r16&&itok.number==0xFFFF)){
  3892.  
  3893.                                                                 CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  3894.  
  3895.                                                                 op66(razr);
  3896.  
  3897.                                                                 outseg(&wtok,2);
  3898.  
  3899.                                                                 op(0x83);
  3900.  
  3901.                                                                 op(wtok.rm+0x8);
  3902.  
  3903.                                                                 outaddress(&wtok);
  3904.  
  3905.                                                                 op(0xFF);
  3906.  
  3907.                                                                 break;
  3908.  
  3909.                                                         }
  3910.  
  3911.                                                         if(regoverstack&&razr==r32&&short_ok(itok.number,TRUE)){
  3912.  
  3913.                                                                 CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  3914.  
  3915.                                                                 op66(razr);
  3916.  
  3917.                                                                 op(0x6A);
  3918.  
  3919.                                                                 op(itok.number);        //push short number
  3920.  
  3921.                                                                 op66(razr);
  3922.  
  3923.                                                                 outseg(&wtok,2);
  3924.  
  3925.                                                                 op(0x8f);
  3926.  
  3927.                                                                 op(wtok.rm);
  3928.  
  3929.                                                                 outaddress(&wtok);
  3930.  
  3931.                                                                 break;
  3932.  
  3933.                                                         }
  3934.  
  3935.                                                 }
  3936.  
  3937.                                         case tk_postnumber:
  3938.  
  3939.                                         case tk_undefofs:
  3940.  
  3941. numbertovar:
  3942.  
  3943.                                                 CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  3944.  
  3945.                                                 op66(razr);
  3946.  
  3947.                                                 outseg(&wtok,2);
  3948.  
  3949.                                                 op(0xC7);       //mov word[],number
  3950.  
  3951.                                                 op(wtok.rm);
  3952.  
  3953.                                                 outaddress(&wtok);
  3954.  
  3955.                                                 if(tok==tk_postnumber)(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
  3956.  
  3957.                                                 else if(tok==tk_undefofs)AddUndefOff(0,itok.name);
  3958.  
  3959.                                                 else if((itok.flag&f_reloc)!=0)AddReloc();
  3960.  
  3961.                                                 if(razr==r16){
  3962.  
  3963.                                                         if(am32!=FALSE&&tok!=tk_number)dwordvalexpected();
  3964.  
  3965.                                                         outword((unsigned int)itok.number);
  3966.  
  3967.                                                 }
  3968.  
  3969.                                                 else outdword(itok.number);
  3970.  
  3971.                                                 break;
  3972.  
  3973.                                         case tk_apioffset:
  3974.  
  3975.                                                 CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  3976.  
  3977.                                                 op66(razr);
  3978.  
  3979.                                                 outseg(&wtok,2);
  3980.  
  3981.                                                 op(0xC7);       //mov word[],number
  3982.  
  3983.                                                 op(wtok.rm);
  3984.  
  3985.                                                 outaddress(&wtok);
  3986.  
  3987.                                                 AddApiToPost(itok.number);
  3988.  
  3989.                                                 break;
  3990.  
  3991.                                         case tk_reg32:
  3992.  
  3993. //                                              if(razr==r16)goto labl1;
  3994.  
  3995.                                         case tk_reg:
  3996.  
  3997.                                                 if(razr==r32&&tok==tk_reg)goto labl1;
  3998.  
  3999. regtovar:
  4000.  
  4001.                                                 if((unsigned int)itok.number==0){
  4002.  
  4003.                                                         getfromAX=1;
  4004.  
  4005.                                                         hnumber=0;
  4006.  
  4007.                                                 }
  4008.  
  4009.                                                 else{
  4010.  
  4011. //                                                      if(wbuf==0&&wstr.bufstr==NULL){
  4012.  
  4013.                                                                 KillVar(wtok.name);
  4014.  
  4015.                                                                 AddRegVar(itok.number,razr,&wtok);
  4016.  
  4017.                                                                 vop++;
  4018.  
  4019. //                                                      }
  4020.  
  4021.                                                         CheckAllMassiv(wbuf,razr,&wstr,&wtok,reg1,reg2);
  4022.  
  4023.                                                         op66(razr);
  4024.  
  4025.                                                         outseg(&wtok,2);
  4026.  
  4027.                                                         op(0x89);
  4028.  
  4029.                                                         op((unsigned int)itok.number*8+wtok.rm);
  4030.  
  4031.                                                         outaddress(&wtok);
  4032.  
  4033.                                                 }
  4034.  
  4035.                                                 break;
  4036.  
  4037.                                         case tk_seg:
  4038.  
  4039.                                                 if(razr==r32)goto labl1;
  4040.  
  4041.                                                 CheckAllMassiv(wbuf,2,&wstr,&wtok);
  4042.  
  4043.                                                 op66(r16);
  4044.  
  4045.                                                 outseg(&wtok,2);
  4046.  
  4047.                                                 op(0x8C);
  4048.  
  4049.                                                 op((unsigned int)itok.number*8+wtok.rm);
  4050.  
  4051.                                                 outaddress(&wtok);
  4052.  
  4053.                                                 if((unsigned int)itok.number==FS||(unsigned int)itok.number==GS)if(cpu<3)cpu=3;
  4054.  
  4055.                                                 break;
  4056.  
  4057.                                         case tk_string:
  4058.  
  4059.                                                 CheckAllMassiv(wbuf,1,&wstr,&wtok);
  4060.  
  4061.                                                 op66(razr);
  4062.  
  4063.                                                 outseg(&wtok,2);
  4064.  
  4065.                                                 op(0xC7);
  4066.  
  4067.                                                 op(wtok.rm);
  4068.  
  4069.                                                 outaddress(&wtok);
  4070.  
  4071.                                                 if(razr==r16){
  4072.  
  4073.                                                         if(am32)dwordvalexpected();
  4074.  
  4075.                                                         outword(addpoststring());
  4076.  
  4077.                                                 }
  4078.  
  4079.                                                 else outdword(addpoststring());
  4080.  
  4081.                                                 break;
  4082.  
  4083.                                         case tk_doublevar:
  4084.  
  4085.                                                 vop=4;
  4086.  
  4087.                                         case tk_floatvar:
  4088.  
  4089.                                                 intinstack(vop);
  4090.  
  4091.                                                 getfromAX=0;
  4092.  
  4093.                                                 CheckAllMassiv(wbuf,4,&wstr,&wtok);
  4094.  
  4095.                                                 outseg(&wtok,2);        //fistp var
  4096.  
  4097.                                                 op(razr==r16?0xDF:0xDB);
  4098.  
  4099.                                                 op(wtok.rm+0x18);
  4100.  
  4101.                                                 outaddress(&wtok);
  4102.  
  4103.                                                 if(sign==0)warningretsign();
  4104.  
  4105.                                                 fwait3();
  4106.  
  4107.                                                 hnumber=EAX;
  4108.  
  4109.                                                 break;
  4110.  
  4111.                                         case tk_new:
  4112.  
  4113.                                                 donew();
  4114.  
  4115.                                                 getfromAX=1;
  4116.  
  4117.                                                 clearregstat();
  4118.  
  4119. #ifdef OPTVARCONST
  4120.  
  4121.                                                 FreeGlobalConst();
  4122.  
  4123. #endif
  4124.  
  4125.                                                 if(ofsstr){
  4126.  
  4127.                                                         free(ofsstr);
  4128.  
  4129.                                                         ofsstr=NULL;
  4130.  
  4131.                                                 }
  4132.  
  4133.                                                 hnumber=0;
  4134.  
  4135.                                                 break;
  4136.  
  4137.                                         case tk_delete:
  4138.  
  4139.                                                 dodelete();
  4140.  
  4141.                                                 terminater=next=0;
  4142.  
  4143.                                                 getfromAX=1;
  4144.  
  4145.                                                 clearregstat();
  4146.  
  4147. #ifdef OPTVARCONST
  4148.  
  4149.                                                 FreeGlobalConst();
  4150.  
  4151. #endif
  4152.  
  4153.                                                 if(ofsstr)free(ofsstr);
  4154.  
  4155.                                                 hnumber=0;
  4156.  
  4157.                                                 break;
  4158.  
  4159.                                         case tk_longvar:
  4160.  
  4161.                                         case tk_dwordvar:
  4162.  
  4163.                                                 if((rettype==tk_long||rettype==tk_dword)&&hnumber&&regoverstack)goto pushvar;
  4164.  
  4165.                                                 goto labl1;
  4166.  
  4167.                                         case tk_intvar:
  4168.  
  4169.                                         case tk_wordvar:
  4170.  
  4171.                                                 if((rettype==tk_int||rettype==tk_word)&&hnumber&&regoverstack){
  4172.  
  4173. pushvar:
  4174.  
  4175.                                                         CheckAllMassiv(bufrm,razr,&strinf);
  4176.  
  4177.                                                         op66(razr);
  4178.  
  4179.                                                         outseg(&itok,2);
  4180.  
  4181.                                                         op(0xFF);       // PUSH [dword]
  4182.  
  4183.                                                         op(0x30+itok.rm);
  4184.  
  4185.                                                         outaddress(&itok);
  4186.  
  4187.                                                         CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  4188.  
  4189.                                                         op66(razr);
  4190.  
  4191.                                                         outseg(&wtok,2);
  4192.  
  4193.                                                         op(0x8f);
  4194.  
  4195.                                                         op(wtok.rm);
  4196.  
  4197.                                                         outaddress(&wtok);
  4198.  
  4199.                                                         break;
  4200.  
  4201.                                                 }
  4202.  
  4203.                                                 goto labl1;
  4204.  
  4205.                                         default:
  4206.  
  4207. labl1:
  4208.  
  4209.                                                 getfromAX=1;
  4210.  
  4211.                                                 if(rettype==tk_char||rettype==tk_byte){
  4212.  
  4213.                                                         if(hnumber==0)retrez=doalmath(sign,&ofsstr);
  4214.  
  4215.                                                         else{
  4216.  
  4217.                                                                 retrez=getintoreg(hnumber,razr,sign,&ofsstr);
  4218.  
  4219.                                                                 posiblret=rettype;
  4220.  
  4221.                                                         }
  4222.  
  4223.                                                 }
  4224.  
  4225.                                                 else if(rettype==tk_int||rettype==tk_word){
  4226.  
  4227.                                                         if(hnumber==0)retrez=do_e_axmath(sign,r16,&ofsstr);
  4228.  
  4229.                                                         else retrez=getintoreg(hnumber,r16,sign,&ofsstr);
  4230.  
  4231.                                                 }
  4232.  
  4233.                                                 else if(rettype==tk_float||rettype==tk_double){
  4234.  
  4235.                                                         doeaxfloatmath(tk_fpust,AX,rettype==tk_float?0:4);
  4236.  
  4237.                                                         getfromAX=0;
  4238.  
  4239.                                                         CheckAllMassiv(wbuf,4,&wstr,&wtok);
  4240.  
  4241.                                                         outseg(&wtok,2);        //fistp var
  4242.  
  4243.                                                         op(razr==r16?0xDF:0xDB);
  4244.  
  4245.                                                         op(wtok.rm+0x18);
  4246.  
  4247.                                                         outaddress(&wtok);
  4248.  
  4249.                                                         if(sign==0)warningretsign();
  4250.  
  4251.                                                         fwait3();
  4252.  
  4253.                                                         hnumber=EAX;
  4254.  
  4255.                                                 }
  4256.  
  4257.                                                 else{
  4258.  
  4259.                                                         if(hnumber==0)retrez=do_e_axmath(sign,r32,&ofsstr);
  4260.  
  4261.                                                         else retrez=getintoreg(hnumber,r32,sign,&ofsstr);
  4262.  
  4263.                                                 }
  4264.  
  4265.                                                 next=0;
  4266.  
  4267.                                                 break;
  4268.  
  4269.                                 }
  4270.  
  4271.                         }
  4272.  
  4273.                         if(getfromAX){
  4274.  
  4275. getfromax:
  4276.  
  4277. #ifdef OPTVARCONST
  4278.  
  4279.                                 initconst=CheckRegToConst(hnumber,&wtok,razr);
  4280.  
  4281. #endif
  4282.  
  4283.                                 if(retrez==0)retrez=razr==r16?tk_reg:tk_reg32;
  4284.  
  4285.                                 convert_returnvalue(posiblret,rettype);
  4286.  
  4287.                                 if(addESP!=oaddESP&&am32&&ESPloc&&(wtok.type==tp_paramvar||wtok.type==tp_localvar))wtok.number+=addESP-oaddESP;
  4288.  
  4289.                                 if(wbuf==NULL&&wstr.bufstr==NULL&&hnumber==0&&
  4290.  
  4291.                                                 ((wtok.rm==rm_d16&&wtok.sib==CODE16)||
  4292.  
  4293.                                                 (wtok.rm==rm_d32&&(wtok.sib==CODE32||wtok.sib==0)))){
  4294.  
  4295.                                         op66(razr);
  4296.  
  4297.                                         outseg(&wtok,1);
  4298.  
  4299.                                         op(0xA3); // MOV [word],AX
  4300.  
  4301.                                         if(wtok.post==UNDEF_OFSET){
  4302.  
  4303.                                                 AddUndefOff(2,wtok.name);
  4304.  
  4305.                                                 wtok.post=0;
  4306.  
  4307.                                         }
  4308.  
  4309.                                         if(am32==FALSE)outword(wtok.number);    //????
  4310.  
  4311.                                         else outdword(wtok.number);
  4312.  
  4313.                                 }
  4314.  
  4315.                                 else{
  4316.  
  4317.                                         CheckAllMassiv(wbuf,razr,&wstr,&wtok,reg1,reg2);
  4318.  
  4319. //      printf("flag=%08X rm=%d num=%d post=%d sib=%d\n",wtok.flag,wtok.rm,wtok.number,wtok.post,wtok.sib);
  4320.  
  4321.                                         op66(razr);
  4322.  
  4323.                                         outseg(&wtok,2);
  4324.  
  4325.                                         op(0x89); op(wtok.rm+hnumber*8); // MOV [rmword],AX
  4326.  
  4327.                                         outaddress(&wtok);
  4328.  
  4329.                                 }
  4330.  
  4331.                                 if(ofsstr)IDZToReg(ofsstr,hnumber,razr);
  4332.  
  4333.                                 else ClearReg(hnumber);
  4334.  
  4335.                                 KillVar(wtok.name);
  4336.  
  4337.                                 AddRegVar(hnumber,razr,&wtok);
  4338.  
  4339.                         }
  4340.  
  4341.                         else{
  4342.  
  4343. //                              printf("vop=%d %s\n",vop,wtok.name);
  4344.  
  4345.                                 if(vop==0)KillVar(wtok.name);
  4346.  
  4347.                         }
  4348.  
  4349.                         if(ofsstr)free(ofsstr);
  4350.  
  4351.                         break;
  4352.  
  4353.                 case tk_minusminus: vop=0x8;
  4354.  
  4355.                 case tk_plusplus:
  4356.  
  4357. #ifdef OPTVARCONST
  4358.  
  4359.                         initconst=UpdVarConst(&wtok,1,tk_byte,tok);
  4360.  
  4361. #endif
  4362.  
  4363.                         CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  4364.  
  4365.                         op66(razr);
  4366.  
  4367.                         outseg(&wtok,2);
  4368.  
  4369.                         op(0xFF); op(vop+wtok.rm);
  4370.  
  4371.                         outaddress(&wtok);
  4372.  
  4373.                         KillVar(wtok.name);
  4374.  
  4375.                         break;
  4376.  
  4377.                 case tk_cdecl:
  4378.  
  4379.                 case tk_pascal:
  4380.  
  4381.                 case tk_fastcall:
  4382.  
  4383.                 case tk_stdcall:
  4384.  
  4385.                         vop=tok;
  4386.  
  4387.                         nexttok();
  4388.  
  4389.                         if(tok!=tk_openbracket){
  4390.  
  4391.                                 expected('(');
  4392.  
  4393.                                 FindStopTok();
  4394.  
  4395.                         }
  4396.  
  4397.                 case tk_openbracket:    //¢ë§®¢ ¯à®æ¥¤ãàë ¯®  ¤à¥áã ¢ ॣ¨áâà¥
  4398.  
  4399.                         param[0]=0;
  4400.  
  4401.                         int i;
  4402.  
  4403.                         i=0;
  4404.  
  4405.                         switch ( vop ) {
  4406.  
  4407.                                 case tk_cdecl:
  4408.  
  4409.                                 case tk_stdcall:
  4410.  
  4411.                                         i=swapparam();
  4412.  
  4413.                                         break;
  4414.  
  4415.                                 case tk_pascal:
  4416.  
  4417.                                         doparams();
  4418.  
  4419.                                         break;
  4420.  
  4421.                                 case tk_fastcall:
  4422.  
  4423.                                         doregparams();
  4424.  
  4425.                                         break;
  4426.  
  4427.                                 default:
  4428.  
  4429.                                         if(comfile==file_w32)swapparam();
  4430.  
  4431.                                         else doparams();
  4432.  
  4433.                         }
  4434.  
  4435.                         if(vop!=tk_cdecl)i=0;
  4436.  
  4437.                         CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  4438.  
  4439.                         outseg(&wtok,2);
  4440.  
  4441.                         op(0xFF); op(0x10+wtok.rm);
  4442.  
  4443.                         outaddress(&wtok);
  4444.  
  4445.                         clearregstat();
  4446.  
  4447. #ifdef OPTVARCONST
  4448.  
  4449.                         FreeGlobalConst();
  4450.  
  4451. #endif
  4452.  
  4453.                         if(i)CorrectStack(i);
  4454.  
  4455.                         break;
  4456.  
  4457.                 case tk_xorequals: vop+=0x08;
  4458.  
  4459.                 case tk_minusequals: vop+=0x08;
  4460.  
  4461.                 case tk_andequals: vop+=0x18;
  4462.  
  4463.                 case tk_orequals: vop+=0x08;
  4464.  
  4465.                 case tk_plusequals:
  4466.  
  4467.                         getoperand(am32==TRUE?EAX:BX);
  4468.  
  4469.                         if(tok==tk_float){
  4470.  
  4471.                                 getoperand(am32==TRUE?EAX:BX);
  4472.  
  4473.                                 doeaxfloatmath(tk_reg32,AX);
  4474.  
  4475.                                 goto axtovar;
  4476.  
  4477.                         }
  4478.  
  4479.                         if(itok2.type==tp_opperand){
  4480.  
  4481.                                 if(tok==tk_number){
  4482.  
  4483.                                         if(OnlyNumber(sign)){
  4484.  
  4485.                                                 next=0;
  4486.  
  4487.                                                 otok=tok;
  4488.  
  4489.                                                 tok=tk_number;
  4490.  
  4491.                                                 goto num;
  4492.  
  4493.                                         }
  4494.  
  4495.                                 }
  4496.  
  4497.                                 retrez=razr==r16?tk_reg:tk_reg32;
  4498.  
  4499.                                 do_e_axmath(sign,razr,&ofsstr);
  4500.  
  4501.                                 if(addESP!=oaddESP&&am32&&ESPloc&&(wtok.type==tp_paramvar||wtok.type==tp_localvar))wtok.number+=addESP-oaddESP;
  4502.  
  4503. axtovar:
  4504.  
  4505.                                 CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  4506.  
  4507.                                 op66(razr);
  4508.  
  4509.                                 outseg(&wtok,2);
  4510.  
  4511.                                 op(0x01+vop); op(wtok.rm);      /* ADD [anyword],AX */
  4512.  
  4513.                                 outaddress(&wtok);
  4514.  
  4515.                                 next=0;
  4516.  
  4517.                         }
  4518.  
  4519.                         else{
  4520.  
  4521.                                 switch(tok){
  4522.  
  4523.                                         case tk_number:
  4524.  
  4525.                                         case tk_postnumber:
  4526.  
  4527.                                         case tk_undefofs:
  4528.  
  4529. num:
  4530.  
  4531. #ifdef OPTVARCONST
  4532.  
  4533.                                                 if(tok==tk_number&&(itok.flag&f_reloc)==0){
  4534.  
  4535.                                                         initconst=UpdVarConst(&wtok,itok.lnumber,itok.rm,operand);
  4536.  
  4537.                                                 }
  4538.  
  4539. #endif
  4540.  
  4541.                                                 CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  4542.  
  4543.                                                 op66(razr);
  4544.  
  4545.                                                 outseg(&wtok,2);
  4546.  
  4547.                                                 if(tok==tk_number&&(itok.flag&f_reloc)==0&&itok.number==1&&(vop==0||vop==0x28)){
  4548.  
  4549.                                                         if(vop)vop=8;
  4550.  
  4551.                                                         op(0xFF); op(vop+wtok.rm);
  4552.  
  4553.                                                         outaddress(&wtok);
  4554.  
  4555.                                                 }
  4556.  
  4557.                                                 else if(tok!=tk_undefofs&&tok!=tk_postnumber&&(itok.flag&f_reloc)==0&&
  4558.  
  4559.                                                                 short_ok(itok.number,razr/2-1)){
  4560.  
  4561.                                                         op(0x83);
  4562.  
  4563.                                                         op(vop+wtok.rm);
  4564.  
  4565.                                                         outaddress(&wtok);
  4566.  
  4567.                                                         op((unsigned int)itok.number);
  4568.  
  4569.                                                 }
  4570.  
  4571.                                                 else{
  4572.  
  4573.                                                         op(0x81);
  4574.  
  4575.                                                         op(vop+wtok.rm);
  4576.  
  4577.                                                         outaddress(&wtok);
  4578.  
  4579.                                                         if(tok==tk_postnumber)(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
  4580.  
  4581.                                                         else if(tok==tk_undefofs)AddUndefOff(0,itok.name);
  4582.  
  4583.                                                         else if((itok.flag&f_reloc)!=0)AddReloc();
  4584.  
  4585.                                                         razr==r16?outword(itok.number):outdword(itok.number);
  4586.  
  4587.                                                 }
  4588.  
  4589.                                                 if(next==0)tok=otok;
  4590.  
  4591.                                                 break;
  4592.  
  4593.                                         case tk_apioffset:
  4594.  
  4595.                                                 CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  4596.  
  4597.                                                 op66(razr);
  4598.  
  4599.                                                 outseg(&wtok,2);
  4600.  
  4601.                                                 op(0x81);
  4602.  
  4603.                                                 op(vop+wtok.rm);
  4604.  
  4605.                                                 outaddress(&wtok);
  4606.  
  4607.                                                 AddApiToPost(itok.number);
  4608.  
  4609.                                                 break;
  4610.  
  4611.                                         case tk_reg32:
  4612.  
  4613.                                                 if(razr==r16)goto defxor;
  4614.  
  4615.                                         case tk_reg:
  4616.  
  4617.                                                 if(tok==tk_reg&&razr==r32)goto defxor;
  4618.  
  4619. #ifdef OPTVARCONST
  4620.  
  4621.                                                 initconst=CheckUpdRegToConst(itok.number,&wtok,operand,razr);
  4622.  
  4623. #endif
  4624.  
  4625.                                                 CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  4626.  
  4627.                                                 op66(razr);
  4628.  
  4629.                                                 outseg(&wtok,2);
  4630.  
  4631.                                                 op(0x01+vop); op((unsigned int)itok.number*8+wtok.rm);
  4632.  
  4633.                                                 outaddress(&wtok);
  4634.  
  4635.                                                 break;
  4636.  
  4637.                                         default:
  4638.  
  4639. defxor:
  4640.  
  4641.                                                 retrez=razr==r16?tk_reg:tk_reg32;
  4642.  
  4643.                                                 do_e_axmath(sign,razr,&ofsstr);
  4644.  
  4645.                                                 if(addESP!=oaddESP&&am32&&ESPloc&&(wtok.type==tp_paramvar||wtok.type==tp_localvar))wtok.number+=addESP-oaddESP;
  4646.  
  4647.                                                 CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  4648.  
  4649.                                                 op66(razr);
  4650.  
  4651.                                                 outseg(&wtok,2);
  4652.  
  4653.                                                 op(0x01+vop); op(wtok.rm);  /* ADD [anyword],AX */
  4654.  
  4655.                                                 outaddress(&wtok);
  4656.  
  4657.                                                 next=0;
  4658.  
  4659.                                                 break;
  4660.  
  4661.                                 }
  4662.  
  4663.                         }
  4664.  
  4665. //                      puts(wtok.name);
  4666.  
  4667.                         KillVar(wtok.name);
  4668.  
  4669.                         break;
  4670.  
  4671.                 case tk_multequals:
  4672.  
  4673.                         getoperand(am32==TRUE?EAX:BX);
  4674.  
  4675.                         if(itok2.type==tp_stopper){
  4676.  
  4677.                                 if(tok==tk_number){
  4678.  
  4679.                                         if(itok.number==1)break;
  4680.  
  4681.                                         if(itok.number==0){
  4682.  
  4683.                                                 ZeroReg(hnumber,razr);
  4684.  
  4685.                                                 goto getfromax;
  4686.  
  4687.                                         }
  4688.  
  4689. #ifdef OPTVARCONST
  4690.  
  4691.                                         if((itok.flag&f_reloc)==0){
  4692.  
  4693.                                                 initconst=UpdVarConst(&wtok,itok.lnumber,itok.rm,operand);
  4694.  
  4695.                                         }
  4696.  
  4697. #endif
  4698.  
  4699.                                         if(hnumber==0)getinto_e_ax(sign,otok,&wtok,wbuf,&wstr,razr,TRUE);
  4700.  
  4701.                                         else getinto_reg(otok,&wtok,wbuf,&wstr,razr,hnumber);
  4702.  
  4703.                                         vop=0;
  4704.  
  4705.                                         RegMulNum(hnumber,itok.number,razr,sign,(int *)&vop,itok.flag);
  4706.  
  4707.                                         goto getfromax;
  4708.  
  4709.                                 }
  4710.  
  4711.                         }
  4712.  
  4713.                         if(hnumber==0)do_e_axmath(sign,razr,&ofsstr);
  4714.  
  4715.                         else getintoreg(hnumber,razr,sign,&ofsstr);
  4716.  
  4717.                         if(addESP!=oaddESP&&am32&&ESPloc&&(wtok.type==tp_paramvar||wtok.type==tp_localvar)){
  4718.  
  4719.                                 wtok.number+=addESP-oaddESP;
  4720.  
  4721.                                 oaddESP=addESP;
  4722.  
  4723.                         }
  4724.  
  4725.                         CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  4726.  
  4727.                         op66(razr);
  4728.  
  4729.                         if(hnumber==0){
  4730.  
  4731.                                 outseg(&wtok,2);
  4732.  
  4733.                                 op(0xF7);       // imul/mul var
  4734.  
  4735.                                 if(sign)op(0x28+wtok.rm);
  4736.  
  4737.                                 else op(0x20+wtok.rm);
  4738.  
  4739.                         }
  4740.  
  4741.                         else{
  4742.  
  4743.                                 outseg(&wtok,3);
  4744.  
  4745.                                 outword(0xaf0f);
  4746.  
  4747.                                 op(wtok.rm+hnumber*8);
  4748.  
  4749.                         }
  4750.  
  4751.                         outaddress(&wtok);
  4752.  
  4753.                         next=0;
  4754.  
  4755.                         KillVar(wtok.name);
  4756.  
  4757.                         goto getfromax;
  4758.  
  4759.                 case tk_divequals:
  4760.  
  4761.                         getoperand(am32==TRUE?EAX:BX);
  4762.  
  4763.                         hnumber=0;
  4764.  
  4765.                         if(itok2.type==tp_stopper){
  4766.  
  4767.                                 if(tok==tk_number){
  4768.  
  4769.                                         if(itok.number==1)break;
  4770.  
  4771. #ifdef OPTVARCONST
  4772.  
  4773.                                         if((itok.flag&f_reloc)==0){
  4774.  
  4775.                                                 initconst=UpdVarConst(&wtok,itok.lnumber,itok.rm,operand);
  4776.  
  4777.                                         }
  4778.  
  4779. #endif
  4780.  
  4781.                                         getinto_e_ax(sign,otok,&wtok,wbuf,&wstr,razr,TRUE);
  4782.  
  4783.                                         DivMod(0,sign,razr,0);
  4784.  
  4785.                                         next=0;
  4786.  
  4787.                                         goto getfromax;
  4788.  
  4789.                                 }
  4790.  
  4791.                                 getintoreg_32(CX,razr,sign,&ofsstr);
  4792.  
  4793.                         }
  4794.  
  4795.                         else{
  4796.  
  4797.                                 do_e_axmath(sign,razr,&ofsstr);
  4798.  
  4799.                                 if(optimizespeed)outword(0xC88B);       //mov CX,ax
  4800.  
  4801.                                 else op(0x90+ECX);      //xchg ax,Cx
  4802.  
  4803.                                 if(addESP!=oaddESP&&am32&&ESPloc&&(wtok.type==tp_paramvar||wtok.type==tp_localvar)){
  4804.  
  4805.                                         wtok.number+=addESP-oaddESP;
  4806.  
  4807.                                         oaddESP=addESP;
  4808.  
  4809.                                 }
  4810.  
  4811.                         }
  4812.  
  4813.                         getinto_e_ax(sign,otok,&wtok,wbuf,&wstr,razr,TRUE);
  4814.  
  4815.                         ClearDX(razr,sign);
  4816.  
  4817.                         op66(razr);
  4818.  
  4819.                         op(0xF7);
  4820.  
  4821.                         if(sign)op(0xF8+ECX); // IDIV CX
  4822.  
  4823.                         else op(0xF0+ECX); // DIV CX
  4824.  
  4825.                         next=0;
  4826.  
  4827.                         warningreg(regs[razr/2-1][ECX]);
  4828.  
  4829.                         KillVar(wtok.name);
  4830.  
  4831.                         goto getfromax;
  4832.  
  4833.                 case tk_swap:
  4834.  
  4835.                         KillVar(wtok.name);
  4836.  
  4837.                         int regdi;
  4838.  
  4839.                         regdi=TRUE;
  4840.  
  4841.                         getoperand();
  4842.  
  4843.                         rbuf=bufrm;
  4844.  
  4845.                         bufrm=NULL;
  4846.  
  4847.                         if(am32!=FALSE&&wbuf!=NULL&&wstr.bufstr!=NULL)regdi=FALSE;
  4848.  
  4849.                         switch(tok){
  4850.  
  4851.                                 case tk_reg32:
  4852.  
  4853.                                         if(razr==r16)swaperror();
  4854.  
  4855.                                 case tk_reg:
  4856.  
  4857.                                         if(tok==tk_reg&&razr==r32)swaperror();
  4858.  
  4859. #ifdef OPTVARCONST
  4860.  
  4861.                                         initconst=SwapVarRegConst(itok.number,&wtok,razr);
  4862.  
  4863. #endif
  4864.  
  4865.                                         CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  4866.  
  4867.                                         op66(razr);
  4868.  
  4869.                                         outseg(&wtok,2);
  4870.  
  4871.                                         op(0x87);
  4872.  
  4873.                                         op((unsigned int)itok.number*8+wtok.rm);
  4874.  
  4875.                                         outaddress(&wtok);
  4876.  
  4877.                                         ClearReg(itok.number);
  4878.  
  4879.                                         break;
  4880.  
  4881.                                 case tk_qwordvar:
  4882.  
  4883.                                 case tk_longvar:
  4884.  
  4885.                                 case tk_dwordvar:
  4886.  
  4887.                                         if(razr==r16)swaperror();
  4888.  
  4889.                                 case tk_intvar:
  4890.  
  4891.                                 case tk_wordvar:
  4892.  
  4893.                                         if((tok==tk_intvar||tok==tk_wordvar)&&razr==r32)swaperror();
  4894.  
  4895. #ifdef OPTVARCONST
  4896.  
  4897.                                         ClearVarByNum(&itok);
  4898.  
  4899. #endif
  4900.  
  4901.                                         if(hnumber==0)getinto_e_ax(sign,otok,&wtok,wbuf,&wstr,razr,TRUE);
  4902.  
  4903.                                         else{
  4904.  
  4905.                                                 if(regoverstack&&(!((bufrm||strinf.bufstr)&&(wbuf||wstr.bufstr)))){
  4906.  
  4907.                                                         CheckAllMassiv(bufrm,razr,&strinf);
  4908.  
  4909.                                                         op66(razr);
  4910.  
  4911.                                                         outseg(&itok,2);
  4912.  
  4913.                                                         op(0xFF);       // PUSH [dword]
  4914.  
  4915.                                                         op(0x30+itok.rm);
  4916.  
  4917.                                                         outaddress(&itok);
  4918.  
  4919.                                                         CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  4920.  
  4921.                                                         op66(razr);
  4922.  
  4923.                                                         outseg(&wtok,2);
  4924.  
  4925.                                                         op(0xFF);       // PUSH [dword]
  4926.  
  4927.                                                         op(0x30+wtok.rm);
  4928.  
  4929.                                                         outaddress(&wtok);
  4930.  
  4931.  
  4932.  
  4933.                                                         CheckAllMassiv(bufrm,razr,&strinf);
  4934.  
  4935.                                                         op66(razr);
  4936.  
  4937.                                                         outseg(&itok,2);
  4938.  
  4939.                                                         op(0x8f);
  4940.  
  4941.                                                         op(itok.rm);
  4942.  
  4943.                                                         outaddress(&itok);
  4944.  
  4945.                                                         CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  4946.  
  4947.                                                         op66(razr);
  4948.  
  4949.                                                         outseg(&wtok,2);
  4950.  
  4951.                                                         op(0x8f);
  4952.  
  4953.                                                         op(wtok.rm);
  4954.  
  4955.                                                         outaddress(&wtok);
  4956.  
  4957.  
  4958.  
  4959.                                                         break;
  4960.  
  4961.                                                 }
  4962.  
  4963.                                                 getinto_reg(otok,&wtok,wbuf,&wstr,razr,hnumber);
  4964.  
  4965.                                         }
  4966.  
  4967.                                         CheckAllMassiv(rbuf,razr,&strinf,&itok,regdi==FALSE?idxregs[2]:idxregs[1],idxregs[3]);
  4968.  
  4969.                                         op66(razr);
  4970.  
  4971.                                         outseg(&itok,2);
  4972.  
  4973.                                         op(0x87);  /* XCHG AX,[wloc] */
  4974.  
  4975.                                         op(itok.rm+hnumber*8);
  4976.  
  4977.                                         outaddress(&itok);
  4978.  
  4979.                                         goto getfromax;
  4980.  
  4981.                                 case tk_seg:
  4982.  
  4983.                                         if(razr==r32)swaperror();
  4984.  
  4985.                                         op66(r16);
  4986.  
  4987.                                         op(0x8C); /* MOV AX,seg */
  4988.  
  4989.                                         op(0xC0+(unsigned int)itok.number*8);
  4990.  
  4991.                                         CheckAllMassiv(wbuf,2,&wstr,&wtok);
  4992.  
  4993.                                         op66(r16);
  4994.  
  4995.                                         outseg(&wtok,2);
  4996.  
  4997.                                         op(0x87);  /* XCHG AX,[wloc] */
  4998.  
  4999.                                         op(wtok.rm);
  5000.  
  5001.                                         outaddress(&wtok);
  5002.  
  5003.                                         op66(r16);
  5004.  
  5005.                                         op(0x8E); /* MOV seg,AX */
  5006.  
  5007.                                         op(0xC0+(unsigned int)itok.number*8);
  5008.  
  5009.                                         break;
  5010.  
  5011.                                 case tk_floatvar:
  5012.  
  5013.                                         if(razr==r16)swaperror();
  5014.  
  5015.                                         if(sign==1){
  5016.  
  5017.                                                 CheckAllMassiv(wbuf,4,&wstr,&wtok);
  5018.  
  5019.                                                 outseg(&wtok,2);        //fild
  5020.  
  5021.                                                 op(0xDB);
  5022.  
  5023.                                                 op(wtok.rm);
  5024.  
  5025.                                                 outaddress(&wtok);
  5026.  
  5027.                                                 CheckAllMassiv(rbuf,4,&strinf,&itok,regdi==FALSE?idxregs[2]:idxregs[1],idxregs[3]);
  5028.  
  5029.                                                 outseg(&itok,2);        //fld val
  5030.  
  5031.                                                 op(0xd9);
  5032.  
  5033.                                                 op(itok.rm);
  5034.  
  5035.                                                 outaddress(&itok);
  5036.  
  5037.                                         }
  5038.  
  5039.                                         else{
  5040.  
  5041.                                                 CheckInitBP();
  5042.  
  5043.                                                 op66(r32);      //push 0L
  5044.  
  5045.                                                 outword(0x6a);
  5046.  
  5047.                                                 CheckAllMassiv(wbuf,4,&wstr,&wtok);
  5048.  
  5049.                                                 op66(r32);      //push var
  5050.  
  5051.                                                 if(ESPloc&&am32&&wtok.segm==SS)wtok.number+=8;
  5052.  
  5053.                                                 addESP+=8;
  5054.  
  5055.                                                 outseg(&wtok,2);
  5056.  
  5057.                                                 op(0xFF);
  5058.  
  5059.                                                 op(wtok.rm+0x30);
  5060.  
  5061.                                                 outaddress(&wtok);
  5062.  
  5063.                                                 fildq_stack();
  5064.  
  5065.                                                 CheckAllMassiv(rbuf,4,&strinf,&itok,regdi==FALSE?idxregs[2]:idxregs[1],idxregs[3]);
  5066.  
  5067.                                                 outseg(&itok,2);        //fld val
  5068.  
  5069.                                                 op(0xd9);
  5070.  
  5071.                                                 op(itok.rm);
  5072.  
  5073.                                                 outaddress(&itok);
  5074.  
  5075.                                                 RestoreBP();
  5076.  
  5077.                                                 if(optimizespeed||am32==0){
  5078.  
  5079.                                                         outword(0xC483);
  5080.  
  5081.                                                         op(8);
  5082.  
  5083.                                                 }
  5084.  
  5085.                                                 else{
  5086.  
  5087.                                                         op(0x58);       // pop EAX
  5088.  
  5089.                                                         op(0x58);       // pop EAX
  5090.  
  5091.                                                 }
  5092.  
  5093.                                                 addESP-=8;
  5094.  
  5095.                                         }
  5096.  
  5097.                                         outseg(&wtok,2);//fistp var
  5098.  
  5099.                                         op(0xDB);
  5100.  
  5101.                                         op(wtok.rm+0x18);
  5102.  
  5103.                                         outaddress(&wtok);
  5104.  
  5105.                                         outseg(&itok,2);        //fstp val
  5106.  
  5107.                                         op(0xd9);
  5108.  
  5109.                                         op(itok.rm+0x18);
  5110.  
  5111.                                         outaddress(&itok);
  5112.  
  5113.                                         fwait3();
  5114.  
  5115.                                         break;
  5116.  
  5117.                                 default: swaperror(); break;
  5118.  
  5119.                         }
  5120.  
  5121.                         break;
  5122.  
  5123.                 case tk_rrequals:
  5124.  
  5125.                         vop=8;
  5126.  
  5127.                         if(sign)vop+=0x10;
  5128.  
  5129.                 case tk_llequals:
  5130.  
  5131.                         KillVar(wtok.name);
  5132.  
  5133.                         getoperand(am32==TRUE?ECX:BX);
  5134.  
  5135.                         if(itok2.type!=tp_stopper){
  5136.  
  5137.                                 doalmath(0,&ofsstr);            // all shifts unsigned byte
  5138.  
  5139.                                 ClearReg(AX);
  5140.  
  5141.                                 ClearReg(CX);
  5142.  
  5143.                                 outword(0xC188);        // MOV CL,AL
  5144.  
  5145.                                 if(addESP!=oaddESP&&am32&&ESPloc&&(wtok.type==tp_paramvar||wtok.type==tp_localvar))wtok.number+=addESP-oaddESP;
  5146.  
  5147.                                 CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  5148.  
  5149.                                 op66(razr);
  5150.  
  5151.                                 outseg(&wtok,2);
  5152.  
  5153.                                 op(0xD3);       op(0x20+vop+wtok.rm);  // SHL [rmword],CL
  5154.  
  5155.                                 outaddress(&wtok);
  5156.  
  5157.                                 warningreg(begs[1]);
  5158.  
  5159.                                 next=0;
  5160.  
  5161.                         }
  5162.  
  5163.                         else if(tok==tk_number){
  5164.  
  5165. #ifdef OPTVARCONST
  5166.  
  5167.                                 if((itok.flag&f_reloc)==0){
  5168.  
  5169.                                         initconst=UpdVarConst(&wtok,itok.lnumber,itok.rm,operand);
  5170.  
  5171.                                 }
  5172.  
  5173. #endif
  5174.  
  5175.                                 CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  5176.  
  5177.                                 if((unsigned int)itok.number==1){
  5178.  
  5179.                                         op66(razr);
  5180.  
  5181.                                         outseg(&wtok,2);
  5182.  
  5183.                                         op(0xD1); op(0x20+vop+wtok.rm); /* SHL [rmword],1 */
  5184.  
  5185.                                         outaddress(&wtok);
  5186.  
  5187.                                 }
  5188.  
  5189.                                 else if((unsigned int)itok.number!=0){
  5190.  
  5191.                                         if(chip<2&&razr==r16){
  5192.  
  5193.                                                 getintobeg(CL,&ofsstr);
  5194.  
  5195.                                                 op66(r16);
  5196.  
  5197.                                                 outseg(&wtok,2);
  5198.  
  5199.                                                 op(0xD3);       op(0x20+vop+wtok.rm);  /* SHL [rmword],CL */
  5200.  
  5201.                                                 outaddress(&wtok);
  5202.  
  5203.                                                 warningreg(begs[1]);
  5204.  
  5205.                                                 ClearReg(CX);
  5206.  
  5207.                                                 next=0;
  5208.  
  5209.                                         }
  5210.  
  5211.                                         else{
  5212.  
  5213.                                                 op66(razr);
  5214.  
  5215.                                                 outseg(&wtok,2);
  5216.  
  5217.                                                 op(0xC1);       op(0x20+vop+wtok.rm);  /* SHL [rmword],imm8 */
  5218.  
  5219.                                                 outaddress(&wtok);
  5220.  
  5221.                                                 if(cpu<2)cpu=2;
  5222.  
  5223.                                         }
  5224.  
  5225.                                         op((unsigned int)itok.number);
  5226.  
  5227.                                 }
  5228.  
  5229.                         }
  5230.  
  5231.                         else{
  5232.  
  5233.                                 if(tok!=tk_beg||(unsigned int)itok.number!=CL){
  5234.  
  5235.                                         getintobeg(CL,&ofsstr);
  5236.  
  5237.                                         warningreg(begs[1]);
  5238.  
  5239.                                         ClearReg(CX);
  5240.  
  5241.                                         next=0;
  5242.  
  5243.                                 }
  5244.  
  5245.                                 CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  5246.  
  5247.                                 op66(razr);
  5248.  
  5249.                                 outseg(&wtok,2);
  5250.  
  5251.                                 op(0xD3);       op(0x20+vop+wtok.rm);  /* SHL [rmword],CL */
  5252.  
  5253.                                 outaddress(&wtok);
  5254.  
  5255.                         }
  5256.  
  5257.                         break;
  5258.  
  5259.                 default: operatorexpected(); break;
  5260.  
  5261.         }
  5262.  
  5263. #ifdef OPTVARCONST
  5264.  
  5265.         if(initconst==FALSE)ClearVarByNum(&wtok);
  5266.  
  5267. #endif
  5268.  
  5269.         if(next)nexttok();
  5270.  
  5271.         if(terminater==tk_semicolon)seminext();
  5272.  
  5273.         if(razr==r32&&cpu<3)cpu=3;
  5274.  
  5275.         return retrez;
  5276.  
  5277. }
  5278.  
  5279.  
  5280.  
  5281. int dobytevar(int sign,int terminater)   // byte, char
  5282.  
  5283. {
  5284.  
  5285. unsigned char next=1,getfromAX=0;
  5286.  
  5287. unsigned int vop=0,otok,rettype,posiblret=0;
  5288.  
  5289. ITOK btok;
  5290.  
  5291. char *bbuf,*rbuf;
  5292.  
  5293. int retrez=0,pointr=0,hnumber=AL;
  5294.  
  5295. SINFO bstr;
  5296.  
  5297. int numpointr=0;
  5298.  
  5299. char *ofsstr=NULL;
  5300.  
  5301. #ifdef OPTVARCONST
  5302.  
  5303. int initconst=FALSE;
  5304.  
  5305. int operand;
  5306.  
  5307. #endif
  5308.  
  5309. unsigned int oaddESP=addESP;
  5310.  
  5311.         sign==0?posiblret=rettype=tk_byte:posiblret=rettype=tk_char;
  5312.  
  5313.         bstr=strinf;
  5314.  
  5315.         strinf.bufstr=NULL;
  5316.  
  5317.         btok=itok;
  5318.  
  5319.         bbuf=bufrm;
  5320.  
  5321.         bufrm=NULL;
  5322.  
  5323.         otok=tok;
  5324.  
  5325.         while(RmEqualReg(hnumber,itok.rm,itok.sib))hnumber++;
  5326.  
  5327.         nexttok();
  5328.  
  5329. #ifdef OPTVARCONST
  5330.  
  5331.         operand=tok;
  5332.  
  5333. #endif
  5334.  
  5335.         switch(tok){
  5336.  
  5337.                 case tk_assign:
  5338.  
  5339.                         if(!((tok2==tk_reg||tok2==tk_reg32||tok2==tk_beg)&&ScanTok3()==terminater)){
  5340.  
  5341.                                 ofsstr=GetLecsem(terminater);
  5342.  
  5343.                         }
  5344.  
  5345.                         if(ofsstr){
  5346.  
  5347.                                 int retreg;
  5348.  
  5349.                                 if((retreg=CheckIDZReg(ofsstr,AX,r8))!=NOINREG){
  5350.  
  5351.                                         GetEndLex(terminater);
  5352.  
  5353.                                         tok=tk_beg;
  5354.  
  5355.                                         itok.number=retreg==SKIPREG?AX:retreg;
  5356.  
  5357.                                         goto regtovar;
  5358.  
  5359.                                 }
  5360.  
  5361.                         }
  5362.  
  5363.                         nexttok();
  5364.  
  5365.                         convert_type(&sign,(int *)&rettype,&pointr);
  5366.  
  5367.                         while(tok==tk_mult){
  5368.  
  5369.                                 nexttok();
  5370.  
  5371.                                 numpointr++;
  5372.  
  5373.                         }
  5374.  
  5375.                         if(numpointr>itok.npointr)unuseableinput();
  5376.  
  5377.                         if(tok2==tk_assign){
  5378.  
  5379.                                 hnumber=MultiAssign(r8,USEALLREG,numpointr);
  5380.  
  5381.                                 if(ofsstr){
  5382.  
  5383.                                         free(ofsstr);
  5384.  
  5385.                                         ofsstr=NULL;
  5386.  
  5387.                                 }
  5388.  
  5389.                                 next=0;
  5390.  
  5391.                                 goto getfromax;
  5392.  
  5393.                         }
  5394.  
  5395.                         if(tok==tk_pointer)cpointr(am32==TRUE?EAX:BX,numpointr);
  5396.  
  5397.                         CheckMinusNum();
  5398.  
  5399.                         if(itok2.type==tp_opperand){
  5400.  
  5401.                                 if(rettype!=tk_float&&tok==tk_number){  //¯à®¢¥àª  ¨ á㬬¨à®¢ ­¨¥ ç¨á¥«
  5402.  
  5403.                                         if(OnlyNumber(sign)){
  5404.  
  5405.                                                 next=0;
  5406.  
  5407.                                                 goto numbertovar;
  5408.  
  5409.                                         }
  5410.  
  5411.                                 }
  5412.  
  5413.                                 goto labl1;
  5414.  
  5415.                         }
  5416.  
  5417.                         else{
  5418.  
  5419. #ifdef OPTVARCONST
  5420.  
  5421.                                 if(tok>=tk_charvar&&tok<=tk_doublevar&&itok.npointr==0){
  5422.  
  5423.                                         if(CheckConstVar(&itok))tok=tk_number;
  5424.  
  5425.                                 }
  5426.  
  5427. #endif
  5428.  
  5429.                                 switch(tok){
  5430.  
  5431.                                         case tk_number:
  5432.  
  5433. numbertovar:
  5434.  
  5435. #ifdef OPTVARCONST
  5436.  
  5437.                                                 if((initconst=Const2Var(&btok,itok.lnumber&0Xff,itok.rm))==FALSE){
  5438.  
  5439.                                                         waralreadinitvar(btok.name,itok.number);
  5440.  
  5441.                                                         initconst=TRUE;
  5442.  
  5443.                                                         break;
  5444.  
  5445.                                                 }
  5446.  
  5447. #endif
  5448.  
  5449.                                                 CheckAllMassiv(bbuf,1,&bstr,&btok);
  5450.  
  5451.                                                 outseg(&btok,2);
  5452.  
  5453.                                                 op(0xC6);
  5454.  
  5455.                                                 op(btok.rm);
  5456.  
  5457.                                                 outaddress(&btok);
  5458.  
  5459.                                                 op((unsigned int)itok.number);
  5460.  
  5461.                                                 break;
  5462.  
  5463.                                         case tk_reg32:
  5464.  
  5465.                                         case tk_reg:
  5466.  
  5467.                                                 if((unsigned int)itok.number>BX)goto labl1;
  5468.  
  5469.                                         case tk_beg:
  5470.  
  5471. regtovar:
  5472.  
  5473.                                                 if((unsigned int)itok.number==0){
  5474.  
  5475.                                                         getfromAX=1;
  5476.  
  5477.                                                         hnumber=0;
  5478.  
  5479.                                                 }
  5480.  
  5481.                                                 else{
  5482.  
  5483.                                                         KillVar(btok.name);
  5484.  
  5485.                                                         AddRegVar(itok.number,r8,&btok);
  5486.  
  5487.                                                         vop++;
  5488.  
  5489.                                                         CheckAllMassiv(bbuf,1,&bstr,&btok);
  5490.  
  5491.                                                         outseg(&btok,2);
  5492.  
  5493.                                                         op(0x88);
  5494.  
  5495.                                                         op((unsigned int)itok.number*8+btok.rm);
  5496.  
  5497.                                                         outaddress(&btok);
  5498.  
  5499.                                                 }
  5500.  
  5501.                                                 break;
  5502.  
  5503.                                         case tk_seg: segbyteerror(); break;
  5504.  
  5505.                                         default:
  5506.  
  5507. labl1:
  5508.  
  5509.                                                 if(rettype==tk_char||rettype==tk_byte){
  5510.  
  5511.                                                         if(hnumber==0)retrez=doalmath(sign,&ofsstr);
  5512.  
  5513.                                                         else retrez=getintobeg(hnumber,&ofsstr);
  5514.  
  5515.                                                 }
  5516.  
  5517.                                                 else if(rettype==tk_int||rettype==tk_word){
  5518.  
  5519.                                                         if(hnumber==0)retrez=do_e_axmath(sign,r16,&ofsstr);
  5520.  
  5521.                                                         else retrez=getintoreg(hnumber,r16,sign,&ofsstr);
  5522.  
  5523.                                                 }
  5524.  
  5525.                                                 else if(rettype==tk_float){
  5526.  
  5527.                                                         doeaxfloatmath(tk_reg32);
  5528.  
  5529.                                                         rettype=tk_long;
  5530.  
  5531.                                                         hnumber=0;
  5532.  
  5533.                                                 }
  5534.  
  5535.                                                 else{
  5536.  
  5537.                                                         if(hnumber==0)retrez=do_e_axmath(sign,r32,&ofsstr);
  5538.  
  5539.                                                         else retrez=getintoreg(hnumber,r32,sign,&ofsstr);
  5540.  
  5541.                                                 }
  5542.  
  5543.                                                 getfromAX=1;
  5544.  
  5545.                                                 next=0;
  5546.  
  5547.                                                 break;
  5548.  
  5549.                                 }
  5550.  
  5551.                         }
  5552.  
  5553.                         if(getfromAX){
  5554.  
  5555. getfromax:
  5556.  
  5557. #ifdef OPTVARCONST
  5558.  
  5559.                                 initconst=CheckRegToConst(hnumber,&btok,r8);
  5560.  
  5561. #endif
  5562.  
  5563.                                 if(retrez==0)retrez=tk_reg;
  5564.  
  5565.                                 convert_returnvalue(posiblret,rettype);
  5566.  
  5567.                                 if(addESP!=oaddESP&&am32&&ESPloc&&(btok.type==tp_paramvar||btok.type==tp_localvar))btok.number+=addESP-oaddESP;
  5568.  
  5569.                                 if(bbuf==NULL&&bstr.bufstr==NULL&&hnumber==0&&((btok.rm==rm_d16&&btok.sib==CODE16)||(btok.rm==rm_d32&&(btok.sib==CODE32||btok.sib==0)))){
  5570.  
  5571.                                         outseg(&btok,1);
  5572.  
  5573.                                         op(0xA2);               // MOV [byte],AL
  5574.  
  5575.                                         if(btok.post==UNDEF_OFSET){
  5576.  
  5577.                                                 AddUndefOff(2,btok.name);
  5578.  
  5579.                                                 btok.post=0;
  5580.  
  5581.                                         }
  5582.  
  5583.                                         if(am32==FALSE)outword(btok.number);
  5584.  
  5585.                                         else outdword(btok.number);
  5586.  
  5587.                                 }
  5588.  
  5589.                                 else{
  5590.  
  5591.                                         CheckAllMassiv(bbuf,1,&bstr,&btok);
  5592.  
  5593.                                         outseg(&btok,2);  // MOV [rmbyte],AL
  5594.  
  5595.                                         op(0x88);
  5596.  
  5597.                                         op(btok.rm+hnumber*8);
  5598.  
  5599.                                         outaddress(&btok);
  5600.  
  5601.                                 }
  5602.  
  5603.                                 if(ofsstr)IDZToReg(ofsstr,hnumber,r8);
  5604.  
  5605.                                 else ClearReg(hnumber);
  5606.  
  5607.                                 KillVar(btok.name);
  5608.  
  5609.                                 AddRegVar(hnumber,r8,&btok);
  5610.  
  5611.                         }
  5612.  
  5613.                         else if(vop)KillVar(btok.name);
  5614.  
  5615.                         if(ofsstr)free(ofsstr);
  5616.  
  5617.                         break;
  5618.  
  5619.                 case tk_multequals:
  5620.  
  5621.                         getoperand(am32==TRUE?EAX:BX);
  5622.  
  5623.                         if(itok2.type==tp_stopper&&tok==tk_number){
  5624.  
  5625.                                 if(itok.number==1)break;
  5626.  
  5627.                                 if(itok.number==0){
  5628.  
  5629.                                         outword(0xB0+hnumber);
  5630.  
  5631.                                         goto getfromax;
  5632.  
  5633.                                 }
  5634.  
  5635. #ifdef OPTVARCONST
  5636.  
  5637.                                 if((itok.flag&f_reloc)==0){
  5638.  
  5639.                                         initconst=UpdVarConst(&btok,itok.lnumber,itok.rm,tk_mult);
  5640.  
  5641.                                 }
  5642.  
  5643. #endif
  5644.  
  5645.                         }
  5646.  
  5647.                         doalmath(sign,&ofsstr);
  5648.  
  5649.                         hnumber=0;
  5650.  
  5651.                         if(addESP!=oaddESP&&am32&&ESPloc&&(btok.type==tp_paramvar||btok.type==tp_localvar)){
  5652.  
  5653.                                 btok.number+=addESP-oaddESP;
  5654.  
  5655.                                 oaddESP=addESP;
  5656.  
  5657.                         }
  5658.  
  5659.                         CheckAllMassiv(bbuf,1,&bstr,&btok);
  5660.  
  5661.                         outseg(&btok,2);
  5662.  
  5663.                         op(0xF6);
  5664.  
  5665.                         if(sign)op(0x28+btok.rm);
  5666.  
  5667.                         else op(0x20+btok.rm);
  5668.  
  5669.                         outaddress(&btok);
  5670.  
  5671.                         next=0;
  5672.  
  5673.                         KillVar(btok.name);
  5674.  
  5675.                         goto getfromax;
  5676.  
  5677.                 case tk_divequals:
  5678.  
  5679.                         hnumber=0;
  5680.  
  5681.                         getoperand(am32==TRUE?EAX:BX);
  5682.  
  5683.                         if(itok2.type==tp_stopper){
  5684.  
  5685.                                 if(tok==tk_number){
  5686.  
  5687.                                         if(itok.number==1)break;
  5688.  
  5689. #ifdef OPTVARCONST
  5690.  
  5691.                                         if((itok.flag&f_reloc)==0){
  5692.  
  5693.                                                 initconst=UpdVarConst(&btok,itok.lnumber,itok.rm,tk_div);
  5694.  
  5695.                                         }
  5696.  
  5697. #endif
  5698.  
  5699.                                 }
  5700.  
  5701.                                 getintobeg(CL,&ofsstr);
  5702.  
  5703.                                 warningreg(begs[1]);
  5704.  
  5705.                         }
  5706.  
  5707.                         else{
  5708.  
  5709.                                 doalmath(sign,&ofsstr);
  5710.  
  5711.                                 outword(0xC88A);        //mov Cl,al
  5712.  
  5713.                                 if(addESP!=oaddESP&&am32&&ESPloc&&(btok.type==tp_paramvar||btok.type==tp_localvar)){
  5714.  
  5715.                                         btok.number+=addESP-oaddESP;
  5716.  
  5717.                                         oaddESP=addESP;
  5718.  
  5719.                                 }
  5720.  
  5721.                         }
  5722.  
  5723.                         if(sign)cbw();
  5724.  
  5725.                         else xorAHAH();
  5726.  
  5727.                         getintoal(otok,&btok,bbuf,&bstr);
  5728.  
  5729.                         warningreg(begs[3]);
  5730.  
  5731.                         op(0xF6);
  5732.  
  5733.                         if(sign)op(0xF8+CL); // IDIV CL
  5734.  
  5735.                         else op(0xF0+CL); // DIV CL
  5736.  
  5737.                         next=0;
  5738.  
  5739.                         ClearReg(CX);
  5740.  
  5741.                         KillVar(btok.name);
  5742.  
  5743.                         goto getfromax;
  5744.  
  5745.                 case tk_minusminus: vop=0x8;
  5746.  
  5747.                 case tk_plusplus:
  5748.  
  5749. #ifdef OPTVARCONST
  5750.  
  5751.                         initconst=UpdVarConst(&btok,1,tk_byte,tok);
  5752.  
  5753. #endif
  5754.  
  5755.                         CheckAllMassiv(bbuf,1,&bstr,&btok);
  5756.  
  5757.                         outseg(&btok,2);
  5758.  
  5759.                         op(0xFE);
  5760.  
  5761.                         op(vop+btok.rm);
  5762.  
  5763.                         outaddress(&btok);
  5764.  
  5765.                         KillVar(btok.name);
  5766.  
  5767.                         break;
  5768.  
  5769.                 case tk_xorequals: vop+=0x08;
  5770.  
  5771.                 case tk_minusequals: vop+=0x08;
  5772.  
  5773.                 case tk_andequals: vop+=0x18;
  5774.  
  5775.                 case tk_orequals: vop+=0x08;
  5776.  
  5777.                 case tk_plusequals:
  5778.  
  5779.                         KillVar(btok.name);
  5780.  
  5781.                         getoperand(am32==TRUE?EAX:BX);
  5782.  
  5783.                         if(itok2.type==tp_opperand){
  5784.  
  5785.                                 if(tok==tk_number){
  5786.  
  5787.                                         if(OnlyNumber(sign)){
  5788.  
  5789.                                                 next=0;
  5790.  
  5791.                                                 otok=tok;
  5792.  
  5793.                                                 tok=tk_number;
  5794.  
  5795.                                                 goto num;
  5796.  
  5797.                                         }
  5798.  
  5799.                                 }
  5800.  
  5801.                                 doalmath(sign,&ofsstr);
  5802.  
  5803.                                 if(addESP!=oaddESP&&am32&&ESPloc&&(btok.type==tp_paramvar||btok.type==tp_localvar))btok.number+=addESP-oaddESP;
  5804.  
  5805.                                 CheckAllMassiv(bbuf,1,&bstr,&btok);
  5806.  
  5807.                                 outseg(&btok,2);
  5808.  
  5809.                                 op(vop); op(btok.rm);  // ADD [anybyte],AL
  5810.  
  5811.                                 outaddress(&btok);
  5812.  
  5813.                                 next=0;
  5814.  
  5815.                                 retrez=tk_reg;
  5816.  
  5817.                         }
  5818.  
  5819.                         else{
  5820.  
  5821.                                 switch(tok){
  5822.  
  5823.                                         case tk_number:
  5824.  
  5825. num:
  5826.  
  5827. #ifdef OPTVARCONST
  5828.  
  5829.                                                 if((itok.flag&f_reloc)==0){
  5830.  
  5831.                                                         initconst=UpdVarConst(&btok,itok.lnumber,itok.rm,operand);
  5832.  
  5833.                                                 }
  5834.  
  5835. #endif
  5836.  
  5837.                                                 CheckAllMassiv(bbuf,1,&bstr,&btok);
  5838.  
  5839.                                                 outseg(&btok,2);
  5840.  
  5841.                                                 if(itok.number==1&&(vop==0||vop==0x28)){
  5842.  
  5843.                                                         if(vop)vop=8;
  5844.  
  5845.                                                         op(0xFE);
  5846.  
  5847.                                                         op(vop+btok.rm);
  5848.  
  5849.                                                         outaddress(&btok);
  5850.  
  5851.                                                 }
  5852.  
  5853.                                                 else{
  5854.  
  5855.                                                         op(0x80);
  5856.  
  5857.                                                         op(vop+btok.rm);
  5858.  
  5859.                                                         outaddress(&btok);
  5860.  
  5861.                                                         op((unsigned int)itok.number);
  5862.  
  5863.                                                 }
  5864.  
  5865.                                                 if(next==0)tok=otok;
  5866.  
  5867.                                                 break;
  5868.  
  5869.                                         case tk_beg:
  5870.  
  5871. #ifdef OPTVARCONST
  5872.  
  5873.                                                 initconst=CheckUpdRegToConst(itok.number,&btok,operand,r8);
  5874.  
  5875. #endif
  5876.  
  5877.                                                 CheckAllMassiv(bbuf,1,&bstr,&btok);
  5878.  
  5879.                                                 outseg(&btok,2);
  5880.  
  5881.                                                 op(vop);
  5882.  
  5883.                                                 op((unsigned int)itok.number*8+btok.rm);
  5884.  
  5885.                                                 outaddress(&btok);
  5886.  
  5887.                                                 break;
  5888.  
  5889.                                         case tk_seg: segbyteerror(); break;
  5890.  
  5891.                                         default:
  5892.  
  5893.                                                 retrez=tk_reg;
  5894.  
  5895.                                                 doalmath(sign,&ofsstr);
  5896.  
  5897.                                                 CheckAllMassiv(bbuf,1,&bstr,&btok);
  5898.  
  5899.                                                 outseg(&btok,2);
  5900.  
  5901.                                                 op(vop); op(btok.rm);  /* ADD [anybyte],AL */
  5902.  
  5903.                                                 outaddress(&btok);
  5904.  
  5905.                                                 next=0;
  5906.  
  5907.                                                 break;
  5908.  
  5909.                                 }
  5910.  
  5911.                         }
  5912.  
  5913.                         break;
  5914.  
  5915.                 case tk_swap:
  5916.  
  5917.                         KillVar(btok.name);
  5918.  
  5919.                         getoperand();
  5920.  
  5921.                         rbuf=bufrm;
  5922.  
  5923.                         bufrm=NULL;
  5924.  
  5925.                         switch(tok){
  5926.  
  5927.                                 case tk_beg:
  5928.  
  5929. #ifdef OPTVARCONST
  5930.  
  5931.                                         initconst=SwapVarRegConst(itok.number,&btok,r8);
  5932.  
  5933. #endif
  5934.  
  5935.                                         CheckAllMassiv(bbuf,1,&bstr,&btok);
  5936.  
  5937.                                         outseg(&btok,2);
  5938.  
  5939.                                         op(0x86);       /* XCHG beg,[anybloc] */
  5940.  
  5941.                                         op((unsigned int)itok.number*8+btok.rm);
  5942.  
  5943.                                         outaddress(&btok);
  5944.  
  5945.                                         ClearReg(itok.number>3?itok.number-4:itok.number);
  5946.  
  5947.                                         break;
  5948.  
  5949.                                 case tk_bytevar:
  5950.  
  5951.                                 case tk_charvar:
  5952.  
  5953. #ifdef OPTVARCONST
  5954.  
  5955.                                         initconst=SwapVarConst(&itok,&btok);
  5956.  
  5957. #endif
  5958.  
  5959.                                         if(hnumber==0)getintoal(otok,&btok,bbuf,&bstr);
  5960.  
  5961.                                         else getinto_reg(otok,&btok,bbuf,&bstr,r8,hnumber);
  5962.  
  5963.                                         CheckAllMassiv(rbuf,1,&strinf,&itok,(am32!=FALSE&&bbuf!=NULL&&bstr.bufstr!=NULL)?BX:DI,DX);
  5964.  
  5965.                                         outseg(&itok,2);
  5966.  
  5967.                                         op(0x86);        /* XCHG AL,[bloc] */
  5968.  
  5969.                                         op(itok.rm+hnumber*8);
  5970.  
  5971.                                         outaddress(&itok);
  5972.  
  5973.                                         KillVar(itok.name);
  5974.  
  5975.                                         goto getfromax;
  5976.  
  5977.                                 default: swaperror(); break;
  5978.  
  5979.                         }
  5980.  
  5981.                         break;
  5982.  
  5983.                 case tk_rrequals:
  5984.  
  5985.                         vop=8;
  5986.  
  5987.                         if(sign)vop+=0x10;
  5988.  
  5989.                 case tk_llequals:
  5990.  
  5991.                         KillVar(btok.name);
  5992.  
  5993.                         getoperand(am32==TRUE?ECX:BX);
  5994.  
  5995.                         if(itok2.type!=tp_stopper){
  5996.  
  5997.                                 doalmath(0,&ofsstr);            // all shifts unsigned byte
  5998.  
  5999.                                 outword(0xC188);        // MOV CL,AL
  6000.  
  6001.                                 if(addESP!=oaddESP&&am32&&ESPloc&&(btok.type==tp_paramvar||btok.type==tp_localvar))btok.number+=addESP-oaddESP;
  6002.  
  6003.                                 CheckAllMassiv(bbuf,1,&bstr,&btok);
  6004.  
  6005.                                 outseg(&btok,2);
  6006.  
  6007.                                 op(0xD2);       op(0x20+vop+btok.rm);  /* SHL [byte],CL */
  6008.  
  6009.                                 outaddress(&btok);
  6010.  
  6011.                                 warningreg(begs[1]);
  6012.  
  6013.                                 ClearReg(CX);
  6014.  
  6015.                                 ClearReg(AX);
  6016.  
  6017.                                 next=0;
  6018.  
  6019.                         }
  6020.  
  6021.                         else if(tok==tk_number){
  6022.  
  6023. #ifdef OPTVARCONST
  6024.  
  6025.                                 if((itok.flag&f_reloc)==0){
  6026.  
  6027.                                                 initconst=UpdVarConst(&btok,itok.lnumber,itok.rm,operand);
  6028.  
  6029.                                 }
  6030.  
  6031. #endif
  6032.  
  6033.                                 if((unsigned int)itok.number==1){
  6034.  
  6035.                                         CheckAllMassiv(bbuf,1,&bstr,&btok);
  6036.  
  6037.                                         outseg(&btok,2);
  6038.  
  6039.                                         op(0xD0);       op(0x20+vop+btok.rm);  /* SHL [byte],1 */
  6040.  
  6041.                                         outaddress(&btok);
  6042.  
  6043.                                 }
  6044.  
  6045.                                 else if((unsigned int)itok.number!=0){
  6046.  
  6047.                                         CheckAllMassiv(bbuf,1,&bstr,&btok);
  6048.  
  6049.                                         if(chip<2){
  6050.  
  6051.                                                 getintobeg(CL,&ofsstr);
  6052.  
  6053.                                                 outseg(&btok,2);
  6054.  
  6055.                                                 op(0xD2);       op(0x20+vop+btok.rm);  /* SHL [byte],CL */
  6056.  
  6057.                                                 outaddress(&btok);
  6058.  
  6059.                                                 warningreg(begs[1]);
  6060.  
  6061.                                                 ClearReg(CX);
  6062.  
  6063.                                                 next=0;
  6064.  
  6065.                                         }
  6066.  
  6067.                                         else{
  6068.  
  6069.                                                 outseg(&btok,2);
  6070.  
  6071.                                                 op(0xC0);       op(0x20+vop+btok.rm);  /* SHL [byte],imm8 */
  6072.  
  6073.                                                 outaddress(&btok);
  6074.  
  6075.                                                 if(cpu<2)cpu=2;
  6076.  
  6077.                                         }
  6078.  
  6079.                                         op((unsigned int)itok.number);
  6080.  
  6081.                                 }
  6082.  
  6083.                         }
  6084.  
  6085.                         else{
  6086.  
  6087.                                 if(tok!=tk_beg||(unsigned int)itok.number!=CL){
  6088.  
  6089.                                         getintobeg(CL,&ofsstr);
  6090.  
  6091.                                         warningreg(begs[1]);
  6092.  
  6093.                                         ClearReg(CX);
  6094.  
  6095.                                         next=0;
  6096.  
  6097.                                 }
  6098.  
  6099.                                 CheckAllMassiv(bbuf,1,&bstr,&btok);
  6100.  
  6101.                                 outseg(&btok,2);
  6102.  
  6103.                                 op(0xD2);       op(0x20+vop+btok.rm);  /* SHL [byte],CL */
  6104.  
  6105.                                 outaddress(&btok);
  6106.  
  6107.                         }
  6108.  
  6109.                         break;
  6110.  
  6111.                 default: operatorexpected(); break;
  6112.  
  6113.         }
  6114.  
  6115. #ifdef OPTVARCONST
  6116.  
  6117.         if(initconst==FALSE)ClearVarByNum(&btok);
  6118.  
  6119. #endif
  6120.  
  6121.         if(next)nexttok();
  6122.  
  6123.         if(terminater==tk_semicolon)seminext();
  6124.  
  6125.         return retrez;
  6126.  
  6127. }
  6128.  
  6129.  
  6130.  
  6131. void  getinto_reg(int gtok,ITOK *gstok,char *&gbuf,SINFO *gstr,int razr,int reg)
  6132.  
  6133. {
  6134.  
  6135. unsigned int i=0;
  6136.  
  6137. int vop=0;
  6138.  
  6139. int reg1=SI,reg2=DI;
  6140.  
  6141.         switch(gtok){
  6142.  
  6143.                 case tk_dwordvar:
  6144.  
  6145.                 case tk_longvar:
  6146.  
  6147.                         i+=4;
  6148.  
  6149. longvar:
  6150.  
  6151.                         CheckAllMassiv(gbuf,i,gstr,gstok,reg1,reg2);
  6152.  
  6153.                         op66(razr);
  6154.  
  6155.                         outseg(gstok,2);
  6156.  
  6157.                         op(0x8B);
  6158.  
  6159.                         op(gstok->rm+reg*8);
  6160.  
  6161.                         outaddress(gstok);
  6162.  
  6163.                         ClearReg(reg);
  6164.  
  6165.                         break;
  6166.  
  6167.                 case tk_intvar:
  6168.  
  6169.                         vop=8;
  6170.  
  6171.                 case tk_wordvar:
  6172.  
  6173.                         i=2;
  6174.  
  6175.                         goto longvar;
  6176.  
  6177.                 case tk_bytevar:
  6178.  
  6179.                 case tk_charvar:
  6180.  
  6181.                         CheckAllMassiv(gbuf,i,gstr,gstok,reg1,reg2);
  6182.  
  6183.                         outseg(gstok,2);
  6184.  
  6185.                         op(0x8A);
  6186.  
  6187.                         op(gstok->rm+reg*8);
  6188.  
  6189.                         outaddress(gstok);
  6190.  
  6191.                         ClearReg(reg);
  6192.  
  6193.                         break;
  6194.  
  6195.         }
  6196.  
  6197. }
  6198.  
  6199.  
  6200.  
  6201. void  getinto_e_ax(int sign,int gtok,ITOK *gstok,char *&gbuf,SINFO *gstr,int razr,int useAX)
  6202.  
  6203. {
  6204.  
  6205. unsigned int i=0;
  6206.  
  6207. int vop=0;
  6208.  
  6209. int reg1=idxregs[0],reg2=idxregs[1];
  6210.  
  6211.         if(am32){
  6212.  
  6213.                 reg1=useAX==FALSE?EAX:idxregs[0];
  6214.  
  6215.                 reg2=idxregs[3];
  6216.  
  6217.         }
  6218.  
  6219. //      printf("tok=%u %s\n",gtok,gstok->name);
  6220.  
  6221.         switch(gtok){
  6222.  
  6223.                 case tk_bits:
  6224.  
  6225.                         vop=gstok->bit.siz+gstok->bit.ofs;
  6226.  
  6227.                         if(vop<=64)i=r64;
  6228.  
  6229.                         if(vop<=32)i=r32;
  6230.  
  6231.                         if(vop<=16)i=r16;
  6232.  
  6233.                         bits2reg(AX,((unsigned int)razr>i?razr:i));
  6234.  
  6235.                         break;
  6236.  
  6237.                 case tk_postnumber:
  6238.  
  6239.                         op66(razr);
  6240.  
  6241.                         op(0xB8); /* MOV EAX,# */
  6242.  
  6243.                         (gstok->flag&f_extern)==0?setwordpost(gstok):setwordext(&gstok->number);
  6244.  
  6245.                         razr==r16?outword(gstok->number):outdword(gstok->number);
  6246.  
  6247.                         ClearReg(AX);
  6248.  
  6249.                         break;
  6250.  
  6251.                 case tk_rmnumber:
  6252.  
  6253.                         CheckAllMassiv(gbuf,gstok->size,gstr,gstok,reg1,reg2);
  6254.  
  6255.                         if(gstok->rm||am32==0){
  6256.  
  6257.                                 op66(razr);
  6258.  
  6259.                                 op67(gstok->sib==CODE16?r16:r32);
  6260.  
  6261.                                 if(gstok->post==0)outseg(gstok,2);
  6262.  
  6263.                                 op(0x8D); op(gstok->rm);
  6264.  
  6265.                                 if(gstok->post!=0&&gstok->post!=UNDEF_OFSET){
  6266.  
  6267.                                         if((gstok->flag&f_extern)==0){
  6268.  
  6269.                                                 i=outptr;
  6270.  
  6271.                                                 if(am32&&gstok->rm==rm_sib)outptr++;
  6272.  
  6273.                                                 setwordpost(gstok);
  6274.  
  6275.                                                 outptr=i;
  6276.  
  6277.                                         }
  6278.  
  6279.                                         else setwordext(&gstok->number);
  6280.  
  6281.                                 }
  6282.  
  6283.                                 outaddress(gstok); /* LEA AX,[rm] */
  6284.  
  6285.                                 ClearReg(AX);
  6286.  
  6287.                         }
  6288.  
  6289.                         else nexttok();
  6290.  
  6291.                         break;
  6292.  
  6293.                 case tk_doublevar:
  6294.  
  6295.                         vop=4;
  6296.  
  6297.                 case tk_floatvar:
  6298.  
  6299.                         CheckInitBP();
  6300.  
  6301.                         if(cpu<3)cpu=3;
  6302.  
  6303.                         op66(r32);
  6304.  
  6305.                         op(0x50);  //push EAX
  6306.  
  6307.                         if(ESPloc&&am32&&gstok->segm==SS)gstok->number+=4;
  6308.  
  6309.                         addESP+=4;
  6310.  
  6311.                         CheckAllMassiv(gbuf,4,gstr,gstok,reg1,reg2);
  6312.  
  6313.                         outseg(gstok,2);        //fld floatvar
  6314.  
  6315.                         op(0xd9+vop);
  6316.  
  6317.                         op(gstok->rm);
  6318.  
  6319.                         outaddress(gstok);
  6320.  
  6321.                         fistp_stack();
  6322.  
  6323.                         op66(r32);
  6324.  
  6325.                         op(0x58);       //pop EAX
  6326.  
  6327.                         addESP-=4;
  6328.  
  6329.                         RestoreBP();
  6330.  
  6331.                         ClearReg(AX);
  6332.  
  6333.                         break;
  6334.  
  6335.                 case tk_qwordvar:
  6336.  
  6337.                         i=4;
  6338.  
  6339.                 case tk_dwordvar:
  6340.  
  6341.                 case tk_longvar:
  6342.  
  6343.                         i+=4;
  6344.  
  6345. longvar:
  6346.  
  6347.                         if((gstok->rm==rm_d16&&gstok->sib==CODE16)||(gstok->rm==rm_d32&&(gstok->sib==CODE32||gstok->sib==0))){
  6348.  
  6349.                                 op66(razr);
  6350.  
  6351.                                 outseg(gstok,1);
  6352.  
  6353.                                 op(0xA1);
  6354.  
  6355.                                 if(gstok->post==UNDEF_OFSET)AddUndefOff(2,gstok->name);
  6356.  
  6357.                                 if(am32==FALSE)outword((unsigned int)gstok->number);
  6358.  
  6359.                                 else outdword(gstok->number);
  6360.  
  6361.                         }
  6362.  
  6363.                         else{
  6364.  
  6365.                                 CheckAllMassiv(gbuf,i,gstr,gstok,reg1,reg2);
  6366.  
  6367.                                 op66(razr);
  6368.  
  6369.                                 outseg(gstok,2);
  6370.  
  6371.                                 op(0x8B);
  6372.  
  6373.                                 op(gstok->rm);
  6374.  
  6375.                                 outaddress(gstok);
  6376.  
  6377.                         }
  6378.  
  6379.                         ClearReg(AX);
  6380.  
  6381.                         break;
  6382.  
  6383.                 case tk_intvar:
  6384.  
  6385.                         vop=8;
  6386.  
  6387.                 case tk_wordvar:
  6388.  
  6389.                         i=2;
  6390.  
  6391.                         if(razr==r16)goto longvar;
  6392.  
  6393.                         i=1;
  6394.  
  6395.                         if(optimizespeed&&vop==0&&chip>3&&chip<7)goto optpent;
  6396.  
  6397. movxx:
  6398.  
  6399.                         CheckAllMassiv(gbuf,1+i,gstr,gstok,reg1,reg2);
  6400.  
  6401.                         op66(razr);
  6402.  
  6403.                         outseg(gstok,3);        /* MOVSX EAX,[charvar] */
  6404.  
  6405.                         op(0x0F); op(0xB6+vop+i); op(gstok->rm);
  6406.  
  6407.                         outaddress(gstok);
  6408.  
  6409.                         ClearReg(AX);
  6410.  
  6411.                         break;
  6412.  
  6413.                 case tk_charvar:
  6414.  
  6415.                         vop=8;
  6416.  
  6417.                         if(razr==r16){
  6418.  
  6419.                                 if((gstok->rm==rm_d16&&gstok->sib==CODE16)||(gstok->rm==rm_d32&&(gstok->sib==CODE32||gstok->sib==0))){
  6420.  
  6421.                                         outseg(gstok,1);
  6422.  
  6423.                                         op(0xA0);
  6424.  
  6425.                                         if(am32==FALSE)outword(gstok->number);
  6426.  
  6427.                                         else outdword(gstok->number);
  6428.  
  6429.                                 }
  6430.  
  6431.                                 else{
  6432.  
  6433.                                         CheckAllMassiv(gbuf,1,gstr,gstok,reg1,reg2);
  6434.  
  6435.                                         outseg(gstok,2);
  6436.  
  6437.                                         op(0x8A); op(gstok->rm);
  6438.  
  6439.                                         outaddress(gstok);
  6440.  
  6441.                                 }
  6442.  
  6443.                                 cbw();
  6444.  
  6445.                                 ClearReg(AX);
  6446.  
  6447.                                 break;
  6448.  
  6449.                         }
  6450.  
  6451.                         goto movxx;
  6452.  
  6453.                 case tk_bytevar:
  6454.  
  6455. optpent:
  6456.  
  6457.                         if((gstok->rm==rm_d16&&gstok->sib==CODE16)||(gstok->rm==rm_d32&&(gstok->sib==CODE32||gstok->sib==0))){
  6458.  
  6459.                                 ZeroReg(EAX,razr);
  6460.  
  6461.                                 if(i)op66(r16);
  6462.  
  6463.                                 outseg(gstok,1);
  6464.  
  6465.                                 op(0xA0+i);
  6466.  
  6467.                                 if(am32==FALSE)outword(gstok->number);
  6468.  
  6469.                                 else outdword(gstok->number);
  6470.  
  6471.                                 ClearReg(AX);
  6472.  
  6473.                                 break;
  6474.  
  6475.                         }
  6476.  
  6477.                         if((chip>=3&&(!optimizespeed))||RmEqualReg(AX,gstok->rm,gstok->sib))goto movxx;
  6478.  
  6479.                         ZeroReg(EAX,razr);
  6480.  
  6481.                         CheckAllMassiv(gbuf,1+i,gstr,gstok,SI,reg2);
  6482.  
  6483.                         if(i)op66(r16);
  6484.  
  6485.                         outseg(gstok,2);
  6486.  
  6487.                         op(0x8A+i); op(gstok->rm);
  6488.  
  6489.                         outaddress(gstok);
  6490.  
  6491.                         break;
  6492.  
  6493.                 case tk_beg:
  6494.  
  6495.                         if(gstok->number==AL&&(!sign)&&razr==r16){
  6496.  
  6497.                                 xorAHAH();
  6498.  
  6499.                                 ClearReg(AX);
  6500.  
  6501.                                 break;
  6502.  
  6503.                         }
  6504.  
  6505.                         if(optimizespeed&&chip>3&&chip<7){
  6506.  
  6507.                                 if(sign){
  6508.  
  6509.                                         if(razr==r32)goto movxxr;
  6510.  
  6511.                                         if(gstok->number!=AL){
  6512.  
  6513.                                                 op(0x88);
  6514.  
  6515.                                                 op(0xC0+gstok->number*8);       //mov al,beg
  6516.  
  6517.                                         }
  6518.  
  6519.                                         if(gstok->number!=AH)outword(0xC488);   //mov ah,al
  6520.  
  6521.                                         outword(0xFCC0);        //sar ah,7
  6522.  
  6523.                                         op(7);
  6524.  
  6525.                                 }
  6526.  
  6527.                                 else{
  6528.  
  6529.                                         if(razr==r32&&(gstok->number==AL||gstok->number==AH)){
  6530.  
  6531.                                                 /*if(chip==4)*/goto movxxr;
  6532.  
  6533. /*                                              op(0x88);
  6534.  
  6535.                                                 op(0xC1+gstok->number*8);       //mov cl,beg
  6536.  
  6537.                                                 xorEAXEAX();
  6538.  
  6539.                                                 outword(0xC888);        // mov al,cl
  6540.  
  6541.                                                 warningreg(begs[1]);
  6542.  
  6543.                                                 break;*/
  6544.  
  6545.                                         }
  6546.  
  6547.                                         if(gstok->number==AH)outdword(0xE430E088);      //mov al,ah xor ah,ah
  6548.  
  6549.                                         else{
  6550.  
  6551.                                                 ZeroReg(EAX,razr);
  6552.  
  6553.                                                 op(0x88);
  6554.  
  6555.                                                 op(0xC0+gstok->number*8);       //mov al,beg
  6556.  
  6557.                                         }
  6558.  
  6559.                                 }
  6560.  
  6561.                                 ClearReg(AX);
  6562.  
  6563.                                 break;
  6564.  
  6565.                         }
  6566.  
  6567. movxxr:
  6568.  
  6569.                         if(chip>2||razr==r32){
  6570.  
  6571.                                 op66(razr);
  6572.  
  6573.                                 if(sign)outword(0xBE0F);
  6574.  
  6575.                                 else outword(0xB60F);
  6576.  
  6577.                                 op(0xC0+(unsigned int)gstok->number); // MOVxX AX,beg
  6578.  
  6579.                         }
  6580.  
  6581.                         else{
  6582.  
  6583.                                 op(0x88);
  6584.  
  6585.                                 op(0xC0+gstok->number*8);
  6586.  
  6587.                                 if(sign)cbw();
  6588.  
  6589.                                 else xorAHAH();
  6590.  
  6591.                         }
  6592.  
  6593.                         ClearReg(AX);
  6594.  
  6595.                         break;
  6596.  
  6597.                 case tk_reg:
  6598.  
  6599.                         if(razr==r32){
  6600.  
  6601.                                 if(tok2==tk_openbracket){       //¢ë§®¢ ¯à®æ¥¤ãàë ¯®  ¤à¥áã ¢ ॣ¨áâà¥
  6602.  
  6603.                                         reg1=gstok->number;
  6604.  
  6605.                                         nexttok();
  6606.  
  6607.                                         param[0]=0;
  6608.  
  6609.                                         if(comfile==file_w32)swapparam();
  6610.  
  6611.                                         else doparams();
  6612.  
  6613.                                         op66(r16);
  6614.  
  6615.                                         op(0xFF);
  6616.  
  6617.                                         op(0xD0+reg1);  /* CALL reg with stack params */
  6618.  
  6619. #ifdef OPTVARCONST
  6620.  
  6621.                                         FreeGlobalConst();
  6622.  
  6623. #endif
  6624.  
  6625.                                         clearregstat();
  6626.  
  6627.                                         break;
  6628.  
  6629.                                 }
  6630.  
  6631.                                 if(optimizespeed&&(!sign)&&chip>3&&chip<7){
  6632.  
  6633.                                         if(gstok->number==AX){
  6634.  
  6635.                                                 goto movxr;
  6636.  
  6637. /*                                              op66(r16);
  6638.  
  6639.                                                 outword(0xC189);        //mov cx,AX
  6640.  
  6641.                                                 xorEAXEAX();
  6642.  
  6643.                                                 op66(r16);
  6644.  
  6645.                                                 outword(0xC889);        //mov aX,cX
  6646.  
  6647.                                                 warningreg(regs[0][1]);*/
  6648.  
  6649.                                         }
  6650.  
  6651.                                         else{
  6652.  
  6653.                                                 xorEAXEAX();
  6654.  
  6655.                                                 op66(r16);
  6656.  
  6657.                                                 op(0x89);
  6658.  
  6659.                                                 op(0xC0+gstok->number*8);       //mov ax,reg
  6660.  
  6661.                                         }
  6662.  
  6663.                                 }
  6664.  
  6665.                                 else{
  6666.  
  6667. movxr:
  6668.  
  6669.                                         op66(r32);
  6670.  
  6671.                                         op(0x0F);       /* MOVSX or MOVZX EAX,reg */
  6672.  
  6673.                                         if(sign)op(0xBF);
  6674.  
  6675.                                         else op(0xB7);
  6676.  
  6677.                                         op(0xC0+gstok->number);
  6678.  
  6679.                                 }
  6680.  
  6681.                                 RegToReg(AX,gstok->number,razr);
  6682.  
  6683.                                 break;
  6684.  
  6685.                         }
  6686.  
  6687.                 case tk_reg32:
  6688.  
  6689.                         if(tok2==tk_openbracket){       //¢ë§®¢ ¯à®æ¥¤ãàë ¯®  ¤à¥áã ¢ ॣ¨áâà¥
  6690.  
  6691.                                 reg1=gstok->number;
  6692.  
  6693.                                 nexttok();
  6694.  
  6695.                                 param[0]=0;
  6696.  
  6697.                                 if(comfile==file_w32)swapparam();
  6698.  
  6699.                                 else doparams();
  6700.  
  6701.                                 op66(razr);
  6702.  
  6703.                                 op(0xFF);
  6704.  
  6705.                                 op(0xD0+reg1);  /* CALL reg with stack params */
  6706.  
  6707.                                 clearregstat();
  6708.  
  6709. #ifdef OPTVARCONST
  6710.  
  6711.                                 FreeGlobalConst();
  6712.  
  6713. #endif
  6714.  
  6715.                                 break;
  6716.  
  6717.                         }
  6718.  
  6719.                         if(gstok->number!=AX){
  6720.  
  6721.                                 op66(razr);
  6722.  
  6723.                                 op(0x89);
  6724.  
  6725.                                 op(0xC0+gstok->number*8);
  6726.  
  6727.                                 RegToReg(AX,gstok->number,razr);
  6728.  
  6729.                         }
  6730.  
  6731.                         break;
  6732.  
  6733.                 case tk_seg:
  6734.  
  6735.                         if(razr==r32)op66(r32);
  6736.  
  6737.                         op(0x8C);       //mov var,SS
  6738.  
  6739.                         op(0xC0+gstok->number*8);
  6740.  
  6741.                         ClearReg(AX);
  6742.  
  6743.                         break;
  6744.  
  6745.                 case tk_string:
  6746.  
  6747.                         op66(razr);
  6748.  
  6749.                         op(0xB8);
  6750.  
  6751.                         if(razr==r16){
  6752.  
  6753.                                 if(am32)dwordvalexpected();
  6754.  
  6755.                                 outword(addpoststring(CS,gstok->number,gstok->flag));
  6756.  
  6757.                         }
  6758.  
  6759.                         else outdword(addpoststring(CS,gstok->number,gstok->flag));
  6760.  
  6761.                         ClearReg(AX);
  6762.  
  6763.                         break;
  6764.  
  6765.                 default: valueexpected();       break;
  6766.  
  6767.         }
  6768.  
  6769.         if(razr==r32&&cpu<3)cpu=3;
  6770.  
  6771. }
  6772.  
  6773.  
  6774.  
  6775. int caselong(unsigned long val)
  6776.  
  6777. {
  6778.  
  6779. int vop=0;
  6780.  
  6781. unsigned long num;
  6782.  
  6783.         for(;vop<NUMNUM;vop++){
  6784.  
  6785.                 num=li[vop];
  6786.  
  6787.                 if(val==num)break;
  6788.  
  6789.                 if(val<num)return NUMNUM;
  6790.  
  6791.         }
  6792.  
  6793.         return vop;
  6794.  
  6795. }
  6796.  
  6797.  
  6798.  
  6799. int caselonglong(unsigned long long val)
  6800.  
  6801. {
  6802.  
  6803. int vop=0;
  6804.  
  6805. unsigned long long num;
  6806.  
  6807.         for(;vop<NUMNUM64;vop++){
  6808.  
  6809.                 num=li[vop];
  6810.  
  6811.                 if(val==num)break;
  6812.  
  6813.                 if(val<num)return NUMNUM64;
  6814.  
  6815.         }
  6816.  
  6817.         return vop;
  6818.  
  6819. }
  6820.  
  6821.  
  6822.  
  6823. int do_e_axmath(int sign,int razr,char **ofsstr)
  6824.  
  6825. {
  6826.  
  6827. int negflag=0,next=0;
  6828.  
  6829. int expand=FALSE,rettype;
  6830.  
  6831. unsigned int i=0;
  6832.  
  6833. unsigned long holdnumber=0;
  6834.  
  6835. int loop=0,otok;
  6836.  
  6837.         rettype=(razr==r16?tk_reg:tk_reg32);
  6838.  
  6839.         if(tok==tk_minus){
  6840.  
  6841.                 if(CheckMinusNum()==FALSE){
  6842.  
  6843.                         negflag=1;
  6844.  
  6845.                         getoperand(am32==TRUE?EAX:BX);
  6846.  
  6847.                 }
  6848.  
  6849.         }
  6850.  
  6851.         if(uselea){
  6852.  
  6853.                 if(razr==r32){
  6854.  
  6855.                         if(Reg32ToLea(EAX)){
  6856.  
  6857.                                 goto contloop;  //®¯â¨¬¨§ æ¨ï á«®¦¥­¨ï 32-¡¨â­ëå ॣ¨áâ஢ ¢ LEA
  6858.  
  6859.                         }
  6860.  
  6861.                 }
  6862.  
  6863.                 else if(Reg16ToLea(AX)){
  6864.  
  6865.                         goto contloop;  //®¯â¨¬¨§ æ¨ï á«®¦¥­¨ï 32-¡¨â­ëå ॣ¨áâ஢
  6866.  
  6867.                 }
  6868.  
  6869.         }
  6870.  
  6871. loopswitch:
  6872.  
  6873.         otok=tok;
  6874.  
  6875. //      printf("tok=%d %s\n",tok,itok.name);
  6876.  
  6877. #ifdef OPTVARCONST
  6878.  
  6879.         CheckConstVar3(&tok,&itok,razr);
  6880.  
  6881.         if(tok==tk_number)calcnumber=TRUE;
  6882.  
  6883. #endif
  6884.  
  6885.         switch(tok){
  6886.  
  6887.                 case tk_number:
  6888.  
  6889.                         holdnumber=CalcNumber(sign);
  6890.  
  6891.                         if(loop==0)i=postnumflag;
  6892.  
  6893.                         else i^=postnumflag;
  6894.  
  6895.                         loop++;
  6896.  
  6897.                         if(tok==tk_mult&&(optimizespeed||razr==r32)&&
  6898.  
  6899.                                         (!((tok2==tk_reg32||tok2==tk_reg)&&itok2.number==EAX))&&expandvar()==FALSE){
  6900.  
  6901.                                 getoperand(am32==TRUE?EAX:BX);
  6902.  
  6903.                                 next=1;
  6904.  
  6905.                                 goto loopswitch;
  6906.  
  6907.                         }
  6908.  
  6909.                         if(tok==tk_plus&&tok2==tk_postnumber){
  6910.  
  6911.                                 nexttok();
  6912.  
  6913.                                 goto loopswitch;
  6914.  
  6915.                         }
  6916.  
  6917.                         MovRegNum(razr,i&f_reloc,holdnumber,EAX);
  6918.  
  6919.                         next=0;
  6920.  
  6921.                         break;
  6922.  
  6923.                 case tk_apioffset:
  6924.  
  6925.                         op66(razr);
  6926.  
  6927.                         op(0xB8);                       /* MOV AX,# */
  6928.  
  6929.                         AddApiToPost(itok.number);
  6930.  
  6931.                         nexttok();
  6932.  
  6933.                         break;
  6934.  
  6935.                 case tk_postnumber:
  6936.  
  6937.                 case tk_undefofs:
  6938.  
  6939.                         if(next==0){
  6940.  
  6941.                                 op66(razr);
  6942.  
  6943.                                 op(0xB8);                       /* MOV AX,# */
  6944.  
  6945.                                 next=1;
  6946.  
  6947.                         }
  6948.  
  6949.                         if(tok==tk_undefofs){
  6950.  
  6951.                                 AddUndefOff(2,itok.name);
  6952.  
  6953. //                              AddUndefOff(0,itok.name);       //22.11.04 20:52
  6954.  
  6955. //                              itok.flag=0;    //new 07.07.04 23:57
  6956.  
  6957.                         }
  6958.  
  6959.                         else (itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
  6960.  
  6961.                         tok=tk_number;
  6962.  
  6963.                         holdnumber+=doconstdwordmath();
  6964.  
  6965.                         if(otok!=tk_postnumber){
  6966.  
  6967.                                 if(loop==0)i=postnumflag;
  6968.  
  6969.                                 else i^=postnumflag;
  6970.  
  6971.                                 loop++;
  6972.  
  6973.                         }
  6974.  
  6975.                         if(tok==tk_plus&&tok2==tk_postnumber){
  6976.  
  6977.                                 nexttok();
  6978.  
  6979.                                 goto loopswitch;
  6980.  
  6981.                         }
  6982.  
  6983.                         if((i&f_reloc)!=0)AddReloc();
  6984.  
  6985.                         next=0;
  6986.  
  6987.                         if(razr==r16)outword(holdnumber);
  6988.  
  6989.                         else outdword(holdnumber);
  6990.  
  6991.                         ClearReg(AX);
  6992.  
  6993.                         break;
  6994.  
  6995.                 case tk_rmnumber:
  6996.  
  6997. int reg1,reg2;
  6998.  
  6999.                         reg1=am32==FALSE?idxregs[0]:EAX;
  7000.  
  7001.                         reg2=am32==FALSE?idxregs[1]:ECX;
  7002.  
  7003.                         CheckAllMassiv(bufrm,itok.size,&strinf,&itok,reg1,reg2);
  7004.  
  7005.                         if(itok.rm||am32==0){
  7006.  
  7007.                                 op66(razr);
  7008.  
  7009.                                 op67(itok.sib==CODE16?r16:r32);
  7010.  
  7011.                                 if((itok.rm&0x3F)==0&&am32&&itok.post==0&&(short_ok(itok.number,TRUE)==FALSE||((itok.rm&rm_mod11)==rm_mod10))){ //add
  7012.  
  7013.                                         outseg(&itok,1);
  7014.  
  7015.                                         op(5);  //add
  7016.  
  7017.                                 }
  7018.  
  7019.                                 else{   //lea
  7020.  
  7021.                                         if(itok.post==0)outseg(&itok,2);
  7022.  
  7023.                                         op(0x8D); op(itok.rm);
  7024.  
  7025.                                 }
  7026.  
  7027. //                              if(itok.post==0)outseg(&itok,2);
  7028.  
  7029. //                              op(0x8D); op(itok.rm);
  7030.  
  7031.                                 if(itok.post!=0&&itok.post!=UNDEF_OFSET){
  7032.  
  7033.                                         if((itok.flag&f_extern)==0){
  7034.  
  7035.                                                 i=outptr;
  7036.  
  7037.                                                 if(am32&&itok.rm==rm_sib)outptr++;
  7038.  
  7039.                                                 setwordpost(&itok);
  7040.  
  7041.                                                 outptr=i;
  7042.  
  7043.                                         }
  7044.  
  7045.                                         else setwordext(&itok.number);
  7046.  
  7047.                                 }
  7048.  
  7049. ITOK oitok;
  7050.  
  7051.                                 oitok=itok;
  7052.  
  7053.                                 tok=tk_number;
  7054.  
  7055.                                 itok.rm=tk_dword;
  7056.  
  7057.                                 oitok.number=doconstdwordmath();
  7058.  
  7059. //                      oitok.flag|=postnumflag;
  7060.  
  7061.                                 outaddress(&oitok); // LEA AX,[rm]
  7062.  
  7063.                                 ClearReg(AX);
  7064.  
  7065.                         }
  7066.  
  7067.                         else nexttok();
  7068.  
  7069.                         break;
  7070.  
  7071.                 case tk_at:
  7072.  
  7073.                         getoperand(am32==TRUE?EAX:BX);
  7074.  
  7075.                         i++;
  7076.  
  7077.                 case tk_ID:
  7078.  
  7079.                 case tk_id:
  7080.  
  7081.                 case tk_proc:
  7082.  
  7083.                 case tk_apiproc:
  7084.  
  7085.                 case tk_undefproc:
  7086.  
  7087.                 case tk_declare:
  7088.  
  7089.                         if(itok.flag&f_retproc)rettype=(itok.flag&f_retproc)/256+tk_overflowflag-1;
  7090.  
  7091.                         if((!i)||
  7092.  
  7093.                                         macros(sign!=0?(razr==r16?tk_int:tk_long):(razr==r16?tk_word:tk_dword))==0){
  7094.  
  7095.                                 procdo(sign!=0?(razr==r16?tk_int:tk_long):(razr==r16?tk_word:tk_dword));
  7096.  
  7097.                         }
  7098.  
  7099.                         nexttok();
  7100.  
  7101.                         if(*ofsstr){
  7102.  
  7103.                                 free(*ofsstr);
  7104.  
  7105.                                 *ofsstr=NULL;
  7106.  
  7107.                         }
  7108.  
  7109.                         break;
  7110.  
  7111.                 case tk_new:
  7112.  
  7113.                         donew();
  7114.  
  7115.                         clearregstat();
  7116.  
  7117. #ifdef OPTVARCONST
  7118.  
  7119.                         FreeGlobalConst();
  7120.  
  7121. #endif
  7122.  
  7123.                         if(*ofsstr){
  7124.  
  7125.                                 free(*ofsstr);
  7126.  
  7127.                                 *ofsstr=NULL;
  7128.  
  7129.                         }
  7130.  
  7131.                         nexttok();
  7132.  
  7133.                         break;
  7134.  
  7135.                 default:
  7136.  
  7137.                         SINFO wstr=strinf;
  7138.  
  7139.                         ITOK witok=itok;
  7140.  
  7141.                         char *wbuf=bufrm;
  7142.  
  7143.                         bufrm=NULL;
  7144.  
  7145.                         strinf.bufstr=NULL;
  7146.  
  7147.                         getinto_e_ax(sign,tok,&witok,wbuf,&wstr,razr);
  7148.  
  7149.                         nexttok(); break;
  7150.  
  7151.         }
  7152.  
  7153. contloop:
  7154.  
  7155.         if(negflag){
  7156.  
  7157.                 NegReg(razr,EAX);
  7158.  
  7159.                 setzeroflag=TRUE;
  7160.  
  7161.         }
  7162.  
  7163. #ifdef OPTVARCONST
  7164.  
  7165.         calcnumber=FALSE;
  7166.  
  7167. #endif
  7168.  
  7169.         if(next)RegMulNum(AX,holdnumber,razr,sign,&expand,i);
  7170.  
  7171. //      printf("tok=%d type=%d name=%s\n",tok,itok.type,itok.name);
  7172.  
  7173.         if(itok.type!=tp_stopper&&tok!=tk_eof&&itok.type!=tp_compare){
  7174.  
  7175.                 do_e_axmath2(sign,razr,expand);
  7176.  
  7177.                 rettype=(razr==r16?tk_reg:tk_reg32);
  7178.  
  7179.         }
  7180.  
  7181.         return rettype;
  7182.  
  7183. }
  7184.  
  7185.  
  7186.  
  7187. void do_e_axmath2(int sign,int razr,int expand)
  7188.  
  7189. {
  7190.  
  7191. int vop,negflag=0,next;
  7192.  
  7193. int optnum=FALSE;
  7194.  
  7195. unsigned int i;
  7196.  
  7197. char *ofsstr=NULL;
  7198.  
  7199. unsigned char oaddstack;
  7200.  
  7201.         while(itok.type!=tp_stopper&&tok!=tk_eof&&itok.type!=tp_compare){
  7202.  
  7203.                 next=1;
  7204.  
  7205.                 vop=0;
  7206.  
  7207.                 i=0;
  7208.  
  7209. // !!! new
  7210.  
  7211. #ifdef OPTVARCONST
  7212.  
  7213.                 CheckConstVar3(&tok2,&itok2,razr);
  7214.  
  7215.                 if(tok2==tk_number)calcnumber=TRUE;
  7216.  
  7217. #endif
  7218.  
  7219.                 if(uselea&&razr==r32){
  7220.  
  7221.                         if(Reg32ToLea2(EAX))continue;   //®¯â¨¬¨§ æ¨ï á«®¦¥­¨ï 32-¡¨â­ëå ॣ¨áâ஢ ¢ LEA
  7222.  
  7223.                         if(itok.type==tp_stopper||tok==tk_eof||itok.type==tp_compare)break;
  7224.  
  7225.                 }
  7226.  
  7227.  
  7228.  
  7229.                 if(tok2==tk_number)optnum=OptimNum();
  7230.  
  7231.                 int oldtok=tok;
  7232.  
  7233.                 switch(tok){
  7234.  
  7235.                         case tk_xor: vop+=0x08;
  7236.  
  7237.                         case tk_minus: vop+=0x08;
  7238.  
  7239.                         case tk_and: vop+=0x18;
  7240.  
  7241.                         case tk_or: vop+=0x08;
  7242.  
  7243.                         case tk_plus:
  7244.  
  7245.                           if(optnum==FALSE)getoperand();
  7246.  
  7247.                                 else{
  7248.  
  7249.                                         tok=tk_number;
  7250.  
  7251.                                         optnum=FALSE;
  7252.  
  7253.                                 }
  7254.  
  7255.                                 switch(tok){
  7256.  
  7257.                                         case tk_number:
  7258.  
  7259.                                                 if((itok.flag&f_reloc)==0){
  7260.  
  7261.                                                         if(optnumadd(itok.number,0,razr,vop))break;
  7262.  
  7263.                                                 }
  7264.  
  7265.                                         case tk_undefofs:
  7266.  
  7267.                                         case tk_postnumber:
  7268.  
  7269.                                                 op66(razr);
  7270.  
  7271.                                           op(0x05+vop);
  7272.  
  7273.                                                 if(tok==tk_postnumber)(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
  7274.  
  7275.                                                 else if(tok==tk_undefofs)AddUndefOff(0,itok.name);
  7276.  
  7277.                                                 else if((itok.flag&f_reloc)!=0)AddReloc();
  7278.  
  7279.                                                 razr==r16?outword((unsigned int)itok.number):outdword(itok.number);
  7280.  
  7281.                                                 setzeroflag=TRUE;
  7282.  
  7283.                                                 break;
  7284.  
  7285.                                         case tk_apioffset:
  7286.  
  7287.                                                 op66(razr);
  7288.  
  7289.                                           op(0x05+vop);
  7290.  
  7291.                                                 AddApiToPost(itok.number);
  7292.  
  7293.                                                 setzeroflag=TRUE;
  7294.  
  7295.                                                 break;
  7296.  
  7297.                                         case tk_qwordvar:
  7298.  
  7299.                                         case tk_longvar:
  7300.  
  7301.                                         case tk_dwordvar:
  7302.  
  7303.                                                 i=2;
  7304.  
  7305.                                         case tk_intvar:
  7306.  
  7307.                                         case tk_wordvar:
  7308.  
  7309.                                                 if(razr==r32&&(tok==tk_intvar||tok==tk_wordvar))goto defxor;
  7310.  
  7311.                                                 i+=2;
  7312.  
  7313.                                                 CheckAllMassiv(bufrm,i,&strinf);
  7314.  
  7315.                                                 op66(razr);
  7316.  
  7317.                                                 outseg(&itok,2);
  7318.  
  7319.                                                 op(0x03+vop);
  7320.  
  7321.                                                 op(itok.rm);
  7322.  
  7323.                                                 outaddress(&itok);
  7324.  
  7325.                                                 setzeroflag=TRUE;
  7326.  
  7327.                                                 break;
  7328.  
  7329.                                         case tk_doublevar:
  7330.  
  7331.                                                 i=4;
  7332.  
  7333.                                         case tk_floatvar:
  7334.  
  7335.                                                 Float2reg32(EDX,i);
  7336.  
  7337.                                                 itok.number=EDX;
  7338.  
  7339.                                                 warningreg(regs[1][EDX]);
  7340.  
  7341.                                                 goto defreg32;
  7342.  
  7343.                                         case tk_ID:
  7344.  
  7345.                                         case tk_id:
  7346.  
  7347.                                         case tk_proc:
  7348.  
  7349.                                         case tk_apiproc:
  7350.  
  7351.                                         case tk_undefproc:
  7352.  
  7353.                                         case tk_declare:
  7354.  
  7355.                                                 op66(razr);
  7356.  
  7357.                                                 op(0x50);       //push AX
  7358.  
  7359.                                                 addESP+=razr==r16?2:4;
  7360.  
  7361.                                                 oaddstack=addstack;
  7362.  
  7363.                                                 addstack=FALSE;
  7364.  
  7365.                                                 procdo(razr==r16?(sign==0?tk_word:tk_int):(sign==0?tk_dword:tk_long));
  7366.  
  7367.                                                 addstack=oaddstack;
  7368.  
  7369.                                                 addESP-=razr==r16?2:4;
  7370.  
  7371.                                                 op66(razr);
  7372.  
  7373.                                                 op(0x58+EDX);
  7374.  
  7375.                                                 itok.number=EDX;
  7376.  
  7377.                                                 warningreg(regs[razr/2-1][EDX]);
  7378.  
  7379.                                                 if(vop>0x20){
  7380.  
  7381.                                                         op66(razr);
  7382.  
  7383.                                                         op(0x90+EDX);   //xchg ax,dx
  7384.  
  7385.                                                 }
  7386.  
  7387.                                                 goto defreg32;
  7388.  
  7389.                                         case tk_bits:
  7390.  
  7391.                                                 int vops;
  7392.  
  7393.                                                 i=itok.bit.siz+itok.bit.ofs;
  7394.  
  7395.                                                 if(i<=64)vops=r64;
  7396.  
  7397.                                                 if(i<=32)vops=r32;
  7398.  
  7399.                                                 if(i<=16)vops=r16;
  7400.  
  7401.                                                 bits2reg(CX,(razr<vops?vops:razr));
  7402.  
  7403.                                                 itok.number=CX;
  7404.  
  7405.                                                 if(vops==r64)vops=r32;
  7406.  
  7407.                                                 warningreg(regs[vops/2-1][ECX]);
  7408.  
  7409.                                                 goto defreg32;
  7410.  
  7411.                                         case tk_reg:
  7412.  
  7413.                                                 if(razr==r32)goto defxor;
  7414.  
  7415.                                         case tk_reg32:
  7416.  
  7417. defreg32:
  7418.  
  7419.                                                 op66(razr);
  7420.  
  7421.                                                 op(0x01+vop);
  7422.  
  7423.                                                 op(0xC0+(unsigned int)itok.number*8);
  7424.  
  7425.                                                 setzeroflag=TRUE;
  7426.  
  7427.                                                 break;
  7428.  
  7429.                                         case tk_rmnumber:
  7430.  
  7431.                                         case tk_charvar:
  7432.  
  7433.                                         case tk_beg:
  7434.  
  7435.                                         case tk_bytevar:
  7436.  
  7437. defxor:
  7438.  
  7439.                                                 getintoreg_32(CX,razr,sign,&ofsstr,FALSE);
  7440.  
  7441.                                                 op66(razr);
  7442.  
  7443.                                                 op(0x01+vop);
  7444.  
  7445.                                                 op(0xC8);       /* OPT AX,CX */
  7446.  
  7447.                                                 warningreg(regs[razr/2-1][1]);
  7448.  
  7449.                                                 next=0;
  7450.  
  7451.                                                 setzeroflag=TRUE;
  7452.  
  7453.                                                 break;
  7454.  
  7455.                                         default: valueexpected(); break;
  7456.  
  7457.                                 }
  7458.  
  7459.                                 if(expand==TRUE){
  7460.  
  7461.                                         op66(razr);
  7462.  
  7463.                                         op(0x83);
  7464.  
  7465.                                         if(oldtok==tk_plus)outword(0x00d2);     //adc dx,0
  7466.  
  7467.                                         else if(oldtok==tk_minus)outword(0x00da);       //sbb dx,0
  7468.  
  7469.                                         setzeroflag=TRUE;
  7470.  
  7471.                                 }
  7472.  
  7473.                                 break;
  7474.  
  7475.                         case tk_modminus: negflag=1;
  7476.  
  7477.                         case tk_mod: negflag=1-negflag; vop=1;
  7478.  
  7479.                         case tk_divminus: negflag=1-negflag;
  7480.  
  7481.                         case tk_div:
  7482.  
  7483.                           if(optnum==FALSE)getoperand();
  7484.  
  7485.                                 else{
  7486.  
  7487.                                         tok=tk_number;
  7488.  
  7489.                                         optnum=FALSE;
  7490.  
  7491.                                 }
  7492.  
  7493.                                 if(tok==tk_number){
  7494.  
  7495.                                         if(negflag){
  7496.  
  7497.                                                 itok.number=-itok.number;
  7498.  
  7499.                                                 negflag=0;
  7500.  
  7501.                                         }
  7502.  
  7503.                                 }
  7504.  
  7505.                                 DivMod(vop,sign,razr,expand);
  7506.  
  7507.                                 if(vop==1&&setzeroflag==0){
  7508.  
  7509.                                         op66(razr);
  7510.  
  7511.                                         if(optimizespeed)outword(0xC28B);       //mov ax,dx
  7512.  
  7513.                                         else op(0x92);  //xchg ax,dx
  7514.  
  7515.                                 }
  7516.  
  7517.                                 next=0;
  7518.  
  7519.                                 expand=FALSE;
  7520.  
  7521.                                 break;
  7522.  
  7523.                         case tk_multminus: negflag=1;
  7524.  
  7525.                         case tk_mult:
  7526.  
  7527.                                 expand=expandvar();     //¢®§¬®¦­®áâì à áè¨à¥­¨ï à §à來®áâ¨
  7528.  
  7529.                           if(optnum==FALSE)getoperand();
  7530.  
  7531.                                 else{
  7532.  
  7533.                                         tok=tk_number;
  7534.  
  7535.                                         optnum=FALSE;
  7536.  
  7537.                                 }
  7538.  
  7539.                                 if(negflag&&tok==tk_number){
  7540.  
  7541.                                         itok.number=-itok.number;
  7542.  
  7543.                                         negflag=0;
  7544.  
  7545.                                 }
  7546.  
  7547.                                 switch(tok){
  7548.  
  7549.                                         case tk_number:
  7550.  
  7551.                                                 RegMulNum(AX,itok.number,razr,sign,&expand,itok.flag);
  7552.  
  7553.                                                 break;
  7554.  
  7555.                                         case tk_qwordvar:
  7556.  
  7557.                                         case tk_longvar:
  7558.  
  7559.                                         case tk_dwordvar:
  7560.  
  7561.                                                 i=2;
  7562.  
  7563.                                         case tk_intvar:
  7564.  
  7565.                                         case tk_wordvar:
  7566.  
  7567.                                                 if(razr==r32&&(tok==tk_intvar||tok==tk_wordvar))goto defmul;
  7568.  
  7569.                                                 i+=2;
  7570.  
  7571.                                                 CheckAllMassiv(bufrm,i,&strinf);
  7572.  
  7573.                                                 op66(razr);
  7574.  
  7575.                                                 outseg(&itok,2);
  7576.  
  7577.                                                 op(0xF7);       //imul var
  7578.  
  7579.                                                 if(sign)op(0x28+itok.rm);
  7580.  
  7581.                                                 else op(0x20+itok.rm);
  7582.  
  7583.                                                 outaddress(&itok);
  7584.  
  7585.                                                 setzeroflag=FALSE;
  7586.  
  7587.                                                 break;
  7588.  
  7589.                                         case tk_doublevar:
  7590.  
  7591.                                                 i=4;
  7592.  
  7593.                                         case tk_floatvar:
  7594.  
  7595.                                                 Float2reg32(EDX,i);
  7596.  
  7597.                                                 op66(razr);
  7598.  
  7599.                                                 op(0xF7);
  7600.  
  7601.                                                 op(0xE8+EDX); // IMUL EDX
  7602.  
  7603.                                                 setzeroflag=FALSE;
  7604.  
  7605.                                                 warningreg(regs[1][EDX]);
  7606.  
  7607.                                                 break;
  7608.  
  7609.                                         case tk_ID:
  7610.  
  7611.                                         case tk_id:
  7612.  
  7613.                                         case tk_proc:
  7614.  
  7615.                                         case tk_apiproc:
  7616.  
  7617.                                         case tk_undefproc:
  7618.  
  7619.                                         case tk_declare:
  7620.  
  7621.                                                 op66(razr);
  7622.  
  7623.                                                 op(0x50);       //push AX
  7624.  
  7625.                                                 addESP+=razr==r16?2:4;
  7626.  
  7627.                                                 oaddstack=addstack;
  7628.  
  7629.                                                 addstack=FALSE;
  7630.  
  7631.                                                 procdo(razr==r16?(sign==0?tk_word:tk_int):(sign==0?tk_dword:tk_long));
  7632.  
  7633.                                                 addstack=oaddstack;
  7634.  
  7635.                                                 addESP-=razr==r16?2:4;
  7636.  
  7637.                                                 op66(razr);
  7638.  
  7639.                                                 op(0x58+EDX);
  7640.  
  7641.                                                 itok.number=EDX;
  7642.  
  7643.                                                 warningreg(regs[razr/2-1][EDX]);
  7644.  
  7645.                                                 goto mulreg32;
  7646.  
  7647.                                         case tk_bits:
  7648.  
  7649.                                                 int vops;
  7650.  
  7651.                                                 i=itok.bit.siz+itok.bit.ofs;
  7652.  
  7653.                                                 if(i<=64)vops=r64;
  7654.  
  7655.                                                 if(i<=32)vops=r32;
  7656.  
  7657.                                                 if(i<=16)vops=r16;
  7658.  
  7659.                                                 bits2reg(CX,(razr<vops?vops:razr));
  7660.  
  7661.                                                 itok.number=CX;
  7662.  
  7663.                                                 if(vops==r64)vops=r32;
  7664.  
  7665.                                                 warningreg(regs[vops/2-1][ECX]);
  7666.  
  7667.                                                 goto mulreg32;
  7668.  
  7669.                                         case tk_reg:
  7670.  
  7671.                                                 i=itok.number;
  7672.  
  7673.                                                 if(razr==r32)goto mulreg;
  7674.  
  7675.                                         case tk_reg32:
  7676.  
  7677. mulreg32:
  7678.  
  7679.                                                 op66(razr);
  7680.  
  7681.                                                 op(0xF7);
  7682.  
  7683.                                                 if(sign)op(0xE8+(unsigned int)itok.number);
  7684.  
  7685.                                                 else op(0xE0+(unsigned int)itok.number);
  7686.  
  7687.                                                 setzeroflag=FALSE;
  7688.  
  7689.                                                 break;
  7690.  
  7691.                                         case tk_postnumber:
  7692.  
  7693.                                         case tk_undefofs:
  7694.  
  7695.                                                 op66(razr);
  7696.  
  7697.                                                 op(0x69);
  7698.  
  7699.                                                 op(0xc0);
  7700.  
  7701.                                                 if(tok==tk_postnumber)(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
  7702.  
  7703.                                                 else if(tok==tk_undefofs)AddUndefOff(0,itok.name);
  7704.  
  7705.                                                 razr==r16?outword(itok.number):outdword(itok.number);
  7706.  
  7707.                                                 setzeroflag=FALSE;
  7708.  
  7709.                                                 break;
  7710.  
  7711.                                         case tk_apioffset:
  7712.  
  7713.                                                 op66(razr);
  7714.  
  7715.                                                 op(0x69);
  7716.  
  7717.                                                 op(0xc0);
  7718.  
  7719.                                                 AddApiToPost(itok.number);
  7720.  
  7721.                                                 setzeroflag=FALSE;
  7722.  
  7723.                                                 break;
  7724.  
  7725.                                         case tk_seg:
  7726.  
  7727.                                         case tk_charvar:
  7728.  
  7729.                                         case tk_beg:
  7730.  
  7731.                                         case tk_bytevar:
  7732.  
  7733.                                         case tk_rmnumber:
  7734.  
  7735. defmul:
  7736.  
  7737.                                                 i=EDX;
  7738.  
  7739. mulreg:
  7740.  
  7741.                                                 getintoreg_32(i,razr,sign,&ofsstr,FALSE);
  7742.  
  7743.                                                 op66(razr);
  7744.  
  7745.                                                 op(0xF7);
  7746.  
  7747.                                                 if(sign)op(0xE8+i);  /* IMUL i */
  7748.  
  7749.                                                 else op(0xE0+i); /* MUL i */
  7750.  
  7751.                                                 next=0;
  7752.  
  7753.                                                 setzeroflag=FALSE;
  7754.  
  7755.                                                 warningreg(regs[razr/2-1][2]);
  7756.  
  7757.                                                 if(i!=EDX)warningreg(regs[razr/2-1][i]);
  7758.  
  7759.                                                 break;
  7760.  
  7761.                                         default: valueexpected();       break;
  7762.  
  7763.                                 }
  7764.  
  7765.                                 break;
  7766.  
  7767.                         case tk_xorminus: vop+=0x10;
  7768.  
  7769.                         case tk_andminus: vop+=0x18;
  7770.  
  7771.                         case tk_orminus: vop+=0x08;
  7772.  
  7773.                           getoperand();
  7774.  
  7775.                                 if(tok==tk_number){
  7776.  
  7777.                                         itok.number=-itok.number;
  7778.  
  7779.                                         op66(razr);
  7780.  
  7781.                                         op(0x05+vop);
  7782.  
  7783.                                         if((itok.flag&f_reloc)!=0)AddReloc();
  7784.  
  7785.                                         razr==r16?outword((unsigned int)itok.number):outdword(itok.number);
  7786.  
  7787.                                 }
  7788.  
  7789.                                 else{
  7790.  
  7791.                                         getintoreg_32(CX,razr,sign,&ofsstr,FALSE);
  7792.  
  7793.                                         NegReg(razr,ECX);
  7794.  
  7795.                                         op66(razr);
  7796.  
  7797.                                         op(0x01+vop);   /* opt AX,CX */
  7798.  
  7799.                                         op(0xC8);
  7800.  
  7801.                                         warningreg(regs[razr/2-1][1]);
  7802.  
  7803.                                         next=0;
  7804.  
  7805.                                 }
  7806.  
  7807.                                 setzeroflag=TRUE;
  7808.  
  7809.                                 break;
  7810.  
  7811.                         case tk_ll:
  7812.  
  7813.                           getoperand();
  7814.  
  7815.                                 if(tok==tk_number){
  7816.  
  7817.                                         if(expand==TRUE){
  7818.  
  7819.                                                 if(chip>2||razr==r32){
  7820.  
  7821.                                                         op66(razr);
  7822.  
  7823.                                                         op(0x0f);
  7824.  
  7825.                                                         outword(0xC2a4);        //SHLD DX,AX,num
  7826.  
  7827.                                                         op(itok.number);
  7828.  
  7829.                                                 }
  7830.  
  7831.                                                 else{
  7832.  
  7833.                                                         if((unsigned int)itok.number==1)outdword(0xd213c001);   //ADD AX,AX ADC DX,DX
  7834.  
  7835.                                                         else if((unsigned int)itok.number!=0){
  7836.  
  7837.                                                                 getintobeg(CL,&ofsstr);
  7838.  
  7839.                                                                 outdword(0xd213c001);   //ADD AX,AX ADC DX,DX
  7840.  
  7841.                                                                 outword(0xfae2);  //LOOP -6
  7842.  
  7843.                                                                 warningreg(begs[1]);
  7844.  
  7845.                                                                 next=0;
  7846.  
  7847.                                                         }
  7848.  
  7849.                                                         break;
  7850.  
  7851.                                                 }
  7852.  
  7853.                                         }
  7854.  
  7855.                                         lshiftmul(itok.number,razr);
  7856.  
  7857.                                         setzeroflag=TRUE;
  7858.  
  7859.                                 }
  7860.  
  7861.                                 else goto llminus;
  7862.  
  7863.                                 break;
  7864.  
  7865.                         case tk_llminus:
  7866.  
  7867.                                 tok=tk_minus;   // do optimization 286+ here later
  7868.  
  7869. llminus:
  7870.  
  7871.                                 if(!((tok==tk_beg||tok==tk_reg||tok==tk_reg32)&&itok.number==1)){
  7872.  
  7873.                                         getintobeg(CL,&ofsstr);
  7874.  
  7875.                                         warningreg(begs[1]);
  7876.  
  7877.                                 }
  7878.  
  7879.                                 else getoperand();
  7880.  
  7881.                                 next=0;
  7882.  
  7883.                                 if(expand==TRUE){
  7884.  
  7885.                                         if(chip>2||razr==r32){
  7886.  
  7887.                                                 op66(razr);
  7888.  
  7889.                                                 op(0x0f);
  7890.  
  7891.                                                 outword(0xC2a5);        //SHLD DX,AX,CL
  7892.  
  7893.                                         }
  7894.  
  7895.                                         else
  7896.  
  7897.                                                 outdword(0xd213c001);   //ADD AX,AX ADC DX,DX
  7898.  
  7899.                                                 outword(0xfae2);  //LOOP -6
  7900.  
  7901.                                                 break;
  7902.  
  7903.                                 }
  7904.  
  7905.                                 op66(razr);
  7906.  
  7907.                                 outword(0xE0D3);        /* SHL AX,CL */
  7908.  
  7909.                                 setzeroflag=TRUE;
  7910.  
  7911.                                 break;
  7912.  
  7913.                         case tk_rr:
  7914.  
  7915.                                 if(sign)vop=0x10;
  7916.  
  7917.                                 getoperand();
  7918.  
  7919.                                 if(expand==TRUE){
  7920.  
  7921.                                         if(tok==tk_number){
  7922.  
  7923.                                                 if((unsigned int)itok.number==1){
  7924.  
  7925.                                                         op66(razr);
  7926.  
  7927.                                                         outword(0xead1);        //shr dx,1 ror ax,1
  7928.  
  7929.                                                         op66(razr);
  7930.  
  7931.                                                         outword(0xc8d1);        //shr dx,1 ror ax,1
  7932.  
  7933.                                                         setzeroflag=TRUE;
  7934.  
  7935.                                                 }
  7936.  
  7937.                                                 else if((unsigned int)itok.number!=0){
  7938.  
  7939.                                                         if(chip>2||razr==r32){
  7940.  
  7941.                                                                 op66(razr);
  7942.  
  7943.                                                                 op(0x0f);
  7944.  
  7945.                                                                 outword(0xd0ac);        //shrd ax,dx,num
  7946.  
  7947.                                                                 op(itok.number);
  7948.  
  7949.                                                                 op66(razr);
  7950.  
  7951.                                                                 op(0xc1); op(0xea+vop);//s?r dx,num
  7952.  
  7953.                                                                 op(itok.number);
  7954.  
  7955.                                                                 setzeroflag=TRUE;
  7956.  
  7957.                                                         }
  7958.  
  7959.                                                         else{
  7960.  
  7961.                                                                 next=0;
  7962.  
  7963.                                                                 getintobeg(CL,&ofsstr);
  7964.  
  7965.                                                                 warningreg(begs[1]);
  7966.  
  7967.                                                                 op(0xd1); op(0xea+vop);//s?r dx,1
  7968.  
  7969.                                                                 outdword(0xfae2d8d1);  //rcr ax,1 LOOP -6
  7970.  
  7971.                                                                 setzeroflag=FALSE;
  7972.  
  7973.                                                         }
  7974.  
  7975.                                                 }
  7976.  
  7977.                                         }
  7978.  
  7979.                                         else goto rrminus;
  7980.  
  7981.                                 }
  7982.  
  7983.                                 else{
  7984.  
  7985.                                         RshiftReg(razr,EAX,vop);
  7986.  
  7987.                                         setzeroflag=TRUE;
  7988.  
  7989.                                         next=0;
  7990.  
  7991.                                 }
  7992.  
  7993.                                 break;
  7994.  
  7995.                         case tk_rrminus:
  7996.  
  7997.                                 if(sign)vop=0x10;
  7998.  
  7999.                                 tok=tk_minus;  // do optimization 286+ here later
  8000.  
  8001. rrminus:
  8002.  
  8003.                                 if(!((tok==tk_beg||tok==tk_reg||tok==tk_reg32)&&itok.number==1)){
  8004.  
  8005.                                         getintobeg(CL,&ofsstr);
  8006.  
  8007.                                         warningreg(begs[1]);
  8008.  
  8009.                                 }
  8010.  
  8011.                                 else getoperand();
  8012.  
  8013.                                 if(expand==TRUE){
  8014.  
  8015.                                         if(chip>2||razr==r32){
  8016.  
  8017.                                                 op66(razr);
  8018.  
  8019.                                                 op(0x0f);
  8020.  
  8021.                                                 outword(0xd0ad);        //shrd ax,dx,cl
  8022.  
  8023.                                                 op66(razr);
  8024.  
  8025.                                                 op(0xd3); op(0xea+vop);//s?r dx,num
  8026.  
  8027.                                                 setzeroflag=TRUE;
  8028.  
  8029.                                         }
  8030.  
  8031.                                         else{
  8032.  
  8033.                                                 op(0xd1); op(0xea+vop);//s?r dx,1
  8034.  
  8035.                                                 outdword(0xfae2d8d1);  //rcr ax,1 //LOOP -6
  8036.  
  8037.                                                 setzeroflag=FALSE;
  8038.  
  8039.                                         }
  8040.  
  8041.                                 }
  8042.  
  8043.                                 else{
  8044.  
  8045.                                         op66(razr);
  8046.  
  8047.                                         op(0xD3);       op(0xE8+vop);  /* SR AX,CL */
  8048.  
  8049.                                         setzeroflag=TRUE;
  8050.  
  8051.                                 }
  8052.  
  8053.                                 next=0;
  8054.  
  8055.                                 break;
  8056.  
  8057.                         default: operatorexpected(); break;
  8058.  
  8059.                 }
  8060.  
  8061.                 calcnumber=FALSE;
  8062.  
  8063.                 ClearReg(EAX);
  8064.  
  8065.                 if(negflag){
  8066.  
  8067.                         NegReg(razr,EAX);
  8068.  
  8069.                         setzeroflag=TRUE;
  8070.  
  8071.                         negflag=0;
  8072.  
  8073.                 }
  8074.  
  8075.                 if(next)nexttok();
  8076.  
  8077.         }
  8078.  
  8079.         calcnumber=FALSE;
  8080.  
  8081.         ClearReg(EAX);
  8082.  
  8083.         if(tok==tk_eof)unexpectedeof();
  8084.  
  8085.         if(razr==r32&&cpu<3)cpu=3;
  8086.  
  8087. }
  8088.  
  8089.  
  8090.  
  8091. void  getintoal(int gtok,ITOK *gstok,char *&gbuf,SINFO *gstr) // AH may also be changed
  8092.  
  8093. {
  8094.  
  8095. unsigned int i=0;
  8096.  
  8097.         switch(gtok){
  8098.  
  8099.                 case tk_bits:
  8100.  
  8101.                         int razr;
  8102.  
  8103.                         i=gstok->bit.siz+gstok->bit.ofs;
  8104.  
  8105.                         if(i<=64)razr=r64;
  8106.  
  8107.                         if(i<=32)razr=r32;
  8108.  
  8109.                         if(i<=16)razr=r16;
  8110.  
  8111.                         if(i<=8)razr=r8;
  8112.  
  8113.                         bits2reg(AL,razr);
  8114.  
  8115.                         break;
  8116.  
  8117.                 case tk_number:
  8118.  
  8119.                         op(0xB0);       /* MOV AL,# */
  8120.  
  8121.                         op(gstok->number);
  8122.  
  8123.                         ConstToReg(gstok->number,AL,r8);
  8124.  
  8125.                         break;
  8126.  
  8127.                 case tk_rmnumber:
  8128.  
  8129.                         CheckAllMassiv(gbuf,gstok->size,gstr,gstok);
  8130.  
  8131.                         op66(r16);
  8132.  
  8133.                         op67(gstok->sib==CODE16?r16:r32);
  8134.  
  8135.                         if(gstok->post==0)outseg(gstok,2);
  8136.  
  8137.                         op(0x8D);       /* LEA AX,[rm] */
  8138.  
  8139.                         op(gstok->rm);
  8140.  
  8141.                         if(gstok->post!=0&&gstok->post!=UNDEF_OFSET){
  8142.  
  8143.                                 if((gstok->flag&f_extern)==0){
  8144.  
  8145.                                         i=outptr;
  8146.  
  8147.                                         if(am32&&gstok->rm==rm_sib)outptr++;
  8148.  
  8149.                                         setwordpost(gstok);
  8150.  
  8151.                                         outptr=i;
  8152.  
  8153.                                 }
  8154.  
  8155.                                 else setwordext(&gstok->number);
  8156.  
  8157.                         }
  8158.  
  8159.                         outaddress(gstok);
  8160.  
  8161.                         ClearReg(AL);
  8162.  
  8163.                         break;
  8164.  
  8165.                 case tk_postnumber:
  8166.  
  8167.                         op66(r16);
  8168.  
  8169.                         op(0xB8);       /* MOV AX,# */
  8170.  
  8171.                         (gstok->flag&f_extern)==0?setwordpost(gstok):setwordext(&gstok->number);
  8172.  
  8173.                         outword(gstok->number);
  8174.  
  8175.                         ClearReg(AL);
  8176.  
  8177.                         break;
  8178.  
  8179.                 case tk_floatvar:
  8180.  
  8181.                         if(cpu<3)cpu=3;
  8182.  
  8183.                         CheckInitBP();
  8184.  
  8185.                         op66(r32);
  8186.  
  8187.                         outword(0x6a);  //push 0
  8188.  
  8189.                         if(ESPloc&&am32&&gstok->segm==SS)gstok->number+=4;
  8190.  
  8191.                         addESP+=4;
  8192.  
  8193.                         CheckAllMassiv(gbuf,4,gstr,gstok);
  8194.  
  8195.                         outseg(gstok,2);        //fld floatvar
  8196.  
  8197.                         op(0xd9);
  8198.  
  8199.                         op(gstok->rm);
  8200.  
  8201.                         outaddress(gstok);
  8202.  
  8203.                         fistp_stack();
  8204.  
  8205.                         op66(r32);
  8206.  
  8207.                         op(0x58);       //pop EAX
  8208.  
  8209.                         addESP-=4;
  8210.  
  8211.                         RestoreBP();
  8212.  
  8213.                         ClearReg(AL);
  8214.  
  8215.                         break;
  8216.  
  8217.                 case tk_qwordvar:
  8218.  
  8219.                         i=4;
  8220.  
  8221.                 case tk_longvar:
  8222.  
  8223.                 case tk_dwordvar:
  8224.  
  8225.                         i+=2;
  8226.  
  8227.                 case tk_intvar:
  8228.  
  8229.                 case tk_wordvar:
  8230.  
  8231.                         i++;
  8232.  
  8233.                 case tk_bytevar:
  8234.  
  8235.                 case tk_charvar:
  8236.  
  8237.                         i++;
  8238.  
  8239.                         if((gstok->rm==rm_d16&&gstok->sib==CODE16)||(gstok->rm==rm_d32&&(gstok->sib==CODE32||gstok->sib==0))){
  8240.  
  8241.                                 outseg(gstok,1);
  8242.  
  8243.                                 op(0xA0);       //mov AL,
  8244.  
  8245.                                 if(gstok->post==UNDEF_OFSET)AddUndefOff(2,gstok->name);
  8246.  
  8247.                                 if(am32==FALSE)outword(gstok->number);
  8248.  
  8249.                                 else outdword(gstok->number);
  8250.  
  8251.                         }
  8252.  
  8253.                         else{
  8254.  
  8255.                                 CheckAllMassiv(gbuf,i,gstr,gstok);
  8256.  
  8257.                                 outseg(gstok,2);
  8258.  
  8259.                                 op(0x8A);
  8260.  
  8261.                                 op(gstok->rm);
  8262.  
  8263.                                 outaddress(gstok);
  8264.  
  8265.                         }
  8266.  
  8267.                         ClearReg(AL);
  8268.  
  8269.                         break;
  8270.  
  8271.                 case tk_reg32:
  8272.  
  8273.                         if(gstok->number>BX){
  8274.  
  8275.                                 i=1;
  8276.  
  8277.                                 if(gstok->number!=AX)op66(r32);
  8278.  
  8279.                         }
  8280.  
  8281.                         goto beg1;
  8282.  
  8283.                 case tk_reg:
  8284.  
  8285.                         if(gstok->number>BX){
  8286.  
  8287.                                 i=1;
  8288.  
  8289.                                 if(gstok->number!=AX)op66(r16);
  8290.  
  8291.                         }
  8292.  
  8293.                 case tk_beg:
  8294.  
  8295. beg1:
  8296.  
  8297.                         if(gstok->number!=AL){
  8298.  
  8299.                                 op(0x88+i);  //mov [],AL
  8300.  
  8301.                                 op(0xC0+gstok->number*8);
  8302.  
  8303.                         }
  8304.  
  8305.                         ClearReg(AL);
  8306.  
  8307.                         break;
  8308.  
  8309.                 case tk_seg:
  8310.  
  8311.                         op66(r16);
  8312.  
  8313.                         op(0x8C); op(0xC0+gstok->number*8); break;
  8314.  
  8315.                         ClearReg(AL);
  8316.  
  8317.                 default: bytevalexpected(0); break;
  8318.  
  8319.         }
  8320.  
  8321. }
  8322.  
  8323.  
  8324.  
  8325. int doalmath(int sign,char **ofsstr)
  8326.  
  8327. {
  8328.  
  8329. int negflag=0,i=0;
  8330.  
  8331. int rettype=tk_beg;
  8332.  
  8333.         if(tok==tk_minus){
  8334.  
  8335.                 if(CheckMinusNum()==FALSE){
  8336.  
  8337.                         negflag=1;
  8338.  
  8339.                         getoperand(am32==TRUE?EAX:BX);
  8340.  
  8341.                 }
  8342.  
  8343.         }
  8344.  
  8345. #ifdef OPTVARCONST
  8346.  
  8347.         if(tok>=tk_charvar&&tok<=tk_doublevar&&itok.npointr==0){
  8348.  
  8349.                 if(CheckConstVar(&itok)){
  8350.  
  8351.                         tok=tk_number;
  8352.  
  8353.                         calcnumber=TRUE;
  8354.  
  8355.                 }
  8356.  
  8357.         }
  8358.  
  8359. #endif
  8360.  
  8361.         switch(tok){
  8362.  
  8363.                 case tk_number:
  8364.  
  8365.                         op(0xB0);       //mov AL,num
  8366.  
  8367.                         i=CalcNumber(sign);
  8368.  
  8369.                         op(i);
  8370.  
  8371.                         ConstToReg(i,AL,r8);
  8372.  
  8373.                         break;
  8374.  
  8375.                 case tk_at:
  8376.  
  8377.                         getoperand(am32==TRUE?EAX:BX);
  8378.  
  8379.                         i++;
  8380.  
  8381.                 case tk_ID:
  8382.  
  8383.                 case tk_id:
  8384.  
  8385.                 case tk_proc:
  8386.  
  8387.                 case tk_apiproc:
  8388.  
  8389.                 case tk_undefproc:
  8390.  
  8391.                 case tk_declare:
  8392.  
  8393.                         if(itok.flag&f_retproc)rettype=(itok.flag&f_retproc)/256+tk_overflowflag-1;
  8394.  
  8395.                         if((!i)||macros(sign!=0?tk_char:tk_byte)==0)procdo(sign!=0?tk_char:tk_byte);
  8396.  
  8397.                         nexttok();
  8398.  
  8399.                         if(*ofsstr){
  8400.  
  8401.                                 free(*ofsstr);
  8402.  
  8403.                                 *ofsstr=NULL;
  8404.  
  8405.                         }
  8406.  
  8407.                         break;
  8408.  
  8409.                 default:
  8410.  
  8411.                         SINFO bstr=strinf;
  8412.  
  8413.                         strinf.bufstr=NULL;
  8414.  
  8415.                         ITOK btok;
  8416.  
  8417.                         char *bbuf;
  8418.  
  8419.                         btok=itok;
  8420.  
  8421.                         bbuf=bufrm;
  8422.  
  8423.                         bufrm=NULL;
  8424.  
  8425.                         getintoal(tok,&btok,bbuf,&bstr); nexttok(); break;
  8426.  
  8427.         }
  8428.  
  8429. #ifdef OPTVARCONST
  8430.  
  8431.         calcnumber=FALSE;
  8432.  
  8433. #endif
  8434.  
  8435.         if(negflag){
  8436.  
  8437.                 if(optimizespeed&&(chip==5||chip==6))outdword(0xC0FEFF34);      //xor AL,-1 AL++
  8438.  
  8439.                 else outword(0xD8F6);// NEG AL
  8440.  
  8441.                 setzeroflag=TRUE;
  8442.  
  8443.         }
  8444.  
  8445.         if(itok.type!=tp_stopper&&tok!=tk_eof&&itok.type!=tp_compare){
  8446.  
  8447.                 doalmath2(sign);
  8448.  
  8449.                 rettype=tk_beg;
  8450.  
  8451.         }
  8452.  
  8453.         return rettype;
  8454.  
  8455. }
  8456.  
  8457.  
  8458.  
  8459. void  doalmath2(int sign)
  8460.  
  8461. {
  8462.  
  8463. int vop,i,next;
  8464.  
  8465. int expand=FALSE,optnum=FALSE;
  8466.  
  8467. int negflag=0;
  8468.  
  8469. char *ofsstr=NULL;
  8470.  
  8471.         while(itok.type!=tp_stopper&&tok!=tk_eof&&itok.type!=tp_compare){
  8472.  
  8473.                 vop=0;
  8474.  
  8475.                 i=0;
  8476.  
  8477.                 next=1;
  8478.  
  8479. #ifdef OPTVARCONST
  8480.  
  8481.                 if(tok2>=tk_charvar&&tok2<=tk_doublevar&&itok2.npointr==0){
  8482.  
  8483.                         if(CheckConstVar(&itok2)){
  8484.  
  8485.                                 tok2=tk_number;
  8486.  
  8487.                                 calcnumber=TRUE;
  8488.  
  8489.                         }
  8490.  
  8491.                 }
  8492.  
  8493. #endif
  8494.  
  8495.                 if(tok2==tk_number)optnum=OptimNum();
  8496.  
  8497.                 int oldtok=tok;
  8498.  
  8499.                 switch(tok){
  8500.  
  8501.                         case tk_xor: vop+=0x08;
  8502.  
  8503.                         case tk_minus: vop+=0x08;
  8504.  
  8505.                         case tk_and: vop+=0x18;
  8506.  
  8507.                         case tk_or: vop+=0x08;
  8508.  
  8509.                         case tk_plus:
  8510.  
  8511.                           if(optnum==FALSE)getoperand();
  8512.  
  8513.                                 else{
  8514.  
  8515.                                         tok=tk_number;
  8516.  
  8517.                                         optnum=FALSE;
  8518.  
  8519.                                 }
  8520.  
  8521.                                 switch(tok){
  8522.  
  8523.                                         case tk_number:
  8524.  
  8525.                                                 if(itok.number==0&&oldtok!=tk_and)break;
  8526.  
  8527.                                                 if(itok.number==255&&oldtok==tk_and)break;
  8528.  
  8529.                                           op(0x04+vop);
  8530.  
  8531.                                                 op((unsigned int)itok.number); /* OPT AL,num */
  8532.  
  8533.                                                 break;
  8534.  
  8535.                                         case tk_rmnumber:
  8536.  
  8537.                                                 CheckAllMassiv(bufrm,itok.size,&strinf);
  8538.  
  8539.                                                 op66(r16);
  8540.  
  8541.                                                 op67(itok.sib==CODE16?r16:r32);
  8542.  
  8543.                                                 if(itok.post==0)outseg(&itok,2);
  8544.  
  8545.                                                 op(0x8D); /* LEA CX,[rm] */
  8546.  
  8547.                                                 op(0x8+itok.rm);
  8548.  
  8549.                                                 if(itok.post!=0&&itok.post!=UNDEF_OFSET){
  8550.  
  8551.                                                         if((itok.flag&f_extern)==0){
  8552.  
  8553.                                                                 unsigned int ooutptr=outptr;
  8554.  
  8555.                                                                 if(am32&&itok.rm==rm_sib)outptr++;
  8556.  
  8557.                                                                 setwordpost(&itok);
  8558.  
  8559.                                                                 outptr=ooutptr;
  8560.  
  8561.                                                         }
  8562.  
  8563.                                                         else setwordext(&itok.number);
  8564.  
  8565.                                                 }
  8566.  
  8567.                                                 outaddress(&itok);
  8568.  
  8569.                                                 op(vop); /* OPT AL,CL */
  8570.  
  8571.                                                 op(0xC8);
  8572.  
  8573.                                                 warningreg(regs[0][1]);
  8574.  
  8575.                                                 break;
  8576.  
  8577.                                         case tk_postnumber:
  8578.  
  8579.                                                 op66(r16);
  8580.  
  8581.                                                 op(0x05+vop); /* OPT AX,# */
  8582.  
  8583.                                                 (itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
  8584.  
  8585.                                                 outword((unsigned int)itok.number);
  8586.  
  8587.                                                 break;
  8588.  
  8589.                                         case tk_qwordvar:
  8590.  
  8591.                                                 i=4;
  8592.  
  8593.                                         case tk_longvar:
  8594.  
  8595.                                         case tk_dwordvar:
  8596.  
  8597.                                                 i+=2;
  8598.  
  8599.                                         case tk_intvar:
  8600.  
  8601.                                         case tk_wordvar:
  8602.  
  8603.                                                 i++;
  8604.  
  8605.                                         case tk_charvar:
  8606.  
  8607.                                         case tk_bytevar:
  8608.  
  8609.                                                 i++;
  8610.  
  8611.                                                 CheckAllMassiv(bufrm,i,&strinf);
  8612.  
  8613.                                                 outseg(&itok,2);
  8614.  
  8615.                                                 op(0x02+vop);   op(itok.rm);
  8616.  
  8617.                                                 outaddress(&itok);
  8618.  
  8619.                                                 break;
  8620.  
  8621.                                         case tk_ID:
  8622.  
  8623.                                         case tk_id:
  8624.  
  8625.                                         case tk_proc:
  8626.  
  8627.                                         case tk_apiproc:
  8628.  
  8629.                                         case tk_undefproc:
  8630.  
  8631.                                         case tk_declare:
  8632.  
  8633.                                                 op66(r16);
  8634.  
  8635.                                                 op(0x50);       //push AX
  8636.  
  8637.                                                 addESP+=2;
  8638.  
  8639. unsigned char oaddstack;
  8640.  
  8641.                                                 oaddstack=addstack;
  8642.  
  8643.                                                 addstack=FALSE;
  8644.  
  8645.                                                 procdo(sign!=0?tk_char:tk_byte);
  8646.  
  8647.                                                 addstack=oaddstack;
  8648.  
  8649.                                                 addESP-=2;
  8650.  
  8651.                                                 op66(r16);
  8652.  
  8653.                                                 op(0x58+CX);
  8654.  
  8655.                                                 itok.number=CX;
  8656.  
  8657.                                                 warningreg(regs[0][CX]);
  8658.  
  8659.                                                 if(vop>0x20){
  8660.  
  8661.                                                         op66(r16);
  8662.  
  8663.                                                         op(0x90+CX);    //xchg ax,Cx
  8664.  
  8665.                                                 }
  8666.  
  8667.                                                 goto defbeg;
  8668.  
  8669.                                         case tk_bits:
  8670.  
  8671.                                                 int razr;
  8672.  
  8673.                                                 i=itok.bit.siz+itok.bit.ofs;
  8674.  
  8675.                                                 if(i<=64)razr=r64;
  8676.  
  8677.                                                 if(i<=32)razr=r32;
  8678.  
  8679.                                                 if(i<=16)razr=r16;
  8680.  
  8681.                                                 if(i<=8)razr=r8;
  8682.  
  8683.                                                 bits2reg(CL,razr);
  8684.  
  8685.                                                 itok.number=CL;
  8686.  
  8687.                                                 if(razr==r64)razr=r32;
  8688.  
  8689.                                                 warningreg(razr==r8?begs[1]:(regs[razr/2-1][1]));
  8690.  
  8691.                                                 goto defbeg;
  8692.  
  8693.                                         case tk_doublevar:
  8694.  
  8695.                                                 i=4;
  8696.  
  8697.                                         case tk_floatvar:
  8698.  
  8699.                                                 Float2reg32(EAX,i);
  8700.  
  8701.                                                 itok.number=0;
  8702.  
  8703.                                         case tk_beg:
  8704.  
  8705. defbeg:
  8706.  
  8707.                                                 op(vop);
  8708.  
  8709.                                                 op(0xC0+(unsigned int)itok.number*8);
  8710.  
  8711.                                                 break;
  8712.  
  8713.                                         case tk_reg32:
  8714.  
  8715.                                         case tk_reg:
  8716.  
  8717.                                                 if((unsigned int)itok.number>BX){
  8718.  
  8719.                                                         op66(r16);
  8720.  
  8721.                                                         op(0x89);       /* MOV CX,reg */
  8722.  
  8723.                                                         warningreg(regs[0][1]);
  8724.  
  8725.                                                 op(0xC1+(unsigned int)itok.number*8); /* MOV instr */
  8726.  
  8727.                                                 itok.number=CL;
  8728.  
  8729.                                                 }
  8730.  
  8731.                                                 goto defbeg;
  8732.  
  8733.                                         default: valueexpected(); break;
  8734.  
  8735.                                 }
  8736.  
  8737.                                 setzeroflag=TRUE;
  8738.  
  8739.                                 if(expand==TRUE){
  8740.  
  8741.                                         if(oldtok==tk_plus){
  8742.  
  8743.                                                 outword(0xd480);        //ADC AH,0
  8744.  
  8745.                                                 op(0);
  8746.  
  8747.                                         }
  8748.  
  8749.                                         else if(oldtok==tk_minus){
  8750.  
  8751.                                                 outword(0xdc80);        //SBB AH,0
  8752.  
  8753.                                                 op(0);
  8754.  
  8755.                                         }
  8756.  
  8757.                                         setzeroflag=FALSE;
  8758.  
  8759.                                 }
  8760.  
  8761.                                 break;
  8762.  
  8763.                         case tk_modminus: negflag=1;
  8764.  
  8765.                         case tk_mod: negflag=1-negflag; vop=1;
  8766.  
  8767.                         case tk_divminus: negflag=1-negflag;
  8768.  
  8769.                         case tk_div:
  8770.  
  8771.                           if(optnum==FALSE)getoperand();
  8772.  
  8773.                                 else{
  8774.  
  8775.                                         tok=tk_number;
  8776.  
  8777.                                         optnum=FALSE;
  8778.  
  8779.                                 }
  8780.  
  8781.                                 if(tok==tk_number){
  8782.  
  8783.                                         if(negflag){
  8784.  
  8785.                                                 itok.number=-itok.number;
  8786.  
  8787.                                                 negflag=0;
  8788.  
  8789.                                         }
  8790.  
  8791.                                         itok.number&=255;
  8792.  
  8793.                                         if(vop){        //%
  8794.  
  8795.                                                 if(itok.number==0)DevideZero();
  8796.  
  8797.                                                 if(caselong(itok.number)!=NUMNUM){
  8798.  
  8799.                                                         op(0x24);       /* AND AL,number-1 */
  8800.  
  8801.                                                         op((unsigned int)itok.number-1);
  8802.  
  8803.                                                         setzeroflag=TRUE;
  8804.  
  8805.                                                 }
  8806.  
  8807.                                                 else{
  8808.  
  8809.                                                         if(expand==FALSE){
  8810.  
  8811.                                                                 if(sign)cbw();
  8812.  
  8813.                                                                 else xorAHAH();
  8814.  
  8815.                                                         }
  8816.  
  8817.                                                         op(0xB1); op((unsigned int)itok.number); /* MOV CL,# */
  8818.  
  8819.                                                         if(sign)outword(0xF9F6);        /* IDIV CL */
  8820.  
  8821.                                                         else outword(0xF1F6); /* DIV CL */
  8822.  
  8823.                                                         outword(0xE088);// MOV AL,AH
  8824.  
  8825.                                                         setzeroflag=FALSE;
  8826.  
  8827.                                                         warningreg(begs[1]);
  8828.  
  8829.                                                         break;
  8830.  
  8831.                                                 }
  8832.  
  8833.                                         }
  8834.  
  8835.                                         else{
  8836.  
  8837.                                                 switch((unsigned int)itok.number){
  8838.  
  8839.                                                         case 0:
  8840.  
  8841.                                                                 DevideZero();
  8842.  
  8843.                                                                 break;
  8844.  
  8845.                                                         case 1: break;
  8846.  
  8847.                                                         case 2:
  8848.  
  8849.                                                                 op(0xd0+expand);
  8850.  
  8851.                                                                 if(sign)op(0xf8);
  8852.  
  8853.                                                                 else op(0xE8);// SHR AL,1
  8854.  
  8855.                                                                 setzeroflag=TRUE;
  8856.  
  8857.                                                                 break;
  8858.  
  8859.                                                         default:
  8860.  
  8861.                                                                 vop=caselong(itok.number);
  8862.  
  8863.                                                                 if(vop!=NUMNUM){
  8864.  
  8865.                                                                         if(chip<2){
  8866.  
  8867.                                                                                 op(0xB1);       op(vop); /* MOV CL,num */
  8868.  
  8869.                                                                                 op(0xd2+expand);
  8870.  
  8871.                                                                                 if(sign)op(0xF8); // SAR AL,CL
  8872.  
  8873.                                                                                 else op(0xE8); // SHR AL,CL
  8874.  
  8875.                                                                                 warningreg(begs[1]);
  8876.  
  8877.                                                                         }
  8878.  
  8879.                                                                         else{
  8880.  
  8881.                                                                                 op(0xc0+expand);
  8882.  
  8883.                                                                                 if(sign)op(0xF8); /* SAR AL,num */
  8884.  
  8885.                                                                                 else op(0xE8); /* SHR AL,num */
  8886.  
  8887.                                                                                 op(vop);
  8888.  
  8889.                                                                                 if(cpu<2)cpu=2;
  8890.  
  8891.                                                                         }
  8892.  
  8893.                                                                         setzeroflag=TRUE;
  8894.  
  8895.                                                                 }
  8896.  
  8897.                                                                 else{
  8898.  
  8899.                                                                         if(expand==FALSE){
  8900.  
  8901.                                                                                 if(optimizespeed&&(itok.flag&f_reloc)==0&&sign==0){     //for signed needed new algoritm
  8902.  
  8903.                                                                                         //§ ¬¥­  ¤¥«¥­¨ï 㬭®¦¥­¨¥¬
  8904.  
  8905.                                                                                         itok.number=256/(unsigned int)itok.number+1;
  8906.  
  8907.                                                                                         if(chip>4){
  8908.  
  8909.                                                                                                 xorAHAH();
  8910.  
  8911.                                                                                                 op66(r16);
  8912.  
  8913.                                                                                                 outword(0xC06B);        //imul AX,num
  8914.  
  8915.                                                                                                 op(itok.number);
  8916.  
  8917.                                                                                                 warningreg(regs[0][2]);
  8918.  
  8919.                                                                                         }
  8920.  
  8921.                                                                                         else{
  8922.  
  8923.                                                                                                 op(0xB2);       //mov DL,num
  8924.  
  8925.                                                                                                 op(itok.number);
  8926.  
  8927.                                                                                                 outword(0xE2F6);        //mul DL
  8928.  
  8929.                                                                                                 warningreg(begs[2]);
  8930.  
  8931.                                                                                         }
  8932.  
  8933.                                                                                         outword(0xE088);        //mov AL.AH
  8934.  
  8935.                                                                                         setzeroflag=FALSE;
  8936.  
  8937.                                                                                         break;
  8938.  
  8939.                                                                                 }
  8940.  
  8941.                                                                                 if(sign)cbw();
  8942.  
  8943.                                                                                 else xorAHAH();
  8944.  
  8945.                                                                         }
  8946.  
  8947.                                                                         op(0xB1);  /* MOV CL,# */
  8948.  
  8949.                                                                         op((unsigned int)itok.number);
  8950.  
  8951.                                                                         if(sign)outword(0xF9F6);  /* IDIV CL */
  8952.  
  8953.                                                                         else outword(0xF1F6); /* DIV CL */
  8954.  
  8955.                                                                         setzeroflag=FALSE;
  8956.  
  8957.                                                                         warningreg(begs[1]);
  8958.  
  8959.                                                                 }
  8960.  
  8961.                                                 }
  8962.  
  8963.                                         }
  8964.  
  8965.                                 }
  8966.  
  8967.                                 else{
  8968.  
  8969.                                         case tk_doublevar:
  8970.  
  8971.                                                 i=4;
  8972.  
  8973.                                         if(tok==tk_floatvar){
  8974.  
  8975.                                                 Float2reg32(ECX,i);
  8976.  
  8977.                                                 itok.number=ECX;
  8978.  
  8979.                                                 tok=tk_beg;
  8980.  
  8981.                                                 sign=1;
  8982.  
  8983.                                         }
  8984.  
  8985.                                         if(expand==FALSE){
  8986.  
  8987.                                                 if(sign)cbw();
  8988.  
  8989.                                                 else xorAHAH();
  8990.  
  8991.                                         }
  8992.  
  8993.                                         switch(tok){
  8994.  
  8995.                                                 case tk_rmnumber:
  8996.  
  8997.                                                 case tk_postnumber:
  8998.  
  8999.                                                         getintoreg_32(CX,r16,sign,&ofsstr,FALSE);
  9000.  
  9001.                                                         if(sign)outword(0xF9F6);  // IDIV CL
  9002.  
  9003.                                                         else outword(0xF1F6);   // DIV CL
  9004.  
  9005.                                                         setzeroflag=FALSE;
  9006.  
  9007.                                                         warningreg(regs[0][1]);
  9008.  
  9009.                                                         break;
  9010.  
  9011.                                                 case tk_qwordvar:
  9012.  
  9013.                                                         i=4;
  9014.  
  9015.                                                 case tk_longvar:
  9016.  
  9017.                                                 case tk_dwordvar:
  9018.  
  9019.                                                         i+=2;
  9020.  
  9021.                                                 case tk_intvar:
  9022.  
  9023.                                                 case tk_wordvar:
  9024.  
  9025.                                                         i++;
  9026.  
  9027.                                                 case tk_charvar:
  9028.  
  9029.                                                 case tk_bytevar:
  9030.  
  9031.                                                         i++;
  9032.  
  9033.                                                         CheckAllMassiv(bufrm,i,&strinf);
  9034.  
  9035.                                                         outseg(&itok,2);
  9036.  
  9037.                                                         op(0xF6);
  9038.  
  9039.                                                         if(sign)op(0x38+itok.rm);
  9040.  
  9041.                                                         else op(0x30+itok.rm);
  9042.  
  9043.                                                         outaddress(&itok);
  9044.  
  9045.                                                         setzeroflag=FALSE;
  9046.  
  9047.                                                         break;
  9048.  
  9049.                                                 case tk_bits:
  9050.  
  9051.                                                         int razr;
  9052.  
  9053.                                                         i=itok.bit.siz+itok.bit.ofs;
  9054.  
  9055.                                                         if(i<=64)razr=r64;
  9056.  
  9057.                                                         if(i<=32)razr=r32;
  9058.  
  9059.                                                         if(i<=16)razr=r16;
  9060.  
  9061.                                                         if(i<=8)razr=r8;
  9062.  
  9063.                                                         bits2reg(CL,razr);
  9064.  
  9065.                                                         itok.number=CL;
  9066.  
  9067.                                                         if(razr==r64)razr=r32;
  9068.  
  9069.                                                         warningreg(razr==r8?begs[1]:(regs[razr/2-1][1]));
  9070.  
  9071.                                                         goto defdiv;
  9072.  
  9073.                                                 case tk_ID:
  9074.  
  9075.                                                 case tk_id:
  9076.  
  9077.                                                 case tk_proc:
  9078.  
  9079.                                                 case tk_apiproc:
  9080.  
  9081.                                                 case tk_undefproc:
  9082.  
  9083.                                                 case tk_declare:
  9084.  
  9085.                                                         op66(r16);
  9086.  
  9087.                                                         op(0x50);       //push AX
  9088.  
  9089.                                                         addESP+=2;
  9090.  
  9091. unsigned char oaddstack;
  9092.  
  9093.                                                         oaddstack=addstack;
  9094.  
  9095.                                                         addstack=FALSE;
  9096.  
  9097.                                                         procdo(sign!=0?tk_char:tk_byte);
  9098.  
  9099.                                                         addstack=oaddstack;
  9100.  
  9101.                                                         addESP-=2;
  9102.  
  9103.                                                         op66(r16);
  9104.  
  9105.                                                         op(0x58+CX);
  9106.  
  9107.                                                         itok.number=CX;
  9108.  
  9109.                                                         warningreg(regs[0][CX]);
  9110.  
  9111.                                                         op66(r16);
  9112.  
  9113.                                                         op(0x90+CX);    //xchg ax,cx
  9114.  
  9115.                                                 case tk_beg:
  9116.  
  9117. defdiv:
  9118.  
  9119.                                                         op(0xF6);
  9120.  
  9121.                                                         if(sign)op(0xF8+(unsigned int)itok.number);
  9122.  
  9123.                                                         else op(0xF0+(unsigned int)itok.number);
  9124.  
  9125.                                                         setzeroflag=FALSE;
  9126.  
  9127.                                                         break;
  9128.  
  9129.                                                 case tk_reg32:
  9130.  
  9131.                                                 case tk_reg:
  9132.  
  9133.                                                         if((unsigned int)itok.number>BX){
  9134.  
  9135.                                                                 op66(r16);
  9136.  
  9137.                                                                 op(0x89);  /* MOV CX,reg */
  9138.  
  9139.                                                                 warningreg(regs[0][1]);
  9140.  
  9141.                                                                 op(0xC1+(unsigned int)itok.number*8); /* MOV instr */
  9142.  
  9143.                                                                 itok.number=CL;
  9144.  
  9145.                                                         }
  9146.  
  9147.                                                         goto defdiv;
  9148.  
  9149.                                                 default: valueexpected();       break;
  9150.  
  9151.                                         }
  9152.  
  9153.                                         if(vop)outword(0xE088);// MOV AL,AH
  9154.  
  9155.                                 }
  9156.  
  9157.                                 expand=FALSE;
  9158.  
  9159.                                 break;
  9160.  
  9161.                         case tk_multminus: negflag=1;
  9162.  
  9163.                         case tk_mult:
  9164.  
  9165.                                 expand=expandvar();
  9166.  
  9167.                           if(optnum==FALSE)getoperand();
  9168.  
  9169.                                 else{
  9170.  
  9171.                                         tok=tk_number;
  9172.  
  9173.                                         optnum=FALSE;
  9174.  
  9175.                                 }
  9176.  
  9177.                                 switch(tok){
  9178.  
  9179.                                         case tk_number:
  9180.  
  9181.                                                 if(negflag){
  9182.  
  9183.                                                         itok.number=-itok.number;
  9184.  
  9185.                                                         negflag=0;
  9186.  
  9187.                                                 }
  9188.  
  9189.                                                 itok.number&=255;
  9190.  
  9191.                                                 switch((unsigned int)itok.number){
  9192.  
  9193.                                                         case 0: /* AL * 0 = MOV AL,0 */
  9194.  
  9195.                                                                 outword(0x00B0);
  9196.  
  9197.                                                         case 1:
  9198.  
  9199.                                                                 expand=FALSE;
  9200.  
  9201.                                                                 setzeroflag=FALSE;
  9202.  
  9203.                                                                 break; /* AL * 1 = AL */
  9204.  
  9205.                                                         case 2:
  9206.  
  9207.                                                                 if(expand==TRUE){
  9208.  
  9209.                                                                         if(sign)cbw();
  9210.  
  9211.                                                                         else xorAHAH();
  9212.  
  9213.                                                                 }
  9214.  
  9215.                                                                 outword(0xC000+expand); // AL * 2 = ADD AL,AL
  9216.  
  9217.                                                                 setzeroflag=TRUE;
  9218.  
  9219.                                                                 break;
  9220.  
  9221.                                                         default:
  9222.  
  9223.                                                                 vop=caselong(itok.number);
  9224.  
  9225.                                                                 if(vop!=NUMNUM){
  9226.  
  9227.                                                                         if(chip<1){
  9228.  
  9229.                                                                                 if(expand==TRUE){
  9230.  
  9231.                                                                                         if(optimizespeed==FALSE&&sign==FALSE)goto num_imul;
  9232.  
  9233.                                                                                         if(sign)cbw();
  9234.  
  9235.                                                                                         else xorAHAH();
  9236.  
  9237.                                                                                 }
  9238.  
  9239.                                                                                 op(0xB1); op(vop); /* MOV CL,num */
  9240.  
  9241.                                                                                 outword(0xE0D2+expand);// SHL AL,CL
  9242.  
  9243.                                                                                 warningreg(begs[1]);
  9244.  
  9245.                                                                         }
  9246.  
  9247.                                                                         else{
  9248.  
  9249.                                                                                 if(expand==TRUE){
  9250.  
  9251.                                                                                         if(optimizespeed==FALSE&&sign==FALSE)goto num_imul;
  9252.  
  9253.                                                                                         if(sign)cbw();
  9254.  
  9255.                                                                                         else xorAHAH();
  9256.  
  9257.                                                                                         op66(r16);
  9258.  
  9259.                                                                                 }
  9260.  
  9261.                                                                                 outword(0xe0c0+expand); //SHL AX/L,num
  9262.  
  9263.                                                                                 op(vop);
  9264.  
  9265.                                                                                 if(cpu<1)cpu=1;
  9266.  
  9267.                                                                         }
  9268.  
  9269.                                                                         setzeroflag=TRUE;
  9270.  
  9271.                                                                 }
  9272.  
  9273.                                                                 else if(expand==FALSE&&optimizespeed!=FALSE&&
  9274.  
  9275.                                                                                 speedmul(itok.number,r8)!=FALSE);
  9276.  
  9277.                                                                 else{
  9278.  
  9279. num_imul:
  9280.  
  9281.                                                                         op(0xB1);  /* MOV CL,# */
  9282.  
  9283.                                                                         op((unsigned int)itok.number);
  9284.  
  9285.                                                                         if(sign)outword(0xE9F6);// IMUL CL
  9286.  
  9287.                                                                         else outword(0xE1F6);   // MUL CL
  9288.  
  9289.                                                                         setzeroflag=FALSE;
  9290.  
  9291.                                                                         warningreg(begs[1]);
  9292.  
  9293.                                                                 }
  9294.  
  9295.                                                 }
  9296.  
  9297.                                                 break;
  9298.  
  9299.                                         case tk_rmnumber:
  9300.  
  9301.                                         case tk_postnumber:
  9302.  
  9303.                                                 getintoreg_32(CX,r16,sign,&ofsstr,FALSE);
  9304.  
  9305.                                                 if(sign)outword(0xE9F6); // IMUL CL
  9306.  
  9307.                                                 else outword(0xE1F6);   // MUL CL
  9308.  
  9309.                                                 setzeroflag=FALSE;
  9310.  
  9311.                                                 warningreg(regs[0][1]);
  9312.  
  9313.                                                 break;
  9314.  
  9315.                                         case tk_doublevar:
  9316.  
  9317.                                                 i=4;
  9318.  
  9319.                                         case tk_floatvar:
  9320.  
  9321.                                                 Float2reg32(ECX,i);
  9322.  
  9323.                                                 itok.number=ECX;
  9324.  
  9325.                                                 outword(0xE9F6); // IMUL CL
  9326.  
  9327.                                                 setzeroflag=FALSE;
  9328.  
  9329.                                                 warningreg(begs[1]);
  9330.  
  9331.                                                 break;
  9332.  
  9333.                                         case tk_qwordvar:
  9334.  
  9335.                                                 i=4;
  9336.  
  9337.                                         case tk_longvar:
  9338.  
  9339.                                         case tk_dwordvar:
  9340.  
  9341.                                                 i+=2;
  9342.  
  9343.                                         case tk_intvar:
  9344.  
  9345.                                         case tk_wordvar:
  9346.  
  9347.                                                 i++;
  9348.  
  9349.                                         case tk_charvar:
  9350.  
  9351.                                         case tk_bytevar:
  9352.  
  9353.                                                 i++;
  9354.  
  9355.                                                 CheckAllMassiv(bufrm,i,&strinf);
  9356.  
  9357.                                                 outseg(&itok,2);
  9358.  
  9359.                                                 op(0xF6);
  9360.  
  9361.                                                 if(sign)op(0x28+itok.rm);
  9362.  
  9363.                                                 else op(0x20+itok.rm);
  9364.  
  9365.                                                 outaddress(&itok);
  9366.  
  9367.                                                 setzeroflag=FALSE;
  9368.  
  9369.                                                 break;
  9370.  
  9371.                                         case tk_bits:
  9372.  
  9373.                                                 int razr;
  9374.  
  9375.                                                 i=itok.bit.siz+itok.bit.ofs;
  9376.  
  9377.                                                 if(i<=64)razr=r64;
  9378.  
  9379.                                                 if(i<=32)razr=r32;
  9380.  
  9381.                                                 if(i<=16)razr=r16;
  9382.  
  9383.                                                 if(i<=8)razr=r8;
  9384.  
  9385.                                                 bits2reg(CL,razr);
  9386.  
  9387.                                                 itok.number=CL;
  9388.  
  9389.                                                 if(razr==r64)razr=r32;
  9390.  
  9391.                                                 warningreg(razr==r8?begs[1]:(regs[razr/2-1][1]));
  9392.  
  9393.                                                 goto defmul;
  9394.  
  9395.                                         case tk_ID:
  9396.  
  9397.                                         case tk_id:
  9398.  
  9399.                                         case tk_proc:
  9400.  
  9401.                                         case tk_apiproc:
  9402.  
  9403.                                         case tk_undefproc:
  9404.  
  9405.                                         case tk_declare:
  9406.  
  9407.                                                 op66(r16);
  9408.  
  9409.                                                 op(0x50);       //push AX
  9410.  
  9411.                                                 addESP+=2;
  9412.  
  9413. unsigned char oaddstack;
  9414.  
  9415.                                                 oaddstack=addstack;
  9416.  
  9417.                                                 addstack=FALSE;
  9418.  
  9419.                                                 procdo(sign!=0?tk_char:tk_byte);
  9420.  
  9421.                                                 addstack=oaddstack;
  9422.  
  9423.                                                 addESP-=2;
  9424.  
  9425.                                                 op66(r16);
  9426.  
  9427.                                                 op(0x58+DX);
  9428.  
  9429.                                                 itok.number=DX;
  9430.  
  9431.                                                 warningreg(regs[0][DX]);
  9432.  
  9433.                                         case tk_beg:
  9434.  
  9435. defmul:
  9436.  
  9437.                                                 op(0xF6);
  9438.  
  9439.                                                 if(sign)op(0xE8+(unsigned int)itok.number);
  9440.  
  9441.                                                 else op(0xE0+(unsigned int)itok.number);
  9442.  
  9443.                                                 setzeroflag=FALSE;
  9444.  
  9445.                                                 break;
  9446.  
  9447.                                         case tk_reg32:
  9448.  
  9449.                                         case tk_reg:
  9450.  
  9451.                                                 if((unsigned int)itok.number>BX){
  9452.  
  9453.                                                         op66(r16);
  9454.  
  9455.                                                         op(0x89);  /* MOV CX,reg */
  9456.  
  9457.                                                         warningreg(regs[0][1]);
  9458.  
  9459.                                                         op(0xC1+(unsigned int)itok.number*8); /* MOV instr */
  9460.  
  9461.                                                         itok.number=CL;
  9462.  
  9463.                                                 }
  9464.  
  9465.                                                 goto defmul;
  9466.  
  9467.                                         default: valueexpected();       break;
  9468.  
  9469.                                 }
  9470.  
  9471.                                 break;
  9472.  
  9473.                         case tk_xorminus: vop+=0x10;
  9474.  
  9475.                         case tk_andminus: vop+=0x18;
  9476.  
  9477.                         case tk_orminus: vop+=0x08;
  9478.  
  9479.                           getoperand();
  9480.  
  9481.                                 if(tok==tk_number){
  9482.  
  9483.                                         itok.number=-itok.number;
  9484.  
  9485.                                         op(0x04+vop);
  9486.  
  9487.                                         op((unsigned int)itok.number);
  9488.  
  9489.                                 }
  9490.  
  9491.                                 else{
  9492.  
  9493.                                         getintobeg(CL,&ofsstr);
  9494.  
  9495.                                         if(optimizespeed&&(chip==5||chip==6)){
  9496.  
  9497.                                                 op(0x80);
  9498.  
  9499.                                                 outdword(0xC1FEFFE1);   //and CL,-1 inc CL
  9500.  
  9501.                                         }
  9502.  
  9503.                                         else outword(0xD9F6);  // NEG CL
  9504.  
  9505.                                         op(0x00+vop);
  9506.  
  9507.                                         op(0xC8);       /* opt AL,CL */
  9508.  
  9509.                                         warningreg(begs[1]);
  9510.  
  9511.                                         next=0;
  9512.  
  9513.                                 }
  9514.  
  9515.                                 setzeroflag=TRUE;
  9516.  
  9517.                                 break;
  9518.  
  9519.                         case tk_rr:
  9520.  
  9521.                                 vop=8;
  9522.  
  9523.                                 if(sign)vop+=0x10;
  9524.  
  9525.                         case tk_ll:
  9526.  
  9527.                           getoperand();
  9528.  
  9529.                                 if(tok==tk_number){
  9530.  
  9531.                                         if((unsigned int)itok.number==1){
  9532.  
  9533.                                                 if(expand==TRUE)op66(r16);
  9534.  
  9535.                                                 op(0xD0+expand); op(0xE0+vop);  /* SR AL,1 */
  9536.  
  9537.                                         }
  9538.  
  9539.                                         else if((unsigned int)itok.number!=0){
  9540.  
  9541.                                                 if(chip<2) goto llminus;
  9542.  
  9543.                                                 else{
  9544.  
  9545.                                                         if(expand==TRUE)op66(r16);
  9546.  
  9547.                                                         op(0xC0+expand); op(0xE0+vop);  /* SR AL,imm8 */
  9548.  
  9549.                                                         op((unsigned int)itok.number);
  9550.  
  9551.                                                         if(cpu<2)cpu=2;
  9552.  
  9553.                                                 }
  9554.  
  9555.                                         }
  9556.  
  9557.                                         setzeroflag=TRUE;
  9558.  
  9559.                                 }
  9560.  
  9561.                                 else goto llminus;
  9562.  
  9563.                                 break;
  9564.  
  9565.                         case tk_rrminus:
  9566.  
  9567.                                 vop=8;
  9568.  
  9569.                                 if(sign)vop+=0x10;
  9570.  
  9571.                         case tk_llminus:
  9572.  
  9573.                                 tok=tk_minus;   // need 286+ opt some time
  9574.  
  9575. llminus:
  9576.  
  9577.                                 if(!((tok==tk_beg||tok==tk_reg||tok==tk_reg32)&&itok.number==1)){
  9578.  
  9579.                                         getintobeg(CL,&ofsstr);
  9580.  
  9581.                                         warningreg(begs[1]);
  9582.  
  9583.                                 }
  9584.  
  9585.                                 else getoperand();
  9586.  
  9587.                                 if(expand==TRUE)op66(r16);
  9588.  
  9589.                                 op(0xD2+expand); op(0xE0+vop);
  9590.  
  9591.                                 setzeroflag=TRUE;
  9592.  
  9593.                                 next=0;
  9594.  
  9595.                                 break;
  9596.  
  9597.                         default: operatorexpected(); break;
  9598.  
  9599.                 }
  9600.  
  9601.                 if(negflag){
  9602.  
  9603.                         if(optimizespeed&&(chip==5||chip==6))outdword(0xC0FEFF34);      //xor AL,-1 AL++
  9604.  
  9605.                         else outword(0xD8F6);// NEG AL
  9606.  
  9607.                         negflag=0;
  9608.  
  9609.                         setzeroflag=TRUE;
  9610.  
  9611.                 }
  9612.  
  9613.                 if(next)nexttok();
  9614.  
  9615.                 ClearReg(AX);
  9616.  
  9617.         }
  9618.  
  9619. #ifdef OPTVARCONST
  9620.  
  9621.         calcnumber=FALSE;
  9622.  
  9623. #endif
  9624.  
  9625.         if(tok==tk_eof)unexpectedeof();
  9626.  
  9627. }
  9628.  
  9629.  
  9630.  
  9631. /* =============== doreg_32(), dobeg(), doseg() ===============*/
  9632.  
  9633.  
  9634.  
  9635. int doreg_32(int reg,int razr,int terminater)
  9636.  
  9637. {
  9638.  
  9639. unsigned char next=1;
  9640.  
  9641. int vop=0,sign=0;
  9642.  
  9643. int i;
  9644.  
  9645. int reg1=idxregs[0],reg2=idxregs[1];
  9646.  
  9647. unsigned long ii;
  9648.  
  9649. int rettype=tk_reg;
  9650.  
  9651. int rrettype,pointr=0;
  9652.  
  9653. int numpointr=0;
  9654.  
  9655. char *ofsstr=NULL;
  9656.  
  9657.         if(reg==reg1){
  9658.  
  9659.                 reg1=idxregs[1];
  9660.  
  9661.                 reg2=idxregs[2];
  9662.  
  9663.         }
  9664.  
  9665.         if(reg==reg2)reg2=idxregs[2];
  9666.  
  9667.         if(reg==ESP)RestoreStack();
  9668.  
  9669.         rrettype=razr==r16?tk_word:tk_dword;
  9670.  
  9671.         nexttok();
  9672.  
  9673.         switch(tok){
  9674.  
  9675.                 case tk_assign://=
  9676.  
  9677.                         if(am32)idxregs[4]=reg;
  9678.  
  9679.                         if(!((tok2==tk_reg||tok2==tk_reg32||tok2==tk_beg)&&ScanTok3()==terminater)){
  9680.  
  9681.                                 ofsstr=GetLecsem(terminater);
  9682.  
  9683.                         }
  9684.  
  9685.                         else{
  9686.  
  9687.                                 nexttok();
  9688.  
  9689.                                 switch(tok){
  9690.  
  9691.                                         case tk_beg:
  9692.  
  9693.                                                 i=r8;
  9694.  
  9695.                                                 break;
  9696.  
  9697.                                         case tk_reg:
  9698.  
  9699.                                                 i=r16;
  9700.  
  9701.                                                 break;
  9702.  
  9703.                                         case tk_reg32:
  9704.  
  9705.                                                 i=r32;
  9706.  
  9707.                                                 break;
  9708.  
  9709.                                 }
  9710.  
  9711.                                 if(i!=razr||RegToReg(reg,itok.number,i)==NOINREG)goto nn1;
  9712.  
  9713.                                 waralreadinitreg(regs[razr/4][itok.number],regs[razr/4][reg]);
  9714.  
  9715.                                 if(am32)idxregs[4]=255;
  9716.  
  9717.                                 break;
  9718.  
  9719.                         }
  9720.  
  9721.                         if(ofsstr){
  9722.  
  9723.                                 int retreg;
  9724.  
  9725.                                 if((retreg=CheckIDZReg(ofsstr,reg,razr))!=NOINREG){
  9726.  
  9727.                                         GetEndLex(terminater);
  9728.  
  9729.                                         if(razr==r16)tok=tk_reg;
  9730.  
  9731.                                         else tok=tk_reg32;
  9732.  
  9733.                                         itok.number=retreg==SKIPREG?reg:retreg;
  9734.  
  9735.                                         goto nn1;
  9736.  
  9737.                                 }
  9738.  
  9739.                         }
  9740.  
  9741.                         nexttok();
  9742.  
  9743.                         convert_type(&sign,&rrettype,&pointr,am32==TRUE?reg:BX);
  9744.  
  9745.                         if(rrettype==tk_float||rrettype==tk_double){
  9746.  
  9747.                                 if(am32)idxregs[4]=255;
  9748.  
  9749.                                 doeaxfloatmath(tk_reg32,reg,rrettype==tk_float?0:4);
  9750.  
  9751.                                 next=0;
  9752.  
  9753.                                 if(ofsstr){
  9754.  
  9755.                                         IDZToReg(ofsstr,reg,razr);
  9756.  
  9757.                                         free(ofsstr);
  9758.  
  9759.                                 }
  9760.  
  9761.                                 break;
  9762.  
  9763.                         }
  9764.  
  9765.                         while(tok==tk_mult){
  9766.  
  9767.                                 nexttok();
  9768.  
  9769.                                 numpointr++;
  9770.  
  9771.                         }
  9772.  
  9773.                         if(numpointr>itok.npointr)unuseableinput();
  9774.  
  9775.                         if(tok2==tk_assign){
  9776.  
  9777.                                 int hnumber=MultiAssign(razr,USEALLREG,numpointr);
  9778.  
  9779. //                              puts("end MultAssign");
  9780.  
  9781.                                 if(ofsstr){
  9782.  
  9783.                                         free(ofsstr);
  9784.  
  9785.                                         ofsstr=NULL;
  9786.  
  9787.                                 }
  9788.  
  9789.                                 if(reg!=hnumber){
  9790.  
  9791.                                         op66(razr);
  9792.  
  9793.                                         op(0x89);
  9794.  
  9795.                                         op(0xC0+reg+hnumber*8); //mov reg,AX
  9796.  
  9797.                                 }
  9798.  
  9799.                                 next=0;
  9800.  
  9801. /*                              if(ofsstr){
  9802.  
  9803.                                         IDZToReg(ofsstr,reg,razr);
  9804.  
  9805.                                         free(ofsstr);
  9806.  
  9807.                                 }*/
  9808.  
  9809.                                 if(am32)idxregs[4]=255;
  9810.  
  9811.                                 break;
  9812.  
  9813.                         }
  9814.  
  9815. //                      printf("tok=%d %s\n",tok,itok.name);
  9816.  
  9817.                         if(tok==tk_pointer)cpointr(am32==TRUE?reg:BX,numpointr);
  9818.  
  9819.                         if(tok==tk_new||tok==tk_delete){
  9820.  
  9821.                                 if(tok==tk_new)donew();
  9822.  
  9823.                                 else{
  9824.  
  9825.                                         dodelete();
  9826.  
  9827.                                         terminater=next=0;
  9828.  
  9829.                                 }
  9830.  
  9831.                                 if(am32)idxregs[4]=255;
  9832.  
  9833.                                 if(reg!=AX){
  9834.  
  9835.                                         GenRegToReg(reg,AX,(am32+1)*2);
  9836.  
  9837.                                 }
  9838.  
  9839.                                 clearregstat();
  9840.  
  9841. #ifdef OPTVARCONST
  9842.  
  9843.                                 FreeGlobalConst();
  9844.  
  9845. #endif
  9846.  
  9847.                                 if(ofsstr){
  9848.  
  9849.                                         free(ofsstr);
  9850.  
  9851.                                         ofsstr=NULL;
  9852.  
  9853.                                 }
  9854.  
  9855.                                 break;
  9856.  
  9857.                         }
  9858.  
  9859. nn1:
  9860.  
  9861.                         if(am32)idxregs[4]=255;
  9862.  
  9863.                         if(reg==AX){
  9864.  
  9865.                                 if(rrettype==tk_char||rrettype==tk_byte)rettype=doalmath(sign,&ofsstr);
  9866.  
  9867.                                 else if(rrettype==tk_int||rrettype==tk_word)rettype=do_e_axmath(sign,r16,&ofsstr);
  9868.  
  9869.                                 else rettype=do_e_axmath(sign,r32,&ofsstr);
  9870.  
  9871.                                 convert_returnvalue(razr==r16?tk_word:tk_dword,rrettype);
  9872.  
  9873.                         }
  9874.  
  9875.                         else{
  9876.  
  9877.                                 if(rrettype==tk_char||rrettype==tk_byte&&reg<=BX){
  9878.  
  9879.                                         rettype=getintobeg(reg,&ofsstr);
  9880.  
  9881.                                         if(itok.type!=tp_stopper&&tok!=tk_eof){
  9882.  
  9883.                                                 dobegmath(reg);
  9884.  
  9885.                                                 rettype=tk_beg;
  9886.  
  9887.                                         }
  9888.  
  9889.                                         op66(razr);
  9890.  
  9891.                                         op(0x0F);
  9892.  
  9893.                                         if(!sign)op(0xB6);
  9894.  
  9895.                                         else op(0xBE);
  9896.  
  9897.                                         op(0xC0+reg*9);
  9898.  
  9899.                                 }
  9900.  
  9901.                                 else{
  9902.  
  9903.                                         if(rrettype==tk_int||rrettype==tk_word)next=r16;
  9904.  
  9905.                                         else next=r32;
  9906.  
  9907.                                         rettype=getintoreg(reg,next,sign,&ofsstr);
  9908.  
  9909.                                         if(next==r16&&razr==r32){
  9910.  
  9911.                                                 op66(r32);
  9912.  
  9913.                                                 op(0x0F);
  9914.  
  9915.                                                 if(!sign)op(0xB7);
  9916.  
  9917.                                                 else op(0xBF);
  9918.  
  9919.                                                 op(0xC0+reg*9);
  9920.  
  9921.                                         }
  9922.  
  9923.                                 }
  9924.  
  9925.                         }
  9926.  
  9927.                         next=0;
  9928.  
  9929.                         if(ofsstr){
  9930.  
  9931.                                 IDZToReg(ofsstr,reg,razr);
  9932.  
  9933.                                 free(ofsstr);
  9934.  
  9935.                         }
  9936.  
  9937.                         break;
  9938.  
  9939.                 case tk_plusplus: op66(razr); op(0x40+reg);
  9940.  
  9941.                         ClearReg(reg);
  9942.  
  9943.                         break;
  9944.  
  9945.                 case tk_minusminus: op66(razr); op(0x48+reg);
  9946.  
  9947.                         ClearReg(reg);
  9948.  
  9949.                         break;
  9950.  
  9951.                 case tk_cdecl:
  9952.  
  9953.                 case tk_pascal:
  9954.  
  9955.                 case tk_fastcall:
  9956.  
  9957.                 case tk_stdcall:
  9958.  
  9959.                         vop=tok;
  9960.  
  9961.                         nexttok();
  9962.  
  9963.                         if(tok!=tk_openbracket){
  9964.  
  9965.                                 expected('(');
  9966.  
  9967.                                 FindStopTok();
  9968.  
  9969.                         }
  9970.  
  9971.                 case tk_openbracket:    //¢ë§®¢ ¯à®æ¥¤ãàë ¯®  ¤à¥áã ¢ ॣ¨áâà¥
  9972.  
  9973.                         param[0]=0;
  9974.  
  9975.                         i=0;
  9976.  
  9977.                         switch ( vop ) {
  9978.  
  9979.                                 case tk_cdecl:
  9980.  
  9981.                                 case tk_stdcall:
  9982.  
  9983.                                         i=swapparam();
  9984.  
  9985.                                         break;
  9986.  
  9987.                                 case tk_pascal:
  9988.  
  9989.                                         doparams();
  9990.  
  9991.                                         break;
  9992.  
  9993.                                 case tk_fastcall:
  9994.  
  9995.                                         doregparams();
  9996.  
  9997.                                         break;
  9998.  
  9999.                                 default:
  10000.  
  10001.                                         if(comfile==file_w32)swapparam();
  10002.  
  10003.                                         else doparams();
  10004.  
  10005.                         }
  10006.  
  10007.                         if(vop!=tk_cdecl)i=0;
  10008.  
  10009.                         op66(razr);
  10010.  
  10011.                         op(0xFF);
  10012.  
  10013.                         op(0xD0+reg);   /* CALL reg with stack params */
  10014.  
  10015.                         if(i)CorrectStack(i);
  10016.  
  10017.                         clearregstat();
  10018.  
  10019. #ifdef OPTVARCONST
  10020.  
  10021.                         FreeGlobalConst();
  10022.  
  10023. #endif
  10024.  
  10025.                         break;
  10026.  
  10027.                 case tk_swap:
  10028.  
  10029.                         getoperand(reg==BX?SI:BX);
  10030.  
  10031.                         switch(tok){
  10032.  
  10033.                                 case tk_qwordvar:
  10034.  
  10035.                                 case tk_longvar:
  10036.  
  10037.                                 case tk_dwordvar:
  10038.  
  10039.                                         if(razr==r16)swaperror();
  10040.  
  10041.                                         i=4;
  10042.  
  10043.                                         goto swapint;
  10044.  
  10045.                                 case tk_intvar:
  10046.  
  10047.                                 case tk_wordvar:
  10048.  
  10049.                                         i=2;
  10050.  
  10051.                                         if(razr==r32)swaperror();
  10052.  
  10053. swapint:
  10054.  
  10055.                                         ClearReg(reg);
  10056.  
  10057.                                         CheckAllMassiv(bufrm,i,&strinf,&itok,reg1,reg2);
  10058.  
  10059.                                         op66(razr);
  10060.  
  10061.                                         outseg(&itok,2);
  10062.  
  10063.                                         op(0x87);
  10064.  
  10065.                                         op(reg*8+itok.rm);
  10066.  
  10067.                                         outaddress(&itok);
  10068.  
  10069.                                         break;
  10070.  
  10071.                                 case tk_reg32:
  10072.  
  10073.                                         if(razr==r16)swaperror();
  10074.  
  10075.                                         goto swapreg;
  10076.  
  10077.                                 case tk_reg:
  10078.  
  10079.                                         if(razr==r32)swaperror();
  10080.  
  10081. swapreg:
  10082.  
  10083.                                         if(reg!=(int)itok.number){
  10084.  
  10085.                                                 if(RegSwapReg(reg,itok.number,razr)==NOINREG){;
  10086.  
  10087.                                                         op66(razr);
  10088.  
  10089.                                                         if(reg==AX)op(0x90+(unsigned int)itok.number);
  10090.  
  10091.                                                         else if((unsigned int)itok.number==AX)op(0x90+reg);
  10092.  
  10093.                                                         else{
  10094.  
  10095.                                                                 op(0x87);
  10096.  
  10097.                                                                 op(0xC0+(unsigned int)itok.number+reg*8);
  10098.  
  10099.                                                         }
  10100.  
  10101.                                                 }
  10102.  
  10103.                                                 else waralreadinitreg(regs[razr/4][reg],regs[razr/4][itok.number]);
  10104.  
  10105.                                         }
  10106.  
  10107.                                         break;
  10108.  
  10109.                                 default: swaperror(); break;
  10110.  
  10111.                         }
  10112.  
  10113.                         break;
  10114.  
  10115.                 case tk_xorequals: vop+=0x08;
  10116.  
  10117.                 case tk_minusequals: vop+=0x08;
  10118.  
  10119.                 case tk_andequals: vop+=0x18;
  10120.  
  10121.                 case tk_orequals: vop+=0x08;
  10122.  
  10123.                 case tk_plusequals:
  10124.  
  10125.                         ClearReg(reg);
  10126.  
  10127.                         if(am32&&uselea&&tok==tk_plusequals){
  10128.  
  10129.                                 if(RegEqualToLea(reg)){
  10130.  
  10131.                                         next=0;
  10132.  
  10133.                                         break;
  10134.  
  10135.                                 }
  10136.  
  10137.                         }
  10138.  
  10139.                         if(CheckAddOnly()){
  10140.  
  10141.                                 inptr2--;
  10142.  
  10143.                                 cha2=' ';
  10144.  
  10145.                                 if(tok==tk_plusequals)tok=tk_plus;
  10146.  
  10147.                                 else tok=tk_minus;
  10148.  
  10149.                                 if(reg==EAX)do_e_axmath2(0,razr,0);
  10150.  
  10151.                                 else doregmath_32(reg,razr,0,&ofsstr);
  10152.  
  10153.                                 next=0;
  10154.  
  10155.                                 break;
  10156.  
  10157.                         }
  10158.  
  10159.                         getoperand(reg==BX?SI:BX);
  10160.  
  10161.                         if(itok2.type==tp_opperand&&tok!=tk_number&&tok!=tk_undefofs&&tok!=tk_postnumber)goto defadd;
  10162.  
  10163.                         CheckMinusNum();
  10164.  
  10165.                         idrec *rrec;
  10166.  
  10167.                         int opost;
  10168.  
  10169.                         i=tok;
  10170.  
  10171.                         switch(tok){
  10172.  
  10173.                                 case tk_postnumber:
  10174.  
  10175.                                 case tk_undefofs:
  10176.  
  10177.                                         ii=itok.number;
  10178.  
  10179.                                         rrec=itok.rec;
  10180.  
  10181.                                         opost=itok.post;
  10182.  
  10183.                                         char uname[IDLENGTH];
  10184.  
  10185.                                         strcpy(uname,itok.name);
  10186.  
  10187.                                         if(itok.flag&f_extern)goto addnum;
  10188.  
  10189.                                         tok=tk_number;
  10190.  
  10191.                                 case tk_number:
  10192.  
  10193.                                         ii=doconstdwordmath();
  10194.  
  10195.                                         next=0;
  10196.  
  10197.                                         if(itok.type==tp_opperand){
  10198.  
  10199.                                                 if(reg==EAX){
  10200.  
  10201.                                                         sign=ECX;
  10202.  
  10203.                                                         if((tok2==tk_reg||tok2==tk_reg32)&&itok2.number==ECX)sign=EDX;
  10204.  
  10205.                                                         warningreg(regs[razr/2-1][sign]);
  10206.  
  10207.                                                 }
  10208.  
  10209.                                                 if(i==tk_postnumber||i==tk_undefofs){
  10210.  
  10211.                                                         op66(razr);
  10212.  
  10213.                                                         op(0xB8+reg);   // MOV reg,#
  10214.  
  10215.                                                         if(i==tk_postnumber)(postnumflag&f_extern)==0?setwordpost(&itok):setwordext((long *)&ii);
  10216.  
  10217.                                                         else{
  10218.  
  10219.                                                                 if((postnumflag&f_reloc)!=0)AddReloc();
  10220.  
  10221.                                                                 if(i==tk_undefofs)AddUndefOff(2,uname);
  10222.  
  10223.                                                         }
  10224.  
  10225.                                                         razr==r16?outword(ii):outdword(ii);
  10226.  
  10227.                                                 }
  10228.  
  10229.                                                 else MovRegNum(razr,postnumflag&f_reloc,ii,sign);
  10230.  
  10231.                                                 if(sign==EAX)do_e_axmath2(0,razr,0);
  10232.  
  10233.                                                 else doregmath_32(sign,razr,0,&ofsstr);
  10234.  
  10235.                                                 itok.number=sign;
  10236.  
  10237.                                                 goto addreg;
  10238.  
  10239.                                         }
  10240.  
  10241.                                         if((postnumflag&f_reloc)==0&&i!=tk_undefofs&&i!=tk_postnumber&&optnumadd(ii,reg,razr,vop))break;
  10242.  
  10243. addnum:
  10244.  
  10245.                                         op66(razr);
  10246.  
  10247.                                   if(reg==AX)op(0x05+vop);
  10248.  
  10249.                                         else{
  10250.  
  10251.                                                 op(0x81);
  10252.  
  10253.                                                 op(0xC0+vop+reg);
  10254.  
  10255.                                         }
  10256.  
  10257.                                         itok.rec=rrec;
  10258.  
  10259.                                         itok.post=opost;
  10260.  
  10261.                                         if(i==tk_postnumber)(postnumflag&f_extern)==0?setwordpost(&itok):setwordext((long *)&ii);
  10262.  
  10263.                                         else{
  10264.  
  10265.                                                 if((postnumflag&f_reloc)!=0)AddReloc();
  10266.  
  10267.                                                 if(i==tk_undefofs)AddUndefOff(2,uname);
  10268.  
  10269.                                         }
  10270.  
  10271.                                         razr==r16?outword(ii):outdword(ii);
  10272.  
  10273.                                         break;
  10274.  
  10275.                                 case tk_qwordvar:
  10276.  
  10277.                                 case tk_longvar:
  10278.  
  10279.                                 case tk_dwordvar:
  10280.  
  10281.                                         i=4;
  10282.  
  10283.                                         goto wordadd;
  10284.  
  10285.                                 case tk_intvar:
  10286.  
  10287.                                 case tk_wordvar:
  10288.  
  10289.                                         i=2;
  10290.  
  10291.                                         if(razr==r32)valueexpected();
  10292.  
  10293. wordadd:
  10294.  
  10295.                                         CheckAllMassiv(bufrm,i,&strinf,&itok,reg1,reg2);
  10296.  
  10297.                                         op66(razr);
  10298.  
  10299.                                         outseg(&itok,2);
  10300.  
  10301.                                         op(0x03+vop);
  10302.  
  10303.                                         op(reg*8+itok.rm);
  10304.  
  10305.                                         outaddress(&itok);
  10306.  
  10307.                                         break;
  10308.  
  10309.                                 case tk_reg:
  10310.  
  10311.                                         if(razr==r32)valueexpected();
  10312.  
  10313.                                 case tk_reg32:
  10314.  
  10315. addreg:
  10316.  
  10317.                                         op66(razr);
  10318.  
  10319.                                         op(0x01+vop);
  10320.  
  10321.                                         op(0xC0+reg+(unsigned int)itok.number*8);
  10322.  
  10323.                                         break;
  10324.  
  10325.                                 case tk_ID:
  10326.  
  10327.                                 case tk_id:
  10328.  
  10329.                                 case tk_proc:
  10330.  
  10331.                                 case tk_apiproc:
  10332.  
  10333.                                 case tk_undefproc:
  10334.  
  10335.                                 case tk_declare:
  10336.  
  10337. unsigned char oaddstack;
  10338.  
  10339.                                         if(reg==EAX){
  10340.  
  10341.                                                 op66(razr);
  10342.  
  10343.                                                 op(0x50);       //push AX
  10344.  
  10345.                                                 addESP+=razr==r16?2:4;
  10346.  
  10347.                                                 warningreg(regs[razr/2-1][EDX]);
  10348.  
  10349.                                                 oaddstack=addstack;
  10350.  
  10351.                                                 addstack=FALSE;
  10352.  
  10353.                                         }
  10354.  
  10355.                                         procdo(razr==r16?tk_word:tk_dword);
  10356.  
  10357.                                         if(itok2.type==tp_opperand){
  10358.  
  10359.                                                 nexttok();
  10360.  
  10361.                                                 do_e_axmath2(0,razr,0);
  10362.  
  10363.                                                 next=0;
  10364.  
  10365.                                         }
  10366.  
  10367.                                         if(reg==EAX){
  10368.  
  10369.                                                 addstack=oaddstack;
  10370.  
  10371.                                                 addESP-=razr==r16?2:4;
  10372.  
  10373.                                                 op66(razr);
  10374.  
  10375.                                                 op(0x58+EDX);   //pop dx
  10376.  
  10377.                                                 if(vop>0x20){
  10378.  
  10379.                                                         op66(razr);
  10380.  
  10381.                                                         op(0x90+EDX);   //xchg ax,dx
  10382.  
  10383.                                                 }
  10384.  
  10385.                                                 op66(razr);
  10386.  
  10387.                                                 op(0x01+vop);
  10388.  
  10389.                                                 op(0xc0+EDX*8); //add ax,dx
  10390.  
  10391.                                         }
  10392.  
  10393.                                         else{
  10394.  
  10395.                                                 op66(razr);
  10396.  
  10397.                                                 op(0x01+vop);
  10398.  
  10399.                                                 op(0xc0+reg);   //add reg,ax
  10400.  
  10401.                                         }
  10402.  
  10403.                                         break;
  10404.  
  10405.                                 case tk_seg:
  10406.  
  10407.                                         if(razr==r32)valueexpected();
  10408.  
  10409.                                 case tk_bytevar:
  10410.  
  10411.                                 case tk_charvar:
  10412.  
  10413.                                 case tk_beg:
  10414.  
  10415. defadd:
  10416.  
  10417.                                         if(reg==AX){
  10418.  
  10419.                                                 getintoreg_32(ECX,razr,sign,&ofsstr);
  10420.  
  10421.                                                 doregmath_32(ECX,razr,sign,&ofsstr);
  10422.  
  10423.                                                 sign=CX;        //sign ¨á¯ ª ª ¯à®¬ ॣ¨áâà
  10424.  
  10425.                                         }
  10426.  
  10427.                                         else{
  10428.  
  10429.                                                 do_e_axmath(0,razr,&ofsstr);
  10430.  
  10431.                                                 sign=EAX;
  10432.  
  10433.                                         }
  10434.  
  10435.                                         warningreg(regs[razr/2-1][sign]);
  10436.  
  10437.                                         op66(razr);// OPT reg32,ECX
  10438.  
  10439.                                         op(0x01+vop);
  10440.  
  10441.                                         op(0xC0+reg+sign*8);
  10442.  
  10443.                                         next=0;
  10444.  
  10445.                                         break;
  10446.  
  10447.                                 default: valueexpected(); break;
  10448.  
  10449.                         }
  10450.  
  10451.                         break;
  10452.  
  10453.                 case tk_rrequals: vop+=0x08;
  10454.  
  10455.                 case tk_llequals:
  10456.  
  10457.                         ClearReg(reg);
  10458.  
  10459.                         getoperand(am32==TRUE?ECX:reg==BX?SI:BX);
  10460.  
  10461.                         CheckMinusNum();
  10462.  
  10463.                         if(tok==tk_number){
  10464.  
  10465.                                 ii=doconstlongmath();
  10466.  
  10467.                                 next=0;
  10468.  
  10469.                                 if(itok.type==tp_opperand){
  10470.  
  10471.                                         if(reg==ECX)regshifterror();
  10472.  
  10473.                                         op(0xB0+CL); op(ii);    //mov CL,num
  10474.  
  10475.                                         dobegmath(CL);
  10476.  
  10477.                                         warningreg(begs[1]);
  10478.  
  10479.                                         ConstToReg(ii,CL,r8);
  10480.  
  10481.                                         goto shiftcl;
  10482.  
  10483.                                 }
  10484.  
  10485.                                 if(ii==1){
  10486.  
  10487.                                         op66(razr);
  10488.  
  10489.                                         op(0xD1); op(0xE0+reg+vop);
  10490.  
  10491.                                 }  /* SHL reg,1 */
  10492.  
  10493.                                 else if(ii!=0){
  10494.  
  10495.                                         if(chip<2&&razr==r16){
  10496.  
  10497.                                                 op(0xB0+CL); op(ii);    //mov CL,num
  10498.  
  10499.                                                 warningreg(begs[1]);
  10500.  
  10501.                                                 ConstToReg(ii,CL,r8);
  10502.  
  10503.                                                 goto shiftcl;
  10504.  
  10505.                                         }
  10506.  
  10507.                                         else{
  10508.  
  10509.                                                 op66(razr);
  10510.  
  10511.                                                 op(0xC1); op(0xE0+reg+vop);     /* SHL reg,imm8 */
  10512.  
  10513.                                                 op(ii);
  10514.  
  10515.                                                 if(cpu<2)cpu=2;
  10516.  
  10517.                                         }
  10518.  
  10519.                                 }
  10520.  
  10521.                         }
  10522.  
  10523.                         else if(reg!=CX){
  10524.  
  10525.                                 if(!(itok2.type==tp_stopper&&(tok==tk_beg||tok==reg||tok==tk_reg32)&&itok.number==CL)){
  10526.  
  10527.                                         getintobeg(CL,&ofsstr);
  10528.  
  10529.                                         dobegmath(CL);
  10530.  
  10531.                                         warningreg(begs[1]);
  10532.  
  10533.                                         ClearReg(CL);
  10534.  
  10535.                                         next=0;
  10536.  
  10537.                                 }
  10538.  
  10539. shiftcl:
  10540.  
  10541.                                 op66(razr);
  10542.  
  10543.                                 op(0xD3); op(0xE0+vop+reg);     /* SHL AX,CL */
  10544.  
  10545.                         }
  10546.  
  10547.                         else regshifterror();
  10548.  
  10549.                         break;
  10550.  
  10551.                 case tk_multequals:
  10552.  
  10553.                         ClearReg(reg);
  10554.  
  10555.                         getoperand(reg==BX?SI:BX);
  10556.  
  10557.                         CheckMinusNum();
  10558.  
  10559.                         if(tok==tk_number){
  10560.  
  10561.                                 ii=doconstlongmath();
  10562.  
  10563.                                 next=0;
  10564.  
  10565.                                 if(itok.type==tp_opperand){
  10566.  
  10567.                                         if(reg==EAX)sign=ECX;
  10568.  
  10569.                                         MovRegNum(razr,postnumflag&f_reloc,ii,sign);
  10570.  
  10571.                                         if(sign==EAX)do_e_axmath2(0,razr,0);
  10572.  
  10573.                                         else doregmath_32(ECX,razr,0,&ofsstr);
  10574.  
  10575.                                         ConstToReg(ii,sign,razr);
  10576.  
  10577.                                         goto mulreg;
  10578.  
  10579.                                 }
  10580.  
  10581.                                 i=0;
  10582.  
  10583.                                 RegMulNum(reg,ii,razr,0,&i,itok.flag);
  10584.  
  10585.                         }
  10586.  
  10587.                         else{
  10588.  
  10589.                                 if(itok2.type==tp_stopper)next=(unsigned char)MulReg(reg,razr);
  10590.  
  10591.                                 else{
  10592.  
  10593.                                         if(reg==AX){
  10594.  
  10595.                                                 getintoreg_32(ECX,razr,sign,&ofsstr);
  10596.  
  10597.                                                 doregmath_32(ECX,razr,sign,&ofsstr);
  10598.  
  10599.                                                 sign=CX;        //sign ¨á¯ ª ª ¯à®¬ ॣ¨áâà
  10600.  
  10601.                                         }
  10602.  
  10603.                                         else{
  10604.  
  10605.                                                 do_e_axmath(0,razr,&ofsstr);
  10606.  
  10607.                                                 sign=EAX;
  10608.  
  10609.                                         }
  10610.  
  10611. mulreg:
  10612.  
  10613.                                         warningreg(regs[razr/2-1][sign]);
  10614.  
  10615.                                         ClearReg(sign);
  10616.  
  10617.                                         op66(razr);
  10618.  
  10619.                                         outword(0xAF0F);
  10620.  
  10621.                                         op(0xC0+reg*8+sign);
  10622.  
  10623.                                         next=0;
  10624.  
  10625.                                 }
  10626.  
  10627.                         }
  10628.  
  10629.                         break;
  10630.  
  10631.                 case tk_divequals:
  10632.  
  10633.                         getoperand(reg==BX?SI:BX);
  10634.  
  10635.                         ClearReg(reg);
  10636.  
  10637.                         CheckMinusNum();
  10638.  
  10639.                         if(tok==tk_number){
  10640.  
  10641.                                 ii=doconstlongmath();
  10642.  
  10643.                                 next=0;
  10644.  
  10645.                                 if(itok.type==tp_opperand){
  10646.  
  10647.                                         op66(razr);
  10648.  
  10649.                                         op(0x50+reg);   //push reg
  10650.  
  10651.                                         addESP+=razr==r16?2:4;
  10652.  
  10653.                                         MovRegNum(razr,postnumflag&f_reloc,ii,EAX);
  10654.  
  10655.                                         do_e_axmath2(0,razr,0);
  10656.  
  10657.                                         ClearReg(AX);
  10658.  
  10659.                                         goto divreg;
  10660.  
  10661.                                 }
  10662.  
  10663.                                 if((vop=caselong(ii))!=NUMNUM&&(!(reg==ECX&&chip<2))){
  10664.  
  10665.                                         if(vop!=0){
  10666.  
  10667.                                                 if(chip<2&&razr==r16){
  10668.  
  10669.                                                         op(0xB1); op(vop); /* MOV CL,num */
  10670.  
  10671.                                                         op(0xD3);
  10672.  
  10673.                                                         op(0xE8+reg); // SHR reg,CL
  10674.  
  10675.                                                         warningreg(begs[1]);
  10676.  
  10677.                                                         ClearReg(CX);
  10678.  
  10679.                                                 }
  10680.  
  10681.                                                 else{
  10682.  
  10683.                                                         op66(razr);
  10684.  
  10685.                                                         op(0xC1);
  10686.  
  10687.                                                         op(0xE8+reg); // SHR reg,num
  10688.  
  10689.                                                         op(vop);
  10690.  
  10691.                                                 }
  10692.  
  10693.                                         }
  10694.  
  10695.                                 }
  10696.  
  10697.                                 else{
  10698.  
  10699.                                         if(reg!=EAX){
  10700.  
  10701.                                                 op66(razr);
  10702.  
  10703.                                                 op(0x90+reg);   //xchg reg,AX
  10704.  
  10705.                                         }
  10706.  
  10707.                                         DivNum(ii,razr,0);
  10708.  
  10709.                                         if(reg!=EAX){
  10710.  
  10711.                                                 op66(razr);
  10712.  
  10713.                                                 op(0x90+reg);   //xchg reg,AX
  10714.  
  10715.                                                 warningreg(regs[razr/2-1][EAX]);
  10716.  
  10717.                                                 ClearReg(AX);
  10718.  
  10719.                                         }
  10720.  
  10721.                                 }
  10722.  
  10723.                         }
  10724.  
  10725.                         else if(itok2.type==tp_stopper){
  10726.  
  10727.                                 if(reg!=EAX){
  10728.  
  10729.                                         op66(razr);
  10730.  
  10731.                                         op(0x90+reg);   //xchg reg,AX
  10732.  
  10733.                                 }
  10734.  
  10735.                                 DivMod(0,0,razr,0);
  10736.  
  10737.                                 next=0;
  10738.  
  10739.                                 if(reg!=EAX){
  10740.  
  10741.                                         op66(razr);
  10742.  
  10743.                                         op(0x90+reg);   //xchg reg,AX
  10744.  
  10745.                                         warningreg(regs[razr/2-1][EAX]);
  10746.  
  10747.                                         ClearReg(AX);
  10748.  
  10749.                                 }
  10750.  
  10751.                         }
  10752.  
  10753.                         else{
  10754.  
  10755.                                 op66(razr);
  10756.  
  10757.                                 op(0x50+reg);   //push reg
  10758.  
  10759.                                 addESP+=razr==r16?2:4;
  10760.  
  10761.                                 do_e_axmath(0,razr,&ofsstr);
  10762.  
  10763. divreg:
  10764.  
  10765.                                 op66(razr);
  10766.  
  10767.                                 sign=reg;
  10768.  
  10769.                                 if(reg==EAX){
  10770.  
  10771.                                         sign=ECX;
  10772.  
  10773.                                         warningreg(regs[razr/2-1][ECX]);
  10774.  
  10775.                                         ClearReg(CX);
  10776.  
  10777.                                 }
  10778.  
  10779.                                 addESP-=razr==r16?2:4;
  10780.  
  10781.                                 op(0x58+sign);  //pop sign
  10782.  
  10783.                                 op66(razr);
  10784.  
  10785.                                 op(0x90+sign);  //xchg AX,sign
  10786.  
  10787.                                 op66(razr);
  10788.  
  10789.                                 op(0xF7);
  10790.  
  10791.                                 op(0xF0+sign); // DIV reg
  10792.  
  10793.                                 op66(razr);
  10794.  
  10795.                                 if(reg!=EAX){
  10796.  
  10797.                                         if(optimizespeed){
  10798.  
  10799.                                                 op(0x89);
  10800.  
  10801.                                                 op(0xC0+reg);   //mov reg,AX
  10802.  
  10803.                                         }
  10804.  
  10805.                                         else op(0x90+reg);      //xchg AX,sign
  10806.  
  10807.                                 }
  10808.  
  10809.                                 warningreg(regs[razr/2-1][EAX]);
  10810.  
  10811.                                 ClearReg(AX);
  10812.  
  10813.                                 next=0;
  10814.  
  10815.                         }
  10816.  
  10817.                         break;
  10818.  
  10819.                 default: operatorexpected(); break;
  10820.  
  10821.         }
  10822.  
  10823.         if(next)nexttok();
  10824.  
  10825.         if(terminater==tk_semicolon)seminext();
  10826.  
  10827.         if(razr==r32&&cpu<3)cpu=3;
  10828.  
  10829. //      puts("return doreg_32");
  10830.  
  10831.         return rettype;
  10832.  
  10833. }
  10834.  
  10835.  
  10836.  
  10837. int optnumadd(unsigned long num,int reg,int razr,int vop)
  10838.  
  10839. {
  10840.  
  10841. int nrazr=0;
  10842.  
  10843.         if(num==0){
  10844.  
  10845.                 if(vop==0x20){  //&=
  10846.  
  10847.                         ZeroReg(reg,razr);
  10848.  
  10849.                         setzeroflag=TRUE;
  10850.  
  10851.                 }
  10852.  
  10853.                 return TRUE;            //+= -= |= ^=
  10854.  
  10855.         }
  10856.  
  10857.         if(vop==8){     //|=
  10858.  
  10859.                 if(num<65536&&razr==r32)nrazr=razr=r16;
  10860.  
  10861.                 if((unsigned short)num<256&&razr==r16&&reg<4){
  10862.  
  10863.                         if(reg==AX)op(0x0C);
  10864.  
  10865.                         else{
  10866.  
  10867.                                 op(0x80);
  10868.  
  10869.                                 op(0xc8+reg);
  10870.  
  10871.                         }
  10872.  
  10873.                         op(num);
  10874.  
  10875.                         return TRUE;
  10876.  
  10877.                 }
  10878.  
  10879.                 if(nrazr==r16){
  10880.  
  10881.                         op66(r16);
  10882.  
  10883.                         if(reg==AX)op(0x0D);
  10884.  
  10885.                         else{
  10886.  
  10887.                                 op(0x81);
  10888.  
  10889.                                 op(0xc8+reg);
  10890.  
  10891.                         }
  10892.  
  10893.                         outword(num);
  10894.  
  10895.                         return TRUE;
  10896.  
  10897.                 }
  10898.  
  10899.         }
  10900.  
  10901.         if(num==1){
  10902.  
  10903.                 if(vop==0x28){  //-=
  10904.  
  10905.                         op66(razr);
  10906.  
  10907.                         op(0x48+reg);
  10908.  
  10909.                         setzeroflag=TRUE;
  10910.  
  10911.                         return TRUE;
  10912.  
  10913.                 }
  10914.  
  10915.                 if(vop==0){     //+=
  10916.  
  10917.                         op66(razr);
  10918.  
  10919.                         op(0x40+reg);
  10920.  
  10921.                         setzeroflag=TRUE;
  10922.  
  10923.                         return TRUE;
  10924.  
  10925.                 }
  10926.  
  10927.         }
  10928.  
  10929.         if(!optimizespeed&&num==2&&((razr==r16&&am32==FALSE)||(razr==r32&&am32))){
  10930.  
  10931.                 if(vop==0x28){  //-=
  10932.  
  10933.                         op(0x48+reg);
  10934.  
  10935.                         op(0x48+reg);
  10936.  
  10937.                         setzeroflag=TRUE;
  10938.  
  10939.                         return TRUE;
  10940.  
  10941.                 }
  10942.  
  10943.                 if(vop==0){     //+=
  10944.  
  10945.                         op66(razr);
  10946.  
  10947.                         op(0x40+reg);
  10948.  
  10949.                         op66(razr);
  10950.  
  10951.                         op(0x40+reg);
  10952.  
  10953.                         setzeroflag=TRUE;
  10954.  
  10955.                         return TRUE;
  10956.  
  10957.                 }
  10958.  
  10959.         }
  10960.  
  10961.         if((razr==r16&&(unsigned short)num==0xffff)||
  10962.  
  10963.                         (razr==r32&&num==0xffffffff)){
  10964.  
  10965.                 if(vop==0x28){  //-=
  10966.  
  10967.                         op66(razr);
  10968.  
  10969.                         op(0x40+reg);
  10970.  
  10971.                         setzeroflag=TRUE;
  10972.  
  10973.                         return TRUE;
  10974.  
  10975.                 }
  10976.  
  10977.                 if(vop==0){     //+=
  10978.  
  10979.                         op66(razr);
  10980.  
  10981.                         op(0x48+reg);
  10982.  
  10983.                         setzeroflag=TRUE;
  10984.  
  10985.                         return TRUE;
  10986.  
  10987.                 }
  10988.  
  10989.                 if(vop==0x20)return TRUE;       //&=
  10990.  
  10991.                 if(vop==0x30){  //^=
  10992.  
  10993.                         if(optimizespeed&&(chip==5||chip==6))return FALSE;
  10994.  
  10995.                         op66(razr);
  10996.  
  10997.                         op(0xF7);
  10998.  
  10999.                         op(0xD0+reg);   //Not reg
  11000.  
  11001.                         setzeroflag=FALSE;
  11002.  
  11003.                         return TRUE;
  11004.  
  11005.                 }
  11006.  
  11007.         }
  11008.  
  11009.         if(vop==0x20){  //&=
  11010.  
  11011.                 if(num>=0xFFFF0000&&razr==r32)nrazr=razr=r16;
  11012.  
  11013.                 if(razr==r16&&(unsigned short)num>=0xFF00&&reg<4){
  11014.  
  11015.                         if(reg==AL)op(0x24);
  11016.  
  11017.                         else{
  11018.  
  11019.                                 op(128);
  11020.  
  11021.                                 op(0xE0+reg);
  11022.  
  11023.                         }
  11024.  
  11025.                         op(num);
  11026.  
  11027.                         return TRUE;
  11028.  
  11029.                 }
  11030.  
  11031.                 if(nrazr==r16){
  11032.  
  11033.                         op66(r16);
  11034.  
  11035.                         if(reg==AX)op(0x25);
  11036.  
  11037.                         else{
  11038.  
  11039.                                 op(129);
  11040.  
  11041.                                 op(0xE0+reg);
  11042.  
  11043.                         }
  11044.  
  11045.                         outword(num);
  11046.  
  11047.                         return TRUE;
  11048.  
  11049.                 }
  11050.  
  11051.         }
  11052.  
  11053.         if(!optimizespeed&&(razr==r16&&(unsigned short)num==0xfffe&&am32==FALSE)||
  11054.  
  11055.                         (razr==r32&&num==0xfffffffe&&am32)){
  11056.  
  11057.                 if(vop==0x28){  //-=
  11058.  
  11059.                         op(0x40+reg);
  11060.  
  11061.                         op(0x40+reg);
  11062.  
  11063.                         setzeroflag=TRUE;
  11064.  
  11065.                         return TRUE;
  11066.  
  11067.                 }
  11068.  
  11069.                 if(vop==0){     //+=
  11070.  
  11071.                         op(0x48+reg);
  11072.  
  11073.                         op(0x48+reg);
  11074.  
  11075.                         setzeroflag=TRUE;
  11076.  
  11077.                         return TRUE;
  11078.  
  11079.                 }
  11080.  
  11081.         }
  11082.  
  11083.         if(short_ok(num,razr/2-1)){
  11084.  
  11085.                 op66(razr);
  11086.  
  11087.                 op(0x83);
  11088.  
  11089.                 op(0xC0+vop+reg);
  11090.  
  11091.                 op(num);
  11092.  
  11093.                 setzeroflag=TRUE;
  11094.  
  11095.                 return TRUE;
  11096.  
  11097.         }
  11098.  
  11099.         return FALSE;
  11100.  
  11101. }
  11102.  
  11103.  
  11104.  
  11105. int dobeg(int beg,int terminater)
  11106.  
  11107. {
  11108.  
  11109. unsigned char next=1;
  11110.  
  11111. int vop=0,i=0,sign=0;
  11112.  
  11113. int rettype=tk_beg,pointr=0;;
  11114.  
  11115. int rrettype=tk_byte;
  11116.  
  11117. int numpointr=0;
  11118.  
  11119. char *ofsstr=NULL;
  11120.  
  11121.         nexttok();
  11122.  
  11123.         switch(tok){
  11124.  
  11125.                 case tk_assign:
  11126.  
  11127.                         if(!((tok2==tk_reg||tok2==tk_reg32||tok2==tk_beg)&&ScanTok3()==terminater)){
  11128.  
  11129.                                 ofsstr=GetLecsem(terminater);
  11130.  
  11131.                         }
  11132.  
  11133.                         else{
  11134.  
  11135.                                 nexttok();
  11136.  
  11137.                                 if(RegToReg(beg,itok.number,r8)==NOINREG)goto nn1;
  11138.  
  11139.                                 waralreadinitreg(begs[itok.number],begs[beg]);
  11140.  
  11141.                                 break;
  11142.  
  11143.                         }
  11144.  
  11145.                         if(ofsstr){
  11146.  
  11147.                                 int retreg;
  11148.  
  11149.                                 if((retreg=CheckIDZReg(ofsstr,beg,r8))!=NOINREG){
  11150.  
  11151.                                         GetEndLex(terminater);
  11152.  
  11153.                                         tok=tk_beg;
  11154.  
  11155.                                         itok.number=retreg==SKIPREG?beg:retreg;
  11156.  
  11157.                                         goto nn1;
  11158.  
  11159.                                 }
  11160.  
  11161.                         }
  11162.  
  11163.                         nexttok();
  11164.  
  11165.                         convert_type(&sign,&rrettype,&pointr,am32==TRUE?(beg>3?beg-4:beg):BX);
  11166.  
  11167.                         while(tok==tk_mult){
  11168.  
  11169.                                 nexttok();
  11170.  
  11171.                                 numpointr++;
  11172.  
  11173.                         }
  11174.  
  11175.                         if(numpointr>itok.npointr)unuseableinput();
  11176.  
  11177.                         if(tok2==tk_assign){
  11178.  
  11179.                                 int hnumber=MultiAssign(r8,(beg>3?beg-4:beg),numpointr);
  11180.  
  11181.                                 if(ofsstr){
  11182.  
  11183.                                         free(ofsstr);
  11184.  
  11185.                                         ofsstr=NULL;
  11186.  
  11187.                                 }
  11188.  
  11189.                                 if(beg!=hnumber){
  11190.  
  11191.                                         op(0x88);
  11192.  
  11193.                                         op(0xC0+beg+hnumber*8); //mov beg,AL
  11194.  
  11195.                                 }
  11196.  
  11197.                                 next=0;
  11198.  
  11199.                                 if(ofsstr){
  11200.  
  11201.                                         IDZToReg(ofsstr,beg,r8);
  11202.  
  11203.                                         free(ofsstr);
  11204.  
  11205.                                 }
  11206.  
  11207.                                 break;
  11208.  
  11209.                         }
  11210.  
  11211.                         if(tok==tk_pointer)cpointr(am32==TRUE?(beg>3?beg-4:beg):BX,numpointr);
  11212.  
  11213. nn1:
  11214.  
  11215.                         if(beg==AL){
  11216.  
  11217.                                 if(rrettype==tk_char||rrettype==tk_byte)rettype=doalmath(sign,&ofsstr);
  11218.  
  11219.                                 else if(rrettype==tk_int||rrettype==tk_word)rettype=do_e_axmath(sign,r16,&ofsstr);
  11220.  
  11221.                                 else rettype=do_e_axmath(sign,r32,&ofsstr);
  11222.  
  11223.                                 next=0;
  11224.  
  11225.                         }
  11226.  
  11227.                         else{
  11228.  
  11229.                                 if(rrettype==tk_char||rrettype==tk_byte||beg>BL){
  11230.  
  11231.                                         rettype=getintobeg(beg,&ofsstr);
  11232.  
  11233.                                         if(itok.type!=tp_stopper&&tok!=tk_eof){
  11234.  
  11235.                                                 dobegmath(beg);
  11236.  
  11237.                                                 rettype=tk_beg;
  11238.  
  11239.                                         }
  11240.  
  11241.                                 }
  11242.  
  11243.                                 else{
  11244.  
  11245.                                         if(rrettype==tk_int||rrettype==tk_word)next=r16;
  11246.  
  11247.                                         else next=r32;
  11248.  
  11249.                                         rettype=getintoreg(beg,next,sign,&ofsstr);
  11250.  
  11251.                                 }
  11252.  
  11253.                                 next=0;
  11254.  
  11255.                         }
  11256.  
  11257.                         if(ofsstr){
  11258.  
  11259.                                 IDZToReg(ofsstr,beg,r8);
  11260.  
  11261.                                 free(ofsstr);
  11262.  
  11263.                         }
  11264.  
  11265.                         break;
  11266.  
  11267.                 case tk_plusplus: op(0xFE); op(0xC0+beg);
  11268.  
  11269.                         ClearReg(beg>3?beg%4:beg);
  11270.  
  11271.                         break;
  11272.  
  11273.                 case tk_minusminus: op(0xFE); op(0xC8+beg);
  11274.  
  11275.                         ClearReg(beg>3?beg%4:beg);
  11276.  
  11277.                         break;
  11278.  
  11279.                 case tk_swap:
  11280.  
  11281.                         getoperand(beg==BL||beg==BH?SI:BX);
  11282.  
  11283.                         switch(tok){
  11284.  
  11285.                                 case tk_charvar:
  11286.  
  11287.                                 case tk_bytevar:
  11288.  
  11289.                                         CheckAllMassiv(bufrm,1,&strinf);
  11290.  
  11291.                                   outseg(&itok,2);
  11292.  
  11293.                                         op(0x86);
  11294.  
  11295.                                         op(beg*8+itok.rm);
  11296.  
  11297.                                         outaddress(&itok);
  11298.  
  11299.                                         KillVar(itok.name);
  11300.  
  11301.                                         ClearReg(beg>3?beg-4:beg);
  11302.  
  11303.                                         break;
  11304.  
  11305.                                 case tk_beg:
  11306.  
  11307.                                         if(beg!=(int)itok.number){
  11308.  
  11309.                                                 if(RegSwapReg(beg,itok.number,r8)==NOINREG){
  11310.  
  11311.                                                         op(0x86);
  11312.  
  11313.                                                         op(0xC0+(unsigned int)itok.number+beg*8);
  11314.  
  11315.                                                 }
  11316.  
  11317.                                                 else waralreadinitreg(begs[beg],begs[itok.number]);
  11318.  
  11319.                                         }
  11320.  
  11321.                                         break;
  11322.  
  11323.                                 default: swaperror(); break;
  11324.  
  11325.                         }
  11326.  
  11327.                         break;
  11328.  
  11329.                 case tk_xorequals: vop+=0x08;
  11330.  
  11331.                 case tk_minusequals: vop+=0x08;
  11332.  
  11333.                 case tk_andequals: vop+=0x18;
  11334.  
  11335.                 case tk_orequals: vop+=0x08;
  11336.  
  11337.                 case tk_plusequals:
  11338.  
  11339.                         ClearReg(beg>3?beg%4:beg);
  11340.  
  11341.                         if(CheckAddOnly()){
  11342.  
  11343.                                 inptr2--;
  11344.  
  11345.                                 cha2=' ';
  11346.  
  11347.                                 if(tok==tk_plusequals)tok=tk_plus;
  11348.  
  11349.                                 else tok=tk_minus;
  11350.  
  11351.                                 if(beg==AL)doalmath2(0);
  11352.  
  11353.                                 else dobegmath(beg);
  11354.  
  11355.                                 next=0;
  11356.  
  11357.                                 break;
  11358.  
  11359.                         }
  11360.  
  11361.                         getoperand(beg==BL||beg==BH?SI:BX);
  11362.  
  11363.                         if(itok2.type==tp_opperand&&tok!=tk_number){
  11364.  
  11365.                                 if(beg==AL){
  11366.  
  11367.                                         getintobeg(CL,&ofsstr);
  11368.  
  11369.                                         dobegmath(CL);
  11370.  
  11371.                                         sign=CL;        //sign ¨á¯ ª ª ¯à®¬ ॣ¨áâà
  11372.  
  11373.                                 }
  11374.  
  11375.                                 else{
  11376.  
  11377.                                         doalmath(0,&ofsstr);
  11378.  
  11379.                                         sign=EAX;
  11380.  
  11381.                                 }
  11382.  
  11383.                                 warningreg(begs[sign]);
  11384.  
  11385.                                 op(0x00+vop);
  11386.  
  11387.                                 op(0xC0+beg+sign*8);
  11388.  
  11389.                                 next=0;
  11390.  
  11391.                                 break;
  11392.  
  11393.                         }
  11394.  
  11395.                         switch(tok){
  11396.  
  11397.                                 case tk_number:
  11398.  
  11399.                                         i=doconstlongmath();
  11400.  
  11401.                                         next=0;
  11402.  
  11403.                                         if(i==0&&(vop==0||vop==0x28||vop==8))break;
  11404.  
  11405.                                         if(i==255&&vop==0x20)break;
  11406.  
  11407.                                         if(beg==AL)op(0x04+vop);
  11408.  
  11409.                                         else{
  11410.  
  11411.                                                 op(0x80);
  11412.  
  11413.                                                 op(0xC0+vop+beg);
  11414.  
  11415.                                         }
  11416.  
  11417.                                         op(i);
  11418.  
  11419.                                         break;
  11420.  
  11421.                                 case tk_qwordvar:
  11422.  
  11423.                                         i+=4;
  11424.  
  11425.                                 case tk_longvar:
  11426.  
  11427.                                 case tk_dwordvar:
  11428.  
  11429.                                         i+=2;
  11430.  
  11431.                                 case tk_wordvar:
  11432.  
  11433.                                 case tk_intvar:
  11434.  
  11435.                                         i++;
  11436.  
  11437.                                 case tk_charvar:
  11438.  
  11439.                                 case tk_bytevar:
  11440.  
  11441.                                         i++;
  11442.  
  11443.                                         CheckAllMassiv(bufrm,i,&strinf);
  11444.  
  11445.                                         outseg(&itok,2);
  11446.  
  11447.                                         op(0x02+vop);
  11448.  
  11449.                                         op(beg*8+itok.rm);
  11450.  
  11451.                                         outaddress(&itok);
  11452.  
  11453.                                         break;
  11454.  
  11455.                                 case tk_beg:
  11456.  
  11457.                                         op(0x00+vop);
  11458.  
  11459.                                         op(0xC0+beg+(unsigned int)itok.number*8);
  11460.  
  11461.                                         break;
  11462.  
  11463.                                 case tk_proc:
  11464.  
  11465.                                 case tk_apiproc:
  11466.  
  11467.                                 case tk_undefproc:
  11468.  
  11469.                                 case tk_declare:
  11470.  
  11471.                                 case tk_ID:
  11472.  
  11473.                                 case tk_id:
  11474.  
  11475.                                         op66(r16);
  11476.  
  11477.                                         i=beg<4?beg:beg-4;
  11478.  
  11479.                                         op(0x50+i);
  11480.  
  11481.                                         addESP+=2;
  11482.  
  11483.                                         warningreg(regs[0][i]);
  11484.  
  11485.                                         procdo(tk_byte);
  11486.  
  11487.                                         if(itok2.type==tp_opperand){
  11488.  
  11489.                                                 nexttok();
  11490.  
  11491.                                                 doalmath2(0);
  11492.  
  11493.                                                 next=0;
  11494.  
  11495.                                         }
  11496.  
  11497.                                         addESP-=2;
  11498.  
  11499.                                         op66(r16);
  11500.  
  11501.                                         op(0x58+(i!=AX?i:CX));
  11502.  
  11503.                                         if(i!=AX){
  11504.  
  11505.                                                 op(0x00+vop);
  11506.  
  11507.                                                 op(0xc0+beg);
  11508.  
  11509.                                         }
  11510.  
  11511.                                         else{
  11512.  
  11513.                                                 if(vop>0x20){
  11514.  
  11515.                                                         op(0x86);
  11516.  
  11517.                                                         op(0xC0+CL+beg);        //xchg al,cl
  11518.  
  11519.                                                 }
  11520.  
  11521.                                                 op(0x00+vop);
  11522.  
  11523.                                                 op(0xc0+CL*8+beg);
  11524.  
  11525.                                         }
  11526.  
  11527.                                         break;
  11528.  
  11529.                                 case tk_reg:
  11530.  
  11531.                                         if((unsigned int)itok.number<BX){
  11532.  
  11533.                                                 op(0x00+vop);
  11534.  
  11535.                                                 op(0xC0+beg+(unsigned int)itok.number*8);
  11536.  
  11537.                                         }
  11538.  
  11539.                                         else begworderror();
  11540.  
  11541.                                         break;
  11542.  
  11543.                                 case tk_seg: begworderror(); break;
  11544.  
  11545.                                 default: valueexpected();       break;
  11546.  
  11547.                         }
  11548.  
  11549.                         break;
  11550.  
  11551.                 case tk_rrequals: vop+=0x08;
  11552.  
  11553.                 case tk_llequals:
  11554.  
  11555.                         getoperand(am32==TRUE?ECX:BX);
  11556.  
  11557.                         ClearReg(beg>3?beg%4:beg);
  11558.  
  11559.                         if(itok2.type==tp_stopper&&tok==tk_number){
  11560.  
  11561.                                 if((unsigned int)itok.number==1){
  11562.  
  11563.                                         op(0xD0);       op(0xE0+beg+vop);
  11564.  
  11565.                                 }       /* SHL beg,1 */
  11566.  
  11567.                                 else if((unsigned int)itok.number!=0){
  11568.  
  11569.                                         if(chip<2)goto shiftbeg;
  11570.  
  11571.                                         else{
  11572.  
  11573.                                                 op(0xc0);
  11574.  
  11575.                                                 op(0xe0+beg+vop);
  11576.  
  11577.                                                 op((unsigned int)itok.number);
  11578.  
  11579.                                         }
  11580.  
  11581.                                 }
  11582.  
  11583.                         }
  11584.  
  11585.                         else{
  11586.  
  11587. shiftbeg:
  11588.  
  11589.                                 if(beg!=CL){
  11590.  
  11591.                                         if(itok2.type==tp_stopper&&tok==tk_beg&&itok.number==CL){
  11592.  
  11593.                                                 op(0xD2); op(0xE0+vop+beg);     /* SHL beg,CL */
  11594.  
  11595.                                         }
  11596.  
  11597.                                         else{
  11598.  
  11599.                                                 ClearReg(CL);
  11600.  
  11601.                                                 getintobeg(CL,&ofsstr);
  11602.  
  11603.                                                 dobegmath(CL);
  11604.  
  11605.                                                 next=0;
  11606.  
  11607.                                                 warningreg(begs[1]);
  11608.  
  11609.                                                 op(0xD2); op(0xE0+vop+beg);     /* SHL beg,CL */
  11610.  
  11611.                                         }
  11612.  
  11613.                                 }
  11614.  
  11615.                                 else regshifterror();
  11616.  
  11617.                         }
  11618.  
  11619.                         break;
  11620.  
  11621.                 default: operatorexpected(); break;
  11622.  
  11623.         }
  11624.  
  11625.         if(next)nexttok();
  11626.  
  11627.         if(terminater==tk_semicolon)seminext();
  11628.  
  11629.         return rettype;
  11630.  
  11631. }
  11632.  
  11633.  
  11634.  
  11635. void doseg(int seg)
  11636.  
  11637. {
  11638.  
  11639. unsigned char next=1;
  11640.  
  11641. int numpointr=0;
  11642.  
  11643. char *ofsstr=NULL;
  11644.  
  11645.         if(seg==CS)preerror("CS not used for destention");
  11646.  
  11647.         if(seg==FS||seg==GS)if(cpu<3)cpu=3;
  11648.  
  11649.         if(seg==SS)RestoreStack();
  11650.  
  11651.         nexttok();
  11652.  
  11653.         KillVar(segs[seg]);
  11654.  
  11655.         if(tok==tk_assign){
  11656.  
  11657.                 nexttok();
  11658.  
  11659.                 while(tok==tk_mult){
  11660.  
  11661.                         nexttok();
  11662.  
  11663.                         numpointr++;
  11664.  
  11665.                 }
  11666.  
  11667.                 if(numpointr>itok.npointr)unuseableinput();
  11668.  
  11669.                 if(tok2==tk_assign){
  11670.  
  11671.                         itok.number=MultiAssign(r16,USEALLREG,numpointr);
  11672.  
  11673.                         if(ofsstr){
  11674.  
  11675.                                 free(ofsstr);
  11676.  
  11677.                                 ofsstr=NULL;
  11678.  
  11679.                         }
  11680.  
  11681.                         goto getfromreg;
  11682.  
  11683.                 }
  11684.  
  11685.                 if(tok==tk_pointer)cpointr(am32==TRUE?EAX:BX,numpointr);
  11686.  
  11687.                 if(itok2.type!=tp_opperand){
  11688.  
  11689.                         switch(tok){
  11690.  
  11691.                                 case tk_reg:
  11692.  
  11693. getfromreg:
  11694.  
  11695.                                         op(0x8E);
  11696.  
  11697.                                         op(0xC0+seg*8+(unsigned int)itok.number);       /* MOV seg,reg */
  11698.  
  11699.                                         break;
  11700.  
  11701.                                 case tk_intvar:
  11702.  
  11703.                                 case tk_wordvar:
  11704.  
  11705.                                 case tk_longvar:
  11706.  
  11707.                                 case tk_dwordvar:
  11708.  
  11709.                                 case tk_qwordvar:
  11710.  
  11711.                                         CheckAllMassiv(bufrm,2,&strinf);
  11712.  
  11713.                                         op66(r16);
  11714.  
  11715.                                         outseg(&itok,2);
  11716.  
  11717.                                         op(0x8E);
  11718.  
  11719.                                         op(seg*8+itok.rm);
  11720.  
  11721.                                         outaddress(&itok);       /* MOV seg,[wordvar] */
  11722.  
  11723.                                         break;
  11724.  
  11725.                                 case tk_seg:
  11726.  
  11727.                                         if(optimizespeed==FALSE||(regoverstack&&chip>2)){
  11728.  
  11729.                                                 PushSeg((unsigned int)itok.number);
  11730.  
  11731.                                                 PopSeg(seg);
  11732.  
  11733.                                                 break;
  11734.  
  11735.                                         }
  11736.  
  11737.                                         goto segax;
  11738.  
  11739.                                 case tk_number:
  11740.  
  11741.                                         if(regoverstack&&chip>1){
  11742.  
  11743. //                                              op66(r16);
  11744.  
  11745.                                                 if(short_ok(itok.number)&&(itok.flag&f_reloc)==0){
  11746.  
  11747.                                                         op(0x6A);
  11748.  
  11749.                                                         op(itok.number);
  11750.  
  11751.                                                 }
  11752.  
  11753.                                                 else{
  11754.  
  11755.                                                         op(0x68);
  11756.  
  11757.                                                         if((itok.flag&f_reloc)!=0)AddReloc();
  11758.  
  11759.                                                         if(am32)outdword(itok.number);
  11760.  
  11761.                                                         else outword(itok.number);
  11762.  
  11763.                                                 }
  11764.  
  11765.                                                 PopSeg(seg);
  11766.  
  11767.                                                 if(cpu<2)cpu=2;
  11768.  
  11769.                                                 break;
  11770.  
  11771.                                         }
  11772.  
  11773.                                         goto segax;
  11774.  
  11775.                                 default: goto segax;
  11776.  
  11777.                         }
  11778.  
  11779.                 }
  11780.  
  11781.                 else{
  11782.  
  11783. segax:
  11784.  
  11785.                         do_e_axmath(0,r16,&ofsstr);
  11786.  
  11787.                         op(0x8E);       /* MOV SEG,AX */
  11788.  
  11789.                         op(0xC0+seg*8);
  11790.  
  11791.                         next=0;
  11792.  
  11793.                 }
  11794.  
  11795.         }
  11796.  
  11797.         else if(tok==tk_swap){
  11798.  
  11799.                 getoperand();
  11800.  
  11801.                 switch(tok){
  11802.  
  11803.                         case tk_intvar:
  11804.  
  11805.                         case tk_wordvar:
  11806.  
  11807.                                 KillVar(itok.name);
  11808.  
  11809.                                 op66(r16);
  11810.  
  11811.                                 op(0x8C);
  11812.  
  11813.                                 op(0xC0+seg*8); /* MOV AX,SEG */
  11814.  
  11815.                                 CheckAllMassiv(bufrm,2,&strinf);
  11816.  
  11817.                                 op66(r16);
  11818.  
  11819.                                 outseg(&itok,2);
  11820.  
  11821.                                 op(0x87);
  11822.  
  11823.                                 op(itok.rm);
  11824.  
  11825.                                 outaddress(&itok);      /* XCHG AX,[word] */
  11826.  
  11827.                                 op66(r16);
  11828.  
  11829.                                 op(0x8E);
  11830.  
  11831.                                 op(0xC0+seg*8); /* MOV seg,AX */
  11832.  
  11833.                                 break;
  11834.  
  11835.                         case tk_seg:
  11836.  
  11837.                                 KillVar(segs[itok.number]);
  11838.  
  11839.                                 PushSeg(seg);
  11840.  
  11841.                                 PushSeg(itok.number);
  11842.  
  11843.                                 PopSeg(seg);
  11844.  
  11845.                                 PopSeg(itok.number);
  11846.  
  11847.                                 break;
  11848.  
  11849.                         default: preerror("Only int, word variables valid for segment register ><");
  11850.  
  11851.                                 break;
  11852.  
  11853.                 }
  11854.  
  11855.         }
  11856.  
  11857.         else segoperror();
  11858.  
  11859.         if(next)nextseminext();
  11860.  
  11861.         else seminext();
  11862.  
  11863. }
  11864.  
  11865.  
  11866.  
  11867. void PushSeg(int seg)
  11868.  
  11869. {
  11870.  
  11871.         switch(seg){
  11872.  
  11873.                 case DS: op(0x1E); break;
  11874.  
  11875.                 case CS: op(0x0E); break;
  11876.  
  11877.                 case SS: op(0x16); break;
  11878.  
  11879.                 case ES: op(0x06); break;
  11880.  
  11881.                 case FS: outword(0xA00F); if(cpu<3)cpu=3; break;
  11882.  
  11883.                 case GS: outword(0xA80F); if(cpu<3)cpu=3; break;
  11884.  
  11885.         }
  11886.  
  11887. }
  11888.  
  11889.  
  11890.  
  11891. void PopSeg(int seg)
  11892.  
  11893. {
  11894.  
  11895.         switch(seg){
  11896.  
  11897.                 case DS: op(0x1F); break;
  11898.  
  11899.                 case SS: op(0x17); break;
  11900.  
  11901.                 case ES: op(0x07); break;
  11902.  
  11903.                 case FS: outword(0xA10F); if(cpu<3)cpu=3;  break;
  11904.  
  11905.                 case GS: outword(0xA90F); if(cpu<3)cpu=3;  break;
  11906.  
  11907.         }
  11908.  
  11909. }
  11910.  
  11911.  
  11912.  
  11913. // =============== doregmath_32(), dobegmath() ===============
  11914.  
  11915.  
  11916.  
  11917. void doregmath_32(int reg,int razr,int sign,char **ofsstr,int fdiv)  // math done is on all regs except AX
  11918.  
  11919. // all other registers preserved
  11920.  
  11921. {
  11922.  
  11923. int vop,i,optnum,negflag=FALSE;
  11924.  
  11925.         while(itok.type!=tp_stopper&&tok!=tk_eof){
  11926.  
  11927.                 if(negflag){
  11928.  
  11929.                         NegReg(razr,reg);
  11930.  
  11931.                         negflag=FALSE;
  11932.  
  11933.                 }
  11934.  
  11935.                 i=vop=0;
  11936.  
  11937.                 optnum=FALSE;
  11938.  
  11939. #ifdef OPTVARCONST
  11940.  
  11941.                 CheckConstVar3(&tok2,&itok2,razr);
  11942.  
  11943.                 if(tok2==tk_number)calcnumber=TRUE;
  11944.  
  11945. #endif
  11946.  
  11947.                 if(uselea){
  11948.  
  11949.                         if(razr==r32){
  11950.  
  11951.                                 if(Reg32ToLea2(reg))continue;   //®¯â¨¬¨§ æ¨ï á«®¦¥­¨ï 32-¡¨â­ëå ॣ¨áâ஢ ¢ LEA
  11952.  
  11953.                         }
  11954.  
  11955.                         else if(Reg16ToLea2(reg))continue;
  11956.  
  11957.                         if(itok.type==tp_stopper||tok==tk_eof)break;
  11958.  
  11959.                 }
  11960.  
  11961.                 if(tok2==tk_number)optnum=OptimNum();
  11962.  
  11963.                 switch(tok){
  11964.  
  11965.                         case tk_xor: vop+=0x08;
  11966.  
  11967.                         case tk_minus: vop+=0x08;
  11968.  
  11969.                         case tk_and: vop+=0x18;
  11970.  
  11971.                         case tk_or: vop+=0x08;
  11972.  
  11973.                         case tk_plus:
  11974.  
  11975.                           if(optnum==FALSE)getoperand(reg==BX?SI:BX);
  11976.  
  11977.                                 else tok=tk_number;
  11978.  
  11979.                                 switch(tok){
  11980.  
  11981.                                         case tk_number:
  11982.  
  11983.                                                 if((itok.flag&f_reloc)==0&&optnumadd(itok.number,reg,razr,vop))break;
  11984.  
  11985.                                         case tk_postnumber:
  11986.  
  11987.                                         case tk_undefofs:
  11988.  
  11989.                                                 op66(razr);
  11990.  
  11991.                                           op(0x81);
  11992.  
  11993.                                                 op(0xC0+vop+reg);
  11994.  
  11995.                                                 if(tok==tk_postnumber)(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
  11996.  
  11997.                                                 else if(tok==tk_undefofs)AddUndefOff(0,itok.name);
  11998.  
  11999.                                                 else if((itok.flag&f_reloc)!=0)AddReloc();
  12000.  
  12001.                                                 razr==r16?outword((unsigned int)itok.number):outdword(itok.number);
  12002.  
  12003.                                                 break;
  12004.  
  12005.                                         case tk_apioffset:
  12006.  
  12007.                                                 op66(razr);
  12008.  
  12009.                                           op(0x81);
  12010.  
  12011.                                                 op(0xC0+vop+reg);
  12012.  
  12013.                                                 AddApiToPost(itok.number);
  12014.  
  12015.                                                 break;
  12016.  
  12017.                                         case tk_doublevar:
  12018.  
  12019.                                                 i=4;
  12020.  
  12021.                                         case tk_floatvar:
  12022.  
  12023.                                                 Float2reg32(EAX,i);
  12024.  
  12025.                                                 itok.number=EAX;
  12026.  
  12027.                                                 warningreg(regs[1][EAX]);
  12028.  
  12029.                                                 goto defreg32;
  12030.  
  12031.                                         case tk_bits:
  12032.  
  12033.                                                 int vops,reg2s;
  12034.  
  12035.                                                 i=itok.bit.siz+itok.bit.ofs;
  12036.  
  12037.                                                 if(i<=64)vops=r64;
  12038.  
  12039.                                                 if(i<=32)vops=r32;
  12040.  
  12041.                                                 if(i<=16)vops=r16;
  12042.  
  12043.                                                 if(vops<razr)vops=razr;
  12044.  
  12045.                                                 reg2s=CX;
  12046.  
  12047.                                                 if(reg==CX)reg2s=DI;
  12048.  
  12049.                                                 bits2reg(reg2s,vops);
  12050.  
  12051.                                                 if(vops==r64)vops=r32;
  12052.  
  12053.                                                 warningreg(regs[vops/2-1][reg2s]);
  12054.  
  12055.                                                 itok.number=reg2s;
  12056.  
  12057.                                                 goto defreg32;
  12058.  
  12059.                                         case tk_reg:
  12060.  
  12061.                                                 if(razr==r32){
  12062.  
  12063.                                                         op66(razr);
  12064.  
  12065.                                                         outword(0xB70F);
  12066.  
  12067.                                                         if(itok.number==reg){
  12068.  
  12069.                                                                 op(0xC0+reg);
  12070.  
  12071.                                                                 itok.number=EAX;
  12072.  
  12073.                                                         }
  12074.  
  12075.                                                         else op(0xC0+itok.number*9);
  12076.  
  12077.                                                         warningreg(regs[razr/2-1][itok.number]);
  12078.  
  12079.                                                 }
  12080.  
  12081.                                         case tk_reg32:
  12082.  
  12083. defreg32:
  12084.  
  12085.                                                 op66(razr);
  12086.  
  12087.                                                 op(0x01+vop);
  12088.  
  12089.                                                 op(0xC0+reg+(unsigned int)itok.number*8);
  12090.  
  12091.                                                 break;
  12092.  
  12093.                                         case tk_qwordvar:
  12094.  
  12095.                                         case tk_longvar:
  12096.  
  12097.                                         case tk_dwordvar:
  12098.  
  12099.                                                 i=4;
  12100.  
  12101.                                                 goto wordvar;
  12102.  
  12103.                                         case tk_intvar:
  12104.  
  12105.                                         case tk_wordvar:
  12106.  
  12107.                                                 if(razr==r32)goto addchar;
  12108.  
  12109.                                                 i=2;
  12110.  
  12111. wordvar:
  12112.  
  12113.                                                 CheckAllMassiv(bufrm,i,&strinf);
  12114.  
  12115.                                                 op66(razr);
  12116.  
  12117.                                                 outseg(&itok,2);
  12118.  
  12119.                                                 op(0x03+vop);
  12120.  
  12121.                                                 op(reg*8+itok.rm);
  12122.  
  12123.                                                 outaddress(&itok);
  12124.  
  12125.                                                 break;
  12126.  
  12127.                                         case tk_charvar:
  12128.  
  12129.                                         case tk_beg:
  12130.  
  12131.                                         case tk_bytevar:
  12132.  
  12133.                                         case tk_seg:
  12134.  
  12135.                                         case tk_rmnumber:
  12136.  
  12137. addchar:
  12138.  
  12139.                                                 SINFO wstr;
  12140.  
  12141.                                                 ITOK wtok;
  12142.  
  12143.                                                 char *wbuf;
  12144.  
  12145.                                                 wstr=strinf;
  12146.  
  12147.                                                 strinf.bufstr=NULL;
  12148.  
  12149.                                                 wbuf=bufrm;
  12150.  
  12151.                                                 bufrm=NULL;
  12152.  
  12153.                                                 wtok=itok;
  12154.  
  12155.                                                 getinto_e_ax(sign,tok,&wtok,wbuf,&wstr,razr);
  12156.  
  12157.                                                 goto addax;
  12158.  
  12159.                                         case tk_ID:
  12160.  
  12161.                                         case tk_id:
  12162.  
  12163.                                         case tk_proc:
  12164.  
  12165.                                         case tk_apiproc:
  12166.  
  12167.                                         case tk_undefproc:
  12168.  
  12169.                                         case tk_declare:
  12170.  
  12171. unsigned char oaddstack;
  12172.  
  12173.                                                 if(!(comfile==file_w32&&(reg==EBX||reg==EDI||reg==ESI))){
  12174.  
  12175.                                                         op66(razr);
  12176.  
  12177.                                                         op(0x50+reg);   //push AX
  12178.  
  12179.                                                 }
  12180.  
  12181.                                                 addESP+=razr==r16?2:4;
  12182.  
  12183.                                                 oaddstack=addstack;
  12184.  
  12185.                                                 addstack=FALSE;
  12186.  
  12187.                                                 procdo(razr==r16?(sign==0?tk_word:tk_int):(sign==0?tk_dword:tk_long));
  12188.  
  12189.                                                 addstack=oaddstack;
  12190.  
  12191.                                                 addESP-=razr==r16?2:4;
  12192.  
  12193.                                                 if(!(comfile==file_w32&&(reg==EBX||reg==EDI||reg==ESI))){
  12194.  
  12195.                                                         op66(razr);
  12196.  
  12197.                                                         op(0x58+reg);
  12198.  
  12199.                                                 }
  12200.  
  12201. addax:
  12202.  
  12203.                                                 op66(razr);
  12204.  
  12205.                                                 op(0x01+vop);
  12206.  
  12207.                                                 op(0xc0+reg);
  12208.  
  12209.                                                 warningreg(regs[razr/2-1][0]);
  12210.  
  12211.                                                 break;
  12212.  
  12213.                                         default: valueexpected(); break;
  12214.  
  12215.                                 }
  12216.  
  12217.                                 break;
  12218.  
  12219.                         case tk_xorminus: vop+=0x10;
  12220.  
  12221.                         case tk_andminus: vop+=0x18;
  12222.  
  12223.                         case tk_orminus: vop+=0x08;
  12224.  
  12225.                           getoperand(reg==BX?SI:BX);
  12226.  
  12227.                                 switch(tok){
  12228.  
  12229.                                         case tk_number:
  12230.  
  12231.                                                 itok.number=-itok.number;
  12232.  
  12233.                                                 op66(razr);
  12234.  
  12235.                                                 op(0x81);
  12236.  
  12237.                                                 op(0xC0+vop+reg);
  12238.  
  12239.                                                 if((itok.flag&f_reloc)!=0)AddReloc();
  12240.  
  12241.                                                 razr==r16?outword((unsigned int)itok.number):outdword(itok.number);
  12242.  
  12243.                                                 break;
  12244.  
  12245.                                         case tk_ID:
  12246.  
  12247.                                         case tk_id:
  12248.  
  12249.                                         case tk_proc:
  12250.  
  12251.                                         case tk_apiproc:
  12252.  
  12253.                                         case tk_undefproc:
  12254.  
  12255.                                         case tk_declare:
  12256.  
  12257.                                                 procdo(razr==r16?tk_word:tk_dword);
  12258.  
  12259.                                                 i=EAX;
  12260.  
  12261.                                                 if(*ofsstr!=NULL){
  12262.  
  12263.                                                         free(*ofsstr);
  12264.  
  12265.                                                         *ofsstr=NULL;
  12266.  
  12267.                                                 }
  12268.  
  12269.                                                 goto defxormin;
  12270.  
  12271.                                         default:
  12272.  
  12273.                                                 if(reg==ECX){
  12274.  
  12275.                                                         i=EAX;
  12276.  
  12277.                                                         SINFO wstr;
  12278.  
  12279.                                                         wstr=strinf;
  12280.  
  12281.                                                         strinf.bufstr=NULL;
  12282.  
  12283.                                                         ITOK wtok;
  12284.  
  12285.                                                         char *wbuf;
  12286.  
  12287.                                                         wbuf=bufrm;
  12288.  
  12289.                                                         bufrm=NULL;
  12290.  
  12291.                                                         wtok=itok;
  12292.  
  12293.                                                         getinto_e_ax(sign,tok,&wtok,wbuf,&wstr,razr);
  12294.  
  12295.                                                 }
  12296.  
  12297.                                                 else{
  12298.  
  12299.                                                         i=ECX;
  12300.  
  12301.                                                         getintoreg_32(CX,razr,sign,ofsstr,FALSE);
  12302.  
  12303.                                                 }
  12304.  
  12305. defxormin:
  12306.  
  12307.                                                 NegReg(razr,i);
  12308.  
  12309.                                                 op66(razr);
  12310.  
  12311.                                                 op(vop+1);      /* opt AX,CX */
  12312.  
  12313.                                                 op(0xC0+i*8+reg);
  12314.  
  12315.                                                 warningreg(regs[razr/2-1][i]);
  12316.  
  12317.                                                 if(i==ECX)continue;
  12318.  
  12319.                                                 break;
  12320.  
  12321.                                 }
  12322.  
  12323.                                 break;
  12324.  
  12325.                         case tk_rrminus:
  12326.  
  12327.                                 if(reg==ECX){
  12328.  
  12329.                                         regmathoperror();
  12330.  
  12331.                                         break;
  12332.  
  12333.                                 }
  12334.  
  12335.                                 tok=tk_minus;
  12336.  
  12337.                                 getintobeg(CL,ofsstr);
  12338.  
  12339.                                 op66(razr);
  12340.  
  12341.                                 op(0xD3);
  12342.  
  12343.                                 op(0xE8+reg);   // SHL xXX,CL
  12344.  
  12345.                                 warningreg(begs[1]);
  12346.  
  12347.                                 continue;
  12348.  
  12349.                         case tk_rr:
  12350.  
  12351.                           getoperand(am32==TRUE?ECX:(reg==BX?SI:BX));
  12352.  
  12353.                                 if(RshiftReg(razr,reg,sign)==FALSE)regmathoperror();
  12354.  
  12355.                                 else continue;
  12356.  
  12357.                                 break;
  12358.  
  12359.                         case tk_llminus:
  12360.  
  12361.                                 if(reg==ECX){
  12362.  
  12363.                                         regmathoperror();
  12364.  
  12365.                                         break;
  12366.  
  12367.                                 }
  12368.  
  12369.                                 tok=tk_minus;
  12370.  
  12371.                                 goto llshift;
  12372.  
  12373.                         case tk_ll:
  12374.  
  12375.                           getoperand(am32==TRUE?ECX:(reg==BX?SI:BX));
  12376.  
  12377.                                 if(tok==tk_number){
  12378.  
  12379.                                         if(chip<2&&reg==CX){
  12380.  
  12381.                                                 regmathoperror();
  12382.  
  12383.                                                 break;
  12384.  
  12385.                                         }
  12386.  
  12387.                                         lshiftmul(itok.number,razr,reg);
  12388.  
  12389.                                 }
  12390.  
  12391.                                 else if(reg!=ECX&&(tok==tk_beg||tok==tk_reg||tok==tk_reg32)&&itok.number==CL){
  12392.  
  12393.                                         op66(razr);
  12394.  
  12395.                                         op(0xD3);
  12396.  
  12397.                                         op(0xE0+reg);   // SHL xXX,CL
  12398.  
  12399.                                 }
  12400.  
  12401.                                 else if(reg!=ECX){
  12402.  
  12403. llshift:
  12404.  
  12405.                                         getintobeg(CL,ofsstr);
  12406.  
  12407.                                         op66(razr);
  12408.  
  12409.                                         op(0xD3);
  12410.  
  12411.                                         op(0xE0+reg);   // SHL xXX,CL
  12412.  
  12413.                                         warningreg(begs[1]);
  12414.  
  12415.                                         continue;
  12416.  
  12417.                                 }
  12418.  
  12419.                                 else regmathoperror();
  12420.  
  12421.                                 break;
  12422.  
  12423.                         case tk_multminus: negflag=TRUE;
  12424.  
  12425.                         case tk_mult:
  12426.  
  12427.                           if(optnum==FALSE)getoperand(reg==BX?SI:BX);
  12428.  
  12429.                                 else tok=tk_number;
  12430.  
  12431.                                 if(negflag&&tok==tk_number){
  12432.  
  12433.                                         itok.number=-itok.number;
  12434.  
  12435.                                         negflag=FALSE;
  12436.  
  12437.                                 }
  12438.  
  12439.                                 if(MulReg(reg,razr)==0)continue;
  12440.  
  12441.                                 break;
  12442.  
  12443.                         case tk_modminus: negflag=1;
  12444.  
  12445.                         case tk_mod:
  12446.  
  12447.                                 vop=1;
  12448.  
  12449.                                 goto divcalc;
  12450.  
  12451.                         case tk_divminus: negflag=1;
  12452.  
  12453.                         case tk_div:
  12454.  
  12455. divcalc:
  12456.  
  12457.                           if(optnum==FALSE)getoperand(reg==BX?SI:BX);
  12458.  
  12459.                                 else tok=tk_number;
  12460.  
  12461.                                 if(negflag&&tok==tk_number){
  12462.  
  12463.                                         itok.number=-itok.number;
  12464.  
  12465.                                         negflag=FALSE;
  12466.  
  12467.                                 }
  12468.  
  12469.                                 if(tok==tk_number&&(i=caselong(itok.number))!=NUMNUM){
  12470.  
  12471.                                         if(vop){        //mod
  12472.  
  12473.                                                 itok.number--;
  12474.  
  12475.                                                 if(itok.number==0){
  12476.  
  12477.                                                         ZeroReg(reg,razr);
  12478.  
  12479.                                                 }
  12480.  
  12481.                                                 else if(short_ok(itok.number,razr/2-1)){
  12482.  
  12483.                                                         op66(razr);
  12484.  
  12485.                                                         op(0x83);
  12486.  
  12487.                                                         op(0xE0+reg);   //and reg,num-1
  12488.  
  12489.                                                         op(itok.number);
  12490.  
  12491.                                                 }
  12492.  
  12493.                                                 else{
  12494.  
  12495.                                                         op66(razr);
  12496.  
  12497.                                                         op(0x81);
  12498.  
  12499.                                                         op(0xE0+reg);   //and reg,num-1
  12500.  
  12501.                                                         razr==r16?outword((unsigned int)itok.number):outdword(itok.number);
  12502.  
  12503.                                                 }
  12504.  
  12505.                                         }
  12506.  
  12507.                                         else{
  12508.  
  12509.                                                 if(i!=0){
  12510.  
  12511.                                                         if(chip<2&&razr==r16){
  12512.  
  12513.                                                                 if(reg==CX)regmathoperror();
  12514.  
  12515.                                                                 op(0xB1); op(i); /* MOV CL,num */
  12516.  
  12517.                                                                 op(0xD3);
  12518.  
  12519.                                                                 op(0xE8+reg); // SHR reg,CL
  12520.  
  12521.                                                                 warningreg(begs[1]);
  12522.  
  12523.                                                         }
  12524.  
  12525.                                                         else{
  12526.  
  12527.                                                                 op66(razr);
  12528.  
  12529.                                                                 op(0xC1);
  12530.  
  12531.                                                                 op(0xE8+reg); // SHR reg,num
  12532.  
  12533.                                                                 op(i);
  12534.  
  12535.                                                         }
  12536.  
  12537.                                                 }
  12538.  
  12539.                                         }
  12540.  
  12541.                                         break;
  12542.  
  12543.                                 }
  12544.  
  12545.                                 if(fdiv!=1){
  12546.  
  12547.                                         op66(razr);
  12548.  
  12549.                                         op(0x90+reg);   //xchg AX,reg
  12550.  
  12551.                                 }
  12552.  
  12553.                                 DivMod(vop,sign,razr,0);
  12554.  
  12555.                                 if(itok.type!=tp_stopper){
  12556.  
  12557.                                         if(vop==1){
  12558.  
  12559.                                                 op66(razr);
  12560.  
  12561.                                                 if(optimizespeed)outword(0xC28B);       //mov ax,dx
  12562.  
  12563.                                                 else op(0x92);  //xchg ax,dx
  12564.  
  12565.                                         }
  12566.  
  12567.                                         do_e_axmath2(0,razr,0);
  12568.  
  12569.                                 }
  12570.  
  12571.                                 else if(vop==1){
  12572.  
  12573.                                         if(reg!=EDX){
  12574.  
  12575.                                                 op66(razr);
  12576.  
  12577.                                                 op(0x89);
  12578.  
  12579.                                                 op(128+64+EDX*8+reg);
  12580.  
  12581.                                         }
  12582.  
  12583.                                         warningreg(regs[razr/2-1][EAX]);
  12584.  
  12585.                                         continue;
  12586.  
  12587.                                 }
  12588.  
  12589.                                 op66(razr);
  12590.  
  12591.                                 if(optimizespeed){
  12592.  
  12593.                                         op(0x89);
  12594.  
  12595.                                         op(128+64+EAX*8+reg);
  12596.  
  12597.                                 }
  12598.  
  12599.                                 else op(0x90+reg);      //xchg AX,reg
  12600.  
  12601.                                 warningreg(regs[razr/2-1][EAX]);
  12602.  
  12603.                                 continue;
  12604.  
  12605.                         default: operatorexpected(); break;
  12606.  
  12607.                 }
  12608.  
  12609.                 calcnumber=FALSE;
  12610.  
  12611.                 ClearReg(reg);
  12612.  
  12613.                 nexttok();
  12614.  
  12615.         }
  12616.  
  12617.         calcnumber=FALSE;
  12618.  
  12619.         ClearReg(reg);
  12620.  
  12621.         if(razr==r32&&cpu<3)cpu=3;
  12622.  
  12623. }
  12624.  
  12625.  
  12626.  
  12627. void  dobegmath(int beg)  // math done is on all begs except AL
  12628.  
  12629. // all other registers preserved
  12630.  
  12631. {
  12632.  
  12633. int vop,i,optnum=FALSE,negflag=FALSE;
  12634.  
  12635.         while(itok.type!=tp_stopper&&tok!=tk_eof){
  12636.  
  12637.                 vop=0;
  12638.  
  12639.                 i=0;
  12640.  
  12641. #ifdef OPTVARCONST
  12642.  
  12643.                 if(tok2>=tk_charvar&&tok2<=tk_doublevar&&itok2.npointr==0){
  12644.  
  12645.                         if(CheckConstVar(&itok2)){
  12646.  
  12647.                                 tok2=tk_number;
  12648.  
  12649.                                 calcnumber=TRUE;
  12650.  
  12651.                         }
  12652.  
  12653.                 }
  12654.  
  12655. #endif
  12656.  
  12657.                 if(tok2==tk_number)optnum=OptimNum();
  12658.  
  12659.                 int oldtok=tok;
  12660.  
  12661.                 switch(tok){
  12662.  
  12663.                         case tk_xor: vop+=0x08;
  12664.  
  12665.                         case tk_minus: vop+=0x08;
  12666.  
  12667.                         case tk_and: vop+=0x18;
  12668.  
  12669.                         case tk_or: vop+=0x08;
  12670.  
  12671.                         case tk_plus:
  12672.  
  12673.                           if(optnum==FALSE)getoperand(beg==BL||beg==BH?SI:BX);
  12674.  
  12675.                                 else{
  12676.  
  12677.                                         tok=tk_number;
  12678.  
  12679.                                         optnum=FALSE;
  12680.  
  12681.                                 }
  12682.  
  12683.                                 switch(tok){
  12684.  
  12685.                                         case tk_number:
  12686.  
  12687.                                                 if(itok.number==0&&oldtok!=tk_and)break;
  12688.  
  12689.                                                 else if(itok.number==1){
  12690.  
  12691.                                                         if(oldtok==tk_plus){
  12692.  
  12693.                                                                 op(0xFE);
  12694.  
  12695.                                                                 op(0xC0+beg);
  12696.  
  12697.                                                                 break;
  12698.  
  12699.                                                         }
  12700.  
  12701.                                                         if(oldtok==tk_minus){
  12702.  
  12703.                                                                 op(0xFE);
  12704.  
  12705.                                                                 op(0xC8+beg);
  12706.  
  12707.                                                                 break;
  12708.  
  12709.                                                         }
  12710.  
  12711.                                                 }
  12712.  
  12713.                                                 else if((unsigned char)itok.number==0xff){
  12714.  
  12715.                                                         if(oldtok==tk_minus){
  12716.  
  12717.                                                                 op(0xFE);
  12718.  
  12719.                                                                 op(0xC0+beg);
  12720.  
  12721.                                                                 break;
  12722.  
  12723.                                                         }
  12724.  
  12725.                                                         if(oldtok==tk_plus){
  12726.  
  12727.                                                                 op(0xFE);
  12728.  
  12729.                                                                 op(0xC8+beg);
  12730.  
  12731.                                                                 break;
  12732.  
  12733.                                                         }
  12734.  
  12735.                                                 }
  12736.  
  12737.                                           op(0x80);
  12738.  
  12739.                                                 op(0xC0+vop+beg);
  12740.  
  12741.                                                 op((unsigned int)itok.number);
  12742.  
  12743.                                                 break;
  12744.  
  12745.                                         case tk_bits:
  12746.  
  12747.                                                 int vops,reg2s;
  12748.  
  12749.                                                 i=itok.bit.siz+itok.bit.ofs;
  12750.  
  12751.                                                 if(i<=64)vops=r64;
  12752.  
  12753.                                                 if(i<=32)vops=r32;
  12754.  
  12755.                                                 if(i<=16)vops=r16;
  12756.  
  12757.                                                 if(i<=8)vops=r8;
  12758.  
  12759.                                                 reg2s=CL;
  12760.  
  12761.                                                 if(beg==CL)reg2s=BL;
  12762.  
  12763.                                                 bits2reg(reg2s,vops);
  12764.  
  12765.                                                 if(vops==r64)vops=r32;
  12766.  
  12767.                                                 warningreg(vops==r8?begs[reg2s]:regs[vops/2-1][reg2s]);
  12768.  
  12769.                                                 itok.number=reg2s;
  12770.  
  12771.                                         case tk_beg:
  12772.  
  12773.                                                 op(0x00+vop);
  12774.  
  12775.                                                 op(0xC0+beg+(unsigned int)itok.number*8);
  12776.  
  12777.                                                 break;
  12778.  
  12779.                                         case tk_qwordvar:
  12780.  
  12781.                                                 i=4;
  12782.  
  12783.                                         case tk_longvar:
  12784.  
  12785.                                         case tk_dwordvar:
  12786.  
  12787.                                                 i+=2;
  12788.  
  12789.                                         case tk_intvar:
  12790.  
  12791.                                         case tk_wordvar:
  12792.  
  12793.                                                 i++;
  12794.  
  12795.                                         case tk_bytevar:
  12796.  
  12797.                                         case tk_charvar:
  12798.  
  12799.                                                 i++;
  12800.  
  12801.                                                 CheckAllMassiv(bufrm,i,&strinf);
  12802.  
  12803.                                                 outseg(&itok,2);
  12804.  
  12805.                                                 op(0x02+vop);
  12806.  
  12807.                                                 op(beg*8+itok.rm);
  12808.  
  12809.                                                 outaddress(&itok);
  12810.  
  12811.                                                 break;
  12812.  
  12813.                                         case tk_postnumber:
  12814.  
  12815.                                         case tk_reg:
  12816.  
  12817.                                         case tk_rmnumber: begworderror();       break;
  12818.  
  12819.                                         case tk_ID:
  12820.  
  12821.                                         case tk_id:
  12822.  
  12823.                                         case tk_proc:
  12824.  
  12825.                                         case tk_apiproc:
  12826.  
  12827.                                         case tk_undefproc:// begcallerror(); break;
  12828.  
  12829.                                         case tk_declare:
  12830.  
  12831.                                                 procdo(tk_byte);
  12832.  
  12833.                                                 if(beg!=AL){
  12834.  
  12835.                                                         op(0x00+vop);
  12836.  
  12837.                                                         op(0xc0+beg);
  12838.  
  12839.                                                 }
  12840.  
  12841.                                                 break;
  12842.  
  12843.                                         default: valueexpected(); break;
  12844.  
  12845.                                 }
  12846.  
  12847.                                 break;
  12848.  
  12849.                         case tk_xorminus: vop+=0x10;
  12850.  
  12851.                         case tk_andminus: vop+=0x18;
  12852.  
  12853.                         case tk_orminus: vop+=0x08;
  12854.  
  12855.                           getoperand(beg==BL||beg==BH?SI:BX);
  12856.  
  12857.                                 if(tok==tk_number){
  12858.  
  12859.                                         itok.number=-itok.number;
  12860.  
  12861.                                         op(0x80);
  12862.  
  12863.                                         op(0xC0+vop +beg);
  12864.  
  12865.                                         op((unsigned int)itok.number);
  12866.  
  12867.                                 }
  12868.  
  12869.                                 else negregerror();
  12870.  
  12871.                                 break;
  12872.  
  12873.                         case tk_rr:
  12874.  
  12875.                                 vop=8;
  12876.  
  12877.                         case tk_ll:
  12878.  
  12879.                                 nexttok();
  12880.  
  12881.                                 if(tok==tk_number){
  12882.  
  12883.                                         if((unsigned int)itok.number==1){
  12884.  
  12885.                                                 if(vop==0){
  12886.  
  12887.                                                         op(2);
  12888.  
  12889.                                                         op(0xC0+9*beg); // ADD reg,reg
  12890.  
  12891.                                                 }
  12892.  
  12893.                                                 else{
  12894.  
  12895.                                                         op(0xD0); op(0xE8+beg);  /* SHR reg,1 */
  12896.  
  12897.                                                 }
  12898.  
  12899.                                         }
  12900.  
  12901.                                         else if((unsigned int)itok.number!=0){
  12902.  
  12903.                                                 if(chip<2)begmathoperror();
  12904.  
  12905.                                                 else{
  12906.  
  12907.                                                         op(0xc0);
  12908.  
  12909.                                                         op(0xe0+beg+vop); // SHL reg,imm8
  12910.  
  12911.                                                         op((unsigned int)itok.number);
  12912.  
  12913.                                                         if(cpu<2)cpu=2;
  12914.  
  12915.                                                 }
  12916.  
  12917.                                         }
  12918.  
  12919.                                 }
  12920.  
  12921.                                 else if(tok==tk_beg&&itok.number==CL&&beg!=CL){
  12922.  
  12923.                                         op(0xD2);
  12924.  
  12925.                                         op(0xE0+beg+vop);       // SHL xXX,CL
  12926.  
  12927.                                 }
  12928.  
  12929.                                 else begmathoperror();
  12930.  
  12931.                                 break;
  12932.  
  12933.                         case tk_multminus: negflag=TRUE;
  12934.  
  12935.                         case tk_mult:
  12936.  
  12937.                           if(optnum==FALSE)getoperand(beg==BL||beg==BH?SI:BX);
  12938.  
  12939.                                 else{
  12940.  
  12941.                                         tok=tk_number;
  12942.  
  12943.                                         optnum=FALSE;
  12944.  
  12945.                                 }
  12946.  
  12947.                                 if(negflag&&tok==tk_number){
  12948.  
  12949.                                         itok.number=-itok.number;
  12950.  
  12951.                                         negflag=FALSE;
  12952.  
  12953.                                 }
  12954.  
  12955.                                 switch(tok){
  12956.  
  12957.                                         case tk_number:
  12958.  
  12959.                                                 itok.number&=255;
  12960.  
  12961.                                                 switch((unsigned int)itok.number){
  12962.  
  12963.                                                         case 0: // beg * 0 = MOV beg,0
  12964.  
  12965.                                                                 outword(0x00B0+beg);
  12966.  
  12967.                                                         case 1: break; //beg*1=beg
  12968.  
  12969.                                                         case 2:
  12970.  
  12971.                                                                 op(0);
  12972.  
  12973.                                                                 op(0xC0+9*beg); // beg * 2 = ADD beg,beg
  12974.  
  12975.                                                                 break;
  12976.  
  12977.                                                         default:
  12978.  
  12979.                                                                 vop=caselong(itok.number);
  12980.  
  12981.                                                                 if(vop!=NUMNUM){
  12982.  
  12983.                                                                         if(chip<1)begmathoperror();
  12984.  
  12985.                                                                         else{
  12986.  
  12987.                                                                                 op(0xc0);
  12988.  
  12989.                                                                                 op(0xe0+beg);   //SHL beg,num
  12990.  
  12991.                                                                                 op(vop);
  12992.  
  12993.                                                                                 if(cpu<1)cpu=1;
  12994.  
  12995.                                                                         }
  12996.  
  12997.                                                                 }
  12998.  
  12999.                                                                 else begmathoperror();
  13000.  
  13001.                                                 }
  13002.  
  13003.                                                 break;
  13004.  
  13005.                                         default: begmathoperror(); break;
  13006.  
  13007.                                 }
  13008.  
  13009.                                 break;
  13010.  
  13011.                         case tk_divminus:
  13012.  
  13013.                         case tk_modminus:
  13014.  
  13015.                         case tk_div:
  13016.  
  13017.                         case tk_mod:
  13018.  
  13019.                         case tk_rrminus:
  13020.  
  13021.                         case tk_llminus:
  13022.  
  13023.                                 begmathoperror();       break;
  13024.  
  13025.                         default: operatorexpected(); break;
  13026.  
  13027.                 }
  13028.  
  13029. #ifdef OPTVARCONST
  13030.  
  13031.                 calcnumber=FALSE;
  13032.  
  13033. #endif
  13034.  
  13035.                 nexttok();
  13036.  
  13037.                 ClearReg(beg%4);
  13038.  
  13039.         }
  13040.  
  13041. }
  13042.  
  13043.  
  13044.  
  13045. // ============= getintoreg_32(), getintobeg() ============
  13046.  
  13047.  
  13048.  
  13049. int getintoreg_32(int reg,int razr,int sign,char **ofsstr,int useloop)  // get into word reg (except AX) with enum
  13050.  
  13051. {
  13052.  
  13053. int negflag=0,next=1,i=0;
  13054.  
  13055. int swap=0,oflag=0;
  13056.  
  13057. unsigned long holdnumber=0;
  13058.  
  13059. int reg1=idxregs[0],reg2=idxregs[1];
  13060.  
  13061. int rettype=tk_reg;
  13062.  
  13063. int loop=0,otok;
  13064.  
  13065. //                              printf("line %d tok=%d %s\n",linenumber,tok,itok.name);
  13066.  
  13067.         if(!am32){
  13068.  
  13069.                 if(reg==idxregs[1]||reg==idxregs[2]){
  13070.  
  13071.                         reg1=reg;
  13072.  
  13073.                         if(reg==idxregs[1])reg2=idxregs[0];
  13074.  
  13075.                 }
  13076.  
  13077.         }
  13078.  
  13079.         else{
  13080.  
  13081.                 reg1=reg;
  13082.  
  13083.                 if(reg==idxregs[1])reg2=idxregs[0];
  13084.  
  13085.         }
  13086.  
  13087.         if(tok==tk_minus){
  13088.  
  13089.                 if(CheckMinusNum()==FALSE){
  13090.  
  13091.                         negflag=1;
  13092.  
  13093.                         getoperand(am32==FALSE?BX:reg);
  13094.  
  13095.                 }
  13096.  
  13097.         }
  13098.  
  13099. loopswitch:
  13100.  
  13101.  
  13102.  
  13103.         if(uselea){
  13104.  
  13105.                 if(razr==r32){
  13106.  
  13107.                         if(cpu<3)cpu=3;
  13108.  
  13109.                         if(Reg32ToLea(reg)){
  13110.  
  13111.                                 return tk_reg;
  13112.  
  13113.                         }
  13114.  
  13115.                 }
  13116.  
  13117.                 else
  13118.  
  13119.                         if(Reg16ToLea(reg)){
  13120.  
  13121.                                 return tk_reg;
  13122.  
  13123.                         }
  13124.  
  13125.         }
  13126.  
  13127. loopswitch1:
  13128.  
  13129.  
  13130.  
  13131. #ifdef OPTVARCONST
  13132.  
  13133.         CheckConstVar3(&tok,&itok,razr);
  13134.  
  13135.         if(tok==tk_number)calcnumber=TRUE;
  13136.  
  13137. #endif
  13138.  
  13139.         otok=tok;
  13140.  
  13141. //      printf("reg=%d tok=%d\n",reg,tok);
  13142.  
  13143.         switch(tok){
  13144.  
  13145.                 case tk_number:
  13146.  
  13147.                         if(useloop==FALSE)MovRegNum(razr,itok.flag&f_reloc,itok.number,reg);
  13148.  
  13149.                         else{
  13150.  
  13151.                                 holdnumber=CalcNumber(sign);
  13152.  
  13153.                                 if(loop==0)oflag=postnumflag;
  13154.  
  13155.                                 else oflag^=postnumflag;
  13156.  
  13157.                                 loop++;
  13158.  
  13159.                                 if(tok==tk_mult){
  13160.  
  13161.                                         nexttok();
  13162.  
  13163.                                         swap=1;
  13164.  
  13165.                                         goto loopswitch1;
  13166.  
  13167.                                 }
  13168.  
  13169.                                 if(tok==tk_plus&&tok2==tk_postnumber){
  13170.  
  13171.                                         nexttok();
  13172.  
  13173. //                              getoperand(am32==TRUE?EAX:BX);
  13174.  
  13175.                                         goto loopswitch1;
  13176.  
  13177.                                 }
  13178.  
  13179.                                 MovRegNum(razr,oflag&f_reloc,holdnumber,reg);
  13180.  
  13181.                                 next=0;
  13182.  
  13183.                         }
  13184.  
  13185.                         break;
  13186.  
  13187.                 case tk_postnumber:
  13188.  
  13189.                 case tk_undefofs:
  13190.  
  13191.                         if(!swap){
  13192.  
  13193.                                 op66(razr);
  13194.  
  13195.                                 op(0xB8+reg);                   /* MOV AX,# */
  13196.  
  13197.                                 swap=1;
  13198.  
  13199.                         }
  13200.  
  13201.                         if(tok==tk_undefofs){
  13202.  
  13203.                                 AddUndefOff(2,itok.name);
  13204.  
  13205. //                              AddUndefOff(0,itok.name);
  13206.  
  13207. //                              itok.flag=0;    //new 07.07.04 23:57
  13208.  
  13209.                         }
  13210.  
  13211.                         else (itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
  13212.  
  13213.                         if(useloop==FALSE)holdnumber=itok.number;
  13214.  
  13215.                         else{
  13216.  
  13217.                                 tok=tk_number;
  13218.  
  13219.                                 holdnumber+=doconstdwordmath();
  13220.  
  13221.                                 if(otok!=tk_postnumber){
  13222.  
  13223.                                         if(loop==0)oflag=postnumflag;
  13224.  
  13225.                                         else oflag^=postnumflag;
  13226.  
  13227.                                         loop++;
  13228.  
  13229.                                 }
  13230.  
  13231.                                 if(tok==tk_plus&&tok2==tk_postnumber){
  13232.  
  13233.                                         nexttok();
  13234.  
  13235.                                         goto loopswitch1;
  13236.  
  13237.                                 }
  13238.  
  13239.                                 swap=0;
  13240.  
  13241.                                 next=0;
  13242.  
  13243.                         }
  13244.  
  13245.                         if(useloop&&(oflag&f_reloc))AddReloc();
  13246.  
  13247.                         if(razr==r16)outword(holdnumber);
  13248.  
  13249.                         else outdword(holdnumber);
  13250.  
  13251.                         ClearReg(reg);
  13252.  
  13253.                         break;
  13254.  
  13255.                 case tk_apioffset:
  13256.  
  13257.                         op66(razr);
  13258.  
  13259.                         op(0xB8+reg);                   /* MOV AX,# */
  13260.  
  13261.                         AddApiToPost(itok.number);
  13262.  
  13263.                         ClearReg(reg);
  13264.  
  13265.                         break;
  13266.  
  13267.                 case tk_rmnumber:
  13268.  
  13269.                         CheckAllMassiv(bufrm,itok.size,&strinf,&itok,reg1,reg2);
  13270.  
  13271.                         if((am32&&itok.rm==reg&&reg!=EBP&&reg!=ESP)||(am32==0&&reg==itok.rm&&
  13272.  
  13273.                                         (reg==SI||reg==DI||reg==BX)))break;
  13274.  
  13275.                         op66(razr);
  13276.  
  13277.                         op67(itok.sib==CODE16?r16:r32);
  13278.  
  13279.                         if(itok.post==0)outseg(&itok,2);
  13280.  
  13281.                         op(0x8D);                       // LEA reg,[rm]
  13282.  
  13283.                         op(reg*8+itok.rm);
  13284.  
  13285.                         if(itok.post!=0&&itok.post!=UNDEF_OFSET){
  13286.  
  13287.                                 if((itok.flag&f_extern)==0){
  13288.  
  13289.                                         unsigned int ooutptr=outptr;
  13290.  
  13291.                                         if(am32&&itok.rm==rm_sib)outptr++;
  13292.  
  13293.                                         setwordpost(&itok);
  13294.  
  13295.                                         outptr=ooutptr;
  13296.  
  13297.                                 }
  13298.  
  13299.                                 else setwordext(&itok.number);
  13300.  
  13301.                         }
  13302.  
  13303.                         if(useloop==FALSE)outaddress(&itok);
  13304.  
  13305.                         else{
  13306.  
  13307. ITOK oitok;
  13308.  
  13309.                                 oitok=itok;
  13310.  
  13311.                                 tok=tk_number;
  13312.  
  13313.                                 itok.rm=tk_dword;
  13314.  
  13315.                                 oitok.number=doconstdwordmath();
  13316.  
  13317.                                 outaddress(&oitok);
  13318.  
  13319.                                 next=0;
  13320.  
  13321.                         }
  13322.  
  13323.                         ClearReg(reg);
  13324.  
  13325.                         break;
  13326.  
  13327.                 case tk_qwordvar:
  13328.  
  13329.                         i=4;
  13330.  
  13331.                 case tk_longvar:
  13332.  
  13333.                 case tk_dwordvar:
  13334.  
  13335.                         i+=4;
  13336.  
  13337. dwordvar:
  13338.  
  13339.                         CheckAllMassiv(bufrm,i,&strinf,&itok,reg1,reg2);
  13340.  
  13341.                         op66(razr);
  13342.  
  13343.                         outseg(&itok,2);
  13344.  
  13345.                         op(0x8B);
  13346.  
  13347.                         op(reg*8+itok.rm);
  13348.  
  13349.                         outaddress(&itok);
  13350.  
  13351.                         ClearReg(reg);
  13352.  
  13353.                         break;
  13354.  
  13355.                 case tk_intvar:
  13356.  
  13357.                 case tk_wordvar:
  13358.  
  13359.                         i=2;
  13360.  
  13361.                         if(razr==r16)goto dwordvar;
  13362.  
  13363.                         CheckAllMassiv(bufrm,2,&strinf,&itok,reg1,reg2);
  13364.  
  13365.                         if(tok==tk_wordvar&&optimizespeed&&chip>3&&chip<7&&RmEqualReg(reg,itok.rm,itok.sib)==FALSE){
  13366.  
  13367.                                 ZeroReg(reg,r32);
  13368.  
  13369.                                 op66(r16);
  13370.  
  13371.                                 outseg(&itok,2);        //mov reg,var
  13372.  
  13373.                                 op(0x8B);
  13374.  
  13375.                         }
  13376.  
  13377.                         else{
  13378.  
  13379.                                 op66(r32);
  13380.  
  13381.                                 outseg(&itok,3);        //movxx reg,var
  13382.  
  13383.                                 op(0x0F); op(tok==tk_wordvar?0xB7:0xBF);
  13384.  
  13385.                         }
  13386.  
  13387.                         op(reg*8+itok.rm);
  13388.  
  13389.                         outaddress(&itok);
  13390.  
  13391.                         ClearReg(reg);
  13392.  
  13393.                         break;
  13394.  
  13395.                 case tk_doublevar:
  13396.  
  13397.                         i=4;
  13398.  
  13399.                 case tk_floatvar:
  13400.  
  13401.                         Float2reg32(reg,i,reg1,reg2);
  13402.  
  13403.                         ClearReg(reg);
  13404.  
  13405.                         break;
  13406.  
  13407.                 case tk_bytevar:
  13408.  
  13409.                 case tk_charvar:
  13410.  
  13411.                         if(chip>2||razr==r32){
  13412.  
  13413.                                 CheckAllMassiv(bufrm,1,&strinf,&itok,reg1,reg2);
  13414.  
  13415.                                 if(reg<=EBX&&tok==tk_bytevar&&optimizespeed&&chip>3&&chip<7&&RmEqualReg(reg,itok.rm,itok.sib)==FALSE){
  13416.  
  13417.                                         ZeroReg(reg,razr);
  13418.  
  13419.                                         outseg(&itok,2);
  13420.  
  13421.                                         op(0x8A);
  13422.  
  13423.                                 }
  13424.  
  13425.                                 else{
  13426.  
  13427.                                         op66(razr);
  13428.  
  13429.                                         outseg(&itok,3);
  13430.  
  13431.                                         op(0xf);
  13432.  
  13433.                                         if(tok==tk_bytevar)op(0xb6);
  13434.  
  13435.                                         else op(0xbe);
  13436.  
  13437.                                 }
  13438.  
  13439.                                 op(reg*8+itok.rm); // MOVZX regL,[byte]
  13440.  
  13441.                                 outaddress(&itok);
  13442.  
  13443.                                 ClearReg(reg);
  13444.  
  13445.                                 break;
  13446.  
  13447.                         }
  13448.  
  13449.                         if(reg<=BX){
  13450.  
  13451.                                 if(reg==AX&&itok.rm==rm_d16&&itok.sib==CODE16){
  13452.  
  13453.                                         outseg(&itok,1);
  13454.  
  13455.                                         op(0xA0); // MOV AL,[byte]
  13456.  
  13457.                                         outword((unsigned int)itok.number);
  13458.  
  13459.                                 }
  13460.  
  13461.                                 else{
  13462.  
  13463.                                         CheckAllMassiv(bufrm,1,&strinf,&itok,reg1,reg2);
  13464.  
  13465.                                         outseg(&itok,2);
  13466.  
  13467.                                         op(0x8A);
  13468.  
  13469.                                         op(reg*8+itok.rm); // MOV regL,[byte]
  13470.  
  13471.                                         outaddress(&itok);
  13472.  
  13473.                                 }
  13474.  
  13475.                                 ClearReg(reg);
  13476.  
  13477.                                 op(0x30); op(0xC0+(reg+4)*9); // XOR regH,regH
  13478.  
  13479.                         }
  13480.  
  13481.                         else regbyteerror();
  13482.  
  13483.                         break;
  13484.  
  13485.                 case tk_reg:
  13486.  
  13487.                         if(razr==r32){
  13488.  
  13489.                                 if(tok2==tk_openbracket){       //¢ë§®¢ ¯à®æ¥¤ãàë ¯®  ¤à¥áã ¢ ॣ¨áâà¥
  13490.  
  13491.                                         reg1=itok.number;
  13492.  
  13493.                                         nexttok();
  13494.  
  13495.                                         param[0]=0;
  13496.  
  13497.                                         if(comfile==file_w32)swapparam();
  13498.  
  13499.                                         else doparams();
  13500.  
  13501.                                         op66(r16);
  13502.  
  13503.                                         op(0xFF);
  13504.  
  13505.                                         op(0xD0+reg1);  /* CALL reg with stack params */
  13506.  
  13507.                                         itok.number=0;
  13508.  
  13509.                                         clearregstat();
  13510.  
  13511. #ifdef OPTVARCONST
  13512.  
  13513.                                         FreeGlobalConst();
  13514.  
  13515. #endif
  13516.  
  13517.                                 }
  13518.  
  13519.                                 if(optimizespeed&&chip>3&&chip<7&&reg!=(int)itok.number){
  13520.  
  13521.                                         ZeroReg(reg,r32);
  13522.  
  13523.                                         op(0x89);
  13524.  
  13525.                                         op(0xC0+reg+(unsigned int)itok.number*8);
  13526.  
  13527.                                 }
  13528.  
  13529.                                 else{
  13530.  
  13531.                                         op66(r32);
  13532.  
  13533.                                         outword(0xB70F);
  13534.  
  13535.                                         op(0xC0+reg*8+(unsigned int)itok.number);
  13536.  
  13537.                                 }
  13538.  
  13539.                                 RegToReg(reg,itok.number,r32);
  13540.  
  13541.                                 break;
  13542.  
  13543.                         }
  13544.  
  13545.                 case tk_reg32:
  13546.  
  13547.                         if(tok2==tk_openbracket){       //¢ë§®¢ ¯à®æ¥¤ãàë ¯®  ¤à¥áã ¢ ॣ¨áâà¥
  13548.  
  13549.                                 reg1=itok.number;
  13550.  
  13551.                                 reg2=tok==tk_reg32?r32:r16;
  13552.  
  13553.                                 nexttok();
  13554.  
  13555.                                 param[0]=0;
  13556.  
  13557.                                 if(comfile==file_w32)swapparam();
  13558.  
  13559.                                 else doparams();
  13560.  
  13561.                                 op66(reg2);
  13562.  
  13563.                                 op(0xFF);
  13564.  
  13565.                                 op(0xD0+reg1);  /* CALL reg with stack params */
  13566.  
  13567.                                 itok.number=0;
  13568.  
  13569.                                 clearregstat();
  13570.  
  13571. #ifdef OPTVARCONST
  13572.  
  13573.                                 FreeGlobalConst();
  13574.  
  13575. #endif
  13576.  
  13577.                         }
  13578.  
  13579.                         if(reg!=(int)itok.number){
  13580.  
  13581.                                 op66(razr);
  13582.  
  13583.                                 op(0x89);
  13584.  
  13585.                                 op(0xC0+reg+(unsigned int)itok.number*8);
  13586.  
  13587.                                 RegToReg(reg,itok.number,r32);
  13588.  
  13589.                         }
  13590.  
  13591.                         break;
  13592.  
  13593.                 case tk_bits:
  13594.  
  13595.                         int vops;
  13596.  
  13597.                         i=itok.bit.siz+itok.bit.ofs;
  13598.  
  13599.                         if(i<=64)vops=r64;
  13600.  
  13601.                         if(i<=32)vops=r32;
  13602.  
  13603.                         if(i<=16)vops=r16;
  13604.  
  13605.                         bits2reg(reg,(razr<vops?vops:razr));
  13606.  
  13607.                         break;
  13608.  
  13609.                 case tk_seg:
  13610.  
  13611.                         op66(razr);
  13612.  
  13613.                         op(0x8C);
  13614.  
  13615.                         op(0xC0+reg+(unsigned int)itok.number*8);
  13616.  
  13617.                         ClearReg(reg);
  13618.  
  13619.                         break;
  13620.  
  13621.                 case tk_beg:
  13622.  
  13623.                         if(chip>2||razr==r32){
  13624.  
  13625.                                 if(optimizespeed&&chip>3&&chip<7&&reg<4&&reg!=(int)(itok.number%4)){
  13626.  
  13627.                                         ZeroReg(reg,razr);
  13628.  
  13629.                                         op(0x88);
  13630.  
  13631.                                         op(0xC0+reg+(unsigned int)itok.number*8); // MOV regL,beg
  13632.  
  13633.                                 }
  13634.  
  13635.                                 else{
  13636.  
  13637.                                         op66(razr);
  13638.  
  13639.                                         outword(0xb60f);
  13640.  
  13641.                                         op(0xC0+reg*8+(unsigned int)itok.number); // MOVZX regL,beg
  13642.  
  13643.                                 }
  13644.  
  13645.                         }
  13646.  
  13647.                         else if(reg>BX)regbyteerror();
  13648.  
  13649.                         else{
  13650.  
  13651.                                 op(0x88); op(0xC0+reg+(unsigned int)itok.number*8); // MOV regL,beg
  13652.  
  13653.                                 op(0x30); op(0xC0+(reg+4)*9);   // XOR regH,regH
  13654.  
  13655.                         }
  13656.  
  13657.                         ClearReg(reg);
  13658.  
  13659.                         break;
  13660.  
  13661.                 case tk_at:
  13662.  
  13663.                         getoperand(am32==FALSE?BX:reg);
  13664.  
  13665.                         i++;
  13666.  
  13667.                 case tk_ID:
  13668.  
  13669.                 case tk_id:
  13670.  
  13671.                 case tk_proc:
  13672.  
  13673.                 case tk_apiproc:
  13674.  
  13675.                 case tk_undefproc:
  13676.  
  13677.                 case tk_declare:
  13678.  
  13679.                         if(itok.flag&f_retproc)rettype=(itok.flag&f_retproc)/256+tk_overflowflag-1;
  13680.  
  13681.                         if((!i)||macros(razr==r16?tk_word:tk_dword)==0)procdo(razr==r16?tk_word:tk_dword);
  13682.  
  13683.                         itok.number=0;
  13684.  
  13685.                         tok=(razr==r16?tk_reg:tk_reg32);
  13686.  
  13687.                         if(*ofsstr!=NULL){
  13688.  
  13689.                                 free(*ofsstr);
  13690.  
  13691.                                 ofsstr=NULL;
  13692.  
  13693.                         }
  13694.  
  13695. //              printf("tok=%d num=%d tok2=%d\n",tok,itok.number,tok2);
  13696.  
  13697.                         goto loopswitch;
  13698.  
  13699. //                      break;
  13700.  
  13701.                 case tk_string:
  13702.  
  13703.                         op66(razr);
  13704.  
  13705.                         op(0xB8+reg);
  13706.  
  13707.                         if(razr==r16){
  13708.  
  13709.                                 if(am32)dwordvalexpected();
  13710.  
  13711.                                 outword(addpoststring());
  13712.  
  13713.                         }
  13714.  
  13715.                         else outdword(addpoststring());
  13716.  
  13717.                         ClearReg(reg);
  13718.  
  13719.                         break;
  13720.  
  13721.                 default: valueexpected();       break;
  13722.  
  13723.         }
  13724.  
  13725. #ifdef OPTVARCONST
  13726.  
  13727.         calcnumber=FALSE;
  13728.  
  13729. #endif
  13730.  
  13731.         if(negflag)NegReg(razr,reg);
  13732.  
  13733.         if(swap){
  13734.  
  13735.                 negflag=0;
  13736.  
  13737.                 RegMulNum(reg,holdnumber,razr,0,&negflag,oflag);
  13738.  
  13739.                 ClearReg(reg);
  13740.  
  13741.         }
  13742.  
  13743.         if(next)nexttok();
  13744.  
  13745. //              printf("tok=%d num=%d tok2=%d\n",tok,itok.number,tok2);
  13746.  
  13747.         return rettype;
  13748.  
  13749. }
  13750.  
  13751.  
  13752.  
  13753. int getintobeg(int beg,char **ofsstr)   // get into beg (CL,DL,BL not others) with enum
  13754.  
  13755. {
  13756.  
  13757. int negflag=0,i=0;
  13758.  
  13759. int rettype=tk_beg;
  13760.  
  13761.         if(tok==tk_minus){
  13762.  
  13763.                 if(CheckMinusNum()==FALSE){
  13764.  
  13765.                         negflag=1;
  13766.  
  13767.                         getoperand(am32==TRUE?(beg>3?beg-4:beg):BX);
  13768.  
  13769.                 }
  13770.  
  13771.         }
  13772.  
  13773. #ifdef OPTVARCONST
  13774.  
  13775.         if(tok>=tk_charvar&&tok<=tk_doublevar&&itok.npointr==0){
  13776.  
  13777. //              printf("type1=%d type2=%d\n",itok.type,itok2.type);
  13778.  
  13779.                 if(CheckConstVar(&itok)){
  13780.  
  13781.                         tok=tk_number;
  13782.  
  13783.                         calcnumber=TRUE;
  13784.  
  13785.                 }
  13786.  
  13787.         }
  13788.  
  13789. #endif
  13790.  
  13791.         switch(tok){
  13792.  
  13793.                 case tk_number:
  13794.  
  13795.                         op(0xB0+beg);
  13796.  
  13797.                         i=(int)doconstlongmath();
  13798.  
  13799.                         op(i);
  13800.  
  13801.                         ConstToReg(i,beg,r8);
  13802.  
  13803.                         break;
  13804.  
  13805.                 case tk_rmnumber:
  13806.  
  13807.                         CheckAllMassiv(bufrm,itok.size,&strinf);
  13808.  
  13809.                         op66(r16);
  13810.  
  13811.                         op67(itok.sib==CODE16?r16:r32);
  13812.  
  13813.                         if(itok.post==0)outseg(&itok,2);
  13814.  
  13815.                         op(0x8D);                               // LEA reg,[rm]
  13816.  
  13817.                         op(beg*8+itok.rm);
  13818.  
  13819.                         if(itok.post!=0&&itok.post!=UNDEF_OFSET){
  13820.  
  13821.                                 if((itok.flag&f_extern)==0){
  13822.  
  13823.                                         unsigned int ooutptr=outptr;
  13824.  
  13825.                                         if(am32&&itok.rm==rm_sib)outptr++;
  13826.  
  13827.                                         setwordpost(&itok);
  13828.  
  13829.                                         outptr=ooutptr;
  13830.  
  13831.                                 }
  13832.  
  13833.                                 else setwordext(&itok.number);
  13834.  
  13835.                         }
  13836.  
  13837.                         outaddress(&itok);
  13838.  
  13839.                         ClearReg(beg%4);
  13840.  
  13841.                         break;
  13842.  
  13843.                 case tk_postnumber:
  13844.  
  13845.                         op66(r16);
  13846.  
  13847.                         op(0xB8+beg);
  13848.  
  13849.                         (itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
  13850.  
  13851.                         outword((unsigned int)itok.number);
  13852.  
  13853.                         nexttok();
  13854.  
  13855.                         ClearReg(beg%4);
  13856.  
  13857.                         break;
  13858.  
  13859.                 case tk_qwordvar:
  13860.  
  13861.                         i=4;
  13862.  
  13863.                 case tk_longvar:
  13864.  
  13865.                 case tk_dwordvar:
  13866.  
  13867.                         i+=2;
  13868.  
  13869.                 case tk_intvar:
  13870.  
  13871.                 case tk_wordvar:
  13872.  
  13873.                         i++;
  13874.  
  13875.                 case tk_charvar:
  13876.  
  13877.                 case tk_bytevar:
  13878.  
  13879.                         i++;
  13880.  
  13881.                         CheckAllMassiv(bufrm,i,&strinf);
  13882.  
  13883.                         outseg(&itok,2);
  13884.  
  13885.                         op(0x8A);
  13886.  
  13887.                         op(beg*8+itok.rm);
  13888.  
  13889.                         outaddress(&itok);
  13890.  
  13891.                         nexttok();
  13892.  
  13893.                         ClearReg(beg%4);
  13894.  
  13895.                         break;
  13896.  
  13897.                 case tk_doublevar:
  13898.  
  13899.                         i=4;
  13900.  
  13901.                 case tk_floatvar:
  13902.  
  13903.                         Float2reg32((beg<4?beg:beg-4),i);
  13904.  
  13905.                         if(beg>3){
  13906.  
  13907.                                 op(0x88);
  13908.  
  13909.                                 op(0xC0+beg+8*(beg-4));
  13910.  
  13911.                         }
  13912.  
  13913.                         nexttok();
  13914.  
  13915.                         ClearReg(beg%4);
  13916.  
  13917.                         break;
  13918.  
  13919.                 case tk_bits:
  13920.  
  13921.                         int vops;
  13922.  
  13923.                         i=itok.bit.siz+itok.bit.ofs;
  13924.  
  13925.                         if(i<=64)vops=r64;
  13926.  
  13927.                         if(i<=32)vops=r32;
  13928.  
  13929.                         if(i<=16)vops=r16;
  13930.  
  13931.                         if(i<=8)vops=r8;
  13932.  
  13933.                         if(beg>BX&&vops!=r8){
  13934.  
  13935.                                 op66(vops==r64?r32:vops);
  13936.  
  13937.                                 op(0x50);
  13938.  
  13939.                                 if(ESPloc&&am32&&itok.segm==SS)itok.number+=4;
  13940.  
  13941.                                 addESP+=vops==r16?2:4;
  13942.  
  13943.                                 bits2reg(AX,vops);
  13944.  
  13945.                                 op(0x88);
  13946.  
  13947.                                 op(0xC0+beg);
  13948.  
  13949.                                 op66(vops==r64?r32:vops);
  13950.  
  13951.                                 addESP-=vops==r16?2:4;
  13952.  
  13953.                                 op(0x58);
  13954.  
  13955.                         }
  13956.  
  13957.                         else bits2reg(beg,vops);
  13958.  
  13959.                         nexttok();
  13960.  
  13961.                         break;
  13962.  
  13963.                 case tk_beg:
  13964.  
  13965.                         if(beg!=(int)itok.number){
  13966.  
  13967.                                 op(0x88);
  13968.  
  13969.                                 op(0xC0+beg+(unsigned int)itok.number*8);
  13970.  
  13971.                                 RegToReg(beg,itok.number,r8);
  13972.  
  13973.                         }
  13974.  
  13975.                         nexttok();
  13976.  
  13977.                         break;
  13978.  
  13979.                 case tk_reg32:
  13980.  
  13981.                 case tk_reg:
  13982.  
  13983.                         if(beg<BX){
  13984.  
  13985.                                 if(beg!=(int)itok.number){
  13986.  
  13987.                                         op66(r16);
  13988.  
  13989.                                         op(0x89);
  13990.  
  13991.                                         op(0xC0+beg+(unsigned int)itok.number*8);
  13992.  
  13993.                                         RegToReg(beg,itok.number,r8);
  13994.  
  13995.                                 }
  13996.  
  13997.                         }
  13998.  
  13999.                         else begworderror();
  14000.  
  14001.                         nexttok();
  14002.  
  14003.                         break;
  14004.  
  14005.                 case tk_seg:
  14006.  
  14007.                         op66(r16);
  14008.  
  14009.                         op(0x8C);
  14010.  
  14011.                         op(0xC0+beg+(unsigned int)itok.number*8);
  14012.  
  14013.                         nexttok();
  14014.  
  14015.                         ClearReg(beg%4);
  14016.  
  14017.                         break;
  14018.  
  14019.                 case tk_ID:
  14020.  
  14021.                 case tk_id:
  14022.  
  14023.                 case tk_proc:
  14024.  
  14025.                 case tk_apiproc:
  14026.  
  14027.                 case tk_undefproc:
  14028.  
  14029.                 case tk_declare:
  14030.  
  14031.                         if(itok.flag&f_retproc)rettype=(itok.flag&f_retproc)/256+tk_overflowflag-1;
  14032.  
  14033.                         procdo(tk_byte);
  14034.  
  14035.                         op(0x88);
  14036.  
  14037.                         op(0xc0+beg);
  14038.  
  14039.                         nexttok();
  14040.  
  14041.                         RegToReg(beg,AL,r8);
  14042.  
  14043.                         if(*ofsstr){
  14044.  
  14045.                                 free(*ofsstr);
  14046.  
  14047.                                 *ofsstr=NULL;
  14048.  
  14049.                         }
  14050.  
  14051.                         break;
  14052.  
  14053.                 default: valueexpected();       nexttok(); return 0;
  14054.  
  14055.         }
  14056.  
  14057. #ifdef OPTVARCONST
  14058.  
  14059.         calcnumber=FALSE;
  14060.  
  14061. #endif
  14062.  
  14063.         if(negflag){
  14064.  
  14065.                 if(optimizespeed&&(chip==5||chip==6)){
  14066.  
  14067.                         op(0x80);
  14068.  
  14069.                         op(0xF0+beg);
  14070.  
  14071.                         op(0xff);
  14072.  
  14073.                         op(0xFE);
  14074.  
  14075.                         op(0xC0+beg);
  14076.  
  14077.                 }
  14078.  
  14079.                 else{
  14080.  
  14081.                         op(0xF6);
  14082.  
  14083.                         op(0xD8+beg);   // NEG beg
  14084.  
  14085.                 }
  14086.  
  14087.                 ClearReg(beg%4);
  14088.  
  14089.         }
  14090.  
  14091.         return rettype;
  14092.  
  14093. }
  14094.  
  14095.  
  14096.  
  14097. void  outaddress(ITOK *outtok)
  14098.  
  14099. {
  14100.  
  14101. int rm=outtok->rm;
  14102.  
  14103.         if(outtok->sib==CODE16){
  14104.  
  14105.                 if(rm==rm_d16){
  14106.  
  14107.                         if(outtok->post==UNDEF_OFSET){
  14108.  
  14109.                                 AddUndefOff(2,outtok->name);
  14110.  
  14111.                                 outtok->post=0;
  14112.  
  14113.                         }
  14114.  
  14115.                         outword(outtok->number);
  14116.  
  14117.                 }
  14118.  
  14119.                 else{
  14120.  
  14121.                         rm&=rm_mod11;
  14122.  
  14123.                         if(rm==rm_mod11)internalerror(badadr);
  14124.  
  14125.                         else if(rm==rm_mod10){
  14126.  
  14127.                                 if(outtok->post==UNDEF_OFSET){
  14128.  
  14129.                                         AddUndefOff(2,outtok->name);
  14130.  
  14131.                                         outtok->post=0;
  14132.  
  14133.                                 }
  14134.  
  14135.                                 outword(outtok->number);
  14136.  
  14137.                         }
  14138.  
  14139.                         else if(rm!=rm_mod00)op(outtok->number);
  14140.  
  14141.                 }
  14142.  
  14143.         }
  14144.  
  14145.         else{
  14146.  
  14147.                 if(rm==rm_d32){
  14148.  
  14149.                         if(outtok->post==UNDEF_OFSET){
  14150.  
  14151.                                 AddUndefOff(2,outtok->name);
  14152.  
  14153.                                 outtok->post=0;
  14154.  
  14155.                         }
  14156.  
  14157.                         outdword(outtok->number);
  14158.  
  14159.                 }
  14160.  
  14161.                 else{
  14162.  
  14163.                         if((rm&7)==rm_sib){
  14164.  
  14165.                                 op(outtok->sib);
  14166.  
  14167.                                 if(rm==4&&(outtok->sib&7)==5){
  14168.  
  14169.                                         if(outtok->post==UNDEF_OFSET){
  14170.  
  14171.                                                 AddUndefOff(2,outtok->name);
  14172.  
  14173.                                                 outtok->post=0;
  14174.  
  14175.                                         }
  14176.  
  14177.                                         outdword(outtok->number);
  14178.  
  14179.                                 }
  14180.  
  14181.                         }
  14182.  
  14183.                         rm&=rm_mod11;
  14184.  
  14185.                         if(rm==rm_mod11)internalerror(badadr);
  14186.  
  14187.                         else if(rm==rm_mod10){
  14188.  
  14189.                                 if(outtok->post==UNDEF_OFSET){
  14190.  
  14191.                                         AddUndefOff(2,outtok->name);
  14192.  
  14193.                                         outtok->post=0;
  14194.  
  14195.                                 }
  14196.  
  14197.                                 outdword(outtok->number);
  14198.  
  14199.                         }
  14200.  
  14201.                         else if(rm==rm_mod01)op(outtok->number);
  14202.  
  14203.                 }
  14204.  
  14205.         }
  14206.  
  14207. }
  14208.  
  14209.  
  14210.  
  14211. /*-----------------05.01.00 23:37-------------------
  14212.  
  14213.  Ž¡à ¡®âª  float
  14214.  
  14215.  ®¯¥à æ¨¨ á ¯¥à¥¬¥­­ë¬¨ ⨯  float
  14216.  
  14217.  --------------------------------------------------*/
  14218.  
  14219. int dofloatvar(int addop,int retrez,int terminater)
  14220.  
  14221. {
  14222.  
  14223. unsigned char next=1, getfromEAX=0;
  14224.  
  14225. unsigned int vop=0,rettype=tk_float,posiblret=tk_float,sign=0;
  14226.  
  14227. char *wbuf,*rbuf;
  14228.  
  14229. ITOK wtok;
  14230.  
  14231. SINFO wstr;
  14232.  
  14233. int pointr=0;
  14234.  
  14235. int razr,i=0;
  14236.  
  14237. int type=tk_floatvar;
  14238.  
  14239.         if(addop){
  14240.  
  14241.                 rettype=posiblret=tk_double;
  14242.  
  14243.                 razr=8;
  14244.  
  14245.                 type=tk_doublevar;
  14246.  
  14247.         }
  14248.  
  14249.         wstr=strinf;
  14250.  
  14251.         strinf.bufstr=NULL;
  14252.  
  14253.         wtok=itok;
  14254.  
  14255.         wbuf=bufrm;
  14256.  
  14257.         bufrm=NULL;
  14258.  
  14259.         KillVar(itok.name);
  14260.  
  14261. char *ofsstr=NULL;
  14262.  
  14263.         nexttok();
  14264.  
  14265.         switch(tok){
  14266.  
  14267.                 case tk_assign: //=
  14268.  
  14269.                         getoperand(am32==TRUE?EAX:BX);
  14270.  
  14271.                         convert_type((int *)&sign,(int *)&rettype,&pointr);
  14272.  
  14273.                         if(tok2==tk_assign){
  14274.  
  14275.                                 MultiAssignFloat(type);
  14276.  
  14277.                                 next=0;
  14278.  
  14279.                                 goto getfromeax;
  14280.  
  14281.                         }
  14282.  
  14283.                         CheckMinusNum();
  14284.  
  14285.                         if(itok2.type==tp_opperand){    //á®áâ ¢­®¥
  14286.  
  14287.                                 if(tok==tk_number){     //¯à®¢¥àª  ¨ á㬬¨à®¢ ­¨¥ ç¨á¥«
  14288.  
  14289.                                         if(OnlyNumber(rettype==tk_float?2:3)){
  14290.  
  14291.                                                 next=0;
  14292.  
  14293.                                                 itok.flag=(unsigned char)postnumflag;
  14294.  
  14295.                                                 itok.rm=rettype;
  14296.  
  14297.                                                 goto numbertovar;
  14298.  
  14299.                                         }
  14300.  
  14301.                                 }
  14302.  
  14303.                                 getfromEAX=1;
  14304.  
  14305.                                 if(rettype==tk_char||rettype==tk_byte)doalmath(sign,&ofsstr);
  14306.  
  14307.                                 else if(rettype==tk_int||rettype==tk_word)do_e_axmath(sign,r16,&ofsstr);
  14308.  
  14309.                                 else if(rettype==tk_long||rettype==tk_dword)do_e_axmath(sign,r32,&ofsstr);
  14310.  
  14311.                                 else goto labl1;
  14312.  
  14313.                         }
  14314.  
  14315.                         else{
  14316.  
  14317.                                 switch(tok){
  14318.  
  14319.                                         case tk_number:
  14320.  
  14321. numbertovar:
  14322.  
  14323.                                                 if(rettype==tk_float){
  14324.  
  14325.                                                         if(itok.rm==tk_double)itok.fnumber=itok.dnumber;
  14326.  
  14327.                                                         else if(itok.rm!=tk_float){
  14328.  
  14329.                                                                 float temp=itok.number;
  14330.  
  14331.                                                                 *(float *)&itok.number=temp;
  14332.  
  14333.                                                         }
  14334.  
  14335.                                                 }
  14336.  
  14337.                                                 else{
  14338.  
  14339.                                                         if(itok.rm==tk_float)itok.dnumber=itok.fnumber;
  14340.  
  14341.                                                         else if(itok.rm!=tk_double)itok.dnumber=itok.lnumber;
  14342.  
  14343.                                                 }
  14344.  
  14345.                                                 CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  14346.  
  14347.                                                 for(i=0;i<2;i++){
  14348.  
  14349.                                                         op66(r32);
  14350.  
  14351.                                                         if((itok.flag&f_reloc)==0&&itok.number==0){
  14352.  
  14353.                                                                 outseg(&wtok,2);
  14354.  
  14355.                                                                 op(0x83);
  14356.  
  14357.                                                                 op(wtok.rm+0x20);
  14358.  
  14359.                                                                 outaddress(&wtok);
  14360.  
  14361.                                                                 op(0);
  14362.  
  14363.                                                         }
  14364.  
  14365.                                                         else if(regoverstack&&short_ok(itok.number,TRUE)&&(itok.flag&f_reloc)==0){
  14366.  
  14367.                                                                 op(0x6A);
  14368.  
  14369.                                                                 op(itok.number);        //push short number
  14370.  
  14371.                                                                 op66(r32);
  14372.  
  14373.                                                                 outseg(&wtok,2);
  14374.  
  14375.                                                                 op(0x8f);
  14376.  
  14377.                                                                 op(wtok.rm);
  14378.  
  14379.                                                                 outaddress(&wtok);
  14380.  
  14381.                                                         }
  14382.  
  14383.                                                         else{
  14384.  
  14385.                                                                 outseg(&wtok,2);
  14386.  
  14387.                                                                 op(0xC7);       //mov word[],number
  14388.  
  14389.                                                                 op(wtok.rm);
  14390.  
  14391.                                                                 outaddress(&wtok);
  14392.  
  14393.                                                                 if((itok.flag&f_reloc)!=0)AddReloc();
  14394.  
  14395.                                                                 outdword(itok.number);
  14396.  
  14397.                                                         }
  14398.  
  14399.                                                         if(i==1||rettype==tk_float)break;
  14400.  
  14401.                                                         itok.lnumber>>=32;
  14402.  
  14403.                                                         wtok.number+=4;
  14404.  
  14405.                                                         compressoffset(&wtok);
  14406.  
  14407.                                                 }
  14408.  
  14409.                                                 break;
  14410.  
  14411.                                         case tk_doublevar:
  14412.  
  14413.                                         case tk_floatvar:
  14414.  
  14415.                                                 if(tok!=type)goto labl1;
  14416.  
  14417.                                                 ITOK w1tok;
  14418.  
  14419.                                                 char *w1buf;
  14420.  
  14421.                                                 w1buf=bufrm;
  14422.  
  14423.                                                 bufrm=NULL;
  14424.  
  14425.                                                 w1tok=itok;
  14426.  
  14427.                                                 SINFO w1str;
  14428.  
  14429.                                                 w1str=strinf;
  14430.  
  14431.                                                 strinf.bufstr=NULL;
  14432.  
  14433.                                                 getinto_e_ax(0,tok==tk_floatvar?tk_dwordvar:tk_qwordvar,&w1tok,w1buf,&w1str,r32);
  14434.  
  14435.                                                 if(tok==tk_doublevar){
  14436.  
  14437.                                                         if((wtok.rm==rm_d16&&wtok.sib==CODE16)||(wtok.rm==rm_d32&&wtok.sib==CODE32)){
  14438.  
  14439.                                                                 op66(r32);
  14440.  
  14441.                                                                 outseg(&wtok,1);
  14442.  
  14443.                                                                 op(0xA3);       // MOV [dword],EAX
  14444.  
  14445.                                                                 if(am32)outdword(wtok.number);
  14446.  
  14447.                                                                 else outword(wtok.number);
  14448.  
  14449.                                                         }
  14450.  
  14451.                                                         else{
  14452.  
  14453.                                                                 CheckAllMassiv(wbuf,4,&wstr,&wtok);
  14454.  
  14455.                                                                 op66(r32);
  14456.  
  14457.                                                                 outseg(&wtok,2);
  14458.  
  14459.                                                                 op(0x89); op(wtok.rm); // MOV [rmdword],EAX
  14460.  
  14461.                                                                 outaddress(&wtok);
  14462.  
  14463.                                                         }
  14464.  
  14465.                                                         itok.number+=4;
  14466.  
  14467.                                                         compressoffset(&itok);
  14468.  
  14469.                                                         wtok.number+=4;
  14470.  
  14471.                                                         compressoffset(&wtok);
  14472.  
  14473.                                                         ITOK w1tok;
  14474.  
  14475.                                                         char *w1buf;
  14476.  
  14477.                                                         w1buf=bufrm;
  14478.  
  14479.                                                         bufrm=NULL;
  14480.  
  14481.                                                         w1tok=itok;
  14482.  
  14483.                                                         SINFO w1str;
  14484.  
  14485.                                                         w1str=strinf;
  14486.  
  14487.                                                         strinf.bufstr=NULL;
  14488.  
  14489.                                                         getinto_e_ax(0,tk_qwordvar,&w1tok,w1buf,&w1str,r32);
  14490.  
  14491.                                                 }
  14492.  
  14493.                                                 getfromEAX=1;
  14494.  
  14495.                                                 break;
  14496.  
  14497.                                         default:
  14498.  
  14499. labl1:
  14500.  
  14501.                                                 if((i=doeaxfloatmath(tk_fpust))==tk_fpust||i==tk_double){
  14502.  
  14503.                                                         getfromEAX=0;
  14504.  
  14505.                                                         if(retrez==tk_floatvar||retrez==tk_doublevar){
  14506.  
  14507.                                                                 CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  14508.  
  14509.                                                                 outseg(&wtok,2);
  14510.  
  14511.                                                                 op(0xd9+addop);
  14512.  
  14513.                                                                 op(wtok.rm+0x18);
  14514.  
  14515.                                                                 outaddress(&wtok);
  14516.  
  14517.                                                                 fwait3();
  14518.  
  14519.                                                         }
  14520.  
  14521.                                                         else retrez=tk_fpust;
  14522.  
  14523.                                                 }
  14524.  
  14525.                                                 else getfromEAX=1;
  14526.  
  14527.                                                 next=0;
  14528.  
  14529.                                 }
  14530.  
  14531.                         }
  14532.  
  14533.                         if(getfromEAX){
  14534.  
  14535. getfromeax:
  14536.  
  14537.                                 retrez=tk_reg32;
  14538.  
  14539.                                 convert_returnvalue(posiblret,rettype);
  14540.  
  14541.                                 if((wtok.rm==rm_d16&&wtok.sib==CODE16)||(wtok.rm==rm_d32&&wtok.sib==CODE32)){
  14542.  
  14543.                                         op66(r32);
  14544.  
  14545.                                         outseg(&wtok,1);
  14546.  
  14547.                                         op(0xA3);       // MOV [dword],EAX
  14548.  
  14549.                                         if(am32)outdword(wtok.number);
  14550.  
  14551.                                         else outword(wtok.number);
  14552.  
  14553.                                 }
  14554.  
  14555.                                 else{
  14556.  
  14557.                                         CheckAllMassiv(wbuf,4,&wstr,&wtok);
  14558.  
  14559.                                         op66(r32);
  14560.  
  14561.                                         outseg(&wtok,2);
  14562.  
  14563.                                         op(0x89); op(wtok.rm); // MOV [rmdword],EAX
  14564.  
  14565.                                         outaddress(&wtok);
  14566.  
  14567.                                 }
  14568.  
  14569.                         }
  14570.  
  14571.                         break;
  14572.  
  14573.                 case tk_minusminus:
  14574.  
  14575.                         vop=0x28;
  14576.  
  14577.                 case tk_plusplus:
  14578.  
  14579. incvar:
  14580.  
  14581.                         outword(0xe8d9);        //fld1
  14582.  
  14583.                         CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  14584.  
  14585.                         outseg(&wtok,2);        //fadd var
  14586.  
  14587.                         op(0xd8+addop);
  14588.  
  14589.                         op(wtok.rm+vop);
  14590.  
  14591.                         outaddress(&wtok);
  14592.  
  14593.                         if(retrez==tk_floatvar||retrez==tk_doublevar){
  14594.  
  14595.                                 outseg(&wtok,2);        //fstp var
  14596.  
  14597.                                 op(0xd9+addop);
  14598.  
  14599.                                 op(wtok.rm+0x18);
  14600.  
  14601.                                 outaddress(&wtok);
  14602.  
  14603.                                 fwait3();
  14604.  
  14605.                         }
  14606.  
  14607.                         break;
  14608.  
  14609.                 case tk_divequals: vop+=0x10;
  14610.  
  14611.                 case tk_minusequals: vop+=0x20;
  14612.  
  14613.                 case tk_multequals: vop+=8;
  14614.  
  14615.                 case tk_plusequals:
  14616.  
  14617.                         getoperand(am32==TRUE?EAX:BX);
  14618.  
  14619.                         if(itok2.type==tp_stopper){
  14620.  
  14621.                                 if(tok==tk_number){
  14622.  
  14623.                                         if((itok.rm==tk_float&&itok.fnumber==1.0)||
  14624.  
  14625.                                                         (itok.rm==tk_double&&itok.dnumber==1.0)||
  14626.  
  14627.                                                         (itok.rm!=tk_float&&itok.rm!=tk_double&&itok.lnumber==1)){
  14628.  
  14629.                                                 if(vop==0||vop==0x28)goto incvar;
  14630.  
  14631.                                                 break;
  14632.  
  14633.                                         }
  14634.  
  14635.                                         if((itok.rm==tk_float&&itok.fnumber==0.0)||
  14636.  
  14637.                                                         (itok.rm==tk_double&&itok.dnumber==0.0)||itok.lnumber==0){
  14638.  
  14639.                                                 switch(vop){
  14640.  
  14641.                                                         case 0x38:
  14642.  
  14643.                                                                 DevideZero();
  14644.  
  14645.                                                                 break;
  14646.  
  14647.                                                         case 8:
  14648.  
  14649.                                                                 outword(0xEED9);        //FLDZ
  14650.  
  14651.                                                                 if(retrez==tk_floatvar||retrez==tk_doublevar){
  14652.  
  14653.                                                                         CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  14654.  
  14655.                                                                         outseg(&wtok,2);        //fstp var
  14656.  
  14657.                                                                         op(0xd9+addop);
  14658.  
  14659.                                                                         op(wtok.rm+0x18);
  14660.  
  14661.                                                                         outaddress(&wtok);
  14662.  
  14663.                                                                         fwait3();
  14664.  
  14665.                                                                 }
  14666.  
  14667.                                                                 break;
  14668.  
  14669.                                                 }
  14670.  
  14671.                                                 break;
  14672.  
  14673.                                         }
  14674.  
  14675.                                 }
  14676.  
  14677.                         }
  14678.  
  14679.                         if(itok2.type==tp_opperand){
  14680.  
  14681.                                 doeaxfloatmath(tk_fpust);
  14682.  
  14683. endequals:
  14684.  
  14685.                                 next=0;
  14686.  
  14687. endequals1:
  14688.  
  14689.                                 CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  14690.  
  14691.                                 outseg(&wtok,2);        //fsubr var
  14692.  
  14693.                                 op(0xd8+addop);
  14694.  
  14695.                                 op(wtok.rm+vop);
  14696.  
  14697.                                 outaddress(&wtok);
  14698.  
  14699.                                 if(retrez==tk_floatvar||retrez==tk_doublevar){
  14700.  
  14701.                                         outseg(&wtok,2);        //fstp var
  14702.  
  14703.                                         op(0xd9+addop);
  14704.  
  14705.                                         op(wtok.rm+0x18);
  14706.  
  14707.                                         outaddress(&wtok);
  14708.  
  14709.                                         fwait3();
  14710.  
  14711.                                 }
  14712.  
  14713.                         }
  14714.  
  14715.                         else{
  14716.  
  14717.                                 switch(tok){
  14718.  
  14719.                                         case tk_number:
  14720.  
  14721.                                                 if(rettype==tk_float){
  14722.  
  14723.                                                         if(itok.rm==tk_double)itok.fnumber=itok.dnumber;
  14724.  
  14725.                                                         else if(itok.rm!=tk_float){
  14726.  
  14727.                                                                 float temp=itok.number;
  14728.  
  14729.                                                                 *(float *)&itok.number=temp;
  14730.  
  14731.                                                         }
  14732.  
  14733.                                                 }
  14734.  
  14735.                                                 else{
  14736.  
  14737.                                                         if(itok.rm==tk_float)itok.dnumber=itok.fnumber;
  14738.  
  14739.                                                         else if(itok.rm!=tk_double)itok.dnumber=itok.lnumber;
  14740.  
  14741.                                                 }
  14742.  
  14743.  
  14744.  
  14745.                                                 if(vop==0x38){  // div 22.12.05 22:10
  14746.  
  14747.                                                         vop=8;  //mult
  14748.  
  14749.                                                         if(itok.rm==tk_float)itok.fnumber=1/itok.fnumber;
  14750.  
  14751.                                                         else itok.dnumber=1/itok.dnumber;
  14752.  
  14753.                                                 }
  14754.  
  14755.  
  14756.  
  14757.                                                 op66(r32);
  14758.  
  14759.                                                 op(0xD9+addop);
  14760.  
  14761.                                                 op((am32==FALSE?0x06:0x05));    //fld
  14762.  
  14763.                                                 AddFloatConst(itok.lnumber,rettype);
  14764.  
  14765.                                                 outword(0);
  14766.  
  14767.                                                 if(am32)outword(0);
  14768.  
  14769.                                                 CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  14770.  
  14771.                                                 outseg(&wtok,2);        //fsubr var
  14772.  
  14773.                                                 op(0xd8+addop);
  14774.  
  14775.                                                 op(wtok.rm+vop);
  14776.  
  14777.                                                 outaddress(&wtok);
  14778.  
  14779.                                                 if(retrez==tk_floatvar||retrez==tk_doublevar){
  14780.  
  14781.                                                         outseg(&wtok,2);        //fstp var
  14782.  
  14783.                                                         op(0xd9+addop);
  14784.  
  14785.                                                         op(wtok.rm+0x18);
  14786.  
  14787.                                                         outaddress(&wtok);
  14788.  
  14789.                                                         fwait3();
  14790.  
  14791.                                                 }
  14792.  
  14793.                                                 break;
  14794.  
  14795.                                         case tk_longvar:
  14796.  
  14797.                                                 sign=2;
  14798.  
  14799.                                         case tk_floatvar:
  14800.  
  14801.                                                 CheckAllMassiv(bufrm,4,&strinf);
  14802.  
  14803.                                                 outseg(&itok,2);        //fld val or fild val
  14804.  
  14805.                                                 op(0xd9+sign);
  14806.  
  14807.                                                 op(itok.rm);
  14808.  
  14809.                                                 outaddress(&itok);
  14810.  
  14811.                                                 goto endequals1;
  14812.  
  14813.                                         case tk_qwordvar:
  14814.  
  14815.                                                 sign=2;
  14816.  
  14817.                                                 i=0x28;
  14818.  
  14819.                                         case tk_doublevar:
  14820.  
  14821.                                                 CheckAllMassiv(bufrm,8,&strinf);
  14822.  
  14823.                                                 outseg(&itok,2);        //fldq val or fild val
  14824.  
  14825.                                                 op(0xdd+sign);
  14826.  
  14827.                                                 op(itok.rm+i);
  14828.  
  14829.                                                 outaddress(&itok);
  14830.  
  14831.                                                 goto endequals1;
  14832.  
  14833.                                         case tk_dwordvar:
  14834.  
  14835.                                                 CheckInitBP();
  14836.  
  14837.                                                 op66(r32);              //push 0L
  14838.  
  14839.                                                 outword(0x6a);
  14840.  
  14841.                                                 if(ESPloc&&am32&&itok.segm==SS)itok.number+=4;
  14842.  
  14843.                                                 addESP+=4;
  14844.  
  14845.                                                 CheckAllMassiv(bufrm,4,&strinf);
  14846.  
  14847.                                                 op66(r32);              //push var
  14848.  
  14849.                                                 outseg(&itok,2);
  14850.  
  14851.                                                 op(0xFF);
  14852.  
  14853.                                                 op(itok.rm+0x30);
  14854.  
  14855.                                                 outaddress(&itok);
  14856.  
  14857.                                                 if(ESPloc&&am32&&wtok.segm==SS)wtok.number+=4;
  14858.  
  14859.                                                 addESP+=4;
  14860.  
  14861.                                                 fildq_stack();
  14862.  
  14863.                                                 CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  14864.  
  14865.                                                 outseg(&wtok,2);        //fsubr var
  14866.  
  14867.                                                 op(0xd8+addop);
  14868.  
  14869.                                                 op(wtok.rm+vop);
  14870.  
  14871.                                                 outaddress(&wtok);
  14872.  
  14873.                                                 if(optimizespeed||am32==0){
  14874.  
  14875.                                                         outword(0xC483);
  14876.  
  14877.                                                         op(8);
  14878.  
  14879.                                                 }
  14880.  
  14881.                                                 else{
  14882.  
  14883.                                                         op(0x58);       // pop EAX
  14884.  
  14885.                                                         op(0x58);       // pop EAX
  14886.  
  14887.                                                 }
  14888.  
  14889.                                                 addESP-=8;
  14890.  
  14891.                                                 if(retrez==tk_floatvar||retrez==tk_doublevar){
  14892.  
  14893.                                                         outseg(&wtok,2);        //fstp var
  14894.  
  14895.                                                         op(0xd9+addop);
  14896.  
  14897.                                                         op(wtok.rm+0x18);
  14898.  
  14899.                                                         outaddress(&wtok);
  14900.  
  14901.                                                         fwait3();
  14902.  
  14903.                                                 }
  14904.  
  14905.                                                 RestoreBP();
  14906.  
  14907.                                                 break;
  14908.  
  14909.                                         case tk_reg32:  //¤®¡ ¢¨âì ®¡à ¡®âªã ¨­â¥à¯à¨â æ¨¨ float, long
  14910.  
  14911.                                                 CheckInitBP();
  14912.  
  14913.                                                 op66(r32);      //push 0L
  14914.  
  14915.                                                 outword(0x6a);
  14916.  
  14917.                                                 op66(r32);  //push reg32
  14918.  
  14919.                                                 op(0x50+(unsigned int)itok.number);
  14920.  
  14921.                                                 if(ESPloc&&am32&&wtok.segm==SS)wtok.number+=8;
  14922.  
  14923.                                                 addESP+=8;
  14924.  
  14925.                                                 fildq_stack();
  14926.  
  14927.                                                 CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  14928.  
  14929.                                                 outseg(&wtok,2);        //fsubr var
  14930.  
  14931.                                                 op(0xd8+addop);
  14932.  
  14933.                                                 op(wtok.rm+vop);
  14934.  
  14935.                                                 outaddress(&wtok);
  14936.  
  14937.                                                 if(optimizespeed||am32==0){
  14938.  
  14939.                                                         outword(0xC483);
  14940.  
  14941.                                                         op(8);
  14942.  
  14943.                                                 }
  14944.  
  14945.                                                 else{
  14946.  
  14947.                                                         op(0x58);       // pop EAX
  14948.  
  14949.                                                         op(0x58);       // pop EAX
  14950.  
  14951.                                                 }
  14952.  
  14953.                                                 addESP-=8;
  14954.  
  14955.                                                 if(retrez==tk_floatvar||retrez==tk_doublevar){
  14956.  
  14957.                                                         outseg(&wtok,2);        //fstp var
  14958.  
  14959.                                                         op(0xd9+addop);
  14960.  
  14961.                                                         op(wtok.rm+0x18);
  14962.  
  14963.                                                         outaddress(&wtok);
  14964.  
  14965.                                                         fwait3();
  14966.  
  14967.                                                 }
  14968.  
  14969.                                                 RestoreBP();
  14970.  
  14971.                                                 break;
  14972.  
  14973.                                         default:
  14974.  
  14975.                                                 if(doeaxfloatmath(tk_fpust)==tk_assign){
  14976.  
  14977.                                                         CheckInitBP();
  14978.  
  14979.                                                         op66(r32);  //push EAX
  14980.  
  14981.                                                         op(0x50);
  14982.  
  14983.                                                         op(0xD9+addop);
  14984.  
  14985.                                                         fld_stack(4+localsize);
  14986.  
  14987.                                                         fwait3();
  14988.  
  14989.                                                         RestoreBP();
  14990.  
  14991.                                                         op66(r32);
  14992.  
  14993.                                                         op(0x58);
  14994.  
  14995.                                                 }
  14996.  
  14997.                                                 goto endequals;
  14998.  
  14999.                                 }
  15000.  
  15001.                         }
  15002.  
  15003.                         break;
  15004.  
  15005.                 case tk_swap:
  15006.  
  15007.                         int regdi;
  15008.  
  15009.                         regdi=TRUE;
  15010.  
  15011.                         getoperand();
  15012.  
  15013.                         rbuf=bufrm;
  15014.  
  15015.                         bufrm=NULL;
  15016.  
  15017.                         if(am32!=FALSE&&wbuf!=NULL&&wstr.bufstr!=NULL)regdi=FALSE;
  15018.  
  15019.                         switch(tok){
  15020.  
  15021.                                 case tk_reg32:  //¤®¡ ¢¨âì ®¡à ¡®âªã ¨­â¥à¯à¨â æ¨¨ float, long
  15022.  
  15023.                                         CheckInitBP();
  15024.  
  15025.                                         op66(r32);              //push 0L
  15026.  
  15027.                                         outword(0x6a);
  15028.  
  15029.                                         op66(r32);     //push reg32
  15030.  
  15031.                                         op(0x50+(unsigned int)itok.number);
  15032.  
  15033.                                         if(ESPloc&&am32&&wtok.segm==SS)wtok.number+=8;
  15034.  
  15035.                                         addESP+=8;
  15036.  
  15037.                                         fildq_stack();
  15038.  
  15039.                                         CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  15040.  
  15041.                                         outseg(&wtok,2);        //fld val
  15042.  
  15043.                                         op(0xd9+addop);
  15044.  
  15045.                                         op(wtok.rm);
  15046.  
  15047.                                         outaddress(&wtok);
  15048.  
  15049.                                         op(0xdb);
  15050.  
  15051.                                         if(am32){
  15052.  
  15053.                                                 if(optimizespeed)outword(0x241c);       //fistp ssdword[bp-8]/ssdword[esp]
  15054.  
  15055.                                                 else{
  15056.  
  15057.                                                         outword(0x245C);
  15058.  
  15059.                                                         op(4);
  15060.  
  15061.                                                 }
  15062.  
  15063.                                         }
  15064.  
  15065.                                         else{
  15066.  
  15067.                                                 int dob;
  15068.  
  15069.                                                 dob=8;
  15070.  
  15071.                                                 if(!optimizespeed)dob=4;
  15072.  
  15073.                                                 if(short_ok(localsize+dob,FALSE)==0){
  15074.  
  15075.                                                         op(0x9E);
  15076.  
  15077.                                                         outword(-dob-localsize);
  15078.  
  15079.                                                 }
  15080.  
  15081.                                                 else{
  15082.  
  15083.                                                         op(0x5E);
  15084.  
  15085.                                                         op(-dob-localsize);
  15086.  
  15087.                                                 }
  15088.  
  15089.                                         }
  15090.  
  15091.                                         outseg(&wtok,2);//fstp val
  15092.  
  15093.                                         op(0xd9+addop);
  15094.  
  15095.                                         op(wtok.rm+0x18);
  15096.  
  15097.                                         outaddress(&wtok);
  15098.  
  15099.                                         fwait3();
  15100.  
  15101.                                         op66(r32);     // pop reg32
  15102.  
  15103.                                   op(0x58+(unsigned int)itok.number);
  15104.  
  15105.                                         if(!optimizespeed){
  15106.  
  15107.                                                 op66(r32);     // pop reg32
  15108.  
  15109.                                           op(0x58+(unsigned int)itok.number);
  15110.  
  15111.                                         }
  15112.  
  15113.                                         else{
  15114.  
  15115.                                                 outword(0xC483);
  15116.  
  15117.                                                 op(4);
  15118.  
  15119.                                         }
  15120.  
  15121.                                         addESP-=8;
  15122.  
  15123.                                         RestoreBP();
  15124.  
  15125.                                         break;
  15126.  
  15127.                                 case tk_longvar:
  15128.  
  15129.                                         CheckAllMassiv(rbuf,4,&strinf,&itok,regdi==FALSE?idxregs[2]:idxregs[1],idxregs[3]);
  15130.  
  15131.                                         outseg(&itok,2);        //fild
  15132.  
  15133.                                         op(0xDB);
  15134.  
  15135.                                         op(itok.rm);
  15136.  
  15137.                                         outaddress(&itok);
  15138.  
  15139.                                         CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  15140.  
  15141.                                         outseg(&wtok,2);        //fld val
  15142.  
  15143.                                         op(0xd9+addop);
  15144.  
  15145.                                         op(wtok.rm);
  15146.  
  15147.                                         outaddress(&wtok);
  15148.  
  15149.                                         outseg(&itok,2);//fistp var
  15150.  
  15151.                                         op(0xDB);
  15152.  
  15153.                                         op(itok.rm+0x18);
  15154.  
  15155.                                         outaddress(&itok);
  15156.  
  15157.                                         outseg(&wtok,2);        //fstp val
  15158.  
  15159.                                         op(0xd9+addop);
  15160.  
  15161.                                         op(wtok.rm+0x18);
  15162.  
  15163.                                         outaddress(&wtok);
  15164.  
  15165.                                         fwait3();
  15166.  
  15167.                                         break;
  15168.  
  15169.                                 case tk_qwordvar:
  15170.  
  15171.                                         CheckAllMassiv(rbuf,8,&strinf,&itok,regdi==FALSE?idxregs[2]:idxregs[1],idxregs[3]);
  15172.  
  15173.                                         outseg(&itok,2);        //fildq val
  15174.  
  15175.                                         op(0xdd);
  15176.  
  15177.                                         op(itok.rm+0x28);
  15178.  
  15179.                                         outaddress(&itok);
  15180.  
  15181.                                         CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  15182.  
  15183.                                         outseg(&wtok,2);        //fld val
  15184.  
  15185.                                         op(0xd9+addop);
  15186.  
  15187.                                         op(wtok.rm);
  15188.  
  15189.                                         outaddress(&wtok);
  15190.  
  15191.                                         outseg(&itok,2);        //fistp val
  15192.  
  15193.                                         op(0xdf);
  15194.  
  15195.                                         op(itok.rm+0x38);
  15196.  
  15197.                                         outaddress(&itok);
  15198.  
  15199.                                         outseg(&wtok,2);        //fstp val
  15200.  
  15201.                                         op(0xd9+addop);
  15202.  
  15203.                                         op(wtok.rm+0x18);
  15204.  
  15205.                                         outaddress(&wtok);
  15206.  
  15207.                                         fwait3();
  15208.  
  15209.                                         break;
  15210.  
  15211.                                 case tk_dwordvar:
  15212.  
  15213.                                         CheckInitBP();
  15214.  
  15215.                                         op66(r32);      //push 0L
  15216.  
  15217.                                         outword(0x6a);
  15218.  
  15219.                                         if(ESPloc&&am32&&itok.segm==SS)itok.number+=4;
  15220.  
  15221.                                         addESP+=4;
  15222.  
  15223.                                         CheckAllMassiv(rbuf,4,&strinf,&itok,regdi==FALSE?idxregs[2]:idxregs[1],idxregs[3]);
  15224.  
  15225.                                         op66(r32);      //push var
  15226.  
  15227.                                         outseg(&itok,2);
  15228.  
  15229.                                         op(0xFF);
  15230.  
  15231.                                         op(itok.rm+0x30);
  15232.  
  15233.                                         outaddress(&itok);
  15234.  
  15235.                                         if(ESPloc&&am32&&wtok.segm==SS)wtok.number+=4;
  15236.  
  15237.                                         addESP+=4;
  15238.  
  15239.                                         fildq_stack();
  15240.  
  15241.                                         CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  15242.  
  15243.                                         outseg(&wtok,2);        //fld val
  15244.  
  15245.                                         op(0xd9+addop);
  15246.  
  15247.                                         op(wtok.rm);
  15248.  
  15249.                                         outaddress(&wtok);
  15250.  
  15251.                                         if(optimizespeed||am32==FALSE){
  15252.  
  15253.                                                 outword(0xC483);
  15254.  
  15255.                                                 op(8);
  15256.  
  15257.                                         }
  15258.  
  15259.                                         else{
  15260.  
  15261.                                                 op(0x58);       // pop EAX
  15262.  
  15263.                                                 op(0x58);       // pop EAX
  15264.  
  15265.                                         }
  15266.  
  15267.                                         addESP-=8;
  15268.  
  15269.                                         outseg(&itok,2);//fistp var
  15270.  
  15271.                                         op(0xDB);
  15272.  
  15273.                                         op(itok.rm+0x18);
  15274.  
  15275.                                         outaddress(&itok);
  15276.  
  15277.                                         outseg(&wtok,2);        //fstp val
  15278.  
  15279.                                         op(0xd9+addop);
  15280.  
  15281.                                         op(wtok.rm+0x18);
  15282.  
  15283.                                         outaddress(&wtok);
  15284.  
  15285.                                         fwait3();
  15286.  
  15287.                                         RestoreBP();
  15288.  
  15289.                                         break;
  15290.  
  15291.                                 case tk_floatvar:
  15292.  
  15293.                                         if(rettype==tk_double){
  15294.  
  15295.                                                 CheckAllMassiv(rbuf,4,&strinf,&itok,regdi==FALSE?idxregs[2]:idxregs[1],idxregs[3]);
  15296.  
  15297.                                                 outseg(&itok,2);        //fld val
  15298.  
  15299.                                                 op(0xd9);
  15300.  
  15301.                                                 op(itok.rm);
  15302.  
  15303.                                                 outaddress(&itok);
  15304.  
  15305.                                                 CheckAllMassiv(wbuf,8,&wstr,&wtok);
  15306.  
  15307.                                                 outseg(&wtok,2);        //fstp val
  15308.  
  15309.                                                 op(0xdd);
  15310.  
  15311.                                                 op(wtok.rm);
  15312.  
  15313.                                                 outaddress(&wtok);
  15314.  
  15315.                                                 outseg(&itok,2);        //fstp val
  15316.  
  15317.                                                 op(0xd9);
  15318.  
  15319.                                                 op(itok.rm+0x18);
  15320.  
  15321.                                                 outaddress(&itok);
  15322.  
  15323.                                                 outseg(&wtok,2);        //fstp val
  15324.  
  15325.                                                 op(0xdd);
  15326.  
  15327.                                                 op(wtok.rm+0x18);
  15328.  
  15329.                                                 outaddress(&wtok);
  15330.  
  15331.                                                 fwait3();
  15332.  
  15333.                                         }
  15334.  
  15335.                                         else{
  15336.  
  15337.                                                 getinto_e_ax(0,tk_dwordvar,&wtok,wbuf,&wstr,r32);
  15338.  
  15339.                                                 CheckAllMassiv(rbuf,4,&strinf,&itok,regdi==FALSE?idxregs[2]:idxregs[1],idxregs[3]);
  15340.  
  15341.                                                 op66(r32);
  15342.  
  15343.                                                 outseg(&itok,2);// XCHG EAX,[dword]
  15344.  
  15345.                                                 op(0x87); op(itok.rm);
  15346.  
  15347.                                                 outaddress(&itok);
  15348.  
  15349.                                                 goto getfromeax;
  15350.  
  15351.                                         }
  15352.  
  15353.                                         break;
  15354.  
  15355.                                 case tk_doublevar:
  15356.  
  15357.                                         if(rettype==tk_float){
  15358.  
  15359.                                                 CheckAllMassiv(rbuf,4,&strinf,&itok,regdi==FALSE?idxregs[2]:idxregs[1],idxregs[3]);
  15360.  
  15361.                                                 outseg(&itok,2);        //fldq val
  15362.  
  15363.                                                 op(0xdd);
  15364.  
  15365.                                                 op(itok.rm);
  15366.  
  15367.                                                 outaddress(&itok);
  15368.  
  15369.                                                 CheckAllMassiv(wbuf,8,&wstr,&wtok);
  15370.  
  15371.                                                 outseg(&wtok,2);        //fld val
  15372.  
  15373.                                                 op(0xd9);
  15374.  
  15375.                                                 op(wtok.rm);
  15376.  
  15377.                                                 outaddress(&wtok);
  15378.  
  15379.                                                 outseg(&itok,2);        //fstp val
  15380.  
  15381.                                                 op(0xdd);
  15382.  
  15383.                                                 op(itok.rm+0x18);
  15384.  
  15385.                                                 outaddress(&itok);
  15386.  
  15387.                                                 outseg(&wtok,2);        //fstp val
  15388.  
  15389.                                                 op(0xd9);
  15390.  
  15391.                                                 op(wtok.rm+0x18);
  15392.  
  15393.                                                 outaddress(&wtok);
  15394.  
  15395.                                                 fwait3();
  15396.  
  15397.                                         }
  15398.  
  15399.                                         else{
  15400.  
  15401.                                                 getinto_e_ax(0,tk_dwordvar,&wtok,wbuf,&wstr,r32);
  15402.  
  15403.                                                 CheckAllMassiv(rbuf,4,&strinf,&itok,regdi==FALSE?idxregs[2]:idxregs[1],idxregs[3]);
  15404.  
  15405.                                                 op66(r32);
  15406.  
  15407.                                                 outseg(&itok,2);// XCHG EAX,[dword]
  15408.  
  15409.                                                 op(0x87); op(itok.rm);
  15410.  
  15411.                                                 outaddress(&itok);
  15412.  
  15413.                                                 goto getfromeax;
  15414.  
  15415.                                         }
  15416.  
  15417.                                         break;
  15418.  
  15419.                                 case tk_fpust:
  15420.  
  15421.                                         if(itok.number>6)fpustdestroed();
  15422.  
  15423.                                         CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  15424.  
  15425.                                         outseg(&wtok,2);        //fld val
  15426.  
  15427.                                         op(0xd9+addop);
  15428.  
  15429.                                         op(wtok.rm);
  15430.  
  15431.                                         outaddress(&wtok);
  15432.  
  15433.                                         op(0xD9);
  15434.  
  15435.                                         op(0xC8+itok.number+1);
  15436.  
  15437.                                         outseg(&wtok,2);        //fstp val
  15438.  
  15439.                                         op(0xd9+addop);
  15440.  
  15441.                                         op(wtok.rm+0x18);
  15442.  
  15443.                                         outaddress(&wtok);
  15444.  
  15445.                                         break;
  15446.  
  15447.                                 default: swaperror(); break;
  15448.  
  15449.                         }
  15450.  
  15451.                         break;
  15452.  
  15453.                 default: operatorexpected(); break;
  15454.  
  15455.         }
  15456.  
  15457.         if(next)nexttok();
  15458.  
  15459.         if(terminater==tk_semicolon)seminext();
  15460.  
  15461.         if(cpu<3)cpu=3;
  15462.  
  15463.         return retrez;
  15464.  
  15465. }
  15466.  
  15467.  
  15468.  
  15469. void fildq2_stack(int size)
  15470.  
  15471. {
  15472.  
  15473.         op(0xdf);
  15474.  
  15475.         if(am32)outword(0x242c);        //fildq ssdword[bp-8]/ssdword[esp]
  15476.  
  15477.         else{
  15478.  
  15479.                 if(short_ok(size,FALSE)==0){
  15480.  
  15481.                         op(0xAE);
  15482.  
  15483.                         outword(-size);
  15484.  
  15485.                 }
  15486.  
  15487.                 else{
  15488.  
  15489.                         op(0x6E);
  15490.  
  15491.                         op(-size);
  15492.  
  15493.                 }
  15494.  
  15495.         }
  15496.  
  15497. }
  15498.  
  15499.  
  15500.  
  15501. void fildq_stack()
  15502.  
  15503. {
  15504.  
  15505.         fildq2_stack(localsize+8);
  15506.  
  15507. }
  15508.  
  15509.  
  15510.  
  15511. void fistp2_stack(int size)
  15512.  
  15513. {
  15514.  
  15515.         if(am32)outword(0x241c);        //fistp ssdword[ebp+2]/ssdword[esp]
  15516.  
  15517.         else{
  15518.  
  15519.                 if(short_ok(size,FALSE)==0){
  15520.  
  15521.                         op(0x9E);
  15522.  
  15523.                         outword(-size);
  15524.  
  15525.                 }
  15526.  
  15527.                 else{
  15528.  
  15529.                         op(0x5E);
  15530.  
  15531.                         op(-size);
  15532.  
  15533.                 }
  15534.  
  15535.         }
  15536.  
  15537. }
  15538.  
  15539.  
  15540.  
  15541. void fistp_stack(int addop)
  15542.  
  15543. {
  15544.  
  15545.         op(0xDB+addop);
  15546.  
  15547.         fistp2_stack(localsize+4+addop);
  15548.  
  15549. }
  15550.  
  15551.  
  15552.  
  15553. void fld_stack(int size)
  15554.  
  15555. {
  15556.  
  15557.         if(am32)outword(0x2404);        //fld ssdword[ebp+2]/ssdword[esp]
  15558.  
  15559.         else{
  15560.  
  15561.                 if(short_ok(size,FALSE)==0){
  15562.  
  15563.                         op(0x86);
  15564.  
  15565.                         outword(-size);
  15566.  
  15567.                 }
  15568.  
  15569.                 else{
  15570.  
  15571.                         op(0x46);
  15572.  
  15573.                         op(-size);
  15574.  
  15575.                 }
  15576.  
  15577.         }
  15578.  
  15579. }
  15580.  
  15581.  
  15582.  
  15583. void FloatToNumer(int addop)
  15584.  
  15585. //ª®­¢¥àâ æ¨ï float ¢ ç¨á«®
  15586.  
  15587. {
  15588.  
  15589.         CheckInitBP();
  15590.  
  15591.         op(0xD9+addop);
  15592.  
  15593.         fld_stack(4+localsize+addop);
  15594.  
  15595.         fistp_stack();
  15596.  
  15597.         RestoreBP();
  15598.  
  15599.         fwait3();
  15600.  
  15601.         op66(r32);
  15602.  
  15603.         op(0x58);       //pop reg
  15604.  
  15605.         if(cpu<3)cpu=3;
  15606.  
  15607. }
  15608.  
  15609.  
  15610.  
  15611. void Float2reg32(int reg,int addop,int reg1,int reg2)
  15612.  
  15613. {
  15614.  
  15615.         CheckInitBP();
  15616.  
  15617.         op66(r32);
  15618.  
  15619.         op(0x50);  //push AX
  15620.  
  15621.         if(ESPloc&&am32&&itok.segm==SS)itok.number+=4;
  15622.  
  15623.         addESP+=4;
  15624.  
  15625.         CheckAllMassiv(bufrm,4+addop,&strinf,&itok,reg1,reg2);
  15626.  
  15627.         outseg(&itok,2);        //fld floatvar
  15628.  
  15629.         op(0xd9+addop);
  15630.  
  15631.         op(itok.rm);
  15632.  
  15633.         outaddress(&itok);
  15634.  
  15635.         fistp_stack();
  15636.  
  15637.         fwait3();
  15638.  
  15639.         op66(r32);
  15640.  
  15641.         op(0x58+reg);   //pop reg
  15642.  
  15643.         addESP-=4;
  15644.  
  15645.         if(cpu<3)cpu=3;
  15646.  
  15647.         RestoreBP();
  15648.  
  15649. }
  15650.  
  15651.  
  15652.  
  15653. void  byteinstack(int *numstak,int *nums)
  15654.  
  15655. {
  15656.  
  15657.         CheckInitBP();
  15658.  
  15659.         CheckAllMassiv(bufrm,1,&strinf);
  15660.  
  15661.         op66(r16);
  15662.  
  15663.         if(tok==tk_bytevar&&optimizespeed&&chip>3&&chip<7){
  15664.  
  15665.                 outword(0xC031);        //xor ax,ax
  15666.  
  15667.                 outseg(&itok,2);
  15668.  
  15669.                 op(0x8A);
  15670.  
  15671.         }
  15672.  
  15673.         else{
  15674.  
  15675.                 outseg(&itok,3);
  15676.  
  15677.                 op(0xf);
  15678.  
  15679.                 if(tok==tk_bytevar)op(0xb6);
  15680.  
  15681.                 else op(0xbe);
  15682.  
  15683.         }
  15684.  
  15685.         op(itok.rm);
  15686.  
  15687.         outaddress(&itok);
  15688.  
  15689.         op66(r16);
  15690.  
  15691.         outword(0xDF50);        //push ax
  15692.  
  15693.         *numstak+=2;
  15694.  
  15695.         addESP+=2;
  15696.  
  15697.         fld_stack(*nums+*numstak);
  15698.  
  15699. }
  15700.  
  15701.  
  15702.  
  15703. void  reginstack(int *numstak,int *nums)
  15704.  
  15705. {
  15706.  
  15707.         CheckInitBP();
  15708.  
  15709.         op66(tok==tk_reg32?r32:r16);
  15710.  
  15711.         if(tok==tk_beg){
  15712.  
  15713.                 if(optimizespeed&&chip>3&&chip<7&&itok.number!=AL&&itok.number!=AH){
  15714.  
  15715.                         xorAXAX();
  15716.  
  15717.                         op(0x88);
  15718.  
  15719.                         op(0xC0+itok.number*8); //mov al,beg
  15720.  
  15721.                 }
  15722.  
  15723.                 else if(itok.number==AL)xorAHAH();
  15724.  
  15725.                 else{
  15726.  
  15727.                         outword(0xB60F);        /* MOVZX AX,beg */
  15728.  
  15729.                         op(0xC0+itok.number);
  15730.  
  15731.                 }
  15732.  
  15733.                 itok.number=0;
  15734.  
  15735.         }
  15736.  
  15737.         else outword(0x6a);  //push 0
  15738.  
  15739.         op66(tok==tk_reg32?r32:r16);
  15740.  
  15741.         op(0x50+itok.number);   //push AX
  15742.  
  15743.         if(tok==tk_reg){
  15744.  
  15745.                 op(0xDB);
  15746.  
  15747.                 *numstak+=4;
  15748.  
  15749.                 addESP+=4;
  15750.  
  15751.                 fld_stack(*nums+*numstak);
  15752.  
  15753.         }
  15754.  
  15755.         else if(tok==tk_beg){
  15756.  
  15757.                 op(0xdf);
  15758.  
  15759.                 *numstak+=2;
  15760.  
  15761.                 addESP+=2;
  15762.  
  15763.                 fld_stack(*nums+*numstak);
  15764.  
  15765.         }
  15766.  
  15767.         else{
  15768.  
  15769.                 *numstak+=8;
  15770.  
  15771.                 addESP+=8;
  15772.  
  15773.                 fildq2_stack(*nums+*numstak);
  15774.  
  15775.         }
  15776.  
  15777. }
  15778.  
  15779.  
  15780.  
  15781. void wordinstack(int *numstak,int *nums)
  15782.  
  15783. {
  15784.  
  15785.         CheckInitBP();
  15786.  
  15787.         op66(tok==tk_wordvar?r16:r32);
  15788.  
  15789.         outword(0x6a);  //push 0
  15790.  
  15791.         if(ESPloc&&am32&&itok.segm==SS)itok.number+=4;
  15792.  
  15793.         CheckAllMassiv(bufrm,tok==tk_wordvar?2:4,&strinf);
  15794.  
  15795.         op66(tok==tk_wordvar?r16:r32);
  15796.  
  15797.         outseg(&itok,2); //push var
  15798.  
  15799.         op(0xFF);
  15800.  
  15801.         op(itok.rm+0x30);
  15802.  
  15803.         outaddress(&itok);
  15804.  
  15805.         if(tok==tk_wordvar){
  15806.  
  15807.                 op(0xDB);
  15808.  
  15809.                 addESP+=4;
  15810.  
  15811.                 *numstak+=4;
  15812.  
  15813.                 fld_stack(*nums+*numstak);
  15814.  
  15815.         }
  15816.  
  15817.         else{
  15818.  
  15819.                 addESP+=8;
  15820.  
  15821.                 *numstak+=8;
  15822.  
  15823.                 fildq2_stack(*nums+*numstak);
  15824.  
  15825.         }
  15826.  
  15827. }
  15828.  
  15829.  
  15830.  
  15831. void intinstack(int addop)
  15832.  
  15833. {
  15834.  
  15835.         CheckAllMassiv(bufrm,tok==tk_intvar?2:4+addop,&strinf);
  15836.  
  15837.         outseg(&itok,2);        //fild intvar
  15838.  
  15839.         if(tok==tk_intvar||tok==tk_qwordvar)op(0xDF);
  15840.  
  15841.         else if(tok==tk_floatvar||tok==tk_doublevar)op(0xd9+addop);
  15842.  
  15843.         else op(0xDB);
  15844.  
  15845.         op(itok.rm+(tok==tk_qwordvar?0x28:0));
  15846.  
  15847.         outaddress(&itok);
  15848.  
  15849. }
  15850.  
  15851.  
  15852.  
  15853. int doeaxfloatmath(int itreturn,int reg,int addop)
  15854.  
  15855. {
  15856.  
  15857. int vop,negflag=0,next,numstak=0;
  15858.  
  15859. static int nums=0;
  15860.  
  15861. int i=0;
  15862.  
  15863. long long lnumber;
  15864.  
  15865. int ols;
  15866.  
  15867.         ols=localsize;
  15868.  
  15869.         nums+=localsize;
  15870.  
  15871.         next=1;
  15872.  
  15873.         if(tok==tk_minus){
  15874.  
  15875.                 if(CheckMinusNum()==FALSE){
  15876.  
  15877.                         negflag=1;
  15878.  
  15879.                         getoperand(am32==TRUE?EAX:BX);
  15880.  
  15881.                 }
  15882.  
  15883.         }
  15884.  
  15885.         if(tok==tk_number){
  15886.  
  15887. //              printf("rm=%d %e %e %08X\n",itok.rm,itok.fnumber,itok.dnumber,itok.number);
  15888.  
  15889.                 if(addop==0/*itok.rm==tk_float*/){
  15890.  
  15891.                         itok.number=doconstfloatmath();
  15892.  
  15893.                         itok.rm=tk_float;
  15894.  
  15895.                 }
  15896.  
  15897.                 else{
  15898.  
  15899.                         itok.lnumber=doconstdoublemath();
  15900.  
  15901.                         itok.rm=tk_double;
  15902.  
  15903.                 }
  15904.  
  15905.                 next=0;
  15906.  
  15907.                 if(itok.type==tp_stopper){
  15908.  
  15909. //                      if(itok.rm==tk_float&&addop==4)itok.dnumber=itok.fnumber;
  15910.  
  15911. //                      if(itok.rm==tk_double&&addop==0)itok.fnumber=itok.dnumber;
  15912.  
  15913.                         if(itreturn==tk_stackstart){
  15914.  
  15915.                                 if(itok.rm==tk_double){
  15916.  
  15917.                                         lnumber=itok.lnumber;
  15918.  
  15919.                                         itok.lnumber=lnumber>>32;
  15920.  
  15921.                                 }
  15922.  
  15923.                                 for(i=0;i<2;i++){
  15924.  
  15925.                                         op66(r32);
  15926.  
  15927.                                         if(short_ok(itok.number,TRUE)){ //PUSH number
  15928.  
  15929.                                                 op(0x6A);
  15930.  
  15931.                                                 op(itok.number);
  15932.  
  15933.                                         }
  15934.  
  15935.                                         else{
  15936.  
  15937.                                                 op(0x68);
  15938.  
  15939.                                                 outdword(itok.number);
  15940.  
  15941.                                         }
  15942.  
  15943.                                         if(itok.rm!=tk_double)break;
  15944.  
  15945.                                         if(i==1)break;
  15946.  
  15947.                                         itok.number=lnumber;
  15948.  
  15949.                                 }
  15950.  
  15951.                                 return itreturn;
  15952.  
  15953.                         }
  15954.  
  15955.                         if(itreturn==tk_reg32){
  15956.  
  15957.                                 MovRegNum(r32,0,itok.number,reg);
  15958.  
  15959.                                 return itreturn;
  15960.  
  15961.                         }
  15962.  
  15963.                         if(itreturn==tk_reg64){
  15964.  
  15965.                                 MovRegNum(r32,0,itok.number,reg&255);
  15966.  
  15967.                                 MovRegNum(r32,0,itok.lnumber>>=32,reg/256);
  15968.  
  15969.                                 return itreturn;
  15970.  
  15971.                         }
  15972.  
  15973.                 }
  15974.  
  15975.         }
  15976.  
  15977.         if(itreturn==tk_stackstart&&(!am32)){
  15978.  
  15979.                 op66(r32);
  15980.  
  15981.                 op(0x50);       //push eax
  15982.  
  15983.                 if(addop){
  15984.  
  15985.                         op66(r32);
  15986.  
  15987.                         op(0x50);       //push eax
  15988.  
  15989.                 }
  15990.  
  15991.                 op(0x55);       //push bp
  15992.  
  15993.                 outword(0xe589);//mov bp,sp
  15994.  
  15995.                 if(initBP>1)initBP++;
  15996.  
  15997.                 localsize=-6-addop;
  15998.  
  15999.         }
  16000.  
  16001.         if(next==0)goto casenumber;
  16002.  
  16003.         switch(tok){
  16004.  
  16005.                 case tk_number:
  16006.  
  16007. casenumber:
  16008.  
  16009. //              printf("rm=%d %e %e %08X\n",itok.rm,itok.fnumber,itok.dnumber,itok.number);
  16010.  
  16011.                         if((itok.rm==tk_float&&itok.fnumber==1.0)||
  16012.  
  16013.                                         (itok.rm==tk_double&&itok.dnumber==1.0)||
  16014.  
  16015.                                         (itok.rm!=tk_float&&itok.rm!=tk_double&&itok.lnumber==1)){
  16016.  
  16017.                                 outword(0xE8D9);        //FLD1
  16018.  
  16019.                                 break;
  16020.  
  16021.                         }
  16022.  
  16023.                         if((itok.rm==tk_float&&itok.fnumber==0.0)||
  16024.  
  16025.                                         (itok.rm==tk_double&&itok.dnumber==0.0)||itok.lnumber==0){
  16026.  
  16027.                                 outword(0xEED9);        //FLDZ
  16028.  
  16029.                                 break;
  16030.  
  16031.                         }
  16032.  
  16033.                         op(0xD9+(itok.rm==tk_float?0:4));
  16034.  
  16035.                         op((am32==FALSE?0x06:0x05));    //fld
  16036.  
  16037.                         AddFloatConst(itok.lnumber,itok.rm);
  16038.  
  16039.                         outword(0);
  16040.  
  16041.                         if(am32)outword(0);
  16042.  
  16043.                         break;
  16044.  
  16045.                 case tk_at:
  16046.  
  16047.                         getoperand(am32==TRUE?EAX:BX);
  16048.  
  16049.                         macros(tk_fpust);
  16050.  
  16051.                         break;
  16052.  
  16053.                 case tk_ID:
  16054.  
  16055.                 case tk_id:
  16056.  
  16057.                 case tk_proc:
  16058.  
  16059.                 case tk_apiproc:
  16060.  
  16061.                 case tk_declare:
  16062.  
  16063.                 case tk_undefproc:
  16064.  
  16065. int onums;
  16066.  
  16067.                         onums=nums;
  16068.  
  16069.                         nums=-(int)localsize;
  16070.  
  16071.                         vop=procdo(tk_fpust);   //¢®§¢à ¨§ ¯à®æ¥¤ãà
  16072.  
  16073.                         nums=onums;
  16074.  
  16075.                         if(tok2==tk_semicolon&&vop!=tk_fpust&&vop!=tk_double){
  16076.  
  16077.                                 nexttok();
  16078.  
  16079.                                 return tk_assign;
  16080.  
  16081.                         }
  16082.  
  16083.                         break;
  16084.  
  16085.                 case tk_qwordvar:
  16086.  
  16087.                 case tk_doublevar:
  16088.  
  16089.                         i=4;
  16090.  
  16091.                 case tk_floatvar:
  16092.  
  16093.                 case tk_longvar:
  16094.  
  16095.                 case tk_intvar:
  16096.  
  16097.                         intinstack(i);
  16098.  
  16099.                         break;
  16100.  
  16101.                 case tk_dwordvar:
  16102.  
  16103.                 case tk_wordvar:
  16104.  
  16105.                         wordinstack(&numstak,&nums);
  16106.  
  16107.                         break;
  16108.  
  16109.                 case tk_charvar:
  16110.  
  16111.                 case tk_bytevar:
  16112.  
  16113.                         byteinstack(&numstak,&nums);
  16114.  
  16115.                         break;
  16116.  
  16117.                 case tk_beg:
  16118.  
  16119.                 case tk_reg32:
  16120.  
  16121.                 case tk_reg:
  16122.  
  16123.                         reginstack(&numstak,&nums);
  16124.  
  16125.                         break;
  16126.  
  16127.                 case tk_fpust:
  16128.  
  16129.                         if(itok.number){
  16130.  
  16131.                                 op(0xD9);
  16132.  
  16133.                                 op(0xC8+itok.number);
  16134.  
  16135.                         }
  16136.  
  16137.                         break;
  16138.  
  16139.                 default: valueexpected();       break;
  16140.  
  16141.         }
  16142.  
  16143.         if(negflag){
  16144.  
  16145.                 outword(0xe0d9);        //fchs
  16146.  
  16147.                 negflag=0;
  16148.  
  16149.         }
  16150.  
  16151.         if(next==1)nexttok();
  16152.  
  16153.         while(itok.type!=tp_stopper&&tok!=tk_eof&&itok.type!=tp_compare){
  16154.  
  16155.                 next=1;
  16156.  
  16157.                 vop=0;
  16158.  
  16159.                 i=0;
  16160.  
  16161.                 switch(tok){
  16162.  
  16163.                         case tk_multminus: negflag=1; goto mult;
  16164.  
  16165.                         case tk_divminus: negflag=1;
  16166.  
  16167.                         case tk_div: vop+=0x10;
  16168.  
  16169.                         case tk_minus: vop+=0x20;
  16170.  
  16171. mult:
  16172.  
  16173.                         case tk_mult: vop+=8;
  16174.  
  16175.                         case tk_plus:
  16176.  
  16177.                                 getoperand();
  16178.  
  16179.                                 switch(tok){
  16180.  
  16181.                                         case tk_number:
  16182.  
  16183.                                                 if(itok.rm!=tk_float&&itok.rm!=tk_double){
  16184.  
  16185.                                                         itok.dnumber=itok.lnumber;
  16186.  
  16187.                                                         itok.rm=tk_double;
  16188.  
  16189.                                                 }
  16190.  
  16191.                                                 if((itok.rm==tk_float&&itok.fnumber==1.0)||
  16192.  
  16193.                                                                 (itok.rm==tk_double&&itok.dnumber==1.0)){
  16194.  
  16195. num1:
  16196.  
  16197.                                                         if(vop==0||vop==0x28){  // + -
  16198.  
  16199.                                                                 outword(0xE8D9);        //FLD1
  16200.  
  16201.                                                                 op(0xDE);
  16202.  
  16203.                                                                 op(0xC1+vop);
  16204.  
  16205.                                                         }
  16206.  
  16207.                                                         break;
  16208.  
  16209.                                                 }
  16210.  
  16211.                                                 op(0xd8+(itok.rm==tk_float?0:4));
  16212.  
  16213.  
  16214.  
  16215.                                                 if(vop==0x38){  // div 22.12.05 22:10
  16216.  
  16217.                                                         vop=8;  //mult
  16218.  
  16219.                                                         if(itok.rm==tk_float)itok.fnumber=1/itok.fnumber;
  16220.  
  16221.                                                         else itok.dnumber=1/itok.dnumber;
  16222.  
  16223.                                                 }
  16224.  
  16225.                                                 if(/*vop==0x38||*/vop==0x28)vop-=8;
  16226.  
  16227.  
  16228.  
  16229.                                                 op((am32==FALSE?0x06:0x05)+vop);
  16230.  
  16231.                                                 AddFloatConst(itok.lnumber,itok.rm);
  16232.  
  16233.                                                 outword(0);
  16234.  
  16235.                                                 if(am32)outword(0);
  16236.  
  16237.                                                 break;
  16238.  
  16239.                                         case tk_doublevar:
  16240.  
  16241.                                                 i=4;
  16242.  
  16243.                                         case tk_floatvar:
  16244.  
  16245.                                                 if(vop==0x38||vop==0x28)vop-=8;
  16246.  
  16247.                                                 CheckAllMassiv(bufrm,4+i,&strinf);
  16248.  
  16249.                                                 outseg(&itok,2);        //fsubr var
  16250.  
  16251.                                                 op(0xd8+i);
  16252.  
  16253.                                                 op(itok.rm+vop);
  16254.  
  16255.                                                 outaddress(&itok);
  16256.  
  16257.                                                 break;
  16258.  
  16259.                                         case tk_longvar:
  16260.  
  16261.                                         case tk_intvar:
  16262.  
  16263.                                                 CheckAllMassiv(bufrm,4,&strinf);
  16264.  
  16265.                                                 outseg(&itok,2);        //fsubr var
  16266.  
  16267.                                                 op(tok==tk_intvar?0xDE:0xDA);
  16268.  
  16269.                                                 if(vop==0x38||vop==0x28)vop-=8;
  16270.  
  16271.                                                 op(itok.rm+vop);
  16272.  
  16273.                                                 outaddress(&itok);
  16274.  
  16275.                                                 break;
  16276.  
  16277.                                         case tk_qwordvar:
  16278.  
  16279.                                                 intinstack(4);
  16280.  
  16281.                                                 op(0xde);
  16282.  
  16283.                                                 op(0xC1+vop);//fsubpr st1
  16284.  
  16285.                                                 break;
  16286.  
  16287.                                         case tk_dwordvar:
  16288.  
  16289.                                         case tk_wordvar:
  16290.  
  16291.                                                 wordinstack(&numstak,&nums);
  16292.  
  16293.                                                 op(0xde);
  16294.  
  16295.                                                 op(0xC1+vop);//fsubpr st1
  16296.  
  16297.                                                 break;
  16298.  
  16299.                                         case tk_beg:
  16300.  
  16301.                                         case tk_reg32:
  16302.  
  16303.                                         case tk_reg:
  16304.  
  16305.                                                 reginstack(&numstak,&nums);
  16306.  
  16307.                                                 op(0xde);
  16308.  
  16309.                                                 op(0xC1+vop);//fsubpr st1
  16310.  
  16311.                                                 break;
  16312.  
  16313.                                         case tk_charvar:
  16314.  
  16315.                                         case tk_bytevar:
  16316.  
  16317.                                                 byteinstack(&numstak,&nums);
  16318.  
  16319.                                                 op(0xde);
  16320.  
  16321.                                                 op(0xC1+vop);//fsubpr st1
  16322.  
  16323.                                                 break;
  16324.  
  16325.                                         case tk_fpust:
  16326.  
  16327.                                                 if(vop==0x38||vop==0x28)vop-=8;
  16328.  
  16329.                                                 op(0xd8);
  16330.  
  16331.                                                 op(0xC0+vop+itok.number);//fsubpr st
  16332.  
  16333.                                                 break;
  16334.  
  16335.                                         default: valueexpected(); break;
  16336.  
  16337.                                 }
  16338.  
  16339.                                 break;
  16340.  
  16341.                         default: illegalfloat(); break;
  16342.  
  16343.                 }
  16344.  
  16345.                 if(negflag){
  16346.  
  16347.                         outword(0xe0d9);        //fchs
  16348.  
  16349.                         negflag=0;
  16350.  
  16351.                 }
  16352.  
  16353.                 if(next)nexttok();
  16354.  
  16355.         }
  16356.  
  16357.         if(tok==tk_eof)unexpectedeof();
  16358.  
  16359.         if(itreturn==tk_stackstart){
  16360.  
  16361.                 if(!am32){
  16362.  
  16363.                         op(0xD9+addop);
  16364.  
  16365.                         outword(0x025e);        //fstp ssdword[bp+2]
  16366.  
  16367.                         numstak-=2;
  16368.  
  16369.                 }
  16370.  
  16371.                 else{
  16372.  
  16373.                         if(numstak<4){
  16374.  
  16375.                                 op66(r32);
  16376.  
  16377.                                 op(0x50);       //push eax
  16378.  
  16379.                                 addESP+=4;
  16380.  
  16381.                         }
  16382.  
  16383.                         else numstak-=4;
  16384.  
  16385.                         if(addop){
  16386.  
  16387.                                 if(numstak<4){
  16388.  
  16389.                                         op66(r32);
  16390.  
  16391.                                         op(0x50);       //push eax
  16392.  
  16393.                                         addESP+=4;
  16394.  
  16395.                                 }
  16396.  
  16397.                                 else numstak-=4;
  16398.  
  16399.                         }
  16400.  
  16401.                         op(0xD9+addop);
  16402.  
  16403.                         if(numstak==0)outword(0x241C);  //fstp ssdword[esp]
  16404.  
  16405.                         else{
  16406.  
  16407.                                 outword(0x245C);        //fstp ssdword[esp+numstak]
  16408.  
  16409.                                 op(numstak);
  16410.  
  16411.                         }
  16412.  
  16413.                 }
  16414.  
  16415.                 fwait3();
  16416.  
  16417.         }
  16418.  
  16419.         else if(itreturn==tk_reg32||itreturn==tk_reg64){
  16420.  
  16421.                 i=4;
  16422.  
  16423.                 if(itreturn==tk_reg64)i=8;
  16424.  
  16425.                 if(numstak<i){
  16426.  
  16427.                         op66(r32);
  16428.  
  16429.                         op(0x50);       //push eax
  16430.  
  16431.                         if(itreturn==tk_reg64){
  16432.  
  16433.                                 op66(r32);
  16434.  
  16435.                                 op(0x50);       //push eax
  16436.  
  16437.                         }
  16438.  
  16439.                         numstak+=i;
  16440.  
  16441.                         addESP+=i;
  16442.  
  16443.                 }
  16444.  
  16445.                 op(itreturn==tk_reg32?0xDB:0xDF);
  16446.  
  16447. //              op(itreturn==tk_reg32?0xD9:0xDB);
  16448.  
  16449.                 fistp2_stack(localsize+numstak);
  16450.  
  16451.                 fwait3();
  16452.  
  16453.                 if(itreturn==tk_reg64){
  16454.  
  16455.                         op66(r32);
  16456.  
  16457.                         op(0x58);       //pop EAX
  16458.  
  16459.                         op66(r32);
  16460.  
  16461.                         op(0x58+EDX);   //pop EDX
  16462.  
  16463.                 }
  16464.  
  16465.                 else{
  16466.  
  16467.                         op66(r32);
  16468.  
  16469.                         op(0x58+reg);   //pop reg
  16470.  
  16471.                 }
  16472.  
  16473.                 numstak-=i;
  16474.  
  16475.                 addESP-=i;
  16476.  
  16477.         }
  16478.  
  16479.         if(localsize!=(unsigned int)ols){
  16480.  
  16481.                 localsize=ols;
  16482.  
  16483.                 Leave();
  16484.  
  16485.                 initBP--;
  16486.  
  16487.         }
  16488.  
  16489.         else if(numstak){
  16490.  
  16491.                 if(numstak<128){
  16492.  
  16493.                         outword(0xC483);
  16494.  
  16495.                         op(numstak);
  16496.  
  16497.                 }
  16498.  
  16499.                 else{
  16500.  
  16501.                         outword(0xC481);
  16502.  
  16503.                         outword(numstak);
  16504.  
  16505.                 }
  16506.  
  16507.                 addESP-=numstak;
  16508.  
  16509.         }
  16510.  
  16511.         RestoreBP();
  16512.  
  16513.         nums-=localsize;
  16514.  
  16515.         return itreturn;
  16516.  
  16517. }
  16518.  
  16519.  
  16520.  
  16521. void float2stack(int num)
  16522.  
  16523. {
  16524.  
  16525.         outword(0xC0DD);
  16526.  
  16527.         if(tok!=tk_fpust)outword(0xf7d9);       //fincstp
  16528.  
  16529. //      if(num>6)fpustdestroed();
  16530.  
  16531. //      outword(0xf6d9);        //fdecstp
  16532.  
  16533.         doeaxfloatmath(tk_fpust);
  16534.  
  16535.         if(num){
  16536.  
  16537.                 op(0xD9);
  16538.  
  16539.                 op(0xC8+num);
  16540.  
  16541.         }
  16542.  
  16543. }
  16544.  
  16545.  
  16546.  
  16547. void dofloatstack(int num)
  16548.  
  16549. {
  16550.  
  16551. int vop=0;
  16552.  
  16553.         nexttok();
  16554.  
  16555.         switch(tok){
  16556.  
  16557.                 case tk_assign: //=
  16558.  
  16559.                         getoperand(am32==TRUE?EAX:BX);
  16560.  
  16561.                         float2stack(num);
  16562.  
  16563.                         break;
  16564.  
  16565.                 case tk_divequals: vop+=0x10;
  16566.  
  16567.                 case tk_minusequals: vop+=0x20;
  16568.  
  16569.                 case tk_multequals: vop+=8;
  16570.  
  16571.                 case tk_plusequals:
  16572.  
  16573.                         getoperand(am32==TRUE?EAX:BX);
  16574.  
  16575.                         float2stack(0);
  16576.  
  16577. //                      doeaxfloatmath(tk_fpust);
  16578.  
  16579.                         op(0xdc);
  16580.  
  16581.                         op(0xC0+vop+num);//fsubpr st
  16582.  
  16583.                         break;
  16584.  
  16585.                 case tk_swap:
  16586.  
  16587.                         getoperand(am32==TRUE?EAX:BX);
  16588.  
  16589.                         switch(tok){
  16590.  
  16591.                                 case tk_fpust:
  16592.  
  16593.                                         op(0xD9);
  16594.  
  16595.                                         op(0xC8+num);
  16596.  
  16597.                                         op(0xD9);
  16598.  
  16599.                                         op(0xC8+itok.number);
  16600.  
  16601.                                         op(0xD9);
  16602.  
  16603.                                         op(0xC8+num);
  16604.  
  16605.                                         break;
  16606.  
  16607.                                 case tk_doublevar:
  16608.  
  16609.                                         vop=4;
  16610.  
  16611.                                 case tk_floatvar:
  16612.  
  16613.                                         CheckAllMassiv(bufrm,4,&strinf);
  16614.  
  16615.                                         outseg(&itok,2);        //fld val
  16616.  
  16617.                                         op(0xd9+vop);
  16618.  
  16619.                                         op(itok.rm);
  16620.  
  16621.                                         outaddress(&itok);
  16622.  
  16623.                                         op(0xD9);
  16624.  
  16625.                                         op(0xC8+num+1);
  16626.  
  16627.                                         outseg(&itok,2);        //fstp val
  16628.  
  16629.                                         op(0xd9+vop);
  16630.  
  16631.                                         op(itok.rm+0x18);
  16632.  
  16633.                                         outaddress(&itok);
  16634.  
  16635.                                         break;
  16636.  
  16637.                                 default:
  16638.  
  16639.                                         swaperror();
  16640.  
  16641.                                         break;
  16642.  
  16643.                         }
  16644.  
  16645.                         nexttok();
  16646.  
  16647.                         break;
  16648.  
  16649.                 default:
  16650.  
  16651.                         illegalfloat(); break;
  16652.  
  16653.         }
  16654.  
  16655. }
  16656.  
  16657.  
  16658.  
  16659. void RestoreBP()
  16660.  
  16661. {
  16662.  
  16663.         if(am32==0&&initBP==2){
  16664.  
  16665.                 Leave();
  16666.  
  16667.                 initBP=0;
  16668.  
  16669.         }
  16670.  
  16671. }
  16672.  
  16673.  
  16674.  
  16675. void CheckInitBP()
  16676.  
  16677. {
  16678.  
  16679.         if(am32==0&&initBP==0){
  16680.  
  16681.                 op(0x55);       //push bp
  16682.  
  16683.                 outword(0xe589);//mov bp,sp
  16684.  
  16685.                 initBP=2;
  16686.  
  16687.         }
  16688.  
  16689. }
  16690.  
  16691.  
  16692.  
  16693. void AddReloc(int segm)
  16694.  
  16695. {
  16696.  
  16697.         if(FixUp!=FALSE){
  16698.  
  16699.                 CheckPosts();
  16700.  
  16701.                 if(segm==DS){
  16702.  
  16703.                         (postbuf+posts)->type=(unsigned short)(am32==FALSE?FIX_VAR:FIX_VAR32);
  16704.  
  16705.                         (postbuf+posts)->loc=outptrdata;
  16706.  
  16707.                 }
  16708.  
  16709.                 else{
  16710.  
  16711.                         (postbuf+posts)->type=(unsigned short)(am32==FALSE?FIX_CODE:FIX_CODE32);
  16712.  
  16713.                         (postbuf+posts)->loc=outptr;
  16714.  
  16715.                 }
  16716.  
  16717.                 posts++;
  16718.  
  16719.         }
  16720.  
  16721.         postnumflag&=(~f_reloc);
  16722.  
  16723. }
  16724.  
  16725.  
  16726.  
  16727. void fwait3()
  16728.  
  16729. {
  16730.  
  16731.         if(chip<4&&tok2!=tk_floatvar&&tok2!=tk_doublevar&&tok2!=tk_float&&tok2!=tk_double)op(0x9B);
  16732.  
  16733. }
  16734.  
  16735.  
  16736.  
  16737. void AddFloatConst(long long fnumber,int type)
  16738.  
  16739. {
  16740.  
  16741. unsigned int i;
  16742.  
  16743. unsigned int ofs;
  16744.  
  16745.         for(i=0;i<numfloatconst;i++){
  16746.  
  16747.                 if(type==(floatnum+i)->type){
  16748.  
  16749.                         ofs=(floatnum+i)->ofs;
  16750.  
  16751.                         if(type==tk_float){
  16752.  
  16753.                                 if(*(long *)&fnumber==(floatnum+i)->num[0])goto endp;
  16754.  
  16755.                         }
  16756.  
  16757.                         else if(*(double *)&fnumber==(floatnum+i)->dnum)goto endp;
  16758.  
  16759.                 }
  16760.  
  16761.         }
  16762.  
  16763.         if(numfloatconst==0){
  16764.  
  16765.                 floatnum=(LISTFLOAT *)MALLOC(sizeof(LISTFLOAT)*STEPFLOATCONST);
  16766.  
  16767.                 maxnumfloatconst=STEPFLOATCONST;
  16768.  
  16769. //              memset(floatnum,0,sizeof(LISTFLOAT)*STEPFLOATCONST);
  16770.  
  16771.         }
  16772.  
  16773.         else if((numfloatconst+1)==maxnumfloatconst){
  16774.  
  16775.                 floatnum=(LISTFLOAT *)REALLOC(floatnum,(maxnumfloatconst+STEPFLOATCONST)*sizeof(LISTFLOAT));
  16776.  
  16777.                 maxnumfloatconst+=STEPFLOATCONST;
  16778.  
  16779.         }
  16780.  
  16781.         numfloatconst++;
  16782.  
  16783.         (floatnum+i)->type=type;
  16784.  
  16785.         ofs=(floatnum+i)->ofs=ofsfloatlist;
  16786.  
  16787.         if(type==tk_float)(floatnum+i)->num[0]=*(unsigned long *)&fnumber;
  16788.  
  16789.         else (floatnum+i)->dnum=*(double *)&fnumber;
  16790.  
  16791.         ofsfloatlist+=(type==tk_float?4:8);
  16792.  
  16793. endp:
  16794.  
  16795.         CheckPosts();
  16796.  
  16797.         (postbuf+posts)->type=POST_FLOATNUM;
  16798.  
  16799.         (postbuf+posts)->loc=outptrdata;
  16800.  
  16801.         (postbuf+posts)->num=ofs;
  16802.  
  16803.         posts++;
  16804.  
  16805. }
  16806.  
  16807.  
  16808.  
  16809. void setwordext(long *id)
  16810.  
  16811. {
  16812.  
  16813.         CheckPosts();
  16814.  
  16815.         (postbuf+posts)->type=EXT_VAR;
  16816.  
  16817.         (postbuf+posts)->loc=outptr;
  16818.  
  16819.         (postbuf+posts)->num=*id&0xFFFF;        //id ­®¬¥à ¢­¥è­¥© ¯¥à¥¬¥­­®©
  16820.  
  16821.         *id>>=16;       //¥¥ §­ ç¥­¨¥
  16822.  
  16823.         posts++;
  16824.  
  16825. }
  16826.  
  16827.  
  16828.  
  16829. void setwordpost(ITOK *stok)                                            /* for post word num setting */
  16830.  
  16831. {
  16832.  
  16833.         CheckPosts();
  16834.  
  16835.         if(stok->post==USED_DIN_VAR){
  16836.  
  16837.                 (postbuf+posts)->type=(unsigned short)(am32==0?DIN_VAR:DIN_VAR32);
  16838.  
  16839. //                      printf("Add tok=%d %s\n",stok->rec->rectok,stok->rec->recid);
  16840.  
  16841. //              printf("rec=%08X\n",stok->rec);
  16842.  
  16843.                 if(stok->rec->rectok==tk_structvar&&stok->rec->recsib==tp_gvar){
  16844.  
  16845.                         (postbuf+posts)->num=(int)stok->rec;//02.09.05 17:11 ->right;
  16846.  
  16847.                 }
  16848.  
  16849.                 else (postbuf+posts)->num=(int)stok->rec;
  16850.  
  16851.         }
  16852.  
  16853.         else if(stok->post>=CODE_SIZE&&stok->post<=STACK_SIZE32)(postbuf+posts)->type=stok->post;
  16854.  
  16855.         else (postbuf+posts)->type=(unsigned short)(am32==FALSE?POST_VAR:POST_VAR32);
  16856.  
  16857.         (postbuf+posts)->loc=outptr;
  16858.  
  16859.         posts++;
  16860.  
  16861. }
  16862.  
  16863.  
  16864.  
  16865. void MovRegNum(int razr,int relocf,unsigned long number,int reg)
  16866.  
  16867. {
  16868.  
  16869. unsigned long num;
  16870.  
  16871. int nreg;
  16872.  
  16873.         op66(razr);
  16874.  
  16875.         if(relocf==0){
  16876.  
  16877.                 if(number!=0&&GetRegNumber(reg,&num,razr)==reg){
  16878.  
  16879.                         ConstToReg(number,reg,razr);
  16880.  
  16881.                         if(num==number)return;
  16882.  
  16883.                         else if(num<number){
  16884.  
  16885.                                 num=number-num;
  16886.  
  16887.                                 if(num==1){
  16888.  
  16889.                                         op(0x40+reg);   //inc reg
  16890.  
  16891.                                         return;
  16892.  
  16893.                                 }
  16894.  
  16895.                                 if(num==2){
  16896.  
  16897.                                         op(0x40+reg);   //inc reg
  16898.  
  16899.                                         op66(razr);
  16900.  
  16901.                                         op(0x40+reg);   //inc reg
  16902.  
  16903.                                         return;
  16904.  
  16905.                                 }
  16906.  
  16907.                                 if(razr==r32&&short_ok(num,TRUE)){
  16908.  
  16909.                                         op(0x83);
  16910.  
  16911.                                         op(0xC0+reg);
  16912.  
  16913.                                         op(num);
  16914.  
  16915.                                         return;
  16916.  
  16917.                                 }
  16918.  
  16919.                         }
  16920.  
  16921.                         else{
  16922.  
  16923.                                 num=num-number;
  16924.  
  16925.                                 if(num==1){
  16926.  
  16927.                                         op(0x48+reg);   //dec reg
  16928.  
  16929.                                         return;
  16930.  
  16931.                                 }
  16932.  
  16933.                                 if(num==2){
  16934.  
  16935.                                         op(0x48+reg);   //dec reg
  16936.  
  16937.                                         op66(razr);
  16938.  
  16939.                                         op(0x48+reg);   //dec reg
  16940.  
  16941.                                         return;
  16942.  
  16943.                                 }
  16944.  
  16945.                                 if(razr==r32&&short_ok(num,TRUE)){
  16946.  
  16947.                                         op(0x83);
  16948.  
  16949.                                         op(0xE8+reg);
  16950.  
  16951.                                         op(num);
  16952.  
  16953.                                         return;
  16954.  
  16955.                                 }
  16956.  
  16957.                         }
  16958.  
  16959.                 }
  16960.  
  16961.                 if((nreg=GetNumberR(reg,&num,razr,number))!=NOINREG){
  16962.  
  16963.                         ConstToReg(number,reg,razr);
  16964.  
  16965.                         if(num==number){
  16966.  
  16967.                                 op(0x89);
  16968.  
  16969.                                 op(128+64+nreg*8+reg);
  16970.  
  16971.                                 return;
  16972.  
  16973.                         }
  16974.  
  16975.                         else if((number-num)==1){
  16976.  
  16977.                                 op(0x89);
  16978.  
  16979.                                 op(128+64+nreg*8+reg);
  16980.  
  16981.                                 op66(razr);
  16982.  
  16983.                                 op(0x40+reg);   //inc reg
  16984.  
  16985.                                 return;
  16986.  
  16987.                         }
  16988.  
  16989.                         else{
  16990.  
  16991.                                 if((num-number)==1){
  16992.  
  16993.                                         op(0x89);
  16994.  
  16995.                                         op(128+64+nreg*8+reg);
  16996.  
  16997.                                         op66(razr);
  16998.  
  16999.                                         op(0x48+reg);   //dec reg
  17000.  
  17001.                                         return;
  17002.  
  17003.                                 }
  17004.  
  17005.                         }
  17006.  
  17007.                 }
  17008.  
  17009.                 ConstToReg(number,reg,razr);
  17010.  
  17011.                 if(number==0){
  17012.  
  17013.                         op(0x31); op(0xC0+reg*9);
  17014.  
  17015.                 }  // XOR reg,reg
  17016.  
  17017.                 else if((long)number==-1&&razr==r32){
  17018.  
  17019.                         op(0x83);       //or reg,-1
  17020.  
  17021.                         op(0xC8+reg);
  17022.  
  17023.                         op(0xFF);
  17024.  
  17025.                 }
  17026.  
  17027.                 else if(number==1&&razr==r32){
  17028.  
  17029.                         op(0x31); op(0xC0+reg*9);       //xor reg,reg
  17030.  
  17031.                         op66(razr);
  17032.  
  17033.                         op(0x40+reg);   //inc reg
  17034.  
  17035.                 }
  17036.  
  17037.                 else if(regoverstack&&razr==r32&&short_ok(number,TRUE)){
  17038.  
  17039.                         op(0x6A);
  17040.  
  17041.                         op(number);     //push short number
  17042.  
  17043.                         op66(razr);
  17044.  
  17045.                   op(0x58+reg);
  17046.  
  17047.                 }
  17048.  
  17049.                 else goto stdmov;
  17050.  
  17051.         }
  17052.  
  17053.         else{
  17054.  
  17055. stdmov:
  17056.  
  17057.                 op(0xB8+reg);   // MOV reg,#
  17058.  
  17059.                 if(relocf)AddReloc();
  17060.  
  17061.                 razr==r16?outword(number):outdword(number);
  17062.  
  17063.                 ClearReg(reg);
  17064.  
  17065.         }
  17066.  
  17067. }
  17068.  
  17069.  
  17070.  
  17071. void NegReg(int razr,int reg)
  17072.  
  17073. {
  17074.  
  17075.         op66(razr);
  17076.  
  17077.         if(optimizespeed&&(chip==5||chip==6)){
  17078.  
  17079.                 op(0x83);       //and reg,-1
  17080.  
  17081.                 op(0xF0+reg);
  17082.  
  17083.                 op(0xFF);
  17084.  
  17085.                 op66(razr);
  17086.  
  17087.                 op(0x40+reg);   //inc reg
  17088.  
  17089.         }
  17090.  
  17091.         else{
  17092.  
  17093.                 op(0xF7);
  17094.  
  17095.                 op(0xD8+reg);  // NEG reg
  17096.  
  17097.         }
  17098.  
  17099.         ClearReg(reg);
  17100.  
  17101. }
  17102.  
  17103.  
  17104.  
  17105. int RshiftReg(int razr,int reg,int sign)
  17106.  
  17107. {
  17108.  
  17109. char *ofsstr=NULL;
  17110.  
  17111.         if(tok==tk_number){
  17112.  
  17113.                 if((unsigned int)itok.number==1){
  17114.  
  17115.                         op66(razr);
  17116.  
  17117.                         op(0xD1); op(0xE8+reg+sign);  // SHR reg,1
  17118.  
  17119.                 }
  17120.  
  17121.                 else if((unsigned int)itok.number!=0){
  17122.  
  17123.                         if(chip<2&&razr==r16){
  17124.  
  17125.                                 if(reg==ECX)return FALSE;
  17126.  
  17127.                                 goto rrshift;
  17128.  
  17129.                         }
  17130.  
  17131.                         else{
  17132.  
  17133.                                 op66(razr);
  17134.  
  17135.                                 op(0xc1);
  17136.  
  17137.                                 op(0xe8+reg+sign); // SHR reg,imm8
  17138.  
  17139.                                 op((unsigned int)itok.number);
  17140.  
  17141.                                 if(cpu<2)cpu=2;
  17142.  
  17143.                         }
  17144.  
  17145.                 }
  17146.  
  17147.                 nexttok();
  17148.  
  17149.         }
  17150.  
  17151.         else if(reg==ECX)return FALSE;
  17152.  
  17153.         else if((tok==tk_beg||tok==tk_reg||tok==tk_reg32)&&itok.number==CL){
  17154.  
  17155.                 nexttok();
  17156.  
  17157.                 goto rshift;
  17158.  
  17159.         }
  17160.  
  17161.         else{
  17162.  
  17163. rrshift:
  17164.  
  17165.                 getintobeg(CL,&ofsstr);
  17166.  
  17167.                 warningreg(begs[1]);
  17168.  
  17169. rshift:
  17170.  
  17171.                 op66(razr);
  17172.  
  17173.                 op(0xD3);
  17174.  
  17175.                 op(0xE8+reg+sign);      // SHL xXX,CL
  17176.  
  17177.         }
  17178.  
  17179.         return TRUE;
  17180.  
  17181. }
  17182.  
  17183.  
  17184.  
  17185. int CheckMinusNum()
  17186.  
  17187. {
  17188.  
  17189.         if(tok==tk_minus&&tok2==tk_number){
  17190.  
  17191.                 nexttok();
  17192.  
  17193.                 if(itok.rm==tk_float)itok.number|=0x80000000;
  17194.  
  17195.                 else if(itok.rm==tk_double)itok.lnumber|=0x8000000000000000LL;
  17196.  
  17197.                 else itok.lnumber=-itok.lnumber;
  17198.  
  17199.                 return TRUE;
  17200.  
  17201.         }
  17202.  
  17203.         return FALSE;
  17204.  
  17205. }
  17206.  
  17207.  
  17208.  
  17209. int MulReg(int reg,int razr)
  17210.  
  17211. {
  17212.  
  17213. int next=1,i=0;
  17214.  
  17215. int ii=0;
  17216.  
  17217. char *ofsstr=NULL;
  17218.  
  17219.         switch(tok){
  17220.  
  17221.                 case tk_number:
  17222.  
  17223.                         RegMulNum(reg,itok.number,razr,0,&i,itok.flag);
  17224.  
  17225.                         break;
  17226.  
  17227.                 case tk_postnumber:
  17228.  
  17229.                 case tk_undefofs:
  17230.  
  17231.                         if(chip<2&&razr==r16)regmathoperror();
  17232.  
  17233.                         op66(razr);
  17234.  
  17235.                         op(0x69);
  17236.  
  17237.                         op(0xc0+reg*9);
  17238.  
  17239.                         if(tok==tk_postnumber)(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
  17240.  
  17241.                         else AddUndefOff(0,itok.name);
  17242.  
  17243.                         razr==r16?outword(itok.number):outdword(itok.number);
  17244.  
  17245.                         break;
  17246.  
  17247.                 case tk_apioffset:
  17248.  
  17249.                         if(chip<2&&razr==r16)regmathoperror();
  17250.  
  17251.                         op66(razr);
  17252.  
  17253.                         op(0x69);
  17254.  
  17255.                         op(0xc0+reg*9);
  17256.  
  17257.                         AddApiToPost(itok.number);
  17258.  
  17259.                         break;
  17260.  
  17261.                 case tk_doublevar:
  17262.  
  17263.                         ii=4;
  17264.  
  17265.                 case tk_floatvar:
  17266.  
  17267.                         if(reg!=EDX)i=EDX;
  17268.  
  17269.                         Float2reg32(i,ii);
  17270.  
  17271.                         op66(razr);
  17272.  
  17273.                         outword(0xAF0F);
  17274.  
  17275.                         op(0xC0+reg*8+i); // IMUL reg,EDX/EAX
  17276.  
  17277.                         warningreg(regs[1][i]);
  17278.  
  17279.                         break;
  17280.  
  17281.                 case tk_qwordvar:
  17282.  
  17283.                         i=4;
  17284.  
  17285.                 case tk_longvar:
  17286.  
  17287.                 case tk_dwordvar:
  17288.  
  17289.                         i+=4;
  17290.  
  17291.                         goto mulword;
  17292.  
  17293.                 case tk_intvar:
  17294.  
  17295.                 case tk_wordvar:
  17296.  
  17297.                         if(chip<2)regmathoperror();
  17298.  
  17299.                         if(razr==r32)goto defmul1;
  17300.  
  17301.                         i=2;
  17302.  
  17303. mulword:
  17304.  
  17305.                         CheckAllMassiv(bufrm,i,&strinf);
  17306.  
  17307.                         op66(razr);
  17308.  
  17309.                         outseg(&itok,3);
  17310.  
  17311.                         outword(0xAF0F);
  17312.  
  17313.                         op(reg*8+itok.rm);
  17314.  
  17315.                         outaddress(&itok);
  17316.  
  17317.                         break;
  17318.  
  17319.                 case tk_bits:
  17320.  
  17321.                         int vops,reg2s;
  17322.  
  17323.                         i=itok.bit.siz+itok.bit.ofs;
  17324.  
  17325.                         if(i<=64)vops=r64;
  17326.  
  17327.                         if(i<=32)vops=r32;
  17328.  
  17329.                         if(i<=16)vops=r16;
  17330.  
  17331.                         if(vops<razr)vops=razr;
  17332.  
  17333.                         reg2s=CX;
  17334.  
  17335.                         if(reg==CX)reg2s=DI;
  17336.  
  17337.                         bits2reg(reg2s,vops);
  17338.  
  17339.                         if(vops==r64)vops=r32;
  17340.  
  17341.                         warningreg(regs[vops/2-1][reg2s]);
  17342.  
  17343.                         itok.number=reg2s;
  17344.  
  17345.                         goto defreg32;
  17346.  
  17347.                 case tk_reg:
  17348.  
  17349.                         if(chip<2)regmathoperror();
  17350.  
  17351.                         if(razr==r32){
  17352.  
  17353.                                 op66(r32);
  17354.  
  17355.                                 outword(0xB70F);
  17356.  
  17357.                                 if(itok.number==reg){
  17358.  
  17359.                                         op(0xC0+reg);
  17360.  
  17361.                                         itok.number=EAX;
  17362.  
  17363.                                 }
  17364.  
  17365.                                 else op(0xC0+itok.number*9);
  17366.  
  17367.                                 warningreg(regs[razr/2-1][itok.number]);
  17368.  
  17369.                         }
  17370.  
  17371.                 case tk_reg32:
  17372.  
  17373. defreg32:
  17374.  
  17375.                         op66(razr);
  17376.  
  17377.                         outword(0xAF0F);
  17378.  
  17379.                         op(0xC0+reg*8+(unsigned int)itok.number);
  17380.  
  17381.                         break;
  17382.  
  17383.                 case tk_ID:
  17384.  
  17385.                 case tk_id:
  17386.  
  17387.                 case tk_proc:
  17388.  
  17389.                 case tk_apiproc:
  17390.  
  17391.                 case tk_undefproc:
  17392.  
  17393.                 case tk_declare:
  17394.  
  17395.                         procdo(razr==r16?tk_word:tk_dword);
  17396.  
  17397.                         i=EAX;
  17398.  
  17399.                         goto defmul;
  17400.  
  17401.                 case tk_seg:
  17402.  
  17403.                 case tk_charvar:
  17404.  
  17405.                 case tk_beg:
  17406.  
  17407.                 case tk_bytevar:
  17408.  
  17409.                 case tk_rmnumber:
  17410.  
  17411. defmul1:
  17412.  
  17413.                         i=EDX;
  17414.  
  17415.                         if(reg==EDX)i=ECX;
  17416.  
  17417.                         getintoreg_32(i,razr,0,&ofsstr,FALSE);
  17418.  
  17419. defmul:
  17420.  
  17421.                         op66(razr);
  17422.  
  17423.                         outword(0xAF0F);
  17424.  
  17425.                         op(0xC0+reg*8+i);
  17426.  
  17427.                         warningreg(regs[razr/2-1][2]);
  17428.  
  17429.                         if(i!=EDX)warningreg(regs[razr/2-1][i]);
  17430.  
  17431.                         if(i!=EAX)next=0;
  17432.  
  17433.                         break;
  17434.  
  17435.                 default: regmathoperror(); break;
  17436.  
  17437.         }
  17438.  
  17439.         return next;
  17440.  
  17441. }
  17442.  
  17443.  
  17444.  
  17445. void DivMod(int vop,int sign,int razr,int expand)
  17446.  
  17447. {
  17448.  
  17449. int i,next;
  17450.  
  17451. char *ofsstr=NULL;
  17452.  
  17453.         if(tok==tk_bits){
  17454.  
  17455.                 i=itok.bit.siz+itok.bit.ofs;
  17456.  
  17457.                 if(i<=64)next=r64;
  17458.  
  17459.                 if(i<=32)next=r32;
  17460.  
  17461.                 if(i<=16)next=r16;
  17462.  
  17463.                 bits2reg(CX,(razr<next?next:razr));
  17464.  
  17465.                 itok.number=CX;
  17466.  
  17467.                 if(next==r64)next=r32;
  17468.  
  17469.                 ClearReg(CX);
  17470.  
  17471.                 warningreg(regs[next/2-1][ECX]);
  17472.  
  17473.                 tok=(razr==r16?tk_reg:tk_reg32);
  17474.  
  17475.         }
  17476.  
  17477.         i=0;
  17478.  
  17479.         next=1;
  17480.  
  17481.         if(tok==tk_number){
  17482.  
  17483.                 if(razr==r16)itok.number&=0xffff;
  17484.  
  17485.                 if(vop){        //%
  17486.  
  17487.                         if((itok.flag&f_reloc)!=0)goto defal;
  17488.  
  17489.                         if(itok.number==0)DevideZero();
  17490.  
  17491.                         if(caselong(itok.number)!=NUMNUM){
  17492.  
  17493.                                 itok.number--;
  17494.  
  17495.                                 if(itok.number==0)ZeroReg(EAX,razr);
  17496.  
  17497.                                 else if(short_ok(itok.number,razr/2-1)){
  17498.  
  17499.                                         op66(razr);
  17500.  
  17501.                                         outword(0xE083);
  17502.  
  17503.                                         op(itok.number);
  17504.  
  17505.                                 }
  17506.  
  17507.                                 else{
  17508.  
  17509.                                         op66(razr);
  17510.  
  17511.                                         op(0x25); // AND EAX,number-1
  17512.  
  17513.                                         razr==r16?outword((unsigned int)itok.number):outdword(itok.number);
  17514.  
  17515.                                 }
  17516.  
  17517.                                 setzeroflag=TRUE;
  17518.  
  17519.                         }
  17520.  
  17521.                         else{
  17522.  
  17523. defal:
  17524.  
  17525.                                 if(!expand)ClearDX(razr,sign);
  17526.  
  17527.                                 DivNum2(itok.number,razr,sign);
  17528.  
  17529.                                 setzeroflag=FALSE;
  17530.  
  17531.                         }
  17532.  
  17533.                 }
  17534.  
  17535.                 else{   //¤¥«¥­¨¥
  17536.  
  17537.                         if((itok.flag&f_reloc)!=0)goto divin;
  17538.  
  17539.                         switch(itok.number){
  17540.  
  17541.                                 case 0:
  17542.  
  17543.                                         DevideZero();
  17544.  
  17545.                                         break;
  17546.  
  17547.                                 case 1: break;
  17548.  
  17549.                                 case 2:
  17550.  
  17551.                                         if(expand==TRUE){
  17552.  
  17553.                                                 op66(razr);
  17554.  
  17555.                                                 if((chip>2||razr==r32)&&chip!=5&&chip!=6){
  17556.  
  17557.                                                         outdword(0x01d0ac0f);   //shrd ax,dx,1
  17558.  
  17559.                                                         setzeroflag=TRUE;
  17560.  
  17561.                                                 }
  17562.  
  17563.                                                 else{
  17564.  
  17565.                                                         outword(0xead1);        //shr dx,1 rcr ax,1
  17566.  
  17567.                                                         op66(razr);
  17568.  
  17569.                                                         outword(0xd8d1);
  17570.  
  17571.                                                         setzeroflag=FALSE;
  17572.  
  17573.                                                 }
  17574.  
  17575.                                                 ClearReg(AX);
  17576.  
  17577.                                                 ClearReg(DX);
  17578.  
  17579.                                                 break;
  17580.  
  17581.                                         }
  17582.  
  17583.                                         op66(razr);
  17584.  
  17585.                                   if(sign)outword(0xF8D1);// SAR AX,1
  17586.  
  17587.                                         else outword(0xE8D1);   // SHR AX,1
  17588.  
  17589.                                         setzeroflag=TRUE;
  17590.  
  17591.                                         ClearReg(AX);
  17592.  
  17593.                                         break;
  17594.  
  17595.                                 default:
  17596.  
  17597.                                         vop=caselong(itok.number);
  17598.  
  17599.                                         if(vop!=NUMNUM){
  17600.  
  17601.                                                 if(expand==TRUE){
  17602.  
  17603.                                                         if(chip>2||razr==r32){
  17604.  
  17605.                                                                 op66(razr);
  17606.  
  17607.                                                                 op(0x0f);
  17608.  
  17609.                                                                 outword(0xd0ac);        //shrd ax,dx,vop
  17610.  
  17611.                                                                 op(vop);
  17612.  
  17613.                                                                 setzeroflag=TRUE;
  17614.  
  17615.                                                                 ClearReg(AX);
  17616.  
  17617.                                                                 ClearReg(DX);
  17618.  
  17619.                                                         }
  17620.  
  17621.                                                         else{
  17622.  
  17623.                                                                 if(optimizespeed==FALSE)goto divin;
  17624.  
  17625.                                                                 op(0xB1); op(vop); /* MOV CL,num */
  17626.  
  17627.                                                                 if(sign)outword(0xFad1); // SAR AX,1
  17628.  
  17629.                                                                 else outword(0xEad1); // SHR AX,1
  17630.  
  17631.                                                                 outdword(0xfae2d8d1);  //rcr ax,1  LOOP -6
  17632.  
  17633.                                                                 warningreg(begs[1]);
  17634.  
  17635.                                                                 setzeroflag=FALSE;
  17636.  
  17637.                                                                 ClearReg(AX);
  17638.  
  17639.                                                                 ConstToReg(vop,CL,r8);
  17640.  
  17641.                                                         }
  17642.  
  17643.                                                 }
  17644.  
  17645.                                                 else{
  17646.  
  17647.                                                         if(chip<2&&razr==r16){
  17648.  
  17649.                                                                 op(0xB1); op(vop); /* MOV CL,num */
  17650.  
  17651.                                                                 if(sign)outword(0xF8D3); // SAR AX,CL
  17652.  
  17653.                                                                 else outword(0xE8D3); // SHR AX,CL
  17654.  
  17655.                                                                 warningreg(begs[1]);
  17656.  
  17657.                                                                 ClearReg(AX);
  17658.  
  17659.                                                                 ConstToReg(vop,CL,r8);
  17660.  
  17661.                                                         }
  17662.  
  17663.                                                         else{
  17664.  
  17665.                                                                 op66(razr);
  17666.  
  17667.                                                                 if(sign)outword(0xF8C1); // SAR AX,num
  17668.  
  17669.                                                                 else outword(0xE8C1); // SHR AX,num
  17670.  
  17671.                                                                 op(vop);
  17672.  
  17673.                                                                 ClearReg(AX);
  17674.  
  17675.                                                         }
  17676.  
  17677.                                                         setzeroflag=TRUE;
  17678.  
  17679.                                                 }
  17680.  
  17681.                                         }
  17682.  
  17683.                                         else{
  17684.  
  17685.                                                 if(expand==FALSE)DivNum(itok.number,razr,sign);
  17686.  
  17687.                                                 else{
  17688.  
  17689. divin:
  17690.  
  17691.  
  17692.  
  17693.                                                         if(!expand)ClearDX(razr,sign);
  17694.  
  17695.                                                         DivNum2(itok.number,razr,sign);
  17696.  
  17697.                                                 }
  17698.  
  17699.                                         }
  17700.  
  17701.                         }
  17702.  
  17703.                 }
  17704.  
  17705.         }
  17706.  
  17707.         else{
  17708.  
  17709.                 if(tok==tk_doublevar){
  17710.  
  17711.                         i=4;
  17712.  
  17713.                         tok=tk_floatvar;
  17714.  
  17715.                 }
  17716.  
  17717.                 if(tok==tk_floatvar){
  17718.  
  17719.                         Float2reg32(ECX,i);
  17720.  
  17721.                         warningreg(regs[razr/2-1][1]);
  17722.  
  17723.                         itok.number=ECX;
  17724.  
  17725.                         tok=(razr==r16?tk_reg:tk_reg32);
  17726.  
  17727.                         sign=1;
  17728.  
  17729.                 }
  17730.  
  17731.                 switch(tok){
  17732.  
  17733.                         case tk_qwordvar:
  17734.  
  17735.                                 i=4;
  17736.  
  17737.                         case tk_longvar:
  17738.  
  17739.                         case tk_dwordvar:
  17740.  
  17741.                                 i+=2;
  17742.  
  17743.                         case tk_intvar:
  17744.  
  17745.                         case tk_wordvar:
  17746.  
  17747.                                 if(razr==r32&&(tok==tk_intvar||tok==tk_wordvar))goto defdiv;
  17748.  
  17749.                                 i+=2;
  17750.  
  17751.                                 CheckAllMassiv(bufrm,i,&strinf);
  17752.  
  17753.                                 if(expand==FALSE)ClearDX(razr,sign);
  17754.  
  17755.                                 op66(razr);
  17756.  
  17757.                                 outseg(&itok,2);
  17758.  
  17759.                                 op(0xF7);
  17760.  
  17761.                                 if(sign)op(0x38+itok.rm); /* IDIV word ptr [#] */
  17762.  
  17763.                                 else op(0x30+itok.rm); /* DIV word ptr [#] */
  17764.  
  17765.                                 outaddress(&itok);
  17766.  
  17767.                                 ClearReg(AX);
  17768.  
  17769.                                 break;
  17770.  
  17771.                         case tk_reg:
  17772.  
  17773.                                 if(razr==r32){
  17774.  
  17775.                                         i=itok.number;
  17776.  
  17777.                                         getintoreg_32(i,r32,0,&ofsstr,FALSE);
  17778.  
  17779.                                         if(expand==FALSE)ClearDX(razr,sign);
  17780.  
  17781.                                         op66(r32);
  17782.  
  17783.                                         op(0xF7);
  17784.  
  17785.                                         if(sign)op(0xF8+i);  /* IDIV ECX */
  17786.  
  17787.                                         else op(0xF0+i); /* DIV ECX */
  17788.  
  17789.                                         next=0;
  17790.  
  17791.                                         warningreg(regs[1][2]);
  17792.  
  17793.                                 ClearReg(AX);
  17794.  
  17795.                                 ClearReg(CX);
  17796.  
  17797.                                         break;
  17798.  
  17799.                                 }
  17800.  
  17801.                         case tk_reg32:
  17802.  
  17803.                                 if(expand==FALSE)ClearDX(razr,sign);
  17804.  
  17805.                                 op66(razr);
  17806.  
  17807.                                 op(0xF7);
  17808.  
  17809.                                 if(sign)op(0xF8+(unsigned int)itok.number);
  17810.  
  17811.                                 else op(0xF0+(unsigned int)itok.number);
  17812.  
  17813.                                 ClearReg(AX);
  17814.  
  17815.                                 break;
  17816.  
  17817.                         case tk_ID:
  17818.  
  17819.                         case tk_id:
  17820.  
  17821.                         case tk_proc:
  17822.  
  17823.                         case tk_apiproc:
  17824.  
  17825.                         case tk_undefproc:
  17826.  
  17827.                         case tk_declare:
  17828.  
  17829.                                 op66(razr);
  17830.  
  17831.                                 op(0x50);       //push AX
  17832.  
  17833.                                 addESP+=razr==r16?2:4;
  17834.  
  17835. unsigned char oaddstack;
  17836.  
  17837.                                 oaddstack=addstack;
  17838.  
  17839.                                 addstack=FALSE;
  17840.  
  17841.                                 procdo(razr==r16?(sign==0?tk_word:tk_int):(sign==0?tk_dword:tk_long));
  17842.  
  17843.                                 addstack=oaddstack;
  17844.  
  17845.                                 addESP-=razr==r16?2:4;
  17846.  
  17847.                                 op66(razr);
  17848.  
  17849.                                 op(0x90+ECX);   //xchg AX,CX
  17850.  
  17851.                                 op66(razr);
  17852.  
  17853.                                 op(0x58);       //pop AX
  17854.  
  17855.                                 if(expand==FALSE)ClearDX(razr,sign);
  17856.  
  17857.                                 op66(razr);
  17858.  
  17859.                                 op(0xF7);
  17860.  
  17861.                                 if(sign)op(0xF8+ECX);  /* IDIV ECX */
  17862.  
  17863.                                 else op(0xF0+ECX); /* DIV ECX */
  17864.  
  17865.                                 warningreg(regs[razr/2-1][ECX]);
  17866.  
  17867.                                 break;
  17868.  
  17869.                         case tk_undefofs:
  17870.  
  17871.                         case tk_seg:
  17872.  
  17873.                         case tk_charvar:
  17874.  
  17875.                         case tk_beg:
  17876.  
  17877.                         case tk_bytevar:
  17878.  
  17879.                         case tk_rmnumber:
  17880.  
  17881.                         case tk_postnumber:
  17882.  
  17883.                         case tk_apioffset:
  17884.  
  17885. defdiv:
  17886.  
  17887.                                 getintoreg_32(CX,razr,0,&ofsstr,FALSE);
  17888.  
  17889.                                 if(expand==FALSE)ClearDX(razr,sign);
  17890.  
  17891.                                 op66(razr);
  17892.  
  17893.                                 if(sign)outword(0xF9F7);  /* IDIV CX */
  17894.  
  17895.                                 else outword(0xF1F7); /* DIV CX */
  17896.  
  17897.                                 next=0;
  17898.  
  17899.                                 warningreg(regs[razr/2-1][ECX]);
  17900.  
  17901.                                 ClearReg(CX);
  17902.  
  17903.                                 ClearReg(AX);
  17904.  
  17905.                                 break;
  17906.  
  17907.                         default: valueexpected();       break;
  17908.  
  17909.                 }
  17910.  
  17911.                 setzeroflag=FALSE;
  17912.  
  17913. /*              if(vop){
  17914.  
  17915.                         op66(razr);
  17916.  
  17917.                         if(optimizespeed)outword(0xC28B);       //mov ax,dx
  17918.  
  17919.                         else op(0x92);  //xchg ax,dx
  17920.  
  17921.                 }*/
  17922.  
  17923.         }
  17924.  
  17925.         if(next)nexttok();
  17926.  
  17927. }
  17928.  
  17929.  
  17930.  
  17931. void DivNum(unsigned long num,int razr,int sign)
  17932.  
  17933. {
  17934.  
  17935. /*int i;
  17936.  
  17937. unsigned long num2;
  17938.  
  17939.         if(num<65536&&optimizespeed&&(itok.flag&f_reloc)==0&&sign==0){  //for signed needed new algoritm
  17940.  
  17941.                 if(razr==r16&&chip>2){
  17942.  
  17943.                         num2=65536/(unsigned int)num+1;
  17944.  
  17945.                         if((65535/num2)!=num)goto stddiv;
  17946.  
  17947.                         op66(r32);
  17948.  
  17949.                         op(0x25);
  17950.  
  17951.                         outdword(0xffff);       //and EAX,ffff
  17952.  
  17953.                         if(short_ok(num2,FALSE))i=2;    //ª®à®âª ï ä®à¬ 
  17954.  
  17955.                         op66(r32);
  17956.  
  17957.                         op(0x69+i);     //imul EAX,num
  17958.  
  17959.                         op(0xc0);
  17960.  
  17961.                         if(i==2)op(num2);
  17962.  
  17963.                         else outdword(num2);
  17964.  
  17965.                         op66(r32);
  17966.  
  17967.                         outword(0xE8C1);
  17968.  
  17969.                         op(0x10);       //shr EAX,16
  17970.  
  17971.                         setzeroflag=TRUE;
  17972.  
  17973.                 }
  17974.  
  17975.                 else{
  17976.  
  17977.                         if(razr==r32)num=(unsigned long)0xFFFFFFFFL/num+1;
  17978.  
  17979.                         else num=65536/(unsigned int)num+1;
  17980.  
  17981.                         op66(razr);
  17982.  
  17983.                         op(0xBA);       //mov DX,num
  17984.  
  17985.                         if(razr==r16)outword(num);
  17986.  
  17987.                         else outdword(num);
  17988.  
  17989.                         op66(razr);
  17990.  
  17991.                         outword(0xE2F7);        //mul DX
  17992.  
  17993.                         op66(razr);
  17994.  
  17995.                         outword(0xD089);  //mov AX,DX
  17996.  
  17997.                         setzeroflag=FALSE;
  17998.  
  17999.                         warningreg(regs[razr/2-1][2]);
  18000.  
  18001.                 }
  18002.  
  18003.                 return;
  18004.  
  18005.         }
  18006.  
  18007. stddiv:*/
  18008.  
  18009.         ClearDX(razr,sign);
  18010.  
  18011.         DivNum2(num,razr,sign);
  18012.  
  18013. }
  18014.  
  18015.  
  18016.  
  18017. void ClearDX(int razr,int sign)
  18018.  
  18019. {
  18020.  
  18021.         if(sign)cwdq(razr);
  18022.  
  18023.         else{
  18024.  
  18025.                 op66(razr);
  18026.  
  18027.                 outword(0xD231);
  18028.  
  18029.         }
  18030.  
  18031.         warningreg(regs[razr/2-1][EDX]);
  18032.  
  18033.         ClearReg(DX);
  18034.  
  18035. }
  18036.  
  18037.  
  18038.  
  18039. void DivNum2(unsigned long num,int razr,int sign)
  18040.  
  18041. {
  18042.  
  18043.         MovRegNum(razr,itok.flag&f_reloc,num,ECX);
  18044.  
  18045.         op66(razr);
  18046.  
  18047.         if(sign)outword(0xF9F7);  /* IDIV CX */
  18048.  
  18049.         else outword(0xF1F7); /* DIV CX */
  18050.  
  18051.         warningreg(regs[razr/2-1][ECX]);
  18052.  
  18053.         ClearReg(CX);
  18054.  
  18055.         ClearReg(AX);
  18056.  
  18057. }
  18058.  
  18059.  
  18060.  
  18061. int getintoreg(int reg,int razr,int sign,char **ofsstr)
  18062.  
  18063. {
  18064.  
  18065. ITOK oitok,oitok2;
  18066.  
  18067. int oline,oendinptr;
  18068.  
  18069. int oinptr,otok,otok2;
  18070.  
  18071. unsigned char *oinput;
  18072.  
  18073. unsigned char ocha;
  18074.  
  18075. int useeax=FALSE;
  18076.  
  18077. int operand=tk_plus;
  18078.  
  18079. int rettype=tk_reg;
  18080.  
  18081. char *obuf;
  18082.  
  18083. SINFO ostr;
  18084.  
  18085. int i=0;
  18086.  
  18087. int j=0;
  18088.  
  18089. int onlynum=FALSE;
  18090.  
  18091. COM_MOD *bmod;
  18092.  
  18093.         switch(tok){
  18094.  
  18095.                 case tk_ID:
  18096.  
  18097.                 case tk_id:
  18098.  
  18099.                 case tk_proc:
  18100.  
  18101.                 case tk_apiproc:
  18102.  
  18103.                 case tk_undefproc:
  18104.  
  18105.                 case tk_declare:
  18106.  
  18107.                         break;
  18108.  
  18109.                 default:
  18110.  
  18111. //                      if(cur_mod)break;       //10.08.04 22:50 ¨§-§  define ¯à¥ªà â¨âì
  18112.  
  18113.                         obuf=bufrm;
  18114.  
  18115.                         bufrm=NULL;
  18116.  
  18117.                         ostr=strinf;
  18118.  
  18119.                         strinf.bufstr=NULL;
  18120.  
  18121.                         oitok=itok;
  18122.  
  18123.                         oitok2=itok2;
  18124.  
  18125.                         otok=tok;
  18126.  
  18127.                         otok2=tok2;
  18128.  
  18129.                         oline=linenum2;
  18130.  
  18131.                         oinptr=inptr2;
  18132.  
  18133.                         oinput=input;
  18134.  
  18135.                         oendinptr=endinptr;
  18136.  
  18137.                         bmod=cur_mod;
  18138.  
  18139.                         while(bmod){
  18140.  
  18141.                                 bmod->freze=TRUE;
  18142.  
  18143.                                 bmod=bmod->next;
  18144.  
  18145.                         }
  18146.  
  18147.                         bmod=cur_mod;
  18148.  
  18149.                         ocha=cha2;
  18150.  
  18151. //                      printf("input=%08X inptr=%08X %s\n",input,inptr2,input+inptr2);
  18152.  
  18153.                         if(tok==tk_number)onlynum=TRUE;
  18154.  
  18155.                         while((!useeax)&&itok.type!=tp_stopper&&tok!=tk_eof){
  18156.  
  18157.                                 nexttok();
  18158.  
  18159.                                 if(itok.type==tp_stopper)break;
  18160.  
  18161.                                 if(itok.type==tp_opperand)operand=tok;
  18162.  
  18163.                                 else{
  18164.  
  18165.                                         i++;
  18166.  
  18167.                                         if(bufrm){
  18168.  
  18169.                                                 free(bufrm);
  18170.  
  18171.                                                 bufrm=NULL;
  18172.  
  18173.                                         }
  18174.  
  18175.                                         if(strinf.bufstr)free(strinf.bufstr);
  18176.  
  18177.                                         switch(operand){
  18178.  
  18179.                                                 case tk_div:
  18180.  
  18181.                                                 case tk_mod:
  18182.  
  18183.                                                 case tk_divminus:
  18184.  
  18185.                                                 case tk_modminus:
  18186.  
  18187.                                                         if(j==0)j=1;
  18188.  
  18189.                                                         if((tok==tk_reg||tok==tk_reg32)&&itok.number==reg)useeax=TRUE;
  18190.  
  18191.                                                         if(j==1){
  18192.  
  18193.                                                                 if(tok==tk_number){
  18194.  
  18195.                                                                         if(onlynum==FALSE&&caselong(itok.number)==NUMNUM)j++;
  18196.  
  18197.                                                                 }
  18198.  
  18199.                                                                 else{
  18200.  
  18201.                                                                         j++;
  18202.  
  18203.                                                                         onlynum=FALSE;
  18204.  
  18205.                                                                 }
  18206.  
  18207.                                                         }
  18208.  
  18209.                                                         break;
  18210.  
  18211.                                         }
  18212.  
  18213.                                 }
  18214.  
  18215.                         }
  18216.  
  18217.                         if(bmod!=cur_mod){
  18218.  
  18219.                                 if(bmod&&bmod->freze){
  18220.  
  18221.                                         cur_mod=bmod;
  18222.  
  18223.                                         while(bmod){
  18224.  
  18225.                                                 bmod->freze=FALSE;
  18226.  
  18227.                                                 bmod=bmod->next;
  18228.  
  18229.                                         }
  18230.  
  18231.                                 }
  18232.  
  18233.                                 else{
  18234.  
  18235.                                         do{
  18236.  
  18237.                                                 COM_MOD *temp=cur_mod;
  18238.  
  18239.                                                 cur_mod=cur_mod->next;
  18240.  
  18241. //                                              printf("bmod=%08X cur_mod=%08X\n",bmod,cur_mod);
  18242.  
  18243.                                                 if(temp->paramdef)free(temp->paramdef);
  18244.  
  18245.                                                 free(temp);
  18246.  
  18247.                                         }while(bmod!=cur_mod);
  18248.  
  18249.                                         while(bmod){
  18250.  
  18251.                                                 bmod->freze=FALSE;
  18252.  
  18253.                                                 bmod=bmod->next;
  18254.  
  18255.                                         }
  18256.  
  18257.                                 }
  18258.  
  18259.                                 input=oinput;
  18260.  
  18261.                         }
  18262.  
  18263.                         endinptr=oendinptr;
  18264.  
  18265.                         itok=oitok;
  18266.  
  18267.                         itok2=oitok2;
  18268.  
  18269.                         tok=otok;
  18270.  
  18271.                         tok2=otok2;
  18272.  
  18273.                         linenum2=oline;
  18274.  
  18275.                         inptr2=oinptr;
  18276.  
  18277.                         cha2=ocha;
  18278.  
  18279.                         endoffile=0;
  18280.  
  18281. //                      printf("input=%08X inptr=%08X %s\n",input,inptr2,input+inptr2);
  18282.  
  18283. //                      if(bufrm) { free(bufrm); bufrm=NULL; }
  18284.  
  18285. //                      if(strinf.bufstr)free(strinf.bufstr);
  18286.  
  18287.                         bufrm=obuf;
  18288.  
  18289.                         strinf=ostr;
  18290.  
  18291.                         break;
  18292.  
  18293.         }
  18294.  
  18295.         if(useeax){
  18296.  
  18297.                 op66(razr);
  18298.  
  18299.                 op(0x50);
  18300.  
  18301.                 addESP+=razr==r16?2:4;
  18302.  
  18303.                 do_e_axmath(0,razr,ofsstr);
  18304.  
  18305.                 op66(razr);
  18306.  
  18307.                 if(optimizespeed){
  18308.  
  18309.                         op(0x89);
  18310.  
  18311.                         op(0xC0+reg);
  18312.  
  18313.                 }
  18314.  
  18315.                 else op(0x90+reg);
  18316.  
  18317.                 op66(razr);
  18318.  
  18319.                 addESP-=razr==r16?2:4;
  18320.  
  18321.                 op(0x58);
  18322.  
  18323.         }
  18324.  
  18325.         else{
  18326.  
  18327.                 if(i==1&&j>=2){
  18328.  
  18329.                         i=EAX;
  18330.  
  18331.                         j=1;
  18332.  
  18333.                 }
  18334.  
  18335.                 else i=reg;
  18336.  
  18337.                 rettype=getintoreg_32(i,razr,sign,ofsstr);
  18338.  
  18339.                 if(itok.type!=tp_stopper&&itok.type!=tp_compare&&tok!=tk_eof){
  18340.  
  18341.                         doregmath_32(reg,razr,sign,ofsstr,j);
  18342.  
  18343.                         rettype=tk_reg;
  18344.  
  18345.                 }
  18346.  
  18347.         }
  18348.  
  18349.         return rettype;
  18350.  
  18351. }
  18352.  
  18353.  
  18354.  
  18355. void dobits()
  18356.  
  18357. {
  18358.  
  18359. ITOK wtok;
  18360.  
  18361. char *wbuf;
  18362.  
  18363. SINFO wstr;
  18364.  
  18365. int razr,i,sign=0,posiblret,pointr=0;
  18366.  
  18367. unsigned int rettype;
  18368.  
  18369. int numpointr=0;
  18370.  
  18371. char *ofsstr=NULL;
  18372.  
  18373.         posiblret=rettype=tk_dword;
  18374.  
  18375.         razr=r32;
  18376.  
  18377.         i=itok.bit.siz+itok.bit.ofs;
  18378.  
  18379.         if(i<9){
  18380.  
  18381.                 razr=r8;
  18382.  
  18383.                 posiblret=rettype=tk_byte;
  18384.  
  18385.         }
  18386.  
  18387.         else if(i<17){
  18388.  
  18389.                 posiblret=rettype=tk_word;
  18390.  
  18391.                 razr=r16;
  18392.  
  18393.         }
  18394.  
  18395.         else if(i>32)razr=r64;
  18396.  
  18397.         if(tok2==tk_assign){
  18398.  
  18399.                 wstr=strinf;
  18400.  
  18401.                 strinf.bufstr=NULL;
  18402.  
  18403.                 wtok=itok;
  18404.  
  18405.                 wbuf=bufrm;
  18406.  
  18407.                 bufrm=NULL;
  18408.  
  18409.                 nexttok();
  18410.  
  18411.                 nexttok();
  18412.  
  18413.                 convert_type(&sign,(int *)&rettype,&pointr);
  18414.  
  18415.                 while(tok==tk_mult){
  18416.  
  18417.                         nexttok();
  18418.  
  18419.                         numpointr++;
  18420.  
  18421.                 }
  18422.  
  18423.                 if(numpointr>itok.npointr)unuseableinput();
  18424.  
  18425.                 if(tok2==tk_assign){
  18426.  
  18427.                         MultiAssign(razr,EAX,numpointr);
  18428.  
  18429.                         goto axtobit;
  18430.  
  18431.                 }
  18432.  
  18433.                 if(tok==tk_pointer)cpointr(am32==TRUE?EAX:BX,numpointr);
  18434.  
  18435.                 CheckMinusNum();
  18436.  
  18437.                 if(tok==tk_number){
  18438.  
  18439.                         if(itok2.type==tp_opperand){    //á«®¦­®¥ ¢ëà ¦¥­¨¥
  18440.  
  18441.                                 if(!OnlyNumber(0))goto labl1;
  18442.  
  18443.                                 itok.flag=(unsigned char)postnumflag;
  18444.  
  18445.                         }
  18446.  
  18447.                         else{
  18448.  
  18449.                                 unsigned long num=itok.number;
  18450.  
  18451.                                 nexttok();
  18452.  
  18453.                                 itok.number=num;
  18454.  
  18455.                         }
  18456.  
  18457.                         CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  18458.  
  18459.                         if(razr!=r64)num2bits(&wtok,itok.number,razr);
  18460.  
  18461.                         else{
  18462.  
  18463.                                 int siz=wtok.bit.siz;
  18464.  
  18465.                                 wtok.bit.siz=32-wtok.bit.ofs;
  18466.  
  18467.                                 num2bits(&wtok,itok.number,r32);
  18468.  
  18469.                                 wtok.bit.siz=siz+wtok.bit.ofs-32;
  18470.  
  18471.                                 wtok.bit.ofs=0;
  18472.  
  18473.                                 itok.number=itok.number>>(32-wtok.bit.siz);
  18474.  
  18475.                                 wtok.number+=4;
  18476.  
  18477.                                 num2bits(&wtok,itok.number,r8);
  18478.  
  18479.                         }
  18480.  
  18481.                 }
  18482.  
  18483.                 else{
  18484.  
  18485. labl1:
  18486.  
  18487.                         if(rettype==tk_char||rettype==tk_byte)doalmath(sign,&ofsstr);
  18488.  
  18489.                         else if(rettype==tk_int||rettype==tk_word)do_e_axmath(sign,r16,&ofsstr);
  18490.  
  18491.                         else if(rettype==tk_float)doeaxfloatmath(tk_reg32,AX);
  18492.  
  18493.                         else do_e_axmath(sign,r32,&ofsstr);
  18494.  
  18495.                         convert_returnvalue(posiblret,rettype);
  18496.  
  18497.                         CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  18498.  
  18499. axtobit:
  18500.  
  18501.                         if(razr!=r64)reg2bits(&wtok,razr);
  18502.  
  18503.                         else{
  18504.  
  18505.                                 int siz=wtok.bit.siz;
  18506.  
  18507.                                 op66(r32);
  18508.  
  18509.                                 op(0x50);       //push eax
  18510.  
  18511.                                 if(ESPloc&&am32&&wtok.segm==SS)wtok.number+=4;
  18512.  
  18513.                                 addESP+=4;
  18514.  
  18515.                                 wtok.bit.siz=32-wtok.bit.ofs;
  18516.  
  18517.                                 reg2bits(&wtok,r32);
  18518.  
  18519.                                 op66(r32);
  18520.  
  18521.                                 op(0x58);       //pop eax
  18522.  
  18523.                                 addESP-=4;
  18524.  
  18525.                                 op66(r32);      //shr eax,size
  18526.  
  18527.                                 outword(0xE8C1);
  18528.  
  18529.                                 op(wtok.bit.siz);
  18530.  
  18531.                                 wtok.bit.siz=siz+wtok.bit.ofs-32;
  18532.  
  18533.                                 wtok.bit.ofs=0;
  18534.  
  18535.                                 wtok.number+=4;
  18536.  
  18537.                                 reg2bits(&wtok,r8);
  18538.  
  18539.                         }
  18540.  
  18541.                         return;
  18542.  
  18543.                 }
  18544.  
  18545.         }
  18546.  
  18547.         else{
  18548.  
  18549.                 bits2reg(AX,razr);
  18550.  
  18551.                 wstr=strinf;
  18552.  
  18553.                 strinf.bufstr=NULL;
  18554.  
  18555.                 wtok=itok;
  18556.  
  18557.                 wbuf=bufrm;
  18558.  
  18559.                 bufrm=NULL;
  18560.  
  18561.                 switch(razr){
  18562.  
  18563.                         case r8:
  18564.  
  18565.                                 dobeg(AL);
  18566.  
  18567.                                 break;
  18568.  
  18569.                         case r16:
  18570.  
  18571.                         case r32:
  18572.  
  18573.                                 doreg_32(AX,razr);
  18574.  
  18575.                                 break;
  18576.  
  18577.                         case r64:
  18578.  
  18579.                                 doreg_32(AX,r32);
  18580.  
  18581.                                 break;
  18582.  
  18583.                 }
  18584.  
  18585.                 goto axtobit;
  18586.  
  18587.         }
  18588.  
  18589.         seminext();
  18590.  
  18591. }
  18592.  
  18593.  
  18594.  
  18595. void bits2reg(int reg,int razr)
  18596.  
  18597. {
  18598.  
  18599. int i,j,skip66=FALSE;
  18600.  
  18601.         i=itok.bit.siz+itok.bit.ofs;
  18602.  
  18603.         j=~GetBitMask(itok.bit.ofs,itok.bit.siz);
  18604.  
  18605.         ITOK wtok;
  18606.  
  18607.         char *wbuf;
  18608.  
  18609.         wbuf=bufrm;
  18610.  
  18611.         bufrm=NULL;
  18612.  
  18613.         wtok=itok;
  18614.  
  18615.         SINFO wstr;
  18616.  
  18617.         wstr=strinf;
  18618.  
  18619.         strinf.bufstr=NULL;
  18620.  
  18621.         switch(razr){
  18622.  
  18623.                 case r8:
  18624.  
  18625.                         if(reg==AL){
  18626.  
  18627.                                 getintoal(tk_bytevar,&wtok,wbuf,&wstr);
  18628.  
  18629.                                 if(i!=8){
  18630.  
  18631.                                         op(4+0x20);     //and al,j
  18632.  
  18633.                                         op(j);
  18634.  
  18635.                                 }
  18636.  
  18637.                         }
  18638.  
  18639.                         else{
  18640.  
  18641.                                 CheckAllMassiv(bufrm,1,&strinf);
  18642.  
  18643.                                 outseg(&itok,2);
  18644.  
  18645.                                 op(0x8A);
  18646.  
  18647.                                 op(reg*8+itok.rm);
  18648.  
  18649.                                 outaddress(&itok);
  18650.  
  18651.                                 if(i!=8){
  18652.  
  18653.                                         op(128);
  18654.  
  18655.                                         op(128+64+reg+0x20);
  18656.  
  18657.                                         op(j);
  18658.  
  18659.                                 }
  18660.  
  18661.                         }
  18662.  
  18663.                         if(itok.bit.ofs){       //shr al,ofs
  18664.  
  18665.                                 if(itok.bit.ofs==1){
  18666.  
  18667.                                         op(0xD0);
  18668.  
  18669.                                         op(0xE8+reg);
  18670.  
  18671.                                 }
  18672.  
  18673.                                 else{
  18674.  
  18675.                                         op(0xC0);
  18676.  
  18677.                                         op(0xE8+reg);
  18678.  
  18679.                                         op(itok.bit.ofs);
  18680.  
  18681.                                 }
  18682.  
  18683.                         }
  18684.  
  18685.                         break;
  18686.  
  18687.                 case r16:
  18688.  
  18689.                 case r32:
  18690.  
  18691.                         if(reg==AX){
  18692.  
  18693.                                 getinto_e_ax(0,(razr==r16?tk_wordvar:tk_dwordvar),&wtok,wbuf,&wstr,razr);
  18694.  
  18695.                                 if(razr==r16&&i!=16){
  18696.  
  18697.                                         op66(razr);     //and (e)ax,j
  18698.  
  18699.                                         op(4+1+0x20);
  18700.  
  18701.                                         outword(j);
  18702.  
  18703.                                 }
  18704.  
  18705.                                 else if(razr==r32&&i!=32){
  18706.  
  18707.                                         op66(razr);     //and (e)ax,j
  18708.  
  18709.                                         if(short_ok(j,TRUE)){
  18710.  
  18711.                                                 op(128+2+1);
  18712.  
  18713.                                                 op(128+64+0x20);
  18714.  
  18715.                                                 op((int)j);
  18716.  
  18717.                                         }
  18718.  
  18719.                                         else{
  18720.  
  18721.                                                 op(4+1+0x20);
  18722.  
  18723.                                                 outdword(j);
  18724.  
  18725.                                         }
  18726.  
  18727.                                 }
  18728.  
  18729.                                 if(j<65536&&razr==r32)skip66=TRUE;
  18730.  
  18731.                                 if(itok.bit.ofs){       //shr (e)ax,ofs
  18732.  
  18733.                                         if(!skip66)op66(razr);
  18734.  
  18735.                                         if(itok.bit.ofs==1)outword(0xE8D1);
  18736.  
  18737.                                         else{
  18738.  
  18739.                                                 outword(0xE8C1);
  18740.  
  18741.                                                 op(itok.bit.ofs);
  18742.  
  18743.                                         }
  18744.  
  18745.                                 }
  18746.  
  18747.                         }
  18748.  
  18749.                         else{
  18750.  
  18751. int reg1=idxregs[0],reg2=idxregs[1];
  18752.  
  18753.                                 if(!am32){
  18754.  
  18755.                                         if(reg==idxregs[2]||reg==idxregs[1]){
  18756.  
  18757.                                                 reg1=reg;
  18758.  
  18759.                                                 if(reg==idxregs[1])reg2=idxregs[0];
  18760.  
  18761.                                         }
  18762.  
  18763.                                 }
  18764.  
  18765.                                 else{
  18766.  
  18767.                                         reg1=reg;
  18768.  
  18769.                                         if(reg==idxregs[1])reg2=idxregs[0];
  18770.  
  18771.                                 }
  18772.  
  18773.                                 CheckAllMassiv(bufrm,razr==r32?4:2,&strinf,&itok,reg1,reg2);
  18774.  
  18775.                                 op66(razr);
  18776.  
  18777.                                 outseg(&itok,2);
  18778.  
  18779.                                 op(0x8B);
  18780.  
  18781.                                 op(reg*8+itok.rm);
  18782.  
  18783.                                 outaddress(&itok);
  18784.  
  18785.                                 if((razr==r16&&i!=16)||(razr==r32&&i!=32)){
  18786.  
  18787.                                         op66(razr);     //and reg,j
  18788.  
  18789.                                         if(short_ok(j,razr==r16?FALSE:TRUE)){
  18790.  
  18791.                                                 op(128+2+1);
  18792.  
  18793.                                                 op(128+64+reg+0x20);
  18794.  
  18795.                                                 op(j);
  18796.  
  18797.                                         }
  18798.  
  18799.                                         else{
  18800.  
  18801.                                                 op(128+1);
  18802.  
  18803.                                                 op(128+64+reg+0x20);
  18804.  
  18805.                                                 if(razr==r16)outword(j);
  18806.  
  18807.                                                 else outdword(j);
  18808.  
  18809.                                         }
  18810.  
  18811.                                 }
  18812.  
  18813.                                 if(itok.bit.ofs){       //shr reg,ofs
  18814.  
  18815.                                         op66(razr);
  18816.  
  18817.                                         if(itok.bit.ofs==1){
  18818.  
  18819.                                                 op(0xD1);
  18820.  
  18821.                                                 op(0xE8+reg);
  18822.  
  18823.                                         }
  18824.  
  18825.                                         else{
  18826.  
  18827.                                                 op(0xC1);
  18828.  
  18829.                                                 op(0xE8+reg);
  18830.  
  18831.                                                 op(itok.bit.ofs);
  18832.  
  18833.                                         }
  18834.  
  18835.                                 }
  18836.  
  18837.                         }
  18838.  
  18839.                         break;
  18840.  
  18841.                 case r64:
  18842.  
  18843.                         if(reg==AX){
  18844.  
  18845.                                 getinto_e_ax(0,tk_dwordvar,&wtok,wbuf,&wstr,r32);
  18846.  
  18847.                                 itok.number+=4;
  18848.  
  18849.                                 outseg(&itok,2);
  18850.  
  18851.                                 op(0x8B);
  18852.  
  18853.                                 op(DX*8+itok.rm);
  18854.  
  18855.                                 outaddress(&itok);
  18856.  
  18857.                                 if(itok.bit.siz!=32){
  18858.  
  18859.                                         op(128);
  18860.  
  18861.                                         op(128+64+DL+0x20);
  18862.  
  18863.                                         op(li[itok.bit.siz+itok.bit.ofs-32]-1);
  18864.  
  18865.                                 }
  18866.  
  18867.                                 op66(r32);
  18868.  
  18869.                                 outword(0xAC0F);        //shrd edx,eax,ofs
  18870.  
  18871.                                 op(0xC2);
  18872.  
  18873.                                 op(itok.bit.ofs);
  18874.  
  18875.                                 itok.number-=4;
  18876.  
  18877.                                 warningreg(regs[1][EDX]);
  18878.  
  18879.                         }
  18880.  
  18881.                         else{
  18882.  
  18883.                                 int reg1=DX;
  18884.  
  18885.                                 if(reg==DX)reg1=CX;
  18886.  
  18887.                                 CheckAllMassiv(bufrm,4,&strinf,&itok);
  18888.  
  18889.                                 op66(r32);
  18890.  
  18891.                                 outseg(&itok,2);
  18892.  
  18893.                                 op(0x8B);
  18894.  
  18895.                                 op(reg*8+itok.rm);
  18896.  
  18897.                                 outaddress(&itok);
  18898.  
  18899.                                 itok.number+=4;
  18900.  
  18901.                                 outseg(&itok,2);
  18902.  
  18903.                                 op(0x8B);
  18904.  
  18905.                                 op(reg1*8+itok.rm);
  18906.  
  18907.                                 outaddress(&itok);
  18908.  
  18909.                                 if(itok.bit.siz!=32){
  18910.  
  18911.                                         op(128+(reg1<4?0:3));
  18912.  
  18913.                                         op(128+64+reg1+0x20);
  18914.  
  18915.                                         op(li[itok.bit.siz+itok.bit.ofs-32]-1);
  18916.  
  18917.                                 }
  18918.  
  18919.                                 itok.number-=4;
  18920.  
  18921.                                 op66(r32);
  18922.  
  18923.                                 outword(0xAC0F);        //shrd edx,eax,ofs
  18924.  
  18925.                                 op(0xc0+reg1+reg*8);
  18926.  
  18927.                                 op(itok.bit.ofs);
  18928.  
  18929.                                 warningreg(regs[1][reg1]);
  18930.  
  18931.                         }
  18932.  
  18933.                         ClearReg(DX);
  18934.  
  18935.                         break;
  18936.  
  18937.         }
  18938.  
  18939.         ClearReg(AX);
  18940.  
  18941.         ClearReg(reg);
  18942.  
  18943. }
  18944.  
  18945.  
  18946.  
  18947. void num2bits(ITOK *gtok,unsigned long num,int razr)
  18948.  
  18949. {
  18950.  
  18951. unsigned int j,mask;
  18952.  
  18953.         mask=GetBitMask(gtok->bit.ofs,gtok->bit.siz);
  18954.  
  18955.         j=li[gtok->bit.siz]-1;
  18956.  
  18957.         if((num&j)!=j){
  18958.  
  18959.                 if(razr!=r8){
  18960.  
  18961.                         op66(razr);     //and bits,mask
  18962.  
  18963.                         outseg(gtok,2);
  18964.  
  18965.                         if((postnumflag&f_reloc)==0&&short_ok(mask,razr/2-1)){
  18966.  
  18967.                                 op(128+2+1);
  18968.  
  18969.                                 op(gtok->rm+0x20);
  18970.  
  18971.                                 outaddress(gtok);
  18972.  
  18973.                                 op(mask);
  18974.  
  18975.                         }
  18976.  
  18977.                         else{
  18978.  
  18979.                                 op(128+1);
  18980.  
  18981.                                 op(gtok->rm+0x20);
  18982.  
  18983.                                 outaddress(gtok);
  18984.  
  18985.                                 if((postnumflag&f_reloc)!=0)AddReloc();
  18986.  
  18987.                                 if(razr==r16)outword(mask);
  18988.  
  18989.                                 else outdword(mask);
  18990.  
  18991.                         }
  18992.  
  18993.                 }
  18994.  
  18995.                 else{
  18996.  
  18997.                         outseg(gtok,2);         //and bits,mask
  18998.  
  18999.                         op(128);
  19000.  
  19001.                         op(gtok->rm+0x20);
  19002.  
  19003.                         outaddress(gtok);
  19004.  
  19005.                         op(mask);
  19006.  
  19007.                 }
  19008.  
  19009.         }
  19010.  
  19011.         num=(num&j)<<gtok->bit.ofs;     //or bits,mask
  19012.  
  19013.         if(num<65536&&razr==r32)razr=r16;
  19014.  
  19015.         if(num<256&&razr==r16)razr=r8;
  19016.  
  19017.         if(razr!=r8){
  19018.  
  19019.                 op66(razr);
  19020.  
  19021.                 outseg(gtok,2);
  19022.  
  19023.                 if((postnumflag&f_reloc)==0&&short_ok(num,razr/2-1)){
  19024.  
  19025.                         op(128+2+1);
  19026.  
  19027.                         op(gtok->rm+8);
  19028.  
  19029.                         outaddress(gtok);
  19030.  
  19031.                         op(num);
  19032.  
  19033.                 }
  19034.  
  19035.                 else{
  19036.  
  19037.                         op(128+1);
  19038.  
  19039.                         op(gtok->rm+8);
  19040.  
  19041.                         outaddress(gtok);
  19042.  
  19043.                         if((postnumflag&f_reloc)!=0)AddReloc();
  19044.  
  19045.                         if(razr==r16)outword(num);
  19046.  
  19047.                         else outdword(num);
  19048.  
  19049.                 }
  19050.  
  19051.         }
  19052.  
  19053.         else{
  19054.  
  19055.                 if((unsigned char)num!=0){
  19056.  
  19057.                         outseg(gtok,2);
  19058.  
  19059.                         op(128);
  19060.  
  19061.                         op(gtok->rm+8);
  19062.  
  19063.                         outaddress(gtok);
  19064.  
  19065.                         op(num);
  19066.  
  19067.                 }
  19068.  
  19069.         }
  19070.  
  19071. }
  19072.  
  19073.  
  19074.  
  19075. void reg2bits(ITOK *gtok,int razr)
  19076.  
  19077. {
  19078.  
  19079. int i,j,mask;
  19080.  
  19081.         j=li[gtok->bit.siz]-1;
  19082.  
  19083.         mask=GetBitMask(gtok->bit.ofs,gtok->bit.siz);
  19084.  
  19085.         i=gtok->bit.ofs+gtok->bit.siz;
  19086.  
  19087.         switch(razr){
  19088.  
  19089.                 case r8:
  19090.  
  19091.                         if(i!=8){
  19092.  
  19093.                                 op(4+0x20);     //and al,size
  19094.  
  19095.                                 op(j);
  19096.  
  19097.                         }
  19098.  
  19099.                         outseg(gtok,2); //and bits,mask
  19100.  
  19101.                         op(128);
  19102.  
  19103.                         op(gtok->rm+0x20);
  19104.  
  19105.                         outaddress(gtok);
  19106.  
  19107.                         op(mask);
  19108.  
  19109.                         if(gtok->bit.ofs)lshiftmul(gtok->bit.ofs,razr);
  19110.  
  19111.                         outseg(gtok,2);
  19112.  
  19113.                         op(8);
  19114.  
  19115.                         op(gtok->rm);
  19116.  
  19117.                         outaddress(gtok);
  19118.  
  19119.                         break;
  19120.  
  19121.                 case r16:
  19122.  
  19123.                 case r32:
  19124.  
  19125.                         if(razr==r16&&i!=16){
  19126.  
  19127.                                 op66(razr);     //and (e)ax,size
  19128.  
  19129.                                 op(4+1+0x20);
  19130.  
  19131.                                 outword(j);
  19132.  
  19133.                         }
  19134.  
  19135.                         else if(razr==r32&&i!=32){
  19136.  
  19137.                                 op66(razr);     //and (e)ax,size
  19138.  
  19139.                                 if(short_ok(j,TRUE)){
  19140.  
  19141.                                         op(128+2+1);
  19142.  
  19143.                                         op(128+64+0x20);
  19144.  
  19145.                                         op((int)j);
  19146.  
  19147.                                 }
  19148.  
  19149.                                 else{
  19150.  
  19151.                                         op(4+1+0x20);
  19152.  
  19153.                                         outdword(j);
  19154.  
  19155.                                 }
  19156.  
  19157.                         }
  19158.  
  19159.                         op66(razr);     //and bits,mask
  19160.  
  19161.                         outseg(gtok,2);
  19162.  
  19163.                         if(short_ok(mask,razr/2-1)){
  19164.  
  19165.                                 op(128+2+1);
  19166.  
  19167.                                 op(gtok->rm+0x20);
  19168.  
  19169.                                 outaddress(gtok);
  19170.  
  19171.                                 op(mask);
  19172.  
  19173.                         }
  19174.  
  19175.                         else{
  19176.  
  19177.                                 op(128+1);
  19178.  
  19179.                                 op(gtok->rm+0x20);
  19180.  
  19181.                                 outaddress(gtok);
  19182.  
  19183.                                 if(razr==r16)outword(mask);
  19184.  
  19185.                                 else outdword(mask);
  19186.  
  19187.                         }
  19188.  
  19189.                         if(gtok->bit.ofs)lshiftmul(gtok->bit.ofs,razr);
  19190.  
  19191.                         op66(razr);
  19192.  
  19193.                         outseg(gtok,2);
  19194.  
  19195.                         op(1+8);
  19196.  
  19197.                         op(gtok->rm);
  19198.  
  19199.                         outaddress(gtok);
  19200.  
  19201.                         break;
  19202.  
  19203.         }
  19204.  
  19205. }
  19206.  
  19207.  
  19208.  
  19209. void getoperand(int reg)
  19210.  
  19211. {
  19212.  
  19213. unsigned int numpointr=0;
  19214.  
  19215.         nexttok();
  19216.  
  19217.         while(tok==tk_mult){
  19218.  
  19219.                 nexttok();
  19220.  
  19221.                 numpointr++;
  19222.  
  19223.         }
  19224.  
  19225.         if(numpointr>itok.npointr){
  19226.  
  19227.                 unuseableinput();
  19228.  
  19229.         }
  19230.  
  19231.         if(tok==tk_pointer){
  19232.  
  19233.                 cpointr(reg,numpointr);
  19234.  
  19235.         }
  19236.  
  19237.         CheckMinusNum();
  19238.  
  19239. }
  19240.  
  19241.  
  19242.  
  19243. void cpointr(int reg,int numpointr)
  19244.  
  19245. {
  19246.  
  19247.         if(itok.type==tk_proc){
  19248.  
  19249.                 if(tok2==tk_openbracket){
  19250.  
  19251.                         tok=tk_proc;
  19252.  
  19253.                 }
  19254.  
  19255.                 else{
  19256.  
  19257.                         itok.rm=itok.sib;
  19258.  
  19259.                         if(am32){
  19260.  
  19261.                                 itok.sib=CODE32;
  19262.  
  19263.                                 tok=tk_dwordvar;
  19264.  
  19265.                         }
  19266.  
  19267.                         else{
  19268.  
  19269.                                 itok.sib=CODE16;
  19270.  
  19271.                                 tok=tk_wordvar;
  19272.  
  19273.                         }
  19274.  
  19275.                         compressoffset(&itok);
  19276.  
  19277.                 }
  19278.  
  19279.                 return;
  19280.  
  19281.         }
  19282.  
  19283.         int razr=typesize(itok.type);
  19284.  
  19285.         if(numpointr==itok.npointr){
  19286.  
  19287.                 getpointeradr(&itok,bufrm,&strinf,numpointr-1,razr,reg);
  19288.  
  19289.                 if(itok.type>=tk_char&&itok.type<=tk_float)tok=tk_charvar+itok.type-tk_char;
  19290.  
  19291.                 else tok=(am32==FALSE?tk_wordvar:tk_dwordvar);
  19292.  
  19293.         }
  19294.  
  19295.         else if(numpointr<itok.npointr){
  19296.  
  19297.                 if(numpointr)getpointeradr(&itok,bufrm,&strinf,numpointr-1,razr,reg);
  19298.  
  19299.                 tok=(am32==FALSE?tk_wordvar:tk_dwordvar);
  19300.  
  19301.         }
  19302.  
  19303.         else unuseableinput();
  19304.  
  19305. }
  19306.  
  19307.  
  19308.  
  19309. void cwpointr(ITOK *wtok,char *&wbuf,SINFO *wstr,int *otok,int npointr,int ureg)
  19310.  
  19311. {
  19312.  
  19313.         if(wtok->type==tk_proc){
  19314.  
  19315.                 wtok->rm=wtok->sib;
  19316.  
  19317.                 if(am32){
  19318.  
  19319.                         wtok->sib=CODE32;
  19320.  
  19321.                         *otok=tk_dwordvar;
  19322.  
  19323.                 }
  19324.  
  19325.                 else{
  19326.  
  19327.                         wtok->sib=CODE16;
  19328.  
  19329.                         *otok=tk_wordvar;
  19330.  
  19331.                 }
  19332.  
  19333.                 compressoffset(wtok);
  19334.  
  19335.         }
  19336.  
  19337.         else{
  19338.  
  19339.                 int razr=typesize(wtok->type);
  19340.  
  19341.                 int reg=idxregs[2];
  19342.  
  19343.                 if(reg==ureg)reg=idxregs[1];
  19344.  
  19345.                 if(npointr==wtok->npointr){
  19346.  
  19347.                         getpointeradr(wtok,wbuf,wstr,npointr-1,razr,reg);
  19348.  
  19349.                         if(wtok->type>=tk_char&&wtok->type<=tk_float)*otok=tk_charvar+wtok->type-tk_char;
  19350.  
  19351.                         else *otok=(am32==FALSE?tk_wordvar:tk_dwordvar);
  19352.  
  19353.                 }
  19354.  
  19355.                 else if(npointr<wtok->npointr){
  19356.  
  19357.                         *otok=(am32==FALSE?tk_wordvar:tk_dwordvar);
  19358.  
  19359.                         if(npointr)getpointeradr(wtok,wbuf,wstr,npointr-1,razr,reg);
  19360.  
  19361.                         else return;
  19362.  
  19363.                 }
  19364.  
  19365.                 else unuseableinput();
  19366.  
  19367.                 memcpy(wtok,&itok,sizeof(ITOK));
  19368.  
  19369.         }
  19370.  
  19371. }
  19372.  
  19373.  
  19374.  
  19375. int CheckAddOnly()
  19376.  
  19377. {
  19378.  
  19379. ITOK oitok,oitok2;
  19380.  
  19381. int oline;
  19382.  
  19383. int oinptr,otok,otok2;
  19384.  
  19385. unsigned char ocha;
  19386.  
  19387. char *obuf;
  19388.  
  19389. SINFO ostr;
  19390.  
  19391. int retval=TRUE;
  19392.  
  19393. int j=3;
  19394.  
  19395. int changesign=0;
  19396.  
  19397.         if(tok==tk_minusequals)changesign++;
  19398.  
  19399.         else if(tok!=tk_plusequals)return FALSE;
  19400.  
  19401.         if(itok2.type==tp_stopper)return FALSE;
  19402.  
  19403. newloop:
  19404.  
  19405.         obuf=bufrm;
  19406.  
  19407.         bufrm=NULL;
  19408.  
  19409.         ostr=strinf;
  19410.  
  19411.         strinf.bufstr=NULL;
  19412.  
  19413.         oitok=itok;
  19414.  
  19415.         oitok2=itok2;
  19416.  
  19417.         otok=tok;
  19418.  
  19419.         otok2=tok2;
  19420.  
  19421.         oline=linenum2;
  19422.  
  19423.         oinptr=inptr2;
  19424.  
  19425.         ocha=cha2;
  19426.  
  19427.         while(tok2==tk_minus||tok2==tk_mult)nexttok();
  19428.  
  19429.         while(itok.type!=tp_stopper&&tok!=tk_eof){
  19430.  
  19431.                 nexttok();
  19432.  
  19433.                 switch(tok){
  19434.  
  19435.                         case tk_ID:
  19436.  
  19437.                         case tk_id:
  19438.  
  19439.                         case tk_proc:
  19440.  
  19441.                         case tk_apiproc:
  19442.  
  19443.                         case tk_undefproc:
  19444.  
  19445.                         case tk_declare:
  19446.  
  19447.                                 retval=FALSE;
  19448.  
  19449.                                 itok.type=tp_stopper;
  19450.  
  19451.                                 break;
  19452.  
  19453.                 }
  19454.  
  19455.                 if(itok.type==tp_stopper)break;
  19456.  
  19457.                 if(itok.type==tp_opperand){
  19458.  
  19459.                         if(tok!=tk_plus&&tok!=tk_minus){
  19460.  
  19461.                                 retval=FALSE;
  19462.  
  19463.                                 break;
  19464.  
  19465.                         }
  19466.  
  19467.                         else if(changesign==2){
  19468.  
  19469.                                 int i=inptr2-1;
  19470.  
  19471.                                 char c;
  19472.  
  19473.                                 do{
  19474.  
  19475.                                         i--;
  19476.  
  19477.                                         c=input[i];
  19478.  
  19479.                                         i--;
  19480.  
  19481.                                 }while(c!='-'&&c!='+');
  19482.  
  19483.                                 i++;
  19484.  
  19485.                                 if(c=='-')c='+';
  19486.  
  19487.                                 else c='-';
  19488.  
  19489.                                 input[i]=c;
  19490.  
  19491.                         }
  19492.  
  19493.                         while(itok2.type==tp_opperand&&tok!=tk_eof)nexttok();
  19494.  
  19495.                 }
  19496.  
  19497.                 else{
  19498.  
  19499.                         if(tok!=tk_number&&tok!=tk_postnumber&&tok!=tk_undefofs){
  19500.  
  19501.                                 if(j>1)j=0;
  19502.  
  19503.                                 if(bufrm){
  19504.  
  19505.                                         free(bufrm);
  19506.  
  19507.                                         bufrm=NULL;
  19508.  
  19509.                                 }
  19510.  
  19511.                                 if(strinf.bufstr)free(strinf.bufstr);
  19512.  
  19513.                         }
  19514.  
  19515.                         else if(j>1)j--;
  19516.  
  19517.                 }
  19518.  
  19519.         }
  19520.  
  19521.         itok=oitok;
  19522.  
  19523.         itok2=oitok2;
  19524.  
  19525.         tok=otok;
  19526.  
  19527.         tok2=otok2;
  19528.  
  19529.         linenum2=oline;
  19530.  
  19531.         inptr2=oinptr;
  19532.  
  19533.         cha2=ocha;
  19534.  
  19535.         endoffile=0;
  19536.  
  19537.         bufrm=obuf;
  19538.  
  19539.         strinf=ostr;
  19540.  
  19541.         if(j==1)retval=FALSE;
  19542.  
  19543.         else if(changesign==1){
  19544.  
  19545.                 changesign++;
  19546.  
  19547.                 goto newloop;
  19548.  
  19549.         }
  19550.  
  19551.         return retval;
  19552.  
  19553. }
  19554.  
  19555.  
  19556.  
  19557. int doqwordvar(int terminater)  //64 bit memory variable
  19558.  
  19559. {
  19560.  
  19561. unsigned char next=1,getfromAX=0;
  19562.  
  19563. unsigned int vop=0,otok,rettype;
  19564.  
  19565. int sign,i;
  19566.  
  19567. ITOK wtok;
  19568.  
  19569. char *wbuf,*rbuf;
  19570.  
  19571. SINFO wstr;
  19572.  
  19573. int retrez=0,pointr=0;
  19574.  
  19575. int numpointr=0;
  19576.  
  19577. int reg;
  19578.  
  19579. char *ofsstr=NULL;
  19580.  
  19581. int reg1=idxregs[0],reg2=idxregs[1];
  19582.  
  19583.         rettype=tk_qword;
  19584.  
  19585.         sign=0;
  19586.  
  19587.         wstr=strinf;
  19588.  
  19589.         strinf.bufstr=NULL;
  19590.  
  19591.         wtok=itok;
  19592.  
  19593.         wbuf=bufrm;
  19594.  
  19595.         bufrm=NULL;
  19596.  
  19597.         otok=tok;
  19598.  
  19599.         nexttok();
  19600.  
  19601.         switch(tok){
  19602.  
  19603.                 case tk_assign: //=
  19604.  
  19605.                         nexttok();
  19606.  
  19607.                         convert_type(&sign,(int *)&rettype,&pointr);
  19608.  
  19609.                         while(tok==tk_mult){
  19610.  
  19611.                                 nexttok();
  19612.  
  19613.                                 numpointr++;
  19614.  
  19615.                         }
  19616.  
  19617.                         if(numpointr>itok.npointr){
  19618.  
  19619.                                 unuseableinput();
  19620.  
  19621.                         }
  19622.  
  19623.                         CheckMinusNum();
  19624.  
  19625.                         if(itok2.type==tp_opperand){    //á«®¦­®¥ ¢ëà ¦¥­¨¥
  19626.  
  19627.                                 if(tok==tk_number){     //¯à®¢¥àª  ¨ á㬬¨à®¢ ­¨¥ ç¨á¥«
  19628.  
  19629.                                         switch(rettype){
  19630.  
  19631.                                                 case tk_float: sign=2; break;
  19632.  
  19633.                                                 case tk_double: sign=3; break;
  19634.  
  19635.                                                 case tk_qword: sign=4; break;
  19636.  
  19637.                                         }
  19638.  
  19639.                                         if(OnlyNumber(sign)){
  19640.  
  19641.                                                 next=0;
  19642.  
  19643.                                                 itok.flag=(unsigned char)postnumflag;
  19644.  
  19645.                                                 goto numbertovar;
  19646.  
  19647.                                         }
  19648.  
  19649.                                 }
  19650.  
  19651.                                 goto labl1;
  19652.  
  19653.                         }
  19654.  
  19655.                         else{
  19656.  
  19657.                                 switch(tok){
  19658.  
  19659.                                         case tk_number:
  19660.  
  19661.                                                 if((itok.flag&f_reloc)==0){
  19662.  
  19663.                                                         if(itok.lnumber==0){
  19664.  
  19665.                                                                 CheckAllMassiv(wbuf,8,&wstr,&wtok);
  19666.  
  19667.                                                                 for(i=0;i<2;i++){
  19668.  
  19669.                                                                         op66(r32);
  19670.  
  19671.                                                                         outseg(&wtok,2);
  19672.  
  19673.                                                                         op(0x83);
  19674.  
  19675.                                                                         op(wtok.rm+0x20);
  19676.  
  19677.                                                                         outaddress(&wtok);
  19678.  
  19679.                                                                         op(0);
  19680.  
  19681.                                                                         if(i==1)break;
  19682.  
  19683.                                                                         wtok.number+=4;
  19684.  
  19685.                                                                         compressoffset(&wtok);
  19686.  
  19687.                                                                 }
  19688.  
  19689.                                                                 break;
  19690.  
  19691.                                                         }
  19692.  
  19693.                                                         if(itok.lnumber==0xFFFFFFFFFFFFFFFFLL){
  19694.  
  19695.                                                                 CheckAllMassiv(wbuf,8,&wstr,&wtok);
  19696.  
  19697.                                                                 for(i=0;i<2;i++){
  19698.  
  19699.                                                                         op66(r32);
  19700.  
  19701.                                                                         outseg(&wtok,2);
  19702.  
  19703.                                                                         op(0x83);
  19704.  
  19705.                                                                         op(wtok.rm+0x8);
  19706.  
  19707.                                                                         outaddress(&wtok);
  19708.  
  19709.                                                                         op(0xFF);
  19710.  
  19711.                                                                         if(i==1)break;
  19712.  
  19713.                                                                         wtok.number+=4;
  19714.  
  19715.                                                                         compressoffset(&wtok);
  19716.  
  19717.                                                                 }
  19718.  
  19719.                                                                 break;
  19720.  
  19721.                                                         }
  19722.  
  19723.                                                 }
  19724.  
  19725. numbertovar:
  19726.  
  19727.                                                 CheckAllMassiv(wbuf,8,&wstr,&wtok);
  19728.  
  19729.                                                 for(i=0;i<2;i++){
  19730.  
  19731.                                                         op66(r32);
  19732.  
  19733.                                                         if(regoverstack&&short_ok(itok.number,TRUE)&&(itok.flag&f_reloc)==0){
  19734.  
  19735.                                                                 op(0x6A);
  19736.  
  19737.                                                                 op(itok.number);        //push short number
  19738.  
  19739.                                                                 op66(r32);
  19740.  
  19741.                                                                 outseg(&wtok,2);
  19742.  
  19743.                                                                 op(0x8f);
  19744.  
  19745.                                                                 op(wtok.rm);
  19746.  
  19747.                                                                 outaddress(&wtok);
  19748.  
  19749.                                                         }
  19750.  
  19751.                                                         else{
  19752.  
  19753.                                                                 outseg(&wtok,2);
  19754.  
  19755.                                                                 op(0xC7);       //mov word[],number
  19756.  
  19757.                                                                 op(wtok.rm);
  19758.  
  19759.                                                                 outaddress(&wtok);
  19760.  
  19761.                                                                 if((itok.flag&f_reloc)!=0)AddReloc();
  19762.  
  19763.                                                                 outdword(itok.number);
  19764.  
  19765.                                                         }
  19766.  
  19767.                                                         if(i==1)break;
  19768.  
  19769.                                                         itok.lnumber>>=32;
  19770.  
  19771.                                                         wtok.number+=4;
  19772.  
  19773.                                                         compressoffset(&wtok);
  19774.  
  19775.                                                 }
  19776.  
  19777.                                                 break;
  19778.  
  19779.                                         case tk_apioffset:
  19780.  
  19781.                                         case tk_postnumber:
  19782.  
  19783.                                         case tk_undefofs:
  19784.  
  19785.                                                 CheckAllMassiv(wbuf,8,&wstr,&wtok);
  19786.  
  19787.                                                 op66(r32);
  19788.  
  19789.                                                 outseg(&wtok,2);
  19790.  
  19791.                                                 op(0xC7);       //mov word[],number
  19792.  
  19793.                                                 op(wtok.rm);
  19794.  
  19795.                                                 outaddress(&wtok);
  19796.  
  19797.                                                 if(tok==tk_apioffset)AddApiToPost(itok.number);
  19798.  
  19799.                                                 else{
  19800.  
  19801.                                                         if(tok==tk_postnumber)(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
  19802.  
  19803.                                                         else if(tok==tk_undefofs)AddUndefOff(0,itok.name);
  19804.  
  19805. //                                              else if((itok.flag&f_reloc)!=0)AddReloc();
  19806.  
  19807.                                                         outdword(itok.number);
  19808.  
  19809.                                                 }
  19810.  
  19811.                                                 wtok.number+=4;
  19812.  
  19813.                                                 compressoffset(&wtok);
  19814.  
  19815.                                                 op66(r32);
  19816.  
  19817.                                                 outseg(&wtok,2);
  19818.  
  19819.                                                 op(0x83);
  19820.  
  19821.                                                 op(wtok.rm+0x20);
  19822.  
  19823.                                                 outaddress(&wtok);
  19824.  
  19825.                                                 op(0);
  19826.  
  19827.                                                 break;
  19828.  
  19829.                                         case tk_reg64:
  19830.  
  19831.                                                 goto getfromreg;
  19832.  
  19833.                                         case tk_reg32:
  19834.  
  19835.                                                 if(itok.number==AX&&wbuf==NULL&&wstr.bufstr==NULL&&
  19836.  
  19837.                                                         ((wtok.rm==rm_d16&&wtok.sib==CODE16)||
  19838.  
  19839.                                                         (wtok.rm==rm_d32&&(wtok.sib==CODE32||wtok.sib==0)))){
  19840.  
  19841.                                                         op66(r32);
  19842.  
  19843.                                                         outseg(&wtok,1);
  19844.  
  19845.                                                         op(0xA3); // MOV [word],AX
  19846.  
  19847.                                                         if(wtok.post==UNDEF_OFSET){
  19848.  
  19849.                                                                 AddUndefOff(2,wtok.name);
  19850.  
  19851.                                                                 wtok.post=0;
  19852.  
  19853.                                                         }
  19854.  
  19855.                                                         if(am32==FALSE)outword(wtok.number);
  19856.  
  19857.                                                         else outdword(wtok.number);
  19858.  
  19859.                                                 }
  19860.  
  19861.                                                 else{
  19862.  
  19863.                                                         CheckAllMassiv(wbuf,8,&wstr,&wtok,reg1,reg2);
  19864.  
  19865.                                                         op66(r32);
  19866.  
  19867.                                                         outseg(&wtok,2);
  19868.  
  19869.                                                         op(0x89);
  19870.  
  19871.                                                         op((unsigned int)itok.number*8+wtok.rm);
  19872.  
  19873.                                                         outaddress(&wtok);
  19874.  
  19875.                                                 }
  19876.  
  19877.                                                 wtok.number+=4;
  19878.  
  19879.                                                 compressoffset(&wtok);
  19880.  
  19881.                                                 op66(r32);
  19882.  
  19883.                                                 outseg(&wtok,2);
  19884.  
  19885.                                                 op(0x83);
  19886.  
  19887.                                                 op(wtok.rm+0x20);
  19888.  
  19889.                                                 outaddress(&wtok);
  19890.  
  19891.                                                 op(0);
  19892.  
  19893.                                                 break;
  19894.  
  19895.                                         case tk_string:
  19896.  
  19897.                                                 CheckAllMassiv(wbuf,8,&wstr,&wtok);
  19898.  
  19899.                                                 op66(r32);
  19900.  
  19901.                                                 outseg(&wtok,2);
  19902.  
  19903.                                                 op(0xC7);
  19904.  
  19905.                                                 op(wtok.rm);
  19906.  
  19907.                                                 outaddress(&wtok);
  19908.  
  19909.                                                 outdword(addpoststring());
  19910.  
  19911.                                                 wtok.number+=4;
  19912.  
  19913.                                                 compressoffset(&wtok);
  19914.  
  19915.                                                 op66(r32);
  19916.  
  19917.                                                 outseg(&wtok,2);
  19918.  
  19919.                                                 op(0x83);
  19920.  
  19921.                                                 op(wtok.rm+0x20);
  19922.  
  19923.                                                 outaddress(&wtok);
  19924.  
  19925.                                                 op(0);
  19926.  
  19927.                                                 break;
  19928.  
  19929.                                         default:
  19930.  
  19931. labl1:
  19932.  
  19933.                                                 reg=EAX|(EDX*256);
  19934.  
  19935.                                                 getintoreg64(reg);
  19936.  
  19937.                                                 doregmath64(reg);
  19938.  
  19939.                                                 getfromAX=1;
  19940.  
  19941.                                                 next=0;
  19942.  
  19943.                                                 break;
  19944.  
  19945.                                 }
  19946.  
  19947.                         }
  19948.  
  19949.                         if(getfromAX){
  19950.  
  19951. getfromax:
  19952.  
  19953.                                 itok.number=EAX|(EDX*256);
  19954.  
  19955. getfromreg:
  19956.  
  19957.                                 reg=itok.number&255;
  19958.  
  19959.                                 for(i=0;i<2;i++){
  19960.  
  19961.                                         if(reg==AX&&wbuf==NULL&&wstr.bufstr==NULL&&
  19962.  
  19963.                                                 ((wtok.rm==rm_d16&&wtok.sib==CODE16)||
  19964.  
  19965.                                                 (wtok.rm==rm_d32&&(wtok.sib==CODE32||wtok.sib==0)))){
  19966.  
  19967.                                                 op66(r32);
  19968.  
  19969.                                                 outseg(&wtok,1);
  19970.  
  19971.                                                 op(0xA3); // MOV [word],AX
  19972.  
  19973.                                                 if(wtok.post==UNDEF_OFSET){
  19974.  
  19975.                                                         AddUndefOff(2,wtok.name);
  19976.  
  19977.                                                         wtok.post=0;
  19978.  
  19979.                                                 }
  19980.  
  19981.                                                 if(am32==FALSE)outword(wtok.number);
  19982.  
  19983.                                                 else outdword(wtok.number);
  19984.  
  19985.                                         }
  19986.  
  19987.                                         else{
  19988.  
  19989.                                                 CheckAllMassiv(wbuf,8,&wstr,&wtok,reg1,reg2);
  19990.  
  19991.                                                 op66(r32);
  19992.  
  19993.                                                 outseg(&wtok,2);
  19994.  
  19995.                                                 op(0x89);
  19996.  
  19997.                                                 op((unsigned int)reg*8+wtok.rm);
  19998.  
  19999.                                                 outaddress(&wtok);
  20000.  
  20001.                                         }
  20002.  
  20003.                                         if(i==1)break;
  20004.  
  20005.                                         wtok.number+=4;
  20006.  
  20007.                                         compressoffset(&wtok);
  20008.  
  20009.                                         reg=itok.number/256;
  20010.  
  20011.                                 }
  20012.  
  20013.                                 warningreg(regs[1][EAX]);
  20014.  
  20015.                                 warningreg(regs[1][EDX]);
  20016.  
  20017.                                 ClearReg(AX);
  20018.  
  20019.                                 ClearReg(DX);
  20020.  
  20021.                                 retrez=tk_reg64;
  20022.  
  20023.                         }
  20024.  
  20025.                         break;
  20026.  
  20027.                 case tk_minusminus: vop=0x8;
  20028.  
  20029.                 case tk_plusplus:
  20030.  
  20031.                         CheckAllMassiv(wbuf,8,&wstr,&wtok);
  20032.  
  20033.                         op66(r32);
  20034.  
  20035.                         outseg(&wtok,2);
  20036.  
  20037. incdec:
  20038.  
  20039.                         op(0xFF); op(vop+wtok.rm);
  20040.  
  20041.                         outaddress(&wtok);
  20042.  
  20043.                         wtok.number+=4;
  20044.  
  20045.                         compressoffset(&wtok);
  20046.  
  20047.                         CheckAllMassiv(wbuf,8,&wstr,&wtok);
  20048.  
  20049.                         op66(r32);
  20050.  
  20051.                         outseg(&wtok,2);
  20052.  
  20053.                         op(0x83); op(0x10+vop+wtok.rm);
  20054.  
  20055.                         outaddress(&wtok);
  20056.  
  20057.                         op(0);
  20058.  
  20059.                         break;
  20060.  
  20061.                 case tk_xorequals: vop+=0x08;
  20062.  
  20063.                 case tk_minusequals: vop+=0x08;
  20064.  
  20065.                 case tk_andequals: vop+=0x18;
  20066.  
  20067.                 case tk_orequals: vop+=0x08;
  20068.  
  20069.                 case tk_plusequals:
  20070.  
  20071.                         getoperand(am32==TRUE?EAX:BX);
  20072.  
  20073.                         if(itok2.type==tp_opperand){
  20074.  
  20075.                                 if(tok==tk_number){
  20076.  
  20077.                                         if(OnlyNumber(4)){
  20078.  
  20079.                                                 next=0;
  20080.  
  20081.                                                 otok=tok;
  20082.  
  20083.                                                 tok=tk_number;
  20084.  
  20085.                                                 goto num;
  20086.  
  20087.                                         }
  20088.  
  20089.                                 }
  20090.  
  20091.                                 goto defxor;
  20092.  
  20093.                         }
  20094.  
  20095.                         else{
  20096.  
  20097.                                 switch(tok){
  20098.  
  20099.                                         case tk_number:
  20100.  
  20101.                                         case tk_postnumber:
  20102.  
  20103.                                         case tk_undefofs:
  20104.  
  20105.                                         case tk_apioffset:
  20106.  
  20107. num:
  20108.  
  20109.                                                 for(i=0;i<2;i++){
  20110.  
  20111.                                                         CheckAllMassiv(wbuf,8,&wstr,&wtok);
  20112.  
  20113.                                                         op66(r32);
  20114.  
  20115.                                                         outseg(&wtok,2);
  20116.  
  20117.                                                         if(tok==tk_number&&(itok.flag&f_reloc)==0&&(vop==0||vop==0x28)){
  20118.  
  20119.                                                                 if(i==0&&itok.lnumber==1){
  20120.  
  20121.                                                                         if(vop)vop=8;
  20122.  
  20123.                                                                         if(next==0)tok=otok;
  20124.  
  20125.                                                                         goto incdec;
  20126.  
  20127.                                                                 }
  20128.  
  20129.                                                                 if(itok.number==1){
  20130.  
  20131.                                                                         op(0xFF); op((vop!=0?8:0)+wtok.rm);
  20132.  
  20133.                                                                         outaddress(&wtok);
  20134.  
  20135.                                                                         goto conl;
  20136.  
  20137.                                                                 }
  20138.  
  20139.                                                         }
  20140.  
  20141.                                                         if(i==1){
  20142.  
  20143.                                                                 if(vop==0)vop+=0x10;
  20144.  
  20145.                                                                 else if(vop==0x28)vop-=0x10;
  20146.  
  20147.                                                         }
  20148.  
  20149.                                                         if(tok!=tk_apioffset&&tok!=tk_undefofs&&tok!=tk_postnumber&&(itok.flag&f_reloc)==0&&
  20150.  
  20151.                                                                 short_ok(itok.number,TRUE)){
  20152.  
  20153.                                                                 op(0x83);
  20154.  
  20155.                                                                 op(vop+wtok.rm);
  20156.  
  20157.                                                                 outaddress(&wtok);
  20158.  
  20159.                                                                 op((unsigned int)itok.number);
  20160.  
  20161.                                                         }
  20162.  
  20163.                                                         else{
  20164.  
  20165.                                                                 op(0x81);
  20166.  
  20167.                                                                 op(vop+wtok.rm);
  20168.  
  20169.                                                                 outaddress(&wtok);
  20170.  
  20171.                                                                 if(tok==tk_apioffset)AddApiToPost(itok.number);
  20172.  
  20173.                                                                 else{
  20174.  
  20175.                                                                         if(tok==tk_postnumber)(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
  20176.  
  20177.                                                                         else if(tok==tk_undefofs)AddUndefOff(0,itok.name);
  20178.  
  20179.                                                                         else if((itok.flag&f_reloc)!=0)AddReloc();
  20180.  
  20181.                                                                         outdword(itok.number);
  20182.  
  20183.                                                                 }
  20184.  
  20185.                                                         }
  20186.  
  20187. conl:
  20188.  
  20189.                                                         wtok.number+=4;
  20190.  
  20191.                                                         compressoffset(&wtok);
  20192.  
  20193.                                                         itok.lnumber>>=32;
  20194.  
  20195.                                                 }
  20196.  
  20197.                                                 if(next==0)tok=otok;
  20198.  
  20199.                                                 break;
  20200.  
  20201.                                         case tk_reg64:
  20202.  
  20203.                                                 reg=itok.number&255;
  20204.  
  20205.                                                 for(i=0;i<2;i++){
  20206.  
  20207.                                                         if(i==1){
  20208.  
  20209.                                                                 if(vop==0)vop+=0x10;
  20210.  
  20211.                                                                 else if(vop==0x28)vop-=0x10;
  20212.  
  20213.                                                         }
  20214.  
  20215.                                                         CheckAllMassiv(wbuf,8,&wstr,&wtok);
  20216.  
  20217.                                                         op66(r32);
  20218.  
  20219.                                                         outseg(&wtok,2);
  20220.  
  20221.                                                         op(0x01+vop); op((unsigned int)reg*8+wtok.rm);
  20222.  
  20223.                                                         outaddress(&wtok);
  20224.  
  20225.                                                         if(i==1)break;
  20226.  
  20227.                                                         wtok.number+=4;
  20228.  
  20229.                                                         compressoffset(&wtok);
  20230.  
  20231.                                                         reg=itok.number/256;
  20232.  
  20233.                                                 }
  20234.  
  20235.                                                 break;
  20236.  
  20237.                                         default:
  20238.  
  20239. defxor:
  20240.  
  20241.                                                 reg=EAX|(EDX*256);
  20242.  
  20243.                                                 getintoreg64(reg);
  20244.  
  20245.                                                 doregmath64(reg);
  20246.  
  20247.                                                 CheckAllMassiv(wbuf,8,&wstr,&wtok);
  20248.  
  20249.                                                 reg=EAX;
  20250.  
  20251.                                                 for(i=0;i<2;i++){
  20252.  
  20253.                                                         op66(r32);
  20254.  
  20255.                                                         op(0x01+vop);
  20256.  
  20257.                                                         op(wtok.rm+reg*8);
  20258.  
  20259.                                                         outaddress(&wtok);
  20260.  
  20261.                                                         if(i==1)break;
  20262.  
  20263.                                                         if(vop==0)vop=0x10;
  20264.  
  20265.                                                         if(vop==0x28)vop=0x18;
  20266.  
  20267.                                                         reg=EDX;
  20268.  
  20269.                                                         wtok.number+=4;
  20270.  
  20271.                                                         compressoffset(&wtok);
  20272.  
  20273.                                                 }
  20274.  
  20275.                                                 next=0;
  20276.  
  20277.                                                 retrez=tk_reg64;
  20278.  
  20279.                                                 warningreg(regs[1][EAX]);
  20280.  
  20281.                                                 warningreg(regs[1][EDX]);
  20282.  
  20283.                                                 break;
  20284.  
  20285.                                 }
  20286.  
  20287.                         }
  20288.  
  20289.                         break;
  20290.  
  20291.                 case tk_multequals:
  20292.  
  20293.                         getoperand(am32==TRUE?EAX:BX);
  20294.  
  20295.                         if(itok2.type==tp_stopper&&tok==tk_number&&(itok.flag&f_reloc)==0){
  20296.  
  20297.                                 if(itok.lnumber==1)break;
  20298.  
  20299.                                 if(itok.lnumber==0){
  20300.  
  20301.                                         ZeroReg(EAX,r32);
  20302.  
  20303.                                         ZeroReg(EDX,r32);
  20304.  
  20305.                                         goto getfromax;
  20306.  
  20307.                                 }
  20308.  
  20309.                                 if((i=caselong(itok.number))!=NUMNUM){
  20310.  
  20311.                                         if(wbuf==NULL&&wstr.bufstr==NULL&&
  20312.  
  20313.                                                         ((wtok.rm==rm_d16&&wtok.sib==CODE16)||
  20314.  
  20315.                                                         (wtok.rm==rm_d32&&(wtok.sib==CODE32||wtok.sib==0)))){
  20316.  
  20317.                                                 op66(r32);
  20318.  
  20319.                                                 outseg(&wtok,1);
  20320.  
  20321.                                                 op(0xA1); // MOV EAX,[dword]
  20322.  
  20323.                                                 if(wtok.post==UNDEF_OFSET){
  20324.  
  20325.                                                         AddUndefOff(2,wtok.name);
  20326.  
  20327.                                                         wtok.post=0;
  20328.  
  20329.                                                 }
  20330.  
  20331.                                                 if(am32==FALSE)outword(wtok.number);
  20332.  
  20333.                                                 else outdword(wtok.number);
  20334.  
  20335.                                         }
  20336.  
  20337.                                         else{
  20338.  
  20339.                                                 CheckAllMassiv(wbuf,8,&wstr,&wtok,reg1,reg2);
  20340.  
  20341.                                                 op66(r32);
  20342.  
  20343.                                                 outseg(&wtok,2);
  20344.  
  20345.                                                 op(0x8B);
  20346.  
  20347.                                                 op(wtok.rm);
  20348.  
  20349.                                                 outaddress(&wtok);
  20350.  
  20351.                                         }
  20352.  
  20353.                                         wtok.number+=4;
  20354.  
  20355.                                         compressoffset(&wtok);
  20356.  
  20357.                                         ClearReg(AX);
  20358.  
  20359.                                         CheckAllMassiv(wbuf,8,&wstr,&wtok);
  20360.  
  20361.                                         op66(r32);
  20362.  
  20363.                                         outseg(&wtok,3);
  20364.  
  20365.                                         op(0x0F);
  20366.  
  20367.                                         op(0xA4+vop);
  20368.  
  20369.                                         op(wtok.rm);  // SHLD [rmword],CL
  20370.  
  20371.                                         outaddress(&wtok);
  20372.  
  20373.                                         op(i);
  20374.  
  20375.                                         wtok.number-=4;
  20376.  
  20377.                                         compressoffset(&wtok);
  20378.  
  20379.                                         CheckAllMassiv(wbuf,8,&wstr,&wtok);
  20380.  
  20381.                                         op66(r32);
  20382.  
  20383.                                         outseg(&wtok,2);
  20384.  
  20385.                                         op(0xC1);
  20386.  
  20387.                                         op(0x20+wtok.rm);
  20388.  
  20389.                                         outaddress(&wtok);
  20390.  
  20391.                                         op(i);
  20392.  
  20393.                                         break;
  20394.  
  20395.                                 }
  20396.  
  20397.                         }
  20398.  
  20399.                         CheckAllMassiv(wbuf,8,&wstr,&wtok);
  20400.  
  20401.                         wtok.number+=4;
  20402.  
  20403.                         compressoffset(&wtok);
  20404.  
  20405.                         for(i=0;i<2;i++){
  20406.  
  20407.                                 op66(r32);
  20408.  
  20409.                                 outseg(&wtok,2);
  20410.  
  20411.                                 op(0xFF);       op(0x30+wtok.rm);
  20412.  
  20413.                                 outaddress(&wtok);
  20414.  
  20415.                                 if(i==1)break;
  20416.  
  20417.                                 wtok.number-=4;
  20418.  
  20419.                                 compressoffset(&wtok);
  20420.  
  20421.                         }
  20422.  
  20423.                         reg=ECX|(EAX*256);
  20424.  
  20425.                         getintoreg64(reg);
  20426.  
  20427.                         doregmath64(reg);
  20428.  
  20429.                         CallExternProc("__llmul");
  20430.  
  20431.                         next=0;
  20432.  
  20433.                         goto getfromax;
  20434.  
  20435.                 case tk_divequals:
  20436.  
  20437.                         getoperand(am32==TRUE?EAX:BX);
  20438.  
  20439.                         if(itok2.type==tp_stopper&&tok==tk_number&&(itok.flag&f_reloc)==0){
  20440.  
  20441.                                 if(itok.number==0){
  20442.  
  20443.                                         DevideZero();
  20444.  
  20445.                                         break;
  20446.  
  20447.                                 }
  20448.  
  20449.                                 if(itok.number==1)break;
  20450.  
  20451.                                 if((i=caselong(itok.number))!=NUMNUM){
  20452.  
  20453.                                         wtok.number+=4;
  20454.  
  20455.                                         compressoffset(&wtok);
  20456.  
  20457.                                         if(wbuf==NULL&&wstr.bufstr==NULL&&
  20458.  
  20459.                                                         ((wtok.rm==rm_d16&&wtok.sib==CODE16)||
  20460.  
  20461.                                                         (wtok.rm==rm_d32&&(wtok.sib==CODE32||wtok.sib==0)))){
  20462.  
  20463.                                                 op66(r32);
  20464.  
  20465.                                                 outseg(&wtok,1);
  20466.  
  20467.                                                 op(0xA1); // MOV EAX,[dword]
  20468.  
  20469.                                                 if(wtok.post==UNDEF_OFSET){
  20470.  
  20471.                                                         AddUndefOff(2,wtok.name);
  20472.  
  20473.                                                         wtok.post=0;
  20474.  
  20475.                                                 }
  20476.  
  20477.                                                 if(am32==FALSE)outword(wtok.number);
  20478.  
  20479.                                                 else outdword(wtok.number);
  20480.  
  20481.                                         }
  20482.  
  20483.                                         else{
  20484.  
  20485.                                                 CheckAllMassiv(wbuf,8,&wstr,&wtok,reg1,reg2);
  20486.  
  20487.                                                 op66(r32);
  20488.  
  20489.                                                 outseg(&wtok,2);
  20490.  
  20491.                                                 op(0x8B);
  20492.  
  20493.                                                 op(wtok.rm);
  20494.  
  20495.                                                 outaddress(&wtok);
  20496.  
  20497.                                         }
  20498.  
  20499.                                         wtok.number-=4;
  20500.  
  20501.                                         compressoffset(&wtok);
  20502.  
  20503.                                         ClearReg(AX);
  20504.  
  20505.                                         CheckAllMassiv(wbuf,8,&wstr,&wtok);
  20506.  
  20507.                                         op66(r32);
  20508.  
  20509.                                         outseg(&wtok,3);
  20510.  
  20511.                                         op(0x0F);
  20512.  
  20513.                                         op(0xAC);
  20514.  
  20515.                                         op(wtok.rm);  // SHLD [rmword],CL
  20516.  
  20517.                                         outaddress(&wtok);
  20518.  
  20519.                                         op(i);
  20520.  
  20521.                                         wtok.number+=4;
  20522.  
  20523.                                         compressoffset(&wtok);
  20524.  
  20525.                                         CheckAllMassiv(wbuf,8,&wstr,&wtok);
  20526.  
  20527.                                         op66(r32);
  20528.  
  20529.                                         outseg(&wtok,2);
  20530.  
  20531.                                         op(0xC1);
  20532.  
  20533.                                         op(0x28+wtok.rm);
  20534.  
  20535.                                         outaddress(&wtok);
  20536.  
  20537.                                         op(i);
  20538.  
  20539.                                         break;
  20540.  
  20541.                                 }
  20542.  
  20543.                                 unsigned long number;
  20544.  
  20545.                                 number=itok.lnumber>>32;
  20546.  
  20547.                                 for(i=0;i<2;i++){
  20548.  
  20549.                                         op66(r32);
  20550.  
  20551.                                         if((itok.flag&f_reloc)==0&&short_ok(number,1)){
  20552.  
  20553.                                                 op(0x6A);
  20554.  
  20555.                                                 op(number);
  20556.  
  20557.                                         }
  20558.  
  20559.                                         else{
  20560.  
  20561.                                                 op(0x68);
  20562.  
  20563.                                                 if(i==0&&(itok.flag&f_reloc)!=0)AddReloc();
  20564.  
  20565.                                                 outdword(number);
  20566.  
  20567.                                         }
  20568.  
  20569.                                         if(i==1)break;
  20570.  
  20571.                                         number=itok.number;
  20572.  
  20573.                                 }
  20574.  
  20575.                                 goto divcont;
  20576.  
  20577.                         }
  20578.  
  20579.                         reg=EAX|(EDX*256);
  20580.  
  20581.                         getintoreg64(reg);
  20582.  
  20583.                         doregmath64(reg);
  20584.  
  20585.                         op66(r32);
  20586.  
  20587.                         op(0x50+EDX);
  20588.  
  20589.                         op66(r32);
  20590.  
  20591.                         op(0x50+EAX);
  20592.  
  20593.                         next=0;
  20594.  
  20595. divcont:
  20596.  
  20597.                         addESP+=8;
  20598.  
  20599.                         if(ESPloc&&am32&&wtok.segm==SS)wtok.number+=8;
  20600.  
  20601.                         reg=EAX;
  20602.  
  20603.                         for(i=0;i<2;i++){
  20604.  
  20605.                                 if(reg==AX&&wbuf==NULL&&wstr.bufstr==NULL&&
  20606.  
  20607.                                         ((wtok.rm==rm_d16&&wtok.sib==CODE16)||
  20608.  
  20609.                                         (wtok.rm==rm_d32&&(wtok.sib==CODE32||wtok.sib==0)))){
  20610.  
  20611.                                         op66(r32);
  20612.  
  20613.                                         outseg(&wtok,1);
  20614.  
  20615.                                         op(0xA1);
  20616.  
  20617.                                         if(wtok.post==UNDEF_OFSET){
  20618.  
  20619.                                                 AddUndefOff(2,wtok.name);
  20620.  
  20621.                                         }
  20622.  
  20623.                                         if(am32==FALSE)outword(wtok.number);
  20624.  
  20625.                                         else outdword(wtok.number);
  20626.  
  20627.                                 }
  20628.  
  20629.                                 else{
  20630.  
  20631.                                         CheckAllMassiv(wbuf,8,&wstr,&wtok,reg1,reg2);
  20632.  
  20633.                                         op66(r32);
  20634.  
  20635.                                         outseg(&wtok,2);
  20636.  
  20637.                                         op(0x8B);
  20638.  
  20639.                                         op(reg*8+wtok.rm);
  20640.  
  20641.                                         outaddress(&wtok);
  20642.  
  20643.                                 }
  20644.  
  20645.                                 if(i==1)break;
  20646.  
  20647.                                 wtok.number+=4;
  20648.  
  20649.                                 compressoffset(&wtok);
  20650.  
  20651.                                 reg=EDX;
  20652.  
  20653.                         }
  20654.  
  20655.                         CallExternProc("__lludiv");
  20656.  
  20657.                         addESP-=8;
  20658.  
  20659.                         wtok.number-=4;
  20660.  
  20661.                         compressoffset(&wtok);
  20662.  
  20663.                         goto getfromax;
  20664.  
  20665.                 case tk_swap:
  20666.  
  20667.                         int regdi;
  20668.  
  20669.                         regdi=TRUE;
  20670.  
  20671.                         getoperand();
  20672.  
  20673.                         rbuf=bufrm;
  20674.  
  20675.                         bufrm=NULL;
  20676.  
  20677.                         if(am32!=FALSE&&wbuf!=NULL&&wstr.bufstr!=NULL)regdi=FALSE;
  20678.  
  20679.                         switch(tok){
  20680.  
  20681.                                 case tk_reg64:
  20682.  
  20683.                                         CheckAllMassiv(wbuf,8,&wstr,&wtok);
  20684.  
  20685.                                         reg=itok.number&255;
  20686.  
  20687.                                         for(i=0;i<2;i++){
  20688.  
  20689.                                                 op66(r32);
  20690.  
  20691.                                                 outseg(&wtok,2);
  20692.  
  20693.                                                 op(0x87);
  20694.  
  20695.                                                 op(reg*8+wtok.rm);
  20696.  
  20697.                                                 outaddress(&wtok);
  20698.  
  20699.                                                 ClearReg(reg);
  20700.  
  20701.                                                 if(i==1)break;
  20702.  
  20703.                                                 reg=itok.number/256;
  20704.  
  20705.                                                 wtok.number+=4;
  20706.  
  20707.                                                 compressoffset(&wtok);
  20708.  
  20709.                                         }
  20710.  
  20711.                                         break;
  20712.  
  20713.                                 case tk_qwordvar:
  20714.  
  20715.                                         for(i=0;i<2;i++){
  20716.  
  20717.                                                 getinto_e_ax(0,tk_dwordvar,&wtok,wbuf,&wstr,r32,TRUE);
  20718.  
  20719.                                                 CheckAllMassiv(rbuf,8,&strinf,&itok,regdi==FALSE?BX:DI,DX);
  20720.  
  20721.                                                 op66(r32);
  20722.  
  20723.                                                 outseg(&itok,2);
  20724.  
  20725.                                                 op(0x87);  // XCHG AX,[wloc]
  20726.  
  20727.                                                 op(itok.rm);
  20728.  
  20729.                                                 outaddress(&itok);
  20730.  
  20731.                                                 KillVar(itok.name);
  20732.  
  20733.                                                 if(wbuf==NULL&&wstr.bufstr==NULL&&
  20734.  
  20735.                                                                 ((wtok.rm==rm_d16&&wtok.sib==CODE16)||
  20736.  
  20737.                                                                 (wtok.rm==rm_d32&&(wtok.sib==CODE32||wtok.sib==0)))){
  20738.  
  20739.                                                         op66(r32);
  20740.  
  20741.                                                         outseg(&wtok,1);
  20742.  
  20743.                                                         op(0xA3); /* MOV [word],AX */
  20744.  
  20745.                                                         if(wtok.post==UNDEF_OFSET){
  20746.  
  20747.                                                                 AddUndefOff(2,wtok.name);
  20748.  
  20749.                                                                 wtok.post=0;
  20750.  
  20751.                                                         }
  20752.  
  20753.                                                         if(am32==FALSE)outword(wtok.number);    //????
  20754.  
  20755.                                                         else outdword(wtok.number);
  20756.  
  20757.                                                 }
  20758.  
  20759.                                                 else{
  20760.  
  20761.                                                         CheckAllMassiv(wbuf,8,&wstr,&wtok,reg1,reg2);
  20762.  
  20763.                                                         op66(r32);
  20764.  
  20765.                                                         outseg(&wtok,2);
  20766.  
  20767.                                                         op(0x89); op(wtok.rm); /* MOV [rmword],AX */
  20768.  
  20769.                                                         outaddress(&wtok);
  20770.  
  20771.                                                 }
  20772.  
  20773.                                                 if(i==1)break;
  20774.  
  20775.                                                 itok.number+=4;
  20776.  
  20777.                                                 compressoffset(&itok);
  20778.  
  20779.                                                 wtok.number+=4;
  20780.  
  20781.                                                 compressoffset(&wtok);
  20782.  
  20783.                                         }
  20784.  
  20785.                                         warningreg(regs[1][EAX]);
  20786.  
  20787.                                         ClearReg(EAX);
  20788.  
  20789.                                         break;
  20790.  
  20791.                                 default: swaperror(); break;
  20792.  
  20793.                         }
  20794.  
  20795.                         break;
  20796.  
  20797.                 case tk_rrequals:
  20798.  
  20799.                         vop=8;
  20800.  
  20801.                         wtok.number+=4;
  20802.  
  20803.                         compressoffset(&wtok);
  20804.  
  20805.                 case tk_llequals:
  20806.  
  20807.                         getoperand(am32==TRUE?ECX:BX);
  20808.  
  20809.                         if(itok2.type!=tp_stopper){
  20810.  
  20811.                                 getintobeg(CL,&ofsstr);
  20812.  
  20813.                                 ClearReg(CX);
  20814.  
  20815.                                 warningreg(begs[1]);
  20816.  
  20817.                                 next=0;
  20818.  
  20819.                                 i=1;
  20820.  
  20821.                         }
  20822.  
  20823.                         else if(tok==tk_number){
  20824.  
  20825.                                 i=0;
  20826.  
  20827.                         }
  20828.  
  20829.                         else{
  20830.  
  20831.                                 if(tok!=tk_beg||(unsigned int)itok.number!=CL){
  20832.  
  20833.                                         getintobeg(CL,&ofsstr);
  20834.  
  20835.                                         ClearReg(CX);
  20836.  
  20837.                                         warningreg(begs[1]);
  20838.  
  20839.                                         next=0;
  20840.  
  20841.                                 }
  20842.  
  20843.                                 i=1;
  20844.  
  20845.                         }
  20846.  
  20847.                         if(wbuf==NULL&&wstr.bufstr==NULL&&
  20848.  
  20849.                                 ((wtok.rm==rm_d16&&wtok.sib==CODE16)||
  20850.  
  20851.                                 (wtok.rm==rm_d32&&(wtok.sib==CODE32||wtok.sib==0)))){
  20852.  
  20853.                                 op66(r32);
  20854.  
  20855.                                 outseg(&wtok,1);
  20856.  
  20857.                                 op(0xA1); // MOV EAX,[dword]
  20858.  
  20859.                                 if(wtok.post==UNDEF_OFSET){
  20860.  
  20861.                                         AddUndefOff(2,wtok.name);
  20862.  
  20863.                                         wtok.post=0;
  20864.  
  20865.                                 }
  20866.  
  20867.                                 if(am32==FALSE)outword(wtok.number);
  20868.  
  20869.                                 else outdword(wtok.number);
  20870.  
  20871.                         }
  20872.  
  20873.                         else{
  20874.  
  20875.                                 CheckAllMassiv(wbuf,8,&wstr,&wtok,reg1,reg2);
  20876.  
  20877.                                 op66(r32);
  20878.  
  20879.                                 outseg(&wtok,2);
  20880.  
  20881.                                 op(0x8B);
  20882.  
  20883.                                 op(wtok.rm);
  20884.  
  20885.                                 outaddress(&wtok);
  20886.  
  20887.                         }
  20888.  
  20889.                         if(vop)wtok.number-=4;
  20890.  
  20891.                         else wtok.number+=4;
  20892.  
  20893.                         compressoffset(&wtok);
  20894.  
  20895.                         ClearReg(AX);
  20896.  
  20897.                         warningreg(regs[1][EAX]);
  20898.  
  20899.                         CheckAllMassiv(wbuf,8,&wstr,&wtok);
  20900.  
  20901.                         op66(r32);
  20902.  
  20903.                         outseg(&wtok,3);
  20904.  
  20905.                         op(0x0F);
  20906.  
  20907.                         op(0xA4+vop+i);
  20908.  
  20909.                         op(wtok.rm);  // SHLD [rmword],CL
  20910.  
  20911.                         outaddress(&wtok);
  20912.  
  20913.                         if(i==0)op((unsigned int)itok.number);
  20914.  
  20915.                         if(vop)wtok.number+=4;
  20916.  
  20917.                         else wtok.number-=4;
  20918.  
  20919.                         compressoffset(&wtok);
  20920.  
  20921.                         CheckAllMassiv(wbuf,8,&wstr,&wtok);
  20922.  
  20923.                         op66(r32);
  20924.  
  20925.                         outseg(&wtok,2);
  20926.  
  20927.                         op(i==0?0xC1:0xD3);
  20928.  
  20929.                         op(0x20+vop+wtok.rm);
  20930.  
  20931.                         outaddress(&wtok);
  20932.  
  20933.                         if(i==0)op(itok.number);
  20934.  
  20935.                         break;
  20936.  
  20937.                 default: operatorexpected(); break;
  20938.  
  20939.         }
  20940.  
  20941.         KillVar(wtok.name);
  20942.  
  20943.         if(next)nexttok();
  20944.  
  20945.         if(terminater==tk_semicolon)seminext();
  20946.  
  20947.         if(cpu<3)cpu=3;
  20948.  
  20949.         return retrez;
  20950.  
  20951. }
  20952.  
  20953.  
  20954.  
  20955. void Select2FreeReg(int r1,int r2,int *reg1,int *reg2)
  20956.  
  20957. {
  20958.  
  20959.         *reg1=idxregs[0];
  20960.  
  20961.         *reg2=idxregs[1];
  20962.  
  20963.         if(r1==idxregs[0]){
  20964.  
  20965.                 if(r2==idxregs[1]){
  20966.  
  20967.                         *reg1=idxregs[2];
  20968.  
  20969.                         *reg2=idxregs[3];
  20970.  
  20971.                 }
  20972.  
  20973.                 else{
  20974.  
  20975.                         *reg1=idxregs[1];
  20976.  
  20977.                         if(r2==idxregs[2])*reg2=idxregs[3];
  20978.  
  20979.                         else *reg2=idxregs[2];
  20980.  
  20981.                 }
  20982.  
  20983.         }
  20984.  
  20985.         if(r1==idxregs[1]){
  20986.  
  20987.                 if(r2==idxregs[0]){
  20988.  
  20989.                         *reg1=idxregs[2];
  20990.  
  20991.                         *reg2=idxregs[3];
  20992.  
  20993.                 }
  20994.  
  20995.                 else{
  20996.  
  20997.                         *reg1=idxregs[0];
  20998.  
  20999.                         if(r2==idxregs[2])*reg2=idxregs[3];
  21000.  
  21001.                         else *reg2=idxregs[2];
  21002.  
  21003.                 }
  21004.  
  21005.         }
  21006.  
  21007. }
  21008.  
  21009.  
  21010.  
  21011. void doreg64(int reg,int terminater)
  21012.  
  21013. {
  21014.  
  21015. unsigned char next=1;
  21016.  
  21017. int vop=0,sign=0;
  21018.  
  21019. int i;
  21020.  
  21021. int reg1,reg2;
  21022.  
  21023. unsigned long long ii;
  21024.  
  21025. int r1,r2;
  21026.  
  21027. char *ofsstr=NULL;
  21028.  
  21029. int rettype;
  21030.  
  21031. int pointr=0;
  21032.  
  21033. int numpointr=0;
  21034.  
  21035.         rettype=tk_qword;
  21036.  
  21037.         r1=reg&255;
  21038.  
  21039.         r2=reg/256;
  21040.  
  21041.         Select2FreeReg(r1,r2,&reg1,&reg2);
  21042.  
  21043.         if(r1==ESP||r2==ESP)RestoreStack();
  21044.  
  21045.         nexttok();
  21046.  
  21047.         switch(tok){
  21048.  
  21049.                 case tk_assign://=
  21050.  
  21051.                         nexttok();
  21052.  
  21053.                         /*-----------------31.08.05 18:39-------------------
  21054.  
  21055.  
  21056.  
  21057.                         --------------------------------------------------*/
  21058.  
  21059.                         convert_type(&sign,(int *)&rettype,&pointr);
  21060.  
  21061.                         while(tok==tk_mult){
  21062.  
  21063.                                 nexttok();
  21064.  
  21065.                                 numpointr++;
  21066.  
  21067.                         }
  21068.  
  21069.                         if(numpointr>itok.npointr){
  21070.  
  21071.                                 unuseableinput();
  21072.  
  21073.                         }
  21074.  
  21075.                         CheckMinusNum();
  21076.  
  21077.                         if(tok==tk_number){     //¯à®¢¥àª  ¨ á㬬¨à®¢ ­¨¥ ç¨á¥«
  21078.  
  21079.                                 switch(rettype){
  21080.  
  21081.                                         case tk_float: sign=2; break;
  21082.  
  21083.                                         case tk_double: sign=3; break;
  21084.  
  21085.                                         case tk_qword: sign=4; break;
  21086.  
  21087.                                 }
  21088.  
  21089.                                 if(OnlyNumber(sign)){
  21090.  
  21091.                                         MovRegNum(r32,postnumflag&f_reloc,itok.number,r1);
  21092.  
  21093.                                         MovRegNum(r32,0,itok.lnumber>>32,r2);
  21094.  
  21095.                                         next=0;
  21096.  
  21097.                                         break;
  21098.  
  21099.                                 }
  21100.  
  21101.                         }
  21102.  
  21103.                         if(rettype==tk_float||rettype==tk_double){
  21104.  
  21105.                                 doeaxfloatmath(tk_stackstart,0,rettype==tk_float?0:4);
  21106.  
  21107.                                 op66(r32);
  21108.  
  21109.                                 op(0x58+r1);
  21110.  
  21111.                                 op66(r32);
  21112.  
  21113.                                 if(rettype==tk_float){
  21114.  
  21115.                                         op(0x31); op(0xC0+r2*9);
  21116.  
  21117.                                 }
  21118.  
  21119.                                 else op(0x58+r2);
  21120.  
  21121.                                 next=0;
  21122.  
  21123.                                 break;
  21124.  
  21125.                         }
  21126.  
  21127.                         /*-----------------31.08.05 18:39-------------------
  21128.  
  21129.  
  21130.  
  21131.                         --------------------------------------------------*/
  21132.  
  21133.                         getintoreg64(reg);
  21134.  
  21135.                         doregmath64(reg);
  21136.  
  21137.                         next=0;
  21138.  
  21139.                         break;
  21140.  
  21141.                 case tk_plusplus: op66(r32); op(0x40+r1);
  21142.  
  21143.                         op66(r32);
  21144.  
  21145.                         op(0x83);
  21146.  
  21147.                         op(0xD0+r2);
  21148.  
  21149.                         op(0);
  21150.  
  21151.                         break;
  21152.  
  21153.                 case tk_minusminus: op66(r32); op(0x48+r1);
  21154.  
  21155.                         op66(r32);
  21156.  
  21157.                         op(0x83);
  21158.  
  21159.                         op(0xD8+r2);
  21160.  
  21161.                         op(0);
  21162.  
  21163.                         break;
  21164.  
  21165.                 case tk_swap:
  21166.  
  21167.                         getoperand(reg1);
  21168.  
  21169.                         switch(tok){
  21170.  
  21171.                                 case tk_qwordvar:
  21172.  
  21173.                                         reg=r1;
  21174.  
  21175.                                         for(i=0;i<2;i++){
  21176.  
  21177.                                                 CheckAllMassiv(bufrm,8,&strinf,&itok,reg1,reg2);
  21178.  
  21179.                                                 op66(r32);
  21180.  
  21181.                                                 outseg(&itok,2);
  21182.  
  21183.                                                 op(0x87);
  21184.  
  21185.                                                 op(reg*8+itok.rm);
  21186.  
  21187.                                                 outaddress(&itok);
  21188.  
  21189.                                                 itok.number+=4;
  21190.  
  21191.                                                 compressoffset(&itok);
  21192.  
  21193.                                                 reg=r2;
  21194.  
  21195.                                         }
  21196.  
  21197.                                         break;
  21198.  
  21199.                                 case tk_reg64:
  21200.  
  21201.                                         reg=r1;
  21202.  
  21203.                                         vop=itok.number;
  21204.  
  21205.                                         itok.number&=255;
  21206.  
  21207.                                         for(i=0;i<2;i++){
  21208.  
  21209.                                                 if(reg!=(int)itok.number){
  21210.  
  21211.                                                         if(RegSwapReg(reg,itok.number,r32)==NOINREG){;
  21212.  
  21213.                                                                 op66(r32);
  21214.  
  21215.                                                                 if(reg==AX)op(0x90+(unsigned int)itok.number);
  21216.  
  21217.                                                                 else if((unsigned int)itok.number==AX)op(0x90+reg);
  21218.  
  21219.                                                                 else{
  21220.  
  21221.                                                                         op(0x87);
  21222.  
  21223.                                                                         op(0xC0+(unsigned int)itok.number+reg*8);
  21224.  
  21225.                                                                 }
  21226.  
  21227.                                                         }
  21228.  
  21229.                                                         else waralreadinitreg(regs[1][reg],regs[1][itok.number]);
  21230.  
  21231.                                                 }
  21232.  
  21233.                                                 reg=r2;
  21234.  
  21235.                                                 itok.number=vop/256;
  21236.  
  21237.                                         }
  21238.  
  21239.                                         break;
  21240.  
  21241.                                 default: swaperror(); break;
  21242.  
  21243.                         }
  21244.  
  21245.                         break;
  21246.  
  21247.                 case tk_xorequals: vop+=0x08;
  21248.  
  21249.                 case tk_minusequals: vop+=0x08;
  21250.  
  21251.                 case tk_andequals: vop+=0x18;
  21252.  
  21253.                 case tk_orequals: vop+=0x08;
  21254.  
  21255.                 case tk_plusequals:
  21256.  
  21257.                         if(CheckAddOnly()){
  21258.  
  21259.                                 inptr2--;
  21260.  
  21261.                                 cha2=' ';
  21262.  
  21263.                                 if(tok==tk_plusequals)tok=tk_plus;
  21264.  
  21265.                                 else tok=tk_minus;
  21266.  
  21267.                                 doregmath64(reg);
  21268.  
  21269.                                 next=0;
  21270.  
  21271.                                 break;
  21272.  
  21273.                         }
  21274.  
  21275.                         getoperand(reg1);
  21276.  
  21277.                         if(itok2.type==tp_opperand&&tok!=tk_number&&tok!=tk_undefofs&&
  21278.  
  21279.                                 tok!=tk_postnumber)goto defadd;
  21280.  
  21281.                         CheckMinusNum();
  21282.  
  21283.                         idrec *rrec;
  21284.  
  21285.                         int opost;
  21286.  
  21287.                         i=tok;
  21288.  
  21289.                         switch(tok){
  21290.  
  21291.                                 case tk_postnumber:
  21292.  
  21293.                                 case tk_undefofs:
  21294.  
  21295.                                         ii=itok.number;
  21296.  
  21297.                                         rrec=itok.rec;
  21298.  
  21299.                                         opost=itok.post;
  21300.  
  21301.                                         char uname[IDLENGTH];
  21302.  
  21303.                                         strcpy(uname,itok.name);
  21304.  
  21305.                                         if(itok.flag&f_extern)goto addnum;
  21306.  
  21307.                                         tok=tk_number;
  21308.  
  21309.                                 case tk_number:
  21310.  
  21311.                                         ii=doconstqwordmath();
  21312.  
  21313.                                         next=0;
  21314.  
  21315.                                         if(itok.type==tp_opperand){
  21316.  
  21317.                                                 sign=reg1|(reg2*256);
  21318.  
  21319.                                                 if(i==tk_postnumber||i==tk_undefofs){
  21320.  
  21321.                                                         op66(r32);
  21322.  
  21323.                                                         op(0xB8+r1);    // MOV reg,#
  21324.  
  21325.                                                         if(i==tk_postnumber)(postnumflag&f_extern)==0?setwordpost(&itok):setwordext((long *)&ii);
  21326.  
  21327.                                                         else{
  21328.  
  21329.                                                                 if((postnumflag&f_reloc)!=0)AddReloc();
  21330.  
  21331.                                                                 if(i==tk_undefofs)AddUndefOff(2,uname);
  21332.  
  21333.                                                         }
  21334.  
  21335.                                                         outdword(ii);
  21336.  
  21337.                                                         ZeroReg(r2,r32);
  21338.  
  21339.                                                 }
  21340.  
  21341.                                                 else{
  21342.  
  21343.                                                         MovRegNum(r32,postnumflag&f_reloc,ii,reg1);
  21344.  
  21345.                                                         MovRegNum(r32,postnumflag&f_reloc,ii>>=32,reg2);
  21346.  
  21347.                                                 }
  21348.  
  21349.                                                 doregmath64(sign);
  21350.  
  21351.                                                 itok.number=sign;
  21352.  
  21353.                                                 goto addreg;
  21354.  
  21355.                                         }
  21356.  
  21357.                                         if((postnumflag&f_reloc)==0&&i!=tk_undefofs&&i!=tk_postnumber){
  21358.  
  21359.                                                 optnumadd64(ii,r1,r2,vop);
  21360.  
  21361.                                                 break;
  21362.  
  21363.                                         }
  21364.  
  21365. addnum:
  21366.  
  21367.                                         op66(r32);
  21368.  
  21369.                                   if(r1==AX)op(0x05+vop);
  21370.  
  21371.                                         else{
  21372.  
  21373.                                                 op(0x81);
  21374.  
  21375.                                                 op(0xC0+vop+r1);
  21376.  
  21377.                                         }
  21378.  
  21379.                                         itok.rec=rrec;
  21380.  
  21381.                                         itok.post=opost;
  21382.  
  21383.                                         if(i==tk_postnumber)(postnumflag&f_extern)==0?setwordpost(&itok):setwordext((long *)&ii);
  21384.  
  21385.                                         else{
  21386.  
  21387.                                                 if((postnumflag&f_reloc)!=0)AddReloc();
  21388.  
  21389.                                                 if(i==tk_undefofs)AddUndefOff(2,uname);
  21390.  
  21391.                                         }
  21392.  
  21393.                                         outdword(ii);
  21394.  
  21395.                                         ii>>=32;
  21396.  
  21397.                                         if(vop==0)vop=0x10;
  21398.  
  21399.                                         else if(vop==0x28)vop=0x18;
  21400.  
  21401.                                         op66(r32);
  21402.  
  21403.                                   if(r2==AX)op(0x05+vop);
  21404.  
  21405.                                         else{
  21406.  
  21407.                                                 op(0x81);
  21408.  
  21409.                                                 op(0xC0+vop+r2);
  21410.  
  21411.                                         }
  21412.  
  21413.                                         outdword(ii);
  21414.  
  21415.                                         break;
  21416.  
  21417.                                 case tk_longvar:
  21418.  
  21419.                                 case tk_dwordvar:
  21420.  
  21421.                                         CheckAllMassiv(bufrm,4,&strinf,&itok,reg1,reg2);
  21422.  
  21423.                                         op66(r32);
  21424.  
  21425.                                         outseg(&itok,2);
  21426.  
  21427.                                         op(0x03+vop);
  21428.  
  21429.                                         op(r1*8+itok.rm);
  21430.  
  21431.                                         outaddress(&itok);
  21432.  
  21433.                                         if(vop==0x20){  //&=
  21434.  
  21435.                                                 ZeroReg(r2,r32);
  21436.  
  21437.                                         }
  21438.  
  21439.                                         else{
  21440.  
  21441.                                                 if(vop==0||vop==0x28){
  21442.  
  21443.                                                         if(vop)vop=8;
  21444.  
  21445.                                                         op66(r32);
  21446.  
  21447.                                                         op(0x83);
  21448.  
  21449.                                                         op(0xD0+vop+r2);
  21450.  
  21451.                                                         op(0);
  21452.  
  21453.                                                 }
  21454.  
  21455.                                         }
  21456.  
  21457.                                         break;
  21458.  
  21459.                                 case tk_qword:
  21460.  
  21461.                                         CheckAllMassiv(bufrm,4,&strinf,&itok,reg1,reg2);
  21462.  
  21463.                                         reg=r1;
  21464.  
  21465.                                         for(i=0;i<2;i++){
  21466.  
  21467.                                                 op66(r32);
  21468.  
  21469.                                                 outseg(&itok,2);
  21470.  
  21471.                                                 op(0x03+vop);
  21472.  
  21473.                                                 op(reg*8+itok.rm);
  21474.  
  21475.                                                 outaddress(&itok);
  21476.  
  21477.                                                 if(i==1)break;
  21478.  
  21479.                                                 reg=r2;
  21480.  
  21481.                                                 itok.number+=4;
  21482.  
  21483.                                                 compressoffset(&itok);
  21484.  
  21485.                                         }
  21486.  
  21487.                                         break;
  21488.  
  21489.                                 case tk_reg64:
  21490.  
  21491. addreg:
  21492.  
  21493.                                         reg=r1;
  21494.  
  21495.                                         reg2=itok.number&255;
  21496.  
  21497.                                         for(i=0;i<2;i++){
  21498.  
  21499.                                                 op66(r32);
  21500.  
  21501.                                                 op(0x01+vop);
  21502.  
  21503.                                                 op(0xC0+reg+reg2*8);
  21504.  
  21505.                                                 if(i==1)break;
  21506.  
  21507.                                                 if(vop==0)vop=0x10;
  21508.  
  21509.                                                 if(vop==0x28)vop=0x18;
  21510.  
  21511.                                                 reg2=itok.number/256;
  21512.  
  21513.                                                 reg=r2;
  21514.  
  21515.                                         }
  21516.  
  21517.                                         break;
  21518.  
  21519.                                 case tk_reg32:
  21520.  
  21521.                                         op66(r32);
  21522.  
  21523.                                         op(0x01+vop);
  21524.  
  21525.                                         op(0xC0+reg+(unsigned int)itok.number*8);
  21526.  
  21527.                                         if(vop==0x20){  //&=
  21528.  
  21529.                                                 ZeroReg(r2,r32);
  21530.  
  21531.                                         }
  21532.  
  21533.                                         else{
  21534.  
  21535.                                                 if(vop==0||vop==0x28){
  21536.  
  21537.                                                         if(vop)vop=8;
  21538.  
  21539.                                                         op66(r32);
  21540.  
  21541.                                                         op(0x83);
  21542.  
  21543.                                                         op(0xD0+vop+r2);
  21544.  
  21545.                                                         op(0);
  21546.  
  21547.                                                 }
  21548.  
  21549.                                         }
  21550.  
  21551.                                         break;
  21552.  
  21553.                                 case tk_ID:
  21554.  
  21555.                                 case tk_id:
  21556.  
  21557.                                 case tk_proc:
  21558.  
  21559.                                 case tk_apiproc:
  21560.  
  21561.                                 case tk_undefproc:
  21562.  
  21563.                                 case tk_declare:
  21564.  
  21565. unsigned char oaddstack;
  21566.  
  21567.                                         oaddstack=addstack;
  21568.  
  21569.                                         if(r1==EAX||r2==EAX){
  21570.  
  21571.                                                 op66(r32);
  21572.  
  21573.                                                 op(0x50);       //push AX
  21574.  
  21575.                                                 warningreg(regs[1][EAX]);
  21576.  
  21577.                                                 addESP+=4;
  21578.  
  21579.                                                 ClearReg(EAX);
  21580.  
  21581.                                                 addstack=FALSE;
  21582.  
  21583.                                         }
  21584.  
  21585.                                         if(r1==EDX||r2==EDX){
  21586.  
  21587.                                                 op66(r32);
  21588.  
  21589.                                                 op(0x50+EDX);   //push DX
  21590.  
  21591.                                                 addESP+=4;
  21592.  
  21593.                                                 warningreg(regs[1][EDX]);
  21594.  
  21595.                                                 ClearReg(EDX);
  21596.  
  21597.                                                 addstack=FALSE;
  21598.  
  21599.                                         }
  21600.  
  21601.                                         procdo(tk_qword);
  21602.  
  21603.                                         addstack=oaddstack;
  21604.  
  21605.                                         if(itok2.type==tp_opperand){
  21606.  
  21607.                                                 nexttok();
  21608.  
  21609.                                                 doregmath64(EAX|(EDX*256));
  21610.  
  21611.                                                 next=0;
  21612.  
  21613.                                         }
  21614.  
  21615.                                         if(r1==EDX||r2==EDX){
  21616.  
  21617.                                                 op66(r32);
  21618.  
  21619.                                                 op(0x89);
  21620.  
  21621.                                                 op(0xC0+reg2+EDX*8);    //mov reg,EDX
  21622.  
  21623.                                                 op66(r32);
  21624.  
  21625.                                                 op(0x58+EDX);   //pop dx
  21626.  
  21627.                                                 addESP-=4;
  21628.  
  21629.                                         }
  21630.  
  21631.                                         else reg2=EDX;
  21632.  
  21633.                                         if(r1==EAX||r2==EAX){
  21634.  
  21635.                                                 op66(r32);
  21636.  
  21637.                                                 op(0x89);
  21638.  
  21639.                                                 op(0xC0+reg1+EAX*8);    //mov reg,EAX
  21640.  
  21641.                                                 op66(r32);
  21642.  
  21643.                                                 op(0x58);       //pop ax
  21644.  
  21645.                                                 addESP-=4;
  21646.  
  21647.                                         }
  21648.  
  21649.                                         else reg1=EAX;
  21650.  
  21651.                                         op66(r32);
  21652.  
  21653.                                         op(0x01+vop);
  21654.  
  21655.                                         op(0xc0+r1+reg1*8);     //add reg,ax
  21656.  
  21657.                                         if(vop==0)vop=0x10;
  21658.  
  21659.                                         if(vop==0x28)vop=0x18;
  21660.  
  21661.                                         op66(r32);
  21662.  
  21663.                                         op(0x01+vop);
  21664.  
  21665.                                         op(0xc0+r2+reg2*8);     //add reg,ax
  21666.  
  21667.                                         break;
  21668.  
  21669.                                 case tk_bytevar:
  21670.  
  21671.                                 case tk_charvar:
  21672.  
  21673.                                 case tk_beg:
  21674.  
  21675.                                 case tk_reg:
  21676.  
  21677.                                 case tk_intvar:
  21678.  
  21679.                                 case tk_wordvar:
  21680.  
  21681. defadd:
  21682.  
  21683.                                         sign=reg1|(reg2*256);
  21684.  
  21685.                                         getintoreg64(sign);
  21686.  
  21687.                                         doregmath64(sign);
  21688.  
  21689.                                         warningreg(regs[1][reg1]);
  21690.  
  21691.                                         warningreg(regs[1][reg2]);
  21692.  
  21693.                                         ClearReg(reg1);
  21694.  
  21695.                                         ClearReg(reg2);
  21696.  
  21697.                                         op66(r32);
  21698.  
  21699.                                         op(0x01+vop);
  21700.  
  21701.                                         op(0xc0+r1+reg1*8);     //add reg,ax
  21702.  
  21703.                                         if(vop==0)vop=0x10;
  21704.  
  21705.                                         if(vop==0x28)vop=0x18;
  21706.  
  21707.                                         op66(r32);
  21708.  
  21709.                                         op(0x01+vop);
  21710.  
  21711.                                         op(0xc0+r2+reg2*8);     //add reg,ax
  21712.  
  21713.                                         next=0;
  21714.  
  21715.                                         break;
  21716.  
  21717.                                 default: valueexpected(); break;
  21718.  
  21719.                         }
  21720.  
  21721.                         break;
  21722.  
  21723.                 case tk_rrequals: vop+=0x08;
  21724.  
  21725.                 case tk_llequals:
  21726.  
  21727.                         getoperand(reg1);
  21728.  
  21729.                         CheckMinusNum();
  21730.  
  21731.                         if(tok==tk_number){
  21732.  
  21733.                                 ii=doconstqwordmath();
  21734.  
  21735.                                 next=0;
  21736.  
  21737.                                 if(itok.type==tp_opperand){
  21738.  
  21739.                                         if(r1==ECX||r2==ECX)regshifterror();
  21740.  
  21741.                                         op(0xB0+CL); op(ii);    //mov CL,num
  21742.  
  21743.                                         ConstToReg(ii,CL,r8);
  21744.  
  21745.                                         dobegmath(CL);
  21746.  
  21747.                                         warningreg(begs[1]);
  21748.  
  21749.                                         ClearReg(CL);
  21750.  
  21751.                                         goto shiftcl;
  21752.  
  21753.                                 }
  21754.  
  21755.                                 if(vop){
  21756.  
  21757.                                         reg=r1;
  21758.  
  21759.                                         r1=r2;
  21760.  
  21761.                                         r2=reg;
  21762.  
  21763.                                 }
  21764.  
  21765.                                 if(ii<32){
  21766.  
  21767.                                         op66(r32);
  21768.  
  21769.                                         op(0x0F);
  21770.  
  21771.                                         op(0xA4+vop);
  21772.  
  21773.                                         op(0xC0+r2+r1*8);
  21774.  
  21775.                                         op(ii);
  21776.  
  21777.                                         op66(r32);
  21778.  
  21779.                                         if(ii==1){
  21780.  
  21781.                                                 op(0xD1); op(0xE0+r1+vop);
  21782.  
  21783.                                         }
  21784.  
  21785.                                         else{
  21786.  
  21787.                                                 op(0xC1);
  21788.  
  21789.                                                 op(0xE0+r1+vop);        //shl ax,num
  21790.  
  21791.                                                 op(ii);
  21792.  
  21793.                                         }
  21794.  
  21795.                                 }
  21796.  
  21797.                                 else{
  21798.  
  21799.                                         op66(r32);
  21800.  
  21801.                                         op(0x89);
  21802.  
  21803.                                         op(0xC0+r2+r1*8);
  21804.  
  21805.                                         ii-=32;
  21806.  
  21807.                                         if(ii!=0){
  21808.  
  21809.                                                 op66(r32);
  21810.  
  21811.                                                 if(ii==1){
  21812.  
  21813.                                                         op(0xD1);
  21814.  
  21815.                                                         op(0xE0+vop+r1);        //shr ax,1
  21816.  
  21817.                                                 }
  21818.  
  21819.                                                 else{
  21820.  
  21821.                                                         op(0xC1);
  21822.  
  21823.                                                         op(0xE0+r2+vop);        //shl ax,num
  21824.  
  21825.                                                         op(ii);
  21826.  
  21827.                                                 }
  21828.  
  21829.                                         }
  21830.  
  21831.                                         ZeroReg(r1,r32);
  21832.  
  21833.                                 }
  21834.  
  21835.                         }
  21836.  
  21837.                         else if(reg!=CX){
  21838.  
  21839.                                 if(!(itok2.type==tp_stopper&&(tok==tk_beg||tok==reg||tok==tk_reg32)&&itok.number==CL)){
  21840.  
  21841.                                         getintobeg(CL,&ofsstr);
  21842.  
  21843.                                         dobegmath(CL);
  21844.  
  21845.                                         warningreg(begs[1]);
  21846.  
  21847.                                         ClearReg(CL);
  21848.  
  21849.                                         next=0;
  21850.  
  21851.                                 }
  21852.  
  21853. shiftcl:
  21854.  
  21855.                                 op66(r32);
  21856.  
  21857.                                 op(0x0F);
  21858.  
  21859.                                 op(0xA5+vop);
  21860.  
  21861.                                 if(vop){
  21862.  
  21863.                                         reg=r1;
  21864.  
  21865.                                         r1=r2;
  21866.  
  21867.                                         r2=reg;
  21868.  
  21869.                                 }
  21870.  
  21871.                                 op(0xC0+r2+r1*8);
  21872.  
  21873.                                 op66(r32);
  21874.  
  21875.                                 op(0xD3);
  21876.  
  21877.                                 op(0xE0+vop+r1);        // SHL xXX,CL
  21878.  
  21879.                         }
  21880.  
  21881.                         else regshifterror();
  21882.  
  21883.                         break;
  21884.  
  21885.                 case tk_multequals:
  21886.  
  21887.                         getoperand(reg1);
  21888.  
  21889.                         CheckMinusNum();
  21890.  
  21891.                         if(tok==tk_number){
  21892.  
  21893.                                 ii=doconstqwordmath();
  21894.  
  21895.                                 next=0;
  21896.  
  21897.                                 if(itok.type==tp_opperand){
  21898.  
  21899.                                         op66(r32);
  21900.  
  21901.                                         op(0x50+r2);
  21902.  
  21903.                                         op66(r32);
  21904.  
  21905.                                         op(0x50+r1);
  21906.  
  21907.                                         addESP+=8;
  21908.  
  21909.                                         MovRegNum(r32,postnumflag&f_reloc,ii,reg1);
  21910.  
  21911.                                         MovRegNum(r32,0,ii>>32,reg2);
  21912.  
  21913.                                         ConstToReg(ii,reg1,r32);
  21914.  
  21915.                                         ConstToReg(ii>>32,reg2,r32);
  21916.  
  21917.                                         doregmath64(reg1|(reg2*256));
  21918.  
  21919.                                         goto mul;
  21920.  
  21921.                                 }
  21922.  
  21923.                                 i=0;
  21924.  
  21925.                                 if((postnumflag&f_reloc)==0){
  21926.  
  21927.                                         if(ii==0){
  21928.  
  21929.                                                 ZeroReg(r1,r32);
  21930.  
  21931.                                                 ZeroReg(r2,r32);
  21932.  
  21933.                                                 break;
  21934.  
  21935.                                         }
  21936.  
  21937.                                         if(ii==1)break;
  21938.  
  21939.                                         if(ii==2){
  21940.  
  21941.                                                 op66(r32);
  21942.  
  21943.                                                 op(1);
  21944.  
  21945.                                                 op(0xC0+9*r1); // ADD r1,r1
  21946.  
  21947.                                                 op66(r32);
  21948.  
  21949.                                                 op(0x83);
  21950.  
  21951.                                                 op(0xC2+r2*8);  //adc r2,0
  21952.  
  21953.                                                 op(0);
  21954.  
  21955.                                                 break;
  21956.  
  21957.                                         }
  21958.  
  21959.                                         if((i=caselonglong(ii))!=NUMNUM64){
  21960.  
  21961.                                                 if(i<32){
  21962.  
  21963.                                                         op66(r32);
  21964.  
  21965.                                                         outword(0xA40F);
  21966.  
  21967.                                                         op(0xC0+r2+r1*8);
  21968.  
  21969.                                                         op(i);
  21970.  
  21971.                                                         op66(r32);
  21972.  
  21973.                                                         op(0xC1);
  21974.  
  21975.                                                         op(0xE0+r1);    //shl ax,num
  21976.  
  21977.                                                         op(i);
  21978.  
  21979.                                                 }
  21980.  
  21981.                                                 else{
  21982.  
  21983.                                                         op66(r32);
  21984.  
  21985.                                                         op(0x89);
  21986.  
  21987.                                                         op(0xC0+r2+r1*8);
  21988.  
  21989.                                                         i-=32;
  21990.  
  21991.                                                         if(i!=0){
  21992.  
  21993.                                                                 op66(r32);
  21994.  
  21995.                                                                 if(i==1){
  21996.  
  21997.                                                                         op(1);
  21998.  
  21999.                                                                         op(0xC0+r2*9);  //add reg,reg
  22000.  
  22001.                                                                 }
  22002.  
  22003.                                                                 else{
  22004.  
  22005.                                                                         op(0xC1);
  22006.  
  22007.                                                                         op(0xE0+r2);    //shl ax,num
  22008.  
  22009.                                                                         op(i);
  22010.  
  22011.                                                                 }
  22012.  
  22013.                                                         }
  22014.  
  22015.                                                         ZeroReg(r1,r32);
  22016.  
  22017.                                                 }
  22018.  
  22019.                                                 break;
  22020.  
  22021.                                         }
  22022.  
  22023.                                 }
  22024.  
  22025.                                 op66(r32);
  22026.  
  22027.                                 op(0x50+r2);
  22028.  
  22029.                                 op66(r32);
  22030.  
  22031.                                 op(0x50+r1);
  22032.  
  22033.                                 addESP+=8;
  22034.  
  22035.                                 MovRegNum(r32,postnumflag&f_reloc,ii,ECX);
  22036.  
  22037.                                 MovRegNum(r32,0,ii>>32,EAX);
  22038.  
  22039.                                 goto mul;
  22040.  
  22041.                         }
  22042.  
  22043.                         op66(r32);
  22044.  
  22045.                         op(0x50+r2);
  22046.  
  22047.                         op66(r32);
  22048.  
  22049.                         op(0x50+r1);
  22050.  
  22051.                         addESP+=8;
  22052.  
  22053.                         reg=ECX|(EAX*256);
  22054.  
  22055.                         warningreg(regs[1][ECX]);
  22056.  
  22057.                         getintoreg64(reg);
  22058.  
  22059.                         doregmath64(reg);
  22060.  
  22061. mul:
  22062.  
  22063.                         CallExternProc("__llmul");
  22064.  
  22065.                         addESP-=8;
  22066.  
  22067. endmul:
  22068.  
  22069.                         ClearReg(EAX);
  22070.  
  22071.                         warningreg(regs[1][EAX]);
  22072.  
  22073.                         ClearReg(EDX);
  22074.  
  22075.                         warningreg(regs[1][EDX]);
  22076.  
  22077.                         next=0;
  22078.  
  22079.                         if(r1!=EAX){
  22080.  
  22081.                                 if(r1==EDX){
  22082.  
  22083.                                         if(r2==EAX){
  22084.  
  22085.                                                 op66(r32);
  22086.  
  22087.                                                 op(0x90+EDX);
  22088.  
  22089.                                                 break;
  22090.  
  22091.                                         }
  22092.  
  22093.                                         op66(r32);
  22094.  
  22095.                                         op(0x89);
  22096.  
  22097.                                         op(0xC0+r2+EDX*8);      //mov reg,EDX
  22098.  
  22099.                                         op66(r32);
  22100.  
  22101.                                         op(0x89);
  22102.  
  22103.                                         op(0xC0+r1+EAX*8);      //mov reg,EAX
  22104.  
  22105.                                         break;
  22106.  
  22107.                                 }
  22108.  
  22109.                                 op66(r32);
  22110.  
  22111.                                 op(0x89);
  22112.  
  22113.                                 op(0xC0+r1+EAX*8);      //mov reg,EAX
  22114.  
  22115.                         }
  22116.  
  22117.                         if(r2!=EDX){
  22118.  
  22119.                                 op66(r32);
  22120.  
  22121.                                 op(0x89);
  22122.  
  22123.                                 op(0xC0+r2+EDX*8);      //mov reg,EDX
  22124.  
  22125.                         }
  22126.  
  22127.                         break;
  22128.  
  22129.                 case tk_divequals:
  22130.  
  22131.                         getoperand(reg1);
  22132.  
  22133.                         CheckMinusNum();
  22134.  
  22135.                         if(tok==tk_number){
  22136.  
  22137.                                 ii=doconstqwordmath();
  22138.  
  22139.                                 next=0;
  22140.  
  22141.                                 if(itok.type==tp_opperand){
  22142.  
  22143.                                         MovRegNum(r32,postnumflag&f_reloc,ii,reg1);
  22144.  
  22145.                                         MovRegNum(r32,0,ii>>32,reg2);
  22146.  
  22147.                                         ConstToReg(ii,reg1,r32);
  22148.  
  22149.                                         ConstToReg(ii>>32,reg2,r32);
  22150.  
  22151.                                         doregmath64(reg1|(reg2*256));
  22152.  
  22153.                                         op66(r32);
  22154.  
  22155.                                         op(0x50+reg2);
  22156.  
  22157.                                         op66(r32);
  22158.  
  22159.                                         op(0x50+reg1);
  22160.  
  22161.                                         addESP+=8;
  22162.  
  22163.                                         warningreg(regs[1][reg1]);
  22164.  
  22165.                                         warningreg(regs[1][reg2]);
  22166.  
  22167.                                         goto divcont;
  22168.  
  22169.                                 }
  22170.  
  22171.                                 if((postnumflag&f_reloc)==0){
  22172.  
  22173.                                         if(ii==0){
  22174.  
  22175.                                                 DevideZero();
  22176.  
  22177.                                                 break;
  22178.  
  22179.                                         }
  22180.  
  22181.                                         if(ii==1)break;
  22182.  
  22183.                                         if((i=caselonglong(ii))!=NUMNUM64){
  22184.  
  22185.                                                 if(i<32){
  22186.  
  22187.                                                         op66(r32);
  22188.  
  22189.                                                         outword(0xAC0F);
  22190.  
  22191.                                                         op(0xC0+r1+r2*8);
  22192.  
  22193.                                                         op(i);
  22194.  
  22195.                                                         op66(r32);
  22196.  
  22197.                                                         op(0xc1);
  22198.  
  22199.                                                         op(0xe8+r2); // SHR reg,imm8
  22200.  
  22201.                                                         op(i);
  22202.  
  22203.                                                 }
  22204.  
  22205.                                                 else{
  22206.  
  22207.                                                         op66(r32);
  22208.  
  22209.                                                         op(0x89);
  22210.  
  22211.                                                         op(0xC0+r1+r2*8);
  22212.  
  22213.                                                         i-=32;
  22214.  
  22215.                                                         if(i!=0){
  22216.  
  22217.                                                                 op66(r32);
  22218.  
  22219.                                                                 if(i==1){
  22220.  
  22221.                                                                         op(0xD1);
  22222.  
  22223.                                                                         op(0xE8+r1);    //shr ax,1
  22224.  
  22225.                                                                 }
  22226.  
  22227.                                                                 else{
  22228.  
  22229.                                                                         op(0xC1);
  22230.  
  22231.                                                                         op(0xE8+r1);    //shr ax,num
  22232.  
  22233.                                                                         op(i);
  22234.  
  22235.                                                                 }
  22236.  
  22237.                                                         }
  22238.  
  22239.                                                         ZeroReg(r2,r32);
  22240.  
  22241.                                                 }
  22242.  
  22243.                                                 break;
  22244.  
  22245.                                         }
  22246.  
  22247.                                 }
  22248.  
  22249.                                 unsigned long number;
  22250.  
  22251.                                 number=ii>>32;
  22252.  
  22253.                                 for(i=0;i<2;i++){
  22254.  
  22255.                                         op66(r32);
  22256.  
  22257.                                         if((postnumflag&f_reloc)==0&&short_ok(number,1)){
  22258.  
  22259.                                                 op(0x6A);
  22260.  
  22261.                                                 op(number);
  22262.  
  22263.                                         }
  22264.  
  22265.                                         else{
  22266.  
  22267.                                                 op(0x68);
  22268.  
  22269.                                                 if(i==0&&(postnumflag&f_reloc)!=0)AddReloc();
  22270.  
  22271.                                                 outdword(number);
  22272.  
  22273.                                         }
  22274.  
  22275.                                         if(i==1)break;
  22276.  
  22277.                                         number=ii;
  22278.  
  22279.                                 }
  22280.  
  22281.                                 addESP+=8;
  22282.  
  22283.                                 goto divcont;
  22284.  
  22285.                         }
  22286.  
  22287.                         reg=reg1|(reg2*256);
  22288.  
  22289.                         getintoreg64(reg);
  22290.  
  22291.                         doregmath64(reg);
  22292.  
  22293.                         op66(r32);
  22294.  
  22295.                         op(0x50+reg2);
  22296.  
  22297.                         op66(r32);
  22298.  
  22299.                         op(0x50+reg1);
  22300.  
  22301.                         addESP+=8;
  22302.  
  22303.                         warningreg(regs[1][reg1]);
  22304.  
  22305.                         warningreg(regs[1][reg2]);
  22306.  
  22307.                         next=0;
  22308.  
  22309. divcont:
  22310.  
  22311.                         if(r1!=EAX){
  22312.  
  22313.                                 if(r2==EAX){
  22314.  
  22315.                                         if(r1==EDX){
  22316.  
  22317.                                                 op66(r32);
  22318.  
  22319.                                                 op(0x90+EDX);
  22320.  
  22321.                                                 goto sdiv;
  22322.  
  22323.                                         }
  22324.  
  22325.                                         op66(r32);
  22326.  
  22327.                                         op(0x89);
  22328.  
  22329.                                         op(0xC0+EDX+r2*8);      //mov EDX,r2
  22330.  
  22331.                                         op66(r32);
  22332.  
  22333.                                         op(0x89);
  22334.  
  22335.                                         op(0xC0+EAX+r1*8);      //mov EAX,r1
  22336.  
  22337.                                         goto sdiv;
  22338.  
  22339.                                 }
  22340.  
  22341.                                 op66(r32);
  22342.  
  22343.                                 op(0x89);
  22344.  
  22345.                                 op(0xC0+EAX+r1*8);      //mov EAX,r1
  22346.  
  22347.                         }
  22348.  
  22349.                         if(r2!=EDX){
  22350.  
  22351.                                 op66(r32);
  22352.  
  22353.                                 op(0x89);
  22354.  
  22355.                                 op(0xC0+EDX+r2*8);      //mov EDX,r2
  22356.  
  22357.                         }
  22358.  
  22359. sdiv:
  22360.  
  22361.                         CallExternProc("__lludiv");
  22362.  
  22363.                         addESP-=8;
  22364.  
  22365.                         goto endmul;
  22366.  
  22367.                 default: operatorexpected(); break;
  22368.  
  22369.         }
  22370.  
  22371.         ClearReg(r1);
  22372.  
  22373.         ClearReg(r2);
  22374.  
  22375.         if(next)nexttok();
  22376.  
  22377.         if(terminater==tk_semicolon)seminext();
  22378.  
  22379.         if(cpu<3)cpu=3;
  22380.  
  22381. }
  22382.  
  22383.  
  22384.  
  22385. void optnumadd64(unsigned long long num,int r1,int r2,int vop)
  22386.  
  22387. {
  22388.  
  22389. int i,reg;
  22390.  
  22391.         if(num==0){
  22392.  
  22393.                 if(vop==0x20){  //&=
  22394.  
  22395.                         reg=r1;
  22396.  
  22397.                         for(i=0;i<2;i++){
  22398.  
  22399.                                 ZeroReg(reg,r32);
  22400.  
  22401.                                 reg=r2;
  22402.  
  22403.                         }
  22404.  
  22405.                         setzeroflag=TRUE;
  22406.  
  22407.                 }
  22408.  
  22409.                 return;         //+= -= |= ^=
  22410.  
  22411.         }
  22412.  
  22413.         if(num==1){
  22414.  
  22415.                 if(vop==0x28){  //-=
  22416.  
  22417.                         op66(r32);
  22418.  
  22419.                         op(0x48+r1);
  22420.  
  22421.                         op66(r32);
  22422.  
  22423.                         op(0x83);
  22424.  
  22425.                         op(0xD8+r2);
  22426.  
  22427.                         op(0);
  22428.  
  22429.                         setzeroflag=TRUE;
  22430.  
  22431.                         return;
  22432.  
  22433.                 }
  22434.  
  22435.                 if(vop==0){     //+=
  22436.  
  22437.                         op66(r32);
  22438.  
  22439.                         op(0x40+r1);
  22440.  
  22441.                         op66(r32);
  22442.  
  22443.                         op(0x83);
  22444.  
  22445.                         op(0xD0+r2);
  22446.  
  22447.                         op(0);
  22448.  
  22449.                         setzeroflag=TRUE;
  22450.  
  22451.                         return;
  22452.  
  22453.                 }
  22454.  
  22455.         }
  22456.  
  22457.         if(vop==8){     //|=
  22458.  
  22459.                 if(num<65536){
  22460.  
  22461.                         if((unsigned short)num<256&&r1<4){
  22462.  
  22463.                                 if(r1==AX)op(0x0C);
  22464.  
  22465.                                 else{
  22466.  
  22467.                                         op(0x80);
  22468.  
  22469.                                         op(0xc8+r1);
  22470.  
  22471.                                 }
  22472.  
  22473.                                 op(num);
  22474.  
  22475.                                 return;
  22476.  
  22477.                         }
  22478.  
  22479.                         op66(r16);
  22480.  
  22481.                         if(r1==AX)op(0x0D);
  22482.  
  22483.                         else{
  22484.  
  22485.                                 op(0x81);
  22486.  
  22487.                                 op(0xc8+r1);
  22488.  
  22489.                         }
  22490.  
  22491.                         outword(num);
  22492.  
  22493.                         return;
  22494.  
  22495.                 }
  22496.  
  22497.                 if(num<0x100000000LL){
  22498.  
  22499.                         op66(r32);
  22500.  
  22501.                         if(r1==AX)op(0x0D);
  22502.  
  22503.                         else{
  22504.  
  22505.                                 op(0x81);
  22506.  
  22507.                                 op(0xc8+r1);
  22508.  
  22509.                         }
  22510.  
  22511.                         outdword(num);
  22512.  
  22513.                         return;
  22514.  
  22515.                 }
  22516.  
  22517.         }
  22518.  
  22519.         if(vop==0x20){  //&=
  22520.  
  22521.                 if(num>=0xFFFFFFFF00000000LL){
  22522.  
  22523.                         if((unsigned long)num>=0xFFFF0000){
  22524.  
  22525.                                 if((unsigned short)num>=0xFF00&&r1<4){
  22526.  
  22527.                                         if(r1==AL)op(0x24);
  22528.  
  22529.                                         else{
  22530.  
  22531.                                                 op(128);
  22532.  
  22533.                                                 op(0xE0+r1);
  22534.  
  22535.                                         }
  22536.  
  22537.                                         op(num);
  22538.  
  22539.                                         return;
  22540.  
  22541.                                 }
  22542.  
  22543.                                 op66(r16);
  22544.  
  22545.                                 if(r1==AX)op(0x25);
  22546.  
  22547.                                 else{
  22548.  
  22549.                                         op(129);
  22550.  
  22551.                                         op(0xE0+r1);
  22552.  
  22553.                                 }
  22554.  
  22555.                                 outword(num);
  22556.  
  22557.                                 return;
  22558.  
  22559.                         }
  22560.  
  22561.                         op66(r32);
  22562.  
  22563.                         if(r1==AX)op(0x25);
  22564.  
  22565.                         else{
  22566.  
  22567.                                 op(129);
  22568.  
  22569.                                 op(0xE0+r1);
  22570.  
  22571.                         }
  22572.  
  22573.                         outdword(num);
  22574.  
  22575.                         return;
  22576.  
  22577.                 }
  22578.  
  22579.         }
  22580.  
  22581.         reg=r1;
  22582.  
  22583.         int j=0;
  22584.  
  22585.         for(i=0;i<2;i++){
  22586.  
  22587.                 if((unsigned long)num==0)j++;
  22588.  
  22589.                 if(optnumadd(num,reg,r32,vop)==FALSE){
  22590.  
  22591.                         op66(r32);
  22592.  
  22593.                         if(short_ok((unsigned long)num,TRUE)){
  22594.  
  22595.                                 op(0x83);
  22596.  
  22597.                                 op(0xC0+vop+reg);
  22598.  
  22599.                                 op(num);
  22600.  
  22601.                         }
  22602.  
  22603.                         else{
  22604.  
  22605.                                 if(reg==EAX)op(5+vop);
  22606.  
  22607.                                 else{
  22608.  
  22609.                                   op(0x81);
  22610.  
  22611.                                         op(0xC0+vop+reg);
  22612.  
  22613.                                 }
  22614.  
  22615.                                 outdword(num);
  22616.  
  22617.                         }
  22618.  
  22619.                 }
  22620.  
  22621.                 num>>=32;
  22622.  
  22623.                 if(j==0&&(vop==0||vop==0x28)){
  22624.  
  22625.                         if(vop)vop=8;
  22626.  
  22627.                         op66(r32);
  22628.  
  22629.                         if(short_ok((unsigned long)num,TRUE)){
  22630.  
  22631.                                 op(0x83);
  22632.  
  22633.                                 op(0xD0+vop+r2);
  22634.  
  22635.                                 op(num);
  22636.  
  22637.                         }
  22638.  
  22639.                         else{
  22640.  
  22641.                                 if(r2==EAX)op(0x15+vop);
  22642.  
  22643.                                 else{
  22644.  
  22645.                                   op(0x81);
  22646.  
  22647.                                         op(0xD3+vop+r2);
  22648.  
  22649.                                 }
  22650.  
  22651.                                 outdword(num);
  22652.  
  22653.                         }
  22654.  
  22655.                         break;
  22656.  
  22657.                 }
  22658.  
  22659.                 reg=r2;
  22660.  
  22661.         }
  22662.  
  22663.         setzeroflag=TRUE;
  22664.  
  22665. }
  22666.  
  22667.  
  22668.  
  22669. void doregmath64(int reg)
  22670.  
  22671. {
  22672.  
  22673. int vop,i,optnum,negflag=FALSE;
  22674.  
  22675. int r1,r2,next=1;
  22676.  
  22677. int reg1,reg2;
  22678.  
  22679. char *ofsstr=NULL;
  22680.  
  22681.         r1=reg&255;
  22682.  
  22683.         r2=reg/256;
  22684.  
  22685.         Select2FreeReg(r1,r2,&reg1,&reg2);
  22686.  
  22687.         while(itok.type!=tp_stopper&&tok!=tk_eof){
  22688.  
  22689.                 if(negflag){
  22690.  
  22691.                         op66(r32);
  22692.  
  22693.                         op(0xF7);
  22694.  
  22695.                         op(0xD8+r2);  // NEG reg
  22696.  
  22697.                         op66(r32);
  22698.  
  22699.                         op(0xF7);
  22700.  
  22701.                         op(0xD8+r1);  // NEG reg
  22702.  
  22703.                         op66(r32);
  22704.  
  22705.                         op(0x83);
  22706.  
  22707.                         op(0xD8+r2);
  22708.  
  22709.                         op(0);
  22710.  
  22711.                         ClearReg(r1);
  22712.  
  22713.                         ClearReg(r2);
  22714.  
  22715.                         negflag=FALSE;
  22716.  
  22717.                 }
  22718.  
  22719.                 vop=0;
  22720.  
  22721.                 next=1;
  22722.  
  22723.                 optnum=FALSE;
  22724.  
  22725.                 if(tok2==tk_number)optnum=OptimNum();
  22726.  
  22727.                 switch(tok){
  22728.  
  22729.                         case tk_xor: vop+=0x08;
  22730.  
  22731.                         case tk_minus: vop+=0x08;
  22732.  
  22733.                         case tk_and: vop+=0x18;
  22734.  
  22735.                         case tk_or: vop+=0x08;
  22736.  
  22737.                         case tk_plus:
  22738.  
  22739.                           if(optnum==FALSE)getoperand(reg1);
  22740.  
  22741.                                 else tok=tk_number;
  22742.  
  22743.                                 switch(tok){
  22744.  
  22745.                                         case tk_number:
  22746.  
  22747.                                                 if((itok.flag&f_reloc)==0){
  22748.  
  22749.                                                         optnumadd64(itok.lnumber,r1,r2,vop);
  22750.  
  22751.                                                         break;
  22752.  
  22753.                                                 }
  22754.  
  22755.                                         case tk_postnumber:
  22756.  
  22757.                                         case tk_undefofs:
  22758.  
  22759.                                         case tk_apioffset:
  22760.  
  22761.                                                 op66(r32);
  22762.  
  22763.                                           op(0x81);
  22764.  
  22765.                                                 op(0xC0+vop+r1);
  22766.  
  22767.                                                 if(tok==tk_apioffset)AddApiToPost(itok.number);
  22768.  
  22769.                                                 else{
  22770.  
  22771.                                                         if(tok==tk_postnumber)(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
  22772.  
  22773.                                                         else if(tok==tk_undefofs)AddUndefOff(0,itok.name);
  22774.  
  22775.                                                         else if((itok.flag&f_reloc)!=0)AddReloc();
  22776.  
  22777.                                                         outdword(itok.number);
  22778.  
  22779.                                                 }
  22780.  
  22781.                                                 if(vop==0x20){  //&=
  22782.  
  22783.                                                         ZeroReg(r2,r32);
  22784.  
  22785.                                                 }
  22786.  
  22787.                                                 else{
  22788.  
  22789.                                                         if(vop==0||vop==0x28){
  22790.  
  22791.                                                                 if(vop)vop=8;
  22792.  
  22793.                                                                 op66(r32);
  22794.  
  22795.                                                                 op(0x83);
  22796.  
  22797.                                                                 op(0xD0+vop+r2);
  22798.  
  22799.                                                                 op(0);
  22800.  
  22801.                                                         }
  22802.  
  22803.                                                 }
  22804.  
  22805.                                                 break;
  22806.  
  22807.                                         case tk_rmnumber:
  22808.  
  22809.                                         case tk_charvar:
  22810.  
  22811.                                         case tk_beg:
  22812.  
  22813.                                         case tk_bytevar:
  22814.  
  22815.                                                 getintoreg_32(reg2,r32,0,&ofsstr,FALSE);
  22816.  
  22817.                                                 op66(r32);
  22818.  
  22819.                                                 op(0x01+vop);
  22820.  
  22821.                                                 op(0xC0+r1+reg2*8);     /* OPT AX,CX */
  22822.  
  22823.                                                 if(vop==0x20){  //&=
  22824.  
  22825.                                                         ZeroReg(r2,r32);
  22826.  
  22827.                                                 }
  22828.  
  22829.                                                 else{
  22830.  
  22831.                                                         if(vop==0||vop==0x28){
  22832.  
  22833.                                                                 if(vop)vop=8;
  22834.  
  22835.                                                                 op66(r32);
  22836.  
  22837.                                                                 op(0x83);
  22838.  
  22839.                                                                 op(0xD0+vop+r2);
  22840.  
  22841.                                                                 op(0);
  22842.  
  22843.                                                         }
  22844.  
  22845.                                                 }
  22846.  
  22847.                                                 warningreg(regs[r32/2-1][reg2]);
  22848.  
  22849.                                                 next=0;
  22850.  
  22851.                                                 break;
  22852.  
  22853.                                 case tk_reg:
  22854.  
  22855.                                                 op66(r32);
  22856.  
  22857.                                                 outword(0xB70F);
  22858.  
  22859.                                                 if(itok.number==r1||itok.number==r2)itok.number=reg1;
  22860.  
  22861.                                                 op(0xC0+itok.number*9);
  22862.  
  22863.                                                 warningreg(regs[1][itok.number]);
  22864.  
  22865.                                         case tk_reg32:
  22866.  
  22867. defreg32:
  22868.  
  22869.                                                 op66(r32);
  22870.  
  22871.                                                 op(0x01+vop);
  22872.  
  22873.                                                 op(0xC0+r1+(unsigned int)itok.number*8);
  22874.  
  22875.                                                 if(vop==0x20){  //&=
  22876.  
  22877.                                                         ZeroReg(r2,r32);
  22878.  
  22879.                                                 }
  22880.  
  22881.                                                 else{
  22882.  
  22883.                                                         if(vop==0||vop==0x28){
  22884.  
  22885.                                                                 if(vop)vop=8;
  22886.  
  22887.                                                                 op66(r32);
  22888.  
  22889.                                                                 op(0x83);
  22890.  
  22891.                                                                 op(0xD0+vop+r2);
  22892.  
  22893.                                                                 op(0);
  22894.  
  22895.                                                         }
  22896.  
  22897.                                                 }
  22898.  
  22899.                                                 break;
  22900.  
  22901.                                         case tk_reg64:
  22902.  
  22903.                                                 int reg2;
  22904.  
  22905.                                                 reg=r1;
  22906.  
  22907.                                                 reg2=itok.number&255;
  22908.  
  22909.                                                 for(i=0;i<2;i++){
  22910.  
  22911.                                                         op66(r32);
  22912.  
  22913.                                                         op(0x01+vop);
  22914.  
  22915.                                                         op(0xC0+reg+reg2*8);
  22916.  
  22917.                                                         if(i==1)break;
  22918.  
  22919.                                                         if(vop==0)vop=0x10;
  22920.  
  22921.                                                         if(vop==0x28)vop=0x18;
  22922.  
  22923.                                                         reg2=itok.number/256;
  22924.  
  22925.                                                         reg=r2;
  22926.  
  22927.                                                 }
  22928.  
  22929.                                                 break;
  22930.  
  22931.                                         case tk_longvar:
  22932.  
  22933.                                         case tk_dwordvar:
  22934.  
  22935.                                                 CheckAllMassiv(bufrm,4,&strinf);
  22936.  
  22937.                                                 op66(r32);
  22938.  
  22939.                                                 outseg(&itok,2);
  22940.  
  22941.                                                 op(0x03+vop);
  22942.  
  22943.                                                 op(r1*8+itok.rm);
  22944.  
  22945.                                                 outaddress(&itok);
  22946.  
  22947.                                                 if(vop==0x20){  //&=
  22948.  
  22949.                                                         ZeroReg(r2,r32);
  22950.  
  22951.                                                 }
  22952.  
  22953.                                                 else{
  22954.  
  22955.                                                         if(vop==0||vop==0x28){
  22956.  
  22957.                                                                 if(vop)vop=8;
  22958.  
  22959.                                                                 op66(r32);
  22960.  
  22961.                                                                 op(0x83);
  22962.  
  22963.                                                                 op(0xD0+vop+r2);
  22964.  
  22965.                                                                 op(0);
  22966.  
  22967.                                                         }
  22968.  
  22969.                                                 }
  22970.  
  22971.                                                 break;
  22972.  
  22973.                                         case tk_qwordvar:
  22974.  
  22975.                                                 reg=r1;
  22976.  
  22977.                                                 for(i=0;i<2;i++){
  22978.  
  22979.                                                         CheckAllMassiv(bufrm,8,&strinf);
  22980.  
  22981.                                                         op66(r32);
  22982.  
  22983.                                                         outseg(&itok,2);
  22984.  
  22985.                                                         op(0x03+vop);
  22986.  
  22987.                                                         op(reg*8+itok.rm);
  22988.  
  22989.                                                         outaddress(&itok);
  22990.  
  22991.                                                         if(i==1)break;
  22992.  
  22993.                                                         if(vop==0)vop=0x10;
  22994.  
  22995.                                                         if(vop==0x28)vop=0x18;
  22996.  
  22997.                                                         itok.number+=4;
  22998.  
  22999.                                                         compressoffset(&itok);
  23000.  
  23001.                                                         reg=r2;
  23002.  
  23003.                                                 }
  23004.  
  23005.                                                 break;
  23006.  
  23007.                                         case tk_ID:
  23008.  
  23009.                                         case tk_id:
  23010.  
  23011.                                         case tk_proc:
  23012.  
  23013.                                         case tk_apiproc:
  23014.  
  23015.                                         case tk_undefproc:
  23016.  
  23017.                                         case tk_declare:
  23018.  
  23019.                                                 procdo(tk_qword);
  23020.  
  23021.                                                 op66(r32);
  23022.  
  23023.                                                 op(0x01+vop);
  23024.  
  23025.                                                 op(0xc0+r1);
  23026.  
  23027.                                                 warningreg(regs[1][0]);
  23028.  
  23029.                                                 if(vop==0)vop=0x10;
  23030.  
  23031.                                                 if(vop==0x28)vop=0x18;
  23032.  
  23033.                                                 op66(r32);
  23034.  
  23035.                                                 op(0x01+vop);
  23036.  
  23037.                                                 op(0xc0+r2+EDX*8);
  23038.  
  23039.                                                 warningreg(regs[1][EDX]);
  23040.  
  23041.                                                 break;
  23042.  
  23043.                                         default: valueexpected(); break;
  23044.  
  23045.                                 }
  23046.  
  23047.                                 break;
  23048.  
  23049.                         case tk_rrminus:
  23050.  
  23051.                                 if(r1==ECX||r2==ECX){
  23052.  
  23053.                                         regshifterror();
  23054.  
  23055.                                         break;
  23056.  
  23057.                                 }
  23058.  
  23059.                                 tok=tk_minus;
  23060.  
  23061.                                 goto rshift2;
  23062.  
  23063.                         case tk_rr:
  23064.  
  23065.                           getoperand(ECX);
  23066.  
  23067.                                 if(tok==tk_number){
  23068.  
  23069.                                         op66(r32);
  23070.  
  23071.                                         outword(0xAC0F);
  23072.  
  23073.                                         op(0xC0+r1+r2*8);
  23074.  
  23075.                                         op(itok.number);
  23076.  
  23077.                                         op66(r32);
  23078.  
  23079.                                         if((unsigned int)itok.number==1){
  23080.  
  23081.                                                 op(0xD1); op(0xE8+r2);  // SHR reg,1
  23082.  
  23083.                                         }
  23084.  
  23085.                                         else if((unsigned int)itok.number!=0){
  23086.  
  23087.                                                 op(0xc1);
  23088.  
  23089.                                                 op(0xe8+r2); // SHR reg,imm8
  23090.  
  23091.                                                 op((unsigned int)itok.number);
  23092.  
  23093.                                         }
  23094.  
  23095.                                 }
  23096.  
  23097.                                 else if(r1==ECX||r2==ECX)regshifterror();
  23098.  
  23099.                                 else if((tok==tk_beg||tok==tk_reg||tok==tk_reg32)&&itok.number==CL)goto rshift;
  23100.  
  23101.                                 else{
  23102.  
  23103. rshift2:
  23104.  
  23105.                                         getintobeg(CL,&ofsstr);
  23106.  
  23107.                                         next=0;
  23108.  
  23109.                                         warningreg(begs[1]);
  23110.  
  23111. rshift:
  23112.  
  23113.                                         op66(r32);
  23114.  
  23115.                                         outword(0xAD0F);
  23116.  
  23117.                                         op(0xC0+r1+r2*8);
  23118.  
  23119.                                         op66(r32);
  23120.  
  23121.                                         op(0xD3);
  23122.  
  23123.                                         op(0xE8+r2);    // SHL xXX,CL
  23124.  
  23125.                                 }
  23126.  
  23127.                                 break;
  23128.  
  23129.                         case tk_llminus:
  23130.  
  23131.                                 if(r1==ECX||r2==ECX){
  23132.  
  23133.                                         regshifterror();
  23134.  
  23135.                                         break;
  23136.  
  23137.                                 }
  23138.  
  23139.                                 tok=tk_minus;
  23140.  
  23141.                                 goto llshift;
  23142.  
  23143.                         case tk_ll:
  23144.  
  23145.                           getoperand(ECX);
  23146.  
  23147.                                 if(tok==tk_number){
  23148.  
  23149.                                         op66(r32);
  23150.  
  23151.                                         outword(0xA40F);
  23152.  
  23153.                                         op(0xC0+r2+r1*8);
  23154.  
  23155.                                         op(itok.number);
  23156.  
  23157.                                         op66(r32);
  23158.  
  23159.                                         if((unsigned int)itok.number==1){
  23160.  
  23161.                                                 op(1);
  23162.  
  23163.                                                 op(0xC0+r1*9);  //add reg,reg
  23164.  
  23165.                                         }
  23166.  
  23167.                                         else{
  23168.  
  23169.                                                 op(0xC1);
  23170.  
  23171.                                                 op(0xE0+r1);    //shl ax,num
  23172.  
  23173.                                                 op(itok.number);
  23174.  
  23175.                                         }
  23176.  
  23177.                                 }
  23178.  
  23179.                                 else if(r1==ECX||r2==ECX)regshifterror();
  23180.  
  23181.                                 else if((tok==tk_beg||tok==tk_reg||tok==tk_reg32)&&itok.number==CL)goto lshift;
  23182.  
  23183.                                 else{
  23184.  
  23185. llshift:
  23186.  
  23187.                                         getintobeg(CL,&ofsstr);
  23188.  
  23189.                                         next=0;
  23190.  
  23191.                                         warningreg(begs[1]);
  23192.  
  23193. lshift:
  23194.  
  23195.                                         op66(r32);
  23196.  
  23197.                                         outword(0xA50F);
  23198.  
  23199.                                         op(0xC0+r2+r1*8);
  23200.  
  23201.                                         op66(r32);
  23202.  
  23203.                                         op(0xD3);
  23204.  
  23205.                                         op(0xE0+r1);    // SHL xXX,CL
  23206.  
  23207.                                 }
  23208.  
  23209.                                 break;
  23210.  
  23211.                         case tk_multminus: negflag=TRUE;
  23212.  
  23213.                         case tk_mult:
  23214.  
  23215.                           getoperand(reg1);
  23216.  
  23217.                                 if(negflag&&tok==tk_number){
  23218.  
  23219.                                         itok.lnumber=-itok.lnumber;
  23220.  
  23221.                                         negflag=FALSE;
  23222.  
  23223.                                 }
  23224.  
  23225.                                 if(tok==tk_number&&((itok.number&f_reloc)==0)){
  23226.  
  23227.                                         if(itok.lnumber==0){
  23228.  
  23229.                                                 ZeroReg(r1,r32);
  23230.  
  23231.                                                 ZeroReg(r2,r32);
  23232.  
  23233.                                                 break;
  23234.  
  23235.                                         }
  23236.  
  23237.                                         if(itok.lnumber==1)break;
  23238.  
  23239.                                         if(itok.lnumber==2){
  23240.  
  23241.                                                 op66(r32);
  23242.  
  23243.                                                 op(1);
  23244.  
  23245.                                                 op(0xC0+9*r1); // ADD r1,r1
  23246.  
  23247.                                                 op66(r32);
  23248.  
  23249.                                                 op(0x83);
  23250.  
  23251.                                                 op(0xC2+r2*8);  //adc r2,0
  23252.  
  23253.                                                 op(0);
  23254.  
  23255.                                                 break;
  23256.  
  23257.                                         }
  23258.  
  23259.                                         if((i=caselonglong(itok.lnumber))!=NUMNUM64){
  23260.  
  23261.                                                 if(i<32){
  23262.  
  23263.                                                         op66(r32);
  23264.  
  23265.                                                         outword(0xA40F);
  23266.  
  23267.                                                         op(0xC0+r2+r1*8);
  23268.  
  23269.                                                         op(i);
  23270.  
  23271.                                                         op66(r32);
  23272.  
  23273.                                                         op(0xC1);
  23274.  
  23275.                                                         op(0xE0+r1);    //shl ax,num
  23276.  
  23277.                                                         op(i);
  23278.  
  23279.                                                 }
  23280.  
  23281.                                                 else{
  23282.  
  23283.                                                         op66(r32);
  23284.  
  23285.                                                         op(0x89);
  23286.  
  23287.                                                         op(0xC0+r2+r1*8);
  23288.  
  23289.                                                         i-=32;
  23290.  
  23291.                                                         if(i!=0){
  23292.  
  23293.                                                                 op66(r32);
  23294.  
  23295.                                                                 if(i==1){
  23296.  
  23297.                                                                         op(1);
  23298.  
  23299.                                                                         op(0xC0+r2*9);  //add reg,reg
  23300.  
  23301.                                                                 }
  23302.  
  23303.                                                                 else{
  23304.  
  23305.                                                                         op(0xC1);
  23306.  
  23307.                                                                         op(0xE0+r2);    //shl ax,num
  23308.  
  23309.                                                                         op(i);
  23310.  
  23311.                                                                 }
  23312.  
  23313.                                                         }
  23314.  
  23315.                                                         ZeroReg(r1,r32);
  23316.  
  23317.                                                 }
  23318.  
  23319.                                                 break;
  23320.  
  23321.                                         }
  23322.  
  23323.                                         op66(r32);
  23324.  
  23325.                                         op(0x50+r2);
  23326.  
  23327.                                         op66(r32);
  23328.  
  23329.                                         op(0x50+r1);
  23330.  
  23331.                                         addESP+=8;
  23332.  
  23333.                                         MovRegNum(r32,postnumflag&f_reloc,itok.number,ECX);
  23334.  
  23335.                                         MovRegNum(r32,0,itok.lnumber>>32,EAX);
  23336.  
  23337.                                         goto mul;
  23338.  
  23339.                                 }
  23340.  
  23341.                                 //¢ë§®¢ ¯à®æ¥¤ãàë __llmul
  23342.  
  23343.                                 op66(r32);
  23344.  
  23345.                                 op(0x50+r2);
  23346.  
  23347.                                 op66(r32);
  23348.  
  23349.                                 op(0x50+r1);
  23350.  
  23351.                                 addESP+=8;
  23352.  
  23353.                                 reg=ECX|(EAX*256);
  23354.  
  23355.                                 getintoreg64(reg);
  23356.  
  23357. //                              doregmath64(reg);
  23358.  
  23359.                                 next=0;
  23360.  
  23361. mul:
  23362.  
  23363.                                 CallExternProc("__llmul");
  23364.  
  23365.                                 addESP-=8;
  23366.  
  23367. endmul:
  23368.  
  23369.                                 if(r1!=EAX){
  23370.  
  23371.                                         if(r1==EDX){
  23372.  
  23373.                                                 if(r2==EAX){
  23374.  
  23375.                                                         op66(r32);
  23376.  
  23377.                                                         op(0x90+EDX);
  23378.  
  23379.                                                         break;
  23380.  
  23381.                                                 }
  23382.  
  23383.                                                 op66(r32);
  23384.  
  23385.                                                 op(0x89);
  23386.  
  23387.                                                 op(0xC0+r2+EDX*8);      //mov reg,EDX
  23388.  
  23389.                                                 op66(r32);
  23390.  
  23391.                                                 op(0x89);
  23392.  
  23393.                                                 op(0xC0+r1+EAX*8);      //mov reg,EAX
  23394.  
  23395.                                                 break;
  23396.  
  23397.                                         }
  23398.  
  23399.                                         op66(r32);
  23400.  
  23401.                                         op(0x89);
  23402.  
  23403.                                         op(0xC0+r1+EAX*8);      //mov reg,EAX
  23404.  
  23405.                                 }
  23406.  
  23407.                                 if(r2!=EDX){
  23408.  
  23409.                                         op66(r32);
  23410.  
  23411.                                         op(0x89);
  23412.  
  23413.                                         op(0xC0+r2+EDX*8);      //mov reg,EDX
  23414.  
  23415.                                 }
  23416.  
  23417.                                 break;
  23418.  
  23419.                         case tk_modminus: negflag=TRUE;
  23420.  
  23421.                         case tk_mod:
  23422.  
  23423.                                 vop=1;
  23424.  
  23425.                                 goto divcalc;;
  23426.  
  23427.                         case tk_divminus: negflag=TRUE;
  23428.  
  23429.                         case tk_div:
  23430.  
  23431. divcalc:
  23432.  
  23433.                           getoperand(reg1);
  23434.  
  23435.                                 if(negflag&&tok==tk_number){
  23436.  
  23437.                                         itok.lnumber=-itok.lnumber;
  23438.  
  23439.                                         negflag=FALSE;
  23440.  
  23441.                                 }
  23442.  
  23443.                                 if(tok==tk_number&&((itok.flag&f_reloc)==0)){
  23444.  
  23445.                                         if(itok.lnumber==0){
  23446.  
  23447.                                                 DevideZero();
  23448.  
  23449.                                                 break;
  23450.  
  23451.                                         }
  23452.  
  23453.                                         if(itok.lnumber==1){
  23454.  
  23455.                                                 if(vop){        //mod
  23456.  
  23457.                                                         ZeroReg(r1,r32);
  23458.  
  23459.                                                         ZeroReg(r2,r32);
  23460.  
  23461.                                                 }
  23462.  
  23463.                                                 break;
  23464.  
  23465.                                         }
  23466.  
  23467.                                         if((i=caselonglong(itok.lnumber))!=NUMNUM64){
  23468.  
  23469.                                                 if(vop){        //mod
  23470.  
  23471.                                                         optnumadd64(itok.lnumber-1,r1,r2,0x20);
  23472.  
  23473.                                                 }
  23474.  
  23475.                                                 else{
  23476.  
  23477.                                                         if(i<32){
  23478.  
  23479.                                                                 op66(r32);
  23480.  
  23481.                                                                 outword(0xAC0F);
  23482.  
  23483.                                                                 op(0xC0+r1+r2*8);
  23484.  
  23485.                                                                 op(i);
  23486.  
  23487.                                                                 op66(r32);
  23488.  
  23489.                                                                 op(0xc1);
  23490.  
  23491.                                                                 op(0xe8+r2); // SHR reg,imm8
  23492.  
  23493.                                                                 op(i);
  23494.  
  23495.                                                         }
  23496.  
  23497.                                                         else{
  23498.  
  23499.                                                                 op66(r32);
  23500.  
  23501.                                                                 op(0x89);
  23502.  
  23503.                                                                 op(0xC0+r1+r2*8);
  23504.  
  23505.                                                                 i-=32;
  23506.  
  23507.                                                                 if(i!=0){
  23508.  
  23509.                                                                         op66(r32);
  23510.  
  23511.                                                                         if(i==1){
  23512.  
  23513.                                                                                 op(0xD1);
  23514.  
  23515.                                                                                 op(0xE8+r1);    //shr ax,1
  23516.  
  23517.                                                                         }
  23518.  
  23519.                                                                         else{
  23520.  
  23521.                                                                                 op(0xC1);
  23522.  
  23523.                                                                                 op(0xE8+r1);    //shr ax,num
  23524.  
  23525.                                                                                 op(i);
  23526.  
  23527.                                                                         }
  23528.  
  23529.                                                                 }
  23530.  
  23531.                                                                 ZeroReg(r2,r32);
  23532.  
  23533.                                                         }
  23534.  
  23535.                                                 }
  23536.  
  23537.                                                 break;
  23538.  
  23539.                                         }
  23540.  
  23541.                                         unsigned long number;
  23542.  
  23543.                                         number=itok.lnumber>>32;
  23544.  
  23545.                                         for(i=0;i<2;i++){
  23546.  
  23547.                                                 op66(r32);
  23548.  
  23549.                                                 if((itok.flag&f_reloc)==0&&short_ok(number,1)){
  23550.  
  23551.                                                         op(0x6A);
  23552.  
  23553.                                                         op(number);
  23554.  
  23555.                                                 }
  23556.  
  23557.                                                 else{
  23558.  
  23559.                                                         op(0x68);
  23560.  
  23561.                                                         if(i==0&&(itok.flag&f_reloc)!=0)AddReloc();
  23562.  
  23563.                                                         outdword(number);
  23564.  
  23565.                                                 }
  23566.  
  23567.                                                 if(i==1)break;
  23568.  
  23569.                                                 number=itok.number;
  23570.  
  23571.                                         }
  23572.  
  23573.                                         addESP+=8;
  23574.  
  23575.                                         goto divcont;
  23576.  
  23577.                                 }
  23578.  
  23579.                                 reg=reg1|(reg2*256);
  23580.  
  23581.                                 getintoreg64(reg);
  23582.  
  23583.                                 op66(r32);
  23584.  
  23585.                                 op(0x50+reg2);
  23586.  
  23587.                                 op66(r32);
  23588.  
  23589.                                 op(0x50+reg1);
  23590.  
  23591.                                 addESP+=8;
  23592.  
  23593.                                 next=0;
  23594.  
  23595. divcont:
  23596.  
  23597.                                 if(r1!=EAX){
  23598.  
  23599.                                         if(r2==EAX){
  23600.  
  23601.                                                 if(r1==EDX){
  23602.  
  23603.                                                         op66(r32);
  23604.  
  23605.                                                         op(0x90+EDX);
  23606.  
  23607.                                                         goto sdiv;
  23608.  
  23609.                                                 }
  23610.  
  23611.                                                 op66(r32);
  23612.  
  23613.                                                 op(0x89);
  23614.  
  23615.                                                 op(0xC0+EDX+r2*8);      //mov EDX,r2
  23616.  
  23617.                                                 op66(r32);
  23618.  
  23619.                                                 op(0x89);
  23620.  
  23621.                                                 op(0xC0+EAX+r1*8);      //mov EAX,r1
  23622.  
  23623.                                                 goto sdiv;
  23624.  
  23625.                                         }
  23626.  
  23627.                                         op66(r32);
  23628.  
  23629.                                         op(0x89);
  23630.  
  23631.                                         op(0xC0+EAX+r1*8);      //mov EAX,r1
  23632.  
  23633.                                 }
  23634.  
  23635.                                 if(r2!=EDX){
  23636.  
  23637.                                         op66(r32);
  23638.  
  23639.                                         op(0x89);
  23640.  
  23641.                                         op(0xC0+EDX+r2*8);      //mov EDX,r2
  23642.  
  23643.                                 }
  23644.  
  23645. sdiv:
  23646.  
  23647.                                 CallExternProc((char*)(vop==0?"__lludiv":"__llumod"));
  23648.  
  23649.                                 addESP-=8;
  23650.  
  23651.                                 goto endmul;
  23652.  
  23653.                         default: operatorexpected(); break;
  23654.  
  23655.                 }
  23656.  
  23657.                 if(next)nexttok();
  23658.  
  23659.         }
  23660.  
  23661.         ClearReg(r1);
  23662.  
  23663.         ClearReg(r2);
  23664.  
  23665.         if(cpu<3)cpu=3;
  23666.  
  23667. }
  23668.  
  23669.  
  23670.  
  23671. void getintoreg64(int reg)
  23672.  
  23673. {
  23674.  
  23675. int negflag=0,next=1,i=0;
  23676.  
  23677. unsigned long long holdnumber=0;
  23678.  
  23679. int r1,r2;
  23680.  
  23681. int reg1,reg2;
  23682.  
  23683.         r1=reg&255;
  23684.  
  23685.         r2=reg/256;
  23686.  
  23687.         Select2FreeReg(r1,r2,&reg1,&reg2);
  23688.  
  23689.         if(tok==tk_minus){
  23690.  
  23691.                 if(CheckMinusNum()==FALSE){
  23692.  
  23693.                         negflag=1;
  23694.  
  23695.                         getoperand(am32==FALSE?BX:r1);
  23696.  
  23697.                 }
  23698.  
  23699.         }
  23700.  
  23701.         switch(tok){
  23702.  
  23703.                 case tk_number:
  23704.  
  23705.                         holdnumber=CalcNumber(4);
  23706.  
  23707.                         MovRegNum(r32,postnumflag&f_reloc,holdnumber,r1);
  23708.  
  23709.                         MovRegNum(r32,0,holdnumber>>32,r2);
  23710.  
  23711.                         next=0;
  23712.  
  23713.                         break;
  23714.  
  23715.                 case tk_postnumber:
  23716.  
  23717.                 case tk_undefofs:
  23718.  
  23719.                 case tk_apioffset:
  23720.  
  23721.                         op66(r32);
  23722.  
  23723.                         op(0xB8+r1);                    /* MOV AX,# */
  23724.  
  23725.                         if(tok==tk_apioffset)AddApiToPost(itok.number);
  23726.  
  23727.                         else{
  23728.  
  23729.                                 if(tok==tk_undefofs)AddUndefOff(0,itok.name);
  23730.  
  23731.                                 else (itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
  23732.  
  23733.                                 tok=tk_number;
  23734.  
  23735.                                 holdnumber+=doconstdwordmath();
  23736.  
  23737.                                 outdword(holdnumber);
  23738.  
  23739.                                 MovRegNum(r32,0,holdnumber>>32,r2);
  23740.  
  23741.                                 next=0;
  23742.  
  23743.                         }
  23744.  
  23745.                         ClearReg(r1);
  23746.  
  23747.                         ClearReg(r2);
  23748.  
  23749.                         break;
  23750.  
  23751.                 case tk_rmnumber:
  23752.  
  23753.                         CheckAllMassiv(bufrm,8,&strinf,&itok,reg1,reg2);
  23754.  
  23755.                         if(!(am32&&itok.rm==r1&&r1!=EBP&&r1!=ESP)){
  23756.  
  23757.                                 op66(r32);
  23758.  
  23759.                                 op67(itok.sib==CODE16?r16:r32);
  23760.  
  23761.                                 if(itok.post==0)outseg(&itok,2);
  23762.  
  23763.                                 op(0x8D);                       // LEA reg,[rm]
  23764.  
  23765.                                 op(r1*8+itok.rm);
  23766.  
  23767.                                 if(itok.post!=0&&itok.post!=UNDEF_OFSET){
  23768.  
  23769.                                         if((itok.flag&f_extern)==0){
  23770.  
  23771.                                                 unsigned int ooutptr=outptr;
  23772.  
  23773.                                                 if(am32&&itok.rm==rm_sib)outptr++;
  23774.  
  23775.                                                 setwordpost(&itok);
  23776.  
  23777.                                                 outptr=ooutptr;
  23778.  
  23779.                                         }
  23780.  
  23781.                                         else setwordext(&itok.number);
  23782.  
  23783.                                 }
  23784.  
  23785.                                 outaddress(&itok);
  23786.  
  23787.                                 ClearReg(r1);
  23788.  
  23789.                         }
  23790.  
  23791.                         ZeroReg(r2,r32);
  23792.  
  23793.                         break;
  23794.  
  23795.                 case tk_qwordvar:
  23796.  
  23797.                         reg=r1;
  23798.  
  23799.                         for(i=0;i<2;i++){
  23800.  
  23801.                                 if(reg==EAX&&((itok.rm==rm_d16&&itok.sib==CODE16)||(itok.rm==rm_d32&&(itok.sib==CODE32||itok.sib==0)))){
  23802.  
  23803.                                         op66(r32);
  23804.  
  23805.                                         outseg(&itok,1);
  23806.  
  23807.                                         op(0xA1);
  23808.  
  23809.                                         if(itok.post==UNDEF_OFSET)AddUndefOff(2,itok.name);
  23810.  
  23811.                                         if(am32==FALSE)outword((unsigned int)itok.number);
  23812.  
  23813.                                         else outdword(itok.number);
  23814.  
  23815.                                 }
  23816.  
  23817.                                 else{
  23818.  
  23819.                                         CheckAllMassiv(bufrm,8,&strinf,&itok,reg1,reg2);
  23820.  
  23821.                                         op66(r32);
  23822.  
  23823.                                         outseg(&itok,2);
  23824.  
  23825.                                         op(0x8B);
  23826.  
  23827.                                         op(reg*8+itok.rm);
  23828.  
  23829.                                         outaddress(&itok);
  23830.  
  23831.                                 }
  23832.  
  23833.                                 ClearReg(reg);
  23834.  
  23835.                                 if(i==1)break;
  23836.  
  23837.                                 itok.number+=4;
  23838.  
  23839.                                 compressoffset(&itok);
  23840.  
  23841.                                 reg=r2;
  23842.  
  23843.                         }
  23844.  
  23845.                         break;
  23846.  
  23847.                 case tk_longvar:
  23848.  
  23849.                 case tk_dwordvar:
  23850.  
  23851.                         if(reg==EAX&&((itok.rm==rm_d16&&itok.sib==CODE16)||(itok.rm==rm_d32&&(itok.sib==CODE32||itok.sib==0)))){
  23852.  
  23853.                                 op66(r32);
  23854.  
  23855.                                 outseg(&itok,1);
  23856.  
  23857.                                 op(0xA1);
  23858.  
  23859.                                 if(itok.post==UNDEF_OFSET)AddUndefOff(2,itok.name);
  23860.  
  23861.                                 if(am32==FALSE)outword((unsigned int)itok.number);
  23862.  
  23863.                                 else outdword(itok.number);
  23864.  
  23865.                         }
  23866.  
  23867.                         else{
  23868.  
  23869.                                 CheckAllMassiv(bufrm,4,&strinf,&itok,reg1,reg2);
  23870.  
  23871.                                 op66(r32);
  23872.  
  23873.                                 outseg(&itok,2);
  23874.  
  23875.                                 op(0x8B);
  23876.  
  23877.                                 op(r1*8+itok.rm);
  23878.  
  23879.                                 outaddress(&itok);
  23880.  
  23881.                         }
  23882.  
  23883.                         ZeroReg(r2,r32);
  23884.  
  23885.                         ClearReg(r1);
  23886.  
  23887.                         break;
  23888.  
  23889.                 case tk_intvar:
  23890.  
  23891.                 case tk_wordvar:
  23892.  
  23893.                         CheckAllMassiv(bufrm,2,&strinf,&itok,reg1,reg2);
  23894.  
  23895.                         if(tok==tk_wordvar&&optimizespeed&&chip>3&&chip<7&&RmEqualReg(reg,itok.rm,itok.sib)==FALSE){
  23896.  
  23897.                                 ZeroReg(r1,r32);
  23898.  
  23899.                                 op66(r16);
  23900.  
  23901.                                 outseg(&itok,2);        //mov reg,var
  23902.  
  23903.                                 op(0x8B);
  23904.  
  23905.                         }
  23906.  
  23907.                         else{
  23908.  
  23909.                                 op66(r32);
  23910.  
  23911.                                 outseg(&itok,3);        //movxx reg,var
  23912.  
  23913.                                 op(0x0F); op(tok==tk_wordvar?0xB7:0xBF);
  23914.  
  23915.                         }
  23916.  
  23917.                         op(r1*8+itok.rm);
  23918.  
  23919.                         outaddress(&itok);
  23920.  
  23921.                         ClearReg(r1);
  23922.  
  23923.                         ZeroReg(r2,r32);
  23924.  
  23925.                         break;
  23926.  
  23927.                 case tk_bytevar:
  23928.  
  23929.                 case tk_charvar:
  23930.  
  23931.                         CheckAllMassiv(bufrm,1,&strinf,&itok,reg1,reg2);
  23932.  
  23933.                         if(reg<=EBX&&tok==tk_bytevar&&optimizespeed&&chip>3&&chip<7&&RmEqualReg(reg,itok.rm,itok.sib)==FALSE){
  23934.  
  23935.                                 ZeroReg(r1,r32);
  23936.  
  23937.                                 outseg(&itok,2);
  23938.  
  23939.                                 op(0x8A);
  23940.  
  23941.                         }
  23942.  
  23943.                         else{
  23944.  
  23945.                                 op66(r32);
  23946.  
  23947.                                 outseg(&itok,3);
  23948.  
  23949.                                 op(0xf);
  23950.  
  23951.                                 if(tok==tk_bytevar)op(0xb6);
  23952.  
  23953.                                 else op(0xbe);
  23954.  
  23955.                         }
  23956.  
  23957.                         op(r1*8+itok.rm); // MOVZX regL,[byte]
  23958.  
  23959.                         outaddress(&itok);
  23960.  
  23961.                         ClearReg(r1);
  23962.  
  23963.                         ZeroReg(r2,r32);
  23964.  
  23965.                         break;
  23966.  
  23967.                 case tk_reg:
  23968.  
  23969.                         if(tok2==tk_openbracket){       //¢ë§®¢ ¯à®æ¥¤ãàë ¯®  ¤à¥áã ¢ ॣ¨áâà¥
  23970.  
  23971.                                 reg1=itok.number;
  23972.  
  23973.                                 nexttok();
  23974.  
  23975.                                 param[0]=0;
  23976.  
  23977.                                 if(comfile==file_w32)swapparam();
  23978.  
  23979.                                 else doparams();
  23980.  
  23981.                                 op66(r16);
  23982.  
  23983.                                 op(0xFF);
  23984.  
  23985.                                 op(0xD0+reg1);  /* CALL reg with stack params */
  23986.  
  23987.                                 itok.number=0;
  23988.  
  23989.                                 clearregstat();
  23990.  
  23991. #ifdef OPTVARCONST
  23992.  
  23993.                                 FreeGlobalConst();
  23994.  
  23995. #endif
  23996.  
  23997.                         }
  23998.  
  23999.                         if(optimizespeed&&chip>3&&chip<7&&reg!=(int)itok.number){
  24000.  
  24001.                                 ZeroReg(r1,r32);
  24002.  
  24003.                                 op(0x89);
  24004.  
  24005.                                 op(0xC0+r1+(unsigned int)itok.number*8);
  24006.  
  24007.                         }
  24008.  
  24009.                         else{
  24010.  
  24011.                                 op66(r32);
  24012.  
  24013.                                 outword(0xB70F);
  24014.  
  24015.                                 op(0xC0+r1*8+(unsigned int)itok.number);
  24016.  
  24017.                         }
  24018.  
  24019.                         RegToReg(r1,itok.number,r32);
  24020.  
  24021.                         ZeroReg(r2,r32);
  24022.  
  24023.                         break;
  24024.  
  24025.                 case tk_reg32:
  24026.  
  24027.                         if(tok2==tk_openbracket){       //¢ë§®¢ ¯à®æ¥¤ãàë ¯®  ¤à¥áã ¢ ॣ¨áâà¥
  24028.  
  24029.                                 reg1=itok.number;
  24030.  
  24031.                                 nexttok();
  24032.  
  24033.                                 param[0]=0;
  24034.  
  24035.                                 if(comfile==file_w32)swapparam();
  24036.  
  24037.                                 else doparams();
  24038.  
  24039.                                 op66(r32);
  24040.  
  24041.                                 op(0xFF);
  24042.  
  24043.                                 op(0xD0+reg1);  /* CALL reg with stack params */
  24044.  
  24045.                                 itok.number=0;
  24046.  
  24047.                                 clearregstat();
  24048.  
  24049. #ifdef OPTVARCONST
  24050.  
  24051.                                 FreeGlobalConst();
  24052.  
  24053. #endif
  24054.  
  24055.                         }
  24056.  
  24057.                         if(r1!=(int)itok.number){
  24058.  
  24059.                                 op66(r32);
  24060.  
  24061.                                 op(0x89);
  24062.  
  24063.                                 op(0xC0+r1+(unsigned int)itok.number*8);
  24064.  
  24065.                                 RegToReg(r1,itok.number,r32);
  24066.  
  24067.                         }
  24068.  
  24069.                         ZeroReg(r2,r32);
  24070.  
  24071.                         break;
  24072.  
  24073.                 case tk_reg64:
  24074.  
  24075.                         reg1=itok.number&255;
  24076.  
  24077.                         reg2=itok.number/256;
  24078.  
  24079. movreg64:
  24080.  
  24081.                         if(r1==reg2){
  24082.  
  24083.                                 if(r2==reg1){
  24084.  
  24085.                                         op66(r32);
  24086.  
  24087.                                         if(r1==AX)op(0x90+r2);
  24088.  
  24089.                                         else if(r2==AX)op(0x90+r1);
  24090.  
  24091.                                         else{
  24092.  
  24093.                                                 op(0x87);
  24094.  
  24095.                                                 op(0xC0+r1+r2*8);
  24096.  
  24097.                                         }
  24098.  
  24099.                                         break;
  24100.  
  24101.                                 }
  24102.  
  24103.                                 int temp;
  24104.  
  24105.                                 temp=r2;
  24106.  
  24107.                                 r2=r1;
  24108.  
  24109.                                 r1=temp;
  24110.  
  24111.                                 temp=reg2;
  24112.  
  24113.                                 reg2=reg1;
  24114.  
  24115.                                 reg1=temp;
  24116.  
  24117.                         }
  24118.  
  24119.                         if(r2==reg1){
  24120.  
  24121.                                 int temp;
  24122.  
  24123.                                 temp=r2;
  24124.  
  24125.                                 r2=r1;
  24126.  
  24127.                                 r1=temp;
  24128.  
  24129.                                 temp=reg2;
  24130.  
  24131.                                 reg2=reg1;
  24132.  
  24133.                                 reg1=temp;
  24134.  
  24135.                         }
  24136.  
  24137.                         if(r1!=reg1){
  24138.  
  24139.                                 op66(r32);
  24140.  
  24141.                                 op(0x89);
  24142.  
  24143.                                 op(0xC0+r1+reg1*8);
  24144.  
  24145.                                 RegToReg(r1,reg1,r32);
  24146.  
  24147.                         }
  24148.  
  24149.                         if(r2!=reg2){
  24150.  
  24151.                                 op66(r32);
  24152.  
  24153.                                 op(0x89);
  24154.  
  24155.                                 op(0xC0+r2+reg2*8);
  24156.  
  24157.                                 RegToReg(r2,reg2,r32);
  24158.  
  24159.                         }
  24160.  
  24161.                         break;
  24162.  
  24163.                 case tk_bits:
  24164.  
  24165.                         int vops;
  24166.  
  24167.                         i=itok.bit.siz+itok.bit.ofs;
  24168.  
  24169.                         if(i<=64)vops=r64;
  24170.  
  24171.                         if(i<=32)vops=r32;
  24172.  
  24173.                         if(i<=16)vops=r16;
  24174.  
  24175.                         bits2reg(r1,(r32<vops?vops:r32));
  24176.  
  24177.                         ZeroReg(r2,r32);
  24178.  
  24179.                         break;
  24180.  
  24181.                 case tk_seg:
  24182.  
  24183.                         op66(r32);
  24184.  
  24185.                         op(0x8C);
  24186.  
  24187.                         op(0xC0+r1+(unsigned int)itok.number*8);
  24188.  
  24189.                         ClearReg(r1);
  24190.  
  24191.                         ZeroReg(r2,r32);
  24192.  
  24193.                         break;
  24194.  
  24195.                 case tk_beg:
  24196.  
  24197.                         if(optimizespeed&&chip>3&&chip<7&&reg<4&&reg!=(int)(itok.number%4)){
  24198.  
  24199.                                 ZeroReg(r1,r32);
  24200.  
  24201.                                 op(0x88);
  24202.  
  24203.                                 op(0xC0+r1+(unsigned int)itok.number*8); // MOV regL,beg
  24204.  
  24205.                         }
  24206.  
  24207.                         else{
  24208.  
  24209.                                 op66(r32);
  24210.  
  24211.                                 outword(0xb60f);
  24212.  
  24213.                                 op(0xC0+r1*8+(unsigned int)itok.number); // MOVZX regL,beg
  24214.  
  24215.                         }
  24216.  
  24217.                         ClearReg(reg);
  24218.  
  24219.                         ZeroReg(r2,r32);
  24220.  
  24221.                         break;
  24222.  
  24223.                 case tk_at:
  24224.  
  24225.                         getoperand(am32==FALSE?BX:reg);
  24226.  
  24227.                         i++;
  24228.  
  24229.                 case tk_ID:
  24230.  
  24231.                 case tk_id:
  24232.  
  24233.                 case tk_proc:
  24234.  
  24235.                 case tk_apiproc:
  24236.  
  24237.                 case tk_undefproc:
  24238.  
  24239.                 case tk_declare:
  24240.  
  24241.                         if((!i)||macros(tk_qword)==0)procdo(tk_qword);
  24242.  
  24243.                         reg1=EAX; reg2=EDX;
  24244.  
  24245.                         goto movreg64;
  24246.  
  24247.                 case tk_string:
  24248.  
  24249.                         op66(r32);
  24250.  
  24251.                         op(0xB8+r1);
  24252.  
  24253.                         outdword(addpoststring());
  24254.  
  24255.                         ClearReg(r1);
  24256.  
  24257.                         ZeroReg(r2,r32);
  24258.  
  24259.                         break;
  24260.  
  24261.                 default: valueexpected();       break;
  24262.  
  24263.         }
  24264.  
  24265.         if(negflag){
  24266.  
  24267.                 op66(r32);
  24268.  
  24269.                 op(0xF7);
  24270.  
  24271.                 op(0xD8+r2);  // NEG reg
  24272.  
  24273.                 op66(r32);
  24274.  
  24275.                 op(0xF7);
  24276.  
  24277.                 op(0xD8+r1);  // NEG reg
  24278.  
  24279.                 op66(r32);
  24280.  
  24281.                 op(0x83);
  24282.  
  24283.                 op(0xD8+r2);
  24284.  
  24285.                 op(0);
  24286.  
  24287.                 ClearReg(r1);
  24288.  
  24289.                 ClearReg(r2);
  24290.  
  24291.         }
  24292.  
  24293.         if(next)nexttok();
  24294.  
  24295. }
  24296.  
  24297.  
  24298.  
  24299. void CallExternProc(char *name)
  24300.  
  24301. {
  24302.  
  24303. ITOK itok4;
  24304.  
  24305. int tok4=tk_id;
  24306.  
  24307. char string4[256];
  24308.  
  24309. struct idrec *ptrs;
  24310.  
  24311.         memset(&itok4,0,sizeof(ITOK));
  24312.  
  24313.         strcpy(string4,name);
  24314.  
  24315.         searchtree(&itok4,&tok4,(unsigned char *)string4);
  24316.  
  24317.         ptrs=itok4.rec;
  24318.  
  24319.         switch(tok4){
  24320.  
  24321.                 case tk_id:
  24322.  
  24323.                         tok4=tok;
  24324.  
  24325.                         itok4=itok;
  24326.  
  24327.                         strcpy((char *)itok.name,string4);
  24328.  
  24329.                         string[0]=0;
  24330.  
  24331.                         itok.flag=tp_stdcall;
  24332.  
  24333.                         tok=tk_undefproc;
  24334.  
  24335.                         itok.number=secondcallnum;
  24336.  
  24337.                         itok.segm=NOT_DYNAMIC;
  24338.  
  24339.                         itok.rm=tk_qword;
  24340.  
  24341.                         itok.post=0;
  24342.  
  24343.                         addtotree(itok.name);
  24344.  
  24345.                         addacall(secondcallnum++,CALL_NEAR);
  24346.  
  24347.                         tok=tok4;
  24348.  
  24349.                         itok=itok4;
  24350.  
  24351.                         callloc0();
  24352.  
  24353.                         break;
  24354.  
  24355.                 case tk_declare:
  24356.  
  24357.                         ptrs->rectok=tk_undefproc;
  24358.  
  24359.                 case tk_undefproc:
  24360.  
  24361.                         addacall(itok4.number,(unsigned char)(am32!=FALSE?CALL_32:CALL_NEAR));
  24362.  
  24363.                         callloc0();             /* produce CALL [#] */
  24364.  
  24365.                         break;
  24366.  
  24367.                 case tk_proc:
  24368.  
  24369.                         if(itok4.segm==DYNAMIC)itok4.segm=ptrs->recsegm=DYNAMIC_USED;
  24370.  
  24371.                         if(itok4.segm<NOT_DYNAMIC){     //¤¨­ ¬¨ç¥áª ï ¯à®æ¥¤ãà 
  24372.  
  24373.                                 addacall(itok4.number,(unsigned char)(am32!=FALSE?CALL_32:CALL_NEAR));
  24374.  
  24375.                                 callloc0();
  24376.  
  24377.                         }
  24378.  
  24379.                         else{
  24380.  
  24381.                                 callloc(itok4.number);
  24382.  
  24383.                         }
  24384.  
  24385.                         break;
  24386.  
  24387.                 default:
  24388.  
  24389.                         sprintf(string4,"'%s' already used",name);
  24390.  
  24391.                         preerror(string4);
  24392.  
  24393.                         break;
  24394.  
  24395.         }
  24396.  
  24397. }
  24398.  
  24399. /* end of TOKB.C */
  24400.  
  24401.