Subversion Repositories Kolibri OS

Rev

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

  1.  
  2. #define _TOKA_
  3.  
  4. #include "tok.h"
  5.  
  6. #pragma option -w-pin
  7.  
  8. #ifdef _WIN32_
  9. #include <windows.h>
  10. #endif
  11.  
  12. #include <unistd.h>
  13. #include <sys/stat.h>
  14.  
  15. #include "dirlist.h"
  16. #include "id.h"
  17. #include "resname.h"
  18.  
  19. struct idrec *treestart=NULL;
  20. struct idrec *definestart=NULL;
  21. UNDEFOFF *undefoffstart=NULL;
  22. DLLLIST *listdll=NULL;
  23. struct structteg *tegtree=NULL; //£«®¡ «ì­ë© áà¨á®ª ⥣®¢
  24. struct structteg *ltegtree=NULL;        //«®ª «ì­ë© áà¨á®ª ⥣®¢
  25. //struct idrec *lstructlist=NULL;  //ᯨ᮪ «®ª «ì­ëå áâàãªâãà
  26. SINFO strinf={NULL};
  27. static int notdef=TRUE;
  28. static char precha;
  29. int scanalltoks=TRUE;
  30.  
  31.  
  32. static volatile idrec **DynamicList=NULL;
  33. static int sizeDL;      //à §¬¥à ᯨ᪠
  34. static volatile int countDP;    //ç¨á«® ¤¨­ ¬¨ç¥áª¨å ¯à®æ¥¤ãà ¢ ᯨ᪥
  35. static int findofset=FALSE;
  36. #define STEPDL 128;     //è £ 㢥«¨ç¥­¨ï à §¬¥à  ᯨ᪠
  37. ITOK structadr;
  38.  
  39.  
  40. char id2[ID2S][9]={
  41.         "ESCHAR","ESBYTE","ESINT","ESWORD","ESLONG","ESDWORD","ESFLOAT","ESQWORD","ESDOUBLE",
  42.         "CSCHAR","CSBYTE","CSINT","CSWORD","CSLONG","CSDWORD","CSFLOAT","CSQWORD","CSDOUBLE",
  43.         "SSCHAR","SSBYTE","SSINT","SSWORD","SSLONG","SSDWORD","SSFLOAT","SSQWORD","SSDOUBLE",
  44.         "DSCHAR","DSBYTE","DSINT","DSWORD","DSLONG","DSDWORD","DSFLOAT","DSQWORD","DSDOUBLE",
  45.         "FSCHAR","FSBYTE","FSINT","FSWORD","FSLONG","FSDWORD","FSFLOAT","FSQWORD","FSDOUBLE",
  46.         "GSCHAR","GSBYTE","GSINT","GSWORD","GSLONG","GSDWORD","GSFLOAT","GSQWORD","GSDOUBLE",};
  47.  
  48. char regs[2][8][4]={"AX","CX","DX","BX","SP","BP","SI","DI",
  49.                    "EAX","ECX","EDX","EBX","ESP","EBP","ESI","EDI"};
  50. char begs[8][3]={"AL","CL","DL","BL","AH","CH","DH","BH"};
  51. char segs[6][3]={"ES","CS","SS","DS","FS","GS"};
  52.  
  53. char mon[12][4]={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug",
  54.                                  "Sep","Oct","Nov","Dec"};
  55.  
  56. unsigned char cha2;
  57. char skipfind=FALSE;    /* ¯à®¯ã᪠¯®¨áª  ¢ £«®¡ «ì­®¬ ¤¥à¥¢¥ ¨ á।¨
  58.                                                                                                                           «®ª «ì­ëå ¯¥à¥¬¥­­ëå */
  59. static unsigned char savestring3=FALSE; //à §à¥è¨âì § ¯¨áì ¢ ¡ãä¥à string3
  60. static int posstr3;     //㪠§ â¥«ì ¯®§¨æ¨¨ ¢ string3
  61.  
  62. unsigned int inptr2;
  63. unsigned int linenum2=0;        //¥á«¨ ­¥ ­ã«ì, â® ¨¤¥â ®¡à ì®âª 
  64. char displaytokerrors;          /* flag to display errors, 0 for tok2 scan */
  65. char *bufrm=NULL;
  66. char *startline=NULL;
  67. char *endinput=NULL;
  68. unsigned char skiplocals=FALSE;
  69. int scanlexmode=STDLEX;
  70. unsigned char bytesize=TRUE;
  71.  
  72. COM_MOD *cur_mod=NULL;
  73.  
  74. void docals(struct idrec *ptr);
  75. void dostructvar2(int *tok4,ITOK *itok4,struct structteg *tteg,unsigned char *string4); //à §¡®à áâàãªâãà ­  ¯¥à¥¬¥­­ë¥ ¨ áâàãªâãàë
  76. void dosizeof(ITOK *itok4);     //®¯à §­ ç¥­¨¥ sizeof
  77. void ofsstr(int *tok4,ITOK *itok4);
  78. int searchlocals(ITOK *itok4,int *tok4,unsigned char *string4);
  79. unsigned char convert_char();
  80. void tokscan (int *tok4,ITOK *itok4,unsigned char *string4);
  81. int calcnum(int *ctok,ITOK *cstok,char *cstring,long *retval);
  82. int GetDirective(char *str);
  83. int CheckAsmName(char *name);
  84. void tag_massiv(int *tok4,ITOK *itok4,unsigned char *string4);
  85. int CheckResName(char *name);
  86. void GetTypeVar(int *tok4);
  87. int RegToRM(int number,int tok4);
  88. elementteg *FindClassEl(structteg *searcht,unsigned char *string4,int *addofs,
  89.         structteg *subteg);
  90. int AskUseDestr(structteg *searcht);
  91. int SaveStruct(int size,idrec *newrec);
  92. int CheckDefPar(char *name);
  93. int searchtree2(idrec *fptr,ITOK *itok4,int *tok4,unsigned char *string4);
  94.  
  95. extern void blockerror();
  96. extern void block16_32error();
  97. extern void notstructname();
  98. extern void badtoken();
  99. extern void opb(unsigned long num,unsigned int ofs,unsigned int size);
  100. extern void CorrectOfsBit(int bitofs);
  101. extern int skipstring(int pos,unsigned char term);
  102. extern int skipcomment(int pos);
  103.  
  104.  
  105. void retoldscanmode(int mode)
  106. {
  107.         if(mode==STDLEX&&cha2==13&&tok!=tk_endline){
  108.                 cha2=cha;
  109.         }
  110.         scanlexmode=mode;
  111. }
  112.  
  113. void CheckConvertString(char *string4)
  114. {
  115.         if(cha=='o'){
  116.                 OemToChar(string4,string4);
  117.                 nextchar();
  118.         }
  119.         else if(cha=='w'){
  120.                 CharToOem(string4,string4);
  121.                 nextchar();
  122.         }
  123. }
  124.  
  125. void DateToStr(char *buf)
  126. {
  127. //      GetDateFormat(LOCALE_SYSTEM_DEFAULT,DATE_SHORTDATE|LOCALE_NOUSEROVERRIDE,NULL,NULL,buf,80);
  128.         sprintf(buf,"%2d %s %d",timeptr.tm_mday,mon[timeptr.tm_mon],timeptr.tm_year+1900);
  129. }
  130.  
  131. void compressoffset(ITOK *thetok)
  132. {
  133.         if(thetok->sib==CODE16){
  134.                 if(thetok->rm!=rm_d16){
  135.                         thetok->rm&=7;
  136.                         if(thetok->number==0){
  137.                                 if(thetok->rm==rm_BP)thetok->rm|=rm_mod01;
  138.                         }
  139.                         else if((int)thetok->number<128&&(int)thetok->number>=-128)thetok->rm|=rm_mod01;
  140.                         else thetok->rm|=rm_mod10;
  141.                 }
  142.         }
  143.         else{
  144.                 if(thetok->rm!=rm_d32&&thetok->rm!=rm_sib){
  145.                         thetok->rm&=7;
  146.                         if(thetok->number==0){
  147.                                 if(thetok->rm==5)thetok->rm|=rm_mod01;
  148.                                 if(thetok->rm==4&&(thetok->sib&7)==5)thetok->rm|=rm_mod01;
  149.                         }
  150.                         else if(thetok->number<128&&thetok->number>=-128)thetok->rm|=rm_mod01;
  151.                         else thetok->rm|=rm_mod10;
  152.                 }
  153.         }
  154. }
  155.  
  156. int CalcRm16(int base,int idx)
  157. {
  158. int rm;
  159.         rm=0;
  160.         switch(base+idx){
  161.                 case 2: rm++;
  162.                 case 4: rm++;
  163.                 case 6: rm++;
  164.                 case 5: rm++;
  165.                 case 12: rm++;
  166.                 case 11: rm++;
  167.                 case 10: rm++;
  168.         }
  169.         return rm;
  170. }
  171.  
  172. void SRBackBuf(int mode)        //save/restore BackTextBlock
  173. {
  174. static int size=0;
  175. static char *buf;
  176.         if(mode==0){
  177.                 if(SizeBackBuf){
  178.                         size=SizeBackBuf;
  179.                         SizeBackBuf=0;
  180.                         buf=BackTextBlock;
  181.                 }
  182.         }
  183.         else{
  184.                 SizeBackBuf=size;
  185.                 size=0;
  186.                 BackTextBlock=buf;
  187.         }
  188. }
  189.  
  190. void ExpandRm(int rm,int sib,int *zoom,int *base,int *idx)
  191. {
  192. int rm0;
  193. int reg1=-1,reg2=-1;
  194. int z=0;
  195.         rm0=rm&0x7;
  196.         if(sib==CODE16||sib==(CODE16+1)){
  197.                 switch(rm0){
  198.                         case 0:
  199.                                 reg1=BX;
  200.                                 reg2=SI;
  201.                                 break;
  202.                         case 1:
  203.                                 reg1=BX;
  204.                                 reg2=DI;
  205.                                 break;
  206.                         case 2:
  207.                                 reg1=BP;
  208.                                 reg2=SI;
  209.                                 break;
  210.                         case 3:
  211.                                 reg1=BP;
  212.                                 reg2=DI;
  213.                                 break;
  214.                         case 4:
  215.                                 reg2=SI;
  216.                                 break;
  217.                         case 5:
  218.                                 reg2=DI;
  219.                                 break;
  220.                         case 6:
  221.                                 if((rm&0xC0)!=0)reg1=BP;
  222.                                 break;
  223.                         case 7:
  224.                                 reg1=BX;
  225.                                 break;
  226.                 }
  227.         }
  228.         else{
  229.                 if(rm0==4){
  230.                         reg1=sib&7;
  231.                         reg2=(sib>>3)&7;
  232.                         if(reg1==5&&(rm&0xc0)==0)reg1=-1;
  233.                         if(reg2==4)reg2=-1;
  234.                         else z=sib>>6;
  235.                 }
  236.                 else{
  237.                         reg1=rm0;
  238.                         if(reg1==5&&(rm&0xc0)==0)reg1=-1;
  239.                 }
  240.         }
  241.         *base=reg1;
  242.         *idx=reg2;
  243.         *zoom=z;
  244. }
  245.  
  246. int CheckZoom(int size)
  247. {
  248. int zoom=0;
  249.         switch(size){
  250.                 case 8: zoom++;
  251.                 case 4: zoom++;
  252.                 case 2: zoom++;
  253.         }
  254.         return zoom;
  255. }
  256.  
  257. void calcrm(ITOK *itok4,int ttok)//®¡à ¡®âª  ¢ëà ¦¥­¨ï ¢ []
  258. {
  259. int idx,base,razr=0,zoom,rm=0;
  260. long numrm=0,cnum,ocnum;
  261. int nextscan;
  262. ITOK cstok,dstok;
  263. int ctok,sopenb;
  264. unsigned char *pstring;
  265. unsigned int flag;
  266. unsigned int sizevar=1;
  267. unsigned int prevtok=tk_number,operand=tk_plus;
  268. int dsword,dsword2;
  269.         nextchar();
  270.         whitespace();//¯à®¯ã᪠­¥§­ ç é¨å ᨬ¢®«®¢
  271.         if(!displaytokerrors){
  272.                 for(int i=1;i!=0;){
  273.                         FastTok(0,&ctok,&cstok);
  274.                         switch(ctok){
  275.                                 case tk_closeblock: i--; break;
  276.                                 case tk_openblock: i++; break;
  277.                                 case tk_eof: i=0; break;
  278.                         }
  279.                 }
  280.                 return;
  281.         }
  282.  
  283.         dsword2=dsword=itok4->post&POINTER;
  284.         itok4->post&=NOTPOINTER;
  285.         memcpy(&dstok,itok4,sizeof(ITOK));
  286.         ExpandRm(dstok.rm,dstok.sib,&zoom,&base,&idx);
  287.         if((dstok.sib==CODE16||dstok.sib==(CODE16+1))&&dstok.rm!=rm_d16)razr=r16;
  288.         if(am32&&dstok.rm!=rm_d32){
  289.                 rm=dstok.rm&0xC0;
  290.                 razr=r32;
  291.         }
  292. //      printf("in idx=%d base=%d zoom=%d\n",idx,base,zoom);
  293.         pstring=(unsigned char *)MALLOC(STRLEN);
  294.         sopenb=inptr;
  295.         char bcha=cha;
  296.         SRBackBuf(0);
  297.         flag=f_useidx;//0;//cstok.flag;
  298.         if(bytesize==FALSE){
  299.                 sizevar=GetVarSize(ttok);
  300.                 if(dsword)sizevar=1;
  301.                 if(am32)zoom=CheckZoom(sizevar);
  302.         }
  303.         if(cha=='&'){
  304.                 nextchar();
  305.                 whitespace();//¯à®¯ã᪠­¥§­ ç é¨å ᨬ¢®«®¢
  306.                 sizevar=1;
  307.                 zoom=0;
  308.         }
  309.         for(;;){
  310.                 nextscan=TRUE;
  311.                 if(cha=='#'&&dsword)dsword=1;
  312.                 tokscan(&ctok,&cstok,pstring);
  313.                 whitespace();//¯à®¯ã᪠­¥§­ ç é¨å ᨬ¢®«®¢
  314.                 if(dsword==1)strcpy(dstok.name,cstok.name);
  315. //              printf("tok=%d num=%d %s\n",ctok,cstok.number,cstok.name);
  316. loopsw:
  317.                 switch(ctok){
  318.                         case tk_reg:
  319.                                 if(razr==0)razr=r16;
  320.                                 else if(razr==r32||sizevar!=1||operand!=tk_plus)goto runblock;  //16.12.04 22:39
  321.                                 if(cstok.number==BP||cstok.number==BX){
  322.                                         if(base==-1)base=cstok.number;
  323.                                         else goto runblock;
  324.                                 }
  325.                                 else if(cstok.number==SI||cstok.number==DI){
  326.                                         if(idx==-1)idx=cstok.number;
  327.                                         else goto runblock;
  328.                                 }
  329.                                 else goto runblock;
  330.                                 prevtok=tk_reg;
  331.                                 break;
  332.                         case tk_minus:
  333.                                 if(calcnum(&ctok,&cstok,(char *)pstring,&cnum)==0)goto runblock;
  334.                                 prevtok=tk_number;
  335.                                 ocnum=cstok.number;
  336.                                 goto enumb;
  337.                         case tk_number:
  338.                                 if(operand==tk_mult&&prevtok==tk_reg32){
  339.                                         if(zoom==0){
  340.                                                 prevtok=tk_number;
  341.                                                 if(razr==0)razr=r32;
  342.                                                 else if(razr==r16)goto runblock;
  343.                                                 zoom=CheckZoom(cstok.number);
  344.                                                 if(zoom)break;
  345.                                         }
  346.                                         else goto runblock;
  347.                                 }
  348.                                 prevtok=tk_number;
  349.                                 ocnum=cstok.number;
  350.                                 if(zoom==0&&razr!=r16&&(idx==-1||base==-1)){
  351.                                         if((zoom=CheckZoom(cstok.number))!=0){
  352.                                                 if(cha=='*'){
  353.                                                         nextchar();
  354.                                                         tokscan(&ctok,&cstok,pstring);
  355.                                                         if(ctok==tk_reg32){
  356.                                                                 if(idx!=-1)base=idx;
  357.                                                                 idx=cstok.number;
  358.                                                                 prevtok=tk_reg32;
  359.                                                                 if(razr==0)razr=r32;
  360.                                                                 break;
  361.                                                         }
  362.                                                         if(ctok==tk_number){
  363.                                                                 calclongnumber(&ocnum,cstok.number,tk_mult);
  364.                                                                 numrm+=ocnum;
  365.                                                                 zoom=0;
  366.                                                                 break;
  367.                                                         }
  368.                                                         goto runblock;
  369.                                                 }
  370.                                                 zoom=0;
  371.                                         }
  372.                                 }
  373.                                 if(calcnum(&ctok,&cstok,(char *)pstring,&cnum)==0)goto runblock;
  374. enumb:
  375.                                 flag^=cstok.flag;
  376.                                 whitespace();//¯à®¯ã᪠­¥§­ ç é¨å ᨬ¢®«®¢
  377.                                 ocnum=cnum;
  378.                                 numrm+=cnum;
  379.                                 if(cstok.type==tp_opperand||cstok.type==tp_stopper)nextscan=FALSE;
  380.                                 else{
  381.                                         operand=tk_plus;
  382.                                         goto loopsw;
  383.                                 }
  384.                                 break;
  385.                         case tk_reg32:
  386. //      printf("prevtok=%d operand=%d ocnum=%d idx=%d base=%d zoom=%d\n",prevtok,operand,ocnum,idx,base,zoom);
  387.                                 if(razr==0)razr=r32;
  388.                                 if(razr==r16||(operand!=tk_plus&&operand!=tk_mult)||(idx!=-1&&base!=-1))goto runblock;
  389.                                 if(sizevar!=1){
  390.                                         if(idx!=-1)goto runblock;
  391.                                         idx=cstok.number;
  392.                                 }
  393.                                 else if(operand==tk_mult){
  394.                                         if(prevtok!=tk_number)goto runblock;
  395.                                         zoom=CheckZoom(ocnum);
  396.                                         numrm-=ocnum;
  397.                                         if(idx!=-1)base=idx;
  398.                                         idx=cstok.number;
  399.                                 }
  400.                                 else if(cha=='*'){
  401.                                         if(idx!=-1)base=idx;
  402.                                         idx=cstok.number;
  403.                                 }
  404.                                 else if(base==-1)base=cstok.number;
  405.                                 else if(idx==-1)idx=cstok.number;
  406. //                                      else goto runblock;
  407.                                 prevtok=tk_reg32;
  408.                                 break;
  409.                         case tk_postnumber:
  410.                                 if(dsword==0||sizevar!=1)goto runblock;
  411.                                 if((cstok.post&USED_DIN_VAR)==USED_DIN_VAR){    //¤¨­ ¬¨ç¥áª ï ¯¥à¥¬¥­­ ï
  412.                                         if(dstok.rec!=NULL)goto runblock;
  413.                                         dstok.rec=cstok.rec;
  414.                                 }
  415.                                 if(operand==tk_minus)numrm-=cstok.number;
  416.                                 else numrm+=cstok.number;
  417.                                 dstok.post|=cstok.post;
  418.                                 prevtok=tk_number;
  419.                                 break;
  420.                         case tk_undefofs:
  421.                                 if(dsword==0||sizevar!=1)goto runblock;
  422.                                 if(operand==tk_minus)numrm-=cstok.number;
  423.                                 else numrm+=cstok.number;
  424.                                 dstok.post|=UNDEF_OFSET;
  425.                                 strcpy(dstok.name,cstok.name);
  426.                                 flag^=cstok.flag;
  427.                                 prevtok=tk_number;
  428.                                 break;
  429.                         case tk_rmnumber:
  430. /*                              if(strinf.bufstr!=NULL){
  431.                                         free(strinf.bufstr);
  432.                                         strinf.bufstr=NULL;
  433.                                         goto runblock;
  434.                                 }*/
  435.                                 if(dsword==0||sizevar!=1)goto runblock;
  436.                                 if(operand==tk_minus)numrm-=cstok.number;
  437.                                 else numrm+=cstok.number;
  438.                                 dstok.post|=cstok.post;
  439.                                 if(dstok.sib==CODE16){
  440.                                         if(cstok.rm!=rm_d16){
  441.                                                 switch(cstok.rm&7){
  442.                                                         case 0:
  443.                                                                 if(base!=-1||idx!=-1)goto runblock;
  444.                                                                 base=BX; idx=SI; break;
  445.                                                         case 1:
  446.                                                                 if(base!=-1||idx!=-1)goto runblock;
  447.                                                                 base=BX; idx=DI; break;
  448.                                                         case 2:
  449.                                                                 if(base!=-1||idx!=-1)goto runblock;
  450.                                                                 base=BP; idx=SI; break;
  451.                                                         case 3:
  452.                                                                 if(base!=-1||idx!=-1)goto runblock;
  453.                                                                 base=BP; idx=DI; break;
  454.                                                         case 4:
  455.                                                                 if(idx!=-1)goto runblock;
  456.                                                                 idx=SI; break;
  457.                                                         case 5:
  458.                                                                 if(idx!=-1)goto runblock;
  459.                                                                 idx=DI; break;
  460.                                                         case 6:
  461.                                                                 if(idx!=-1)goto runblock;
  462.                                                                 base=BP; break;
  463.                                                         case 7:
  464.                                                                 if(idx!=-1)goto runblock;
  465.                                                                 base=BX; break;
  466.                                                 }
  467.                                         }
  468.                                         razr=r16;
  469.                                 }
  470.                                 else{
  471.                                         if(cstok.rm!=rm_d32){
  472.                                                 rm=cstok.rm&0xC0;
  473.                                                 cstok.rm&=7;
  474.                                                 if(base==-1)base=cstok.rm;
  475.                                                 else if(idx==-1){
  476.                                                         idx=base;
  477.                                                         base=cstok.rm;
  478.                                                 }
  479.                                                 else goto runblock;
  480.                                                 if(base==4){
  481.                                                         base=cstok.sib&7;
  482.                                                         idx=(cstok.sib>>3)&7;
  483.                                                         if(base==5&&rm==0)base=-1;
  484.                                                         if(idx==4)idx=-1;
  485.                                                 }
  486.                                         }
  487.                                         else dstok.flag|=cstok.flag&f_reloc;
  488.                                         razr=r32;
  489.                                 }
  490.                                 break;
  491. //-----------------28.07.98 13:59-------------------
  492. // var[i]
  493. //--------------------------------------------------
  494.                         default:
  495. runblock:
  496.                                 if(dsword2){
  497.                                         CharToBackBuf('&');
  498.                                         if(strinf.bufstr){
  499.                                                 free(strinf.bufstr);
  500.                                                 strinf.bufstr=NULL;
  501.                                         }
  502.                                 }
  503.                                 AddBackBuf(sopenb,bcha);
  504.                                 if(bufrm){
  505.                                         if(strcmp(bufrm,"&this;")==0){
  506.                                                 free(bufrm);
  507.                                                 CharToBackBuf(0);
  508.                                                 sprintf((char *)string3,"&%s*%d+this;",BackTextBlock,GetVarSize(ttok));
  509.                                                 bufrm=BackString((char *)string3);
  510. //                                                      puts((char *)string3);
  511.                                                 goto con1;
  512.                                         }
  513.                                         else free(bufrm);
  514.                                 }
  515.                                 CharToBackBuf(';');
  516.                                 CharToBackBuf(0);
  517.                                 bufrm=(char *)REALLOC(BackTextBlock,SizeBackBuf+1);
  518. con1:
  519.                                 if(cha!=']')blockerror();
  520.                                 tokscan(&ctok,&cstok,pstring);
  521.                                 if(itok4->sib>=CODE16)itok4->sib++;
  522.                                 SRBackBuf(1);
  523. //                              if(itok4->post&POINTER)itok4->post=0;//&=NOTPOINTER;
  524.                                 free(pstring);
  525.                                 itok4->flag|=flag;
  526.                                 return;
  527. //-----------------28.07.98 13:59-------------------
  528. // end
  529. //--------------------------------------------------
  530.                 }
  531.                 if(dsword==1)dsword=0;
  532.                 if(nextscan){
  533.                         tokscan(&ctok,&cstok,pstring);
  534.                         whitespace();//¯à®¯ã᪠­¥§­ ç é¨å ᨬ¢®«®¢
  535.                 }
  536.                 while(ctok==tk_minus){
  537.                         if(calcnum(&ctok,&cstok,(char *)pstring,&cnum)==0)goto runblock;
  538.                         whitespace();//¯à®¯ã᪠­¥§­ ç é¨å ᨬ¢®«®¢
  539.                         numrm+=cnum;
  540.                         flag^=cstok.flag;
  541.                         if(cstok.type!=tp_opperand&&cstok.type!=tp_stopper){
  542.                                 operand=tk_plus;
  543.                                 goto loopsw;
  544.                         }
  545.                 }
  546.                 operand=ctok;
  547. //              printf("operand tok=%d flag=%08X %s\n",ctok,cstok.flag,cstok.name);
  548.                 if(ctok==tk_closeblock||ctok==tokens||ctok==tk_eof)break;
  549.                 if(ctok!=tk_plus&&ctok!=tk_mult)goto runblock;
  550. //              flag|=cstok.flag;
  551.         }
  552. //      printf("out idx=%d base=%d zoom=%d\n",idx,base,zoom);
  553.         SRBackBuf(1);
  554.         if(ctok!=tk_closeblock)expected(']');
  555.         numrm*=sizevar;
  556.         dstok.number+=numrm;
  557.         if(razr==r16){
  558.                 if(idx==-1&&base==-1)cstok.rm=6;
  559.                 else{
  560.                         cstok.rm=CalcRm16(base,idx)|rm_mod10;
  561.                         dstok.sib=CODE16;
  562.                 }
  563.         }
  564.         else if(razr==0){
  565.                 if(dstok.number<65536&&dstok.number>-65535)cstok.rm=6;
  566.                 else{
  567.                         cstok.rm=5;
  568.                         dstok.sib=0;
  569.                 }
  570.                 if(am32)cstok.rm=5;
  571.         }
  572.         else{
  573. //              printf("razr=%d sib=%08X %s\n",razr,dstok.sib,dstok.name);
  574.                 if(dstok.sib>CODE32)dstok.sib-=CODE32;
  575.                 else dstok.sib=0;
  576.                 if(idx!=-1){
  577.                         cstok.rm=4;
  578.                         if(idx==4)preerror("ESP cannot be the index register");
  579.                         if(base!=-1)dstok.sib=(zoom<<6)+(idx<<3)+base;
  580.                         else{
  581.                                 dstok.sib=(zoom<<6)+(idx<<3)+5;
  582.                                 rm=(base==5?rm_mod10:0);
  583.                         }
  584.                 }
  585.                 else{
  586.                         if(base==4){
  587.                                 dstok.sib=(4<<3)+4;
  588.                                 cstok.rm=4;
  589.                         }
  590.                         else if(base==-1){
  591.                                 cstok.rm=rm_d32;
  592.                         }
  593.                         else cstok.rm=base;
  594.                 }
  595.                 if(base!=-1||rm!=0)cstok.rm|=rm_mod10;  //ª®à¥ªæ¨ï MOD ¡ã¤¥â ¯®§¤­¥¥,   ᥩç á ¬ ªá¨¬ã¬
  596.         }
  597.         dstok.rm=cstok.rm;
  598.         dstok.flag|=flag;
  599.         memcpy(itok4,&dstok,sizeof(ITOK));
  600.         free(pstring);
  601. }
  602.  
  603. int calcnum(int *ctok,ITOK *cstok,char *cstring,long *retval)
  604. {
  605. long value;
  606. unsigned int flag;
  607.         if(*ctok==tk_minus){
  608.                 tokscan(ctok,cstok,(unsigned char *)cstring);
  609.                 if(*ctok!=tk_number)return(0);
  610.                 cstok->number=-cstok->number;
  611.         }
  612.         else if(*ctok!=tk_number)return(0);
  613.         value=cstok->number;
  614.         flag=cstok->flag;
  615.         for(;;){
  616. int otok;
  617.                 tokscan(ctok,cstok,(unsigned char *)cstring);
  618.                 otok=*ctok;
  619.                 if(otok==tk_closeblock)break;
  620.                 tokscan(ctok,cstok,(unsigned char *)cstring);
  621.                 if(*ctok!=tk_number){
  622.                         if(*ctok==tk_reg32&&(otok==tk_mult||otok==tk_minus)){
  623.                                 *ctok=(unsigned int)cstok->number;
  624.                                 *retval=value;
  625.                                 cstok->flag=flag;
  626.                                 return 0;
  627.                         }
  628.                         break;
  629.                 }
  630.                 if(calclongnumber(&value,cstok->number,otok)==FALSE){
  631.                         if(displaytokerrors)blockerror();
  632.                         break;
  633.                 }
  634. /*              switch(otok){
  635.                         case tk_minus: value-=cstok->number; break;
  636.                         case tk_plus: value+=cstok->number; break;
  637.                         case tk_xor: value^=cstok->number; break;
  638.                         case tk_and: value&=cstok->number; break;
  639.                         case tk_or: value|=cstok->number; break;
  640.                         case tk_mod: value%=cstok->number; break;
  641.                         case tk_div: value/=cstok->number; break;
  642.                         case tk_mult: value*=cstok->number; break;
  643.                         case tk_rr: value>>=cstok->number; break;
  644.                         case tk_ll: value<<=cstok->number; break;
  645.                         case tk_xorminus: value^=-cstok->number; break;
  646.                         case tk_andminus: value&=-cstok->number; break;
  647.                         case tk_orminus: value|=-cstok->number; break;
  648.                         case tk_modminus: value%=-cstok->number; break;
  649.                         case tk_divminus: value/=-cstok->number; break;
  650.                         case tk_multminus: value*=-cstok->number; break;
  651.                         case tk_rrminus: value>>=-cstok->number; break;
  652.                         case tk_llminus: value<<=-cstok->number; break;
  653.                         default: if(displaytokerrors)blockerror(); goto end;
  654.                 }*/
  655.                 flag^=cstok->flag;
  656.         }
  657. //end:
  658.         cstok->flag=flag;
  659.         *retval=value;
  660.         return -1;
  661. }
  662.  
  663. void CheckReg(int idx,int base,int *reg1,int *reg2,int razr)
  664. {
  665.         if(razr==r32){
  666.                 unsigned char lreg[8];
  667.                 int i;
  668.                 for(i=0;i<8;i++){
  669.                         if(i==ESP||i==EBP)lreg[i]=1;
  670.                         else{
  671.                                 if((idx!=-1&&idx==i)||(base!=-1&&base==i))lreg[i]=1;
  672.                                 else lreg[i]=0;
  673.                         }
  674. //                      printf("%c",lreg[i]+'0');
  675.                 }
  676.                 if(lreg[*reg1]==0)lreg[*reg1]=1;
  677.                 else{
  678.                         for(i=8;i!=0;i--){
  679.                                 if(lreg[i]==0){
  680.                                         lreg[i]=1;
  681.                                         *reg1=i;
  682.                                         break;
  683.                                 }
  684.                         }
  685.                 }
  686. //              printf("\nreg1=%d",*reg1);
  687.                 if(lreg[*reg2]!=0){
  688.                         for(i=8;i!=0;i--){
  689.                                 if(lreg[i]==0){
  690.                                         *reg2=i;
  691.                                         break;
  692.                                 }
  693.                         }
  694.                 }
  695. //              printf(" reg2=%d\n",*reg2);
  696.         }
  697.         else{
  698.                 if(base!=-1){
  699.                         if(base==*reg1)*reg1=SI;
  700.                         else if(base==*reg2)*reg2=DI;
  701.                         if(*reg1==*reg2){
  702.                                 if(*reg1==SI)*reg2=DI;
  703.                                 else *reg2=SI;
  704.                         }
  705.                 }
  706.                 if(idx!=-1){
  707.                         if(idx==SI)*reg1=DI;
  708.                         else *reg1=SI;
  709.                         *reg2=CX;
  710.                 }
  711.         }
  712. }
  713.  
  714. void CheckAllMassiv(char *&buf,int sizeel,SINFO *strc,ITOK *ctok,int reg1,int reg2)
  715. {
  716. int zoom0,idx0,base0,newreg;
  717. int zoom1=0,zoom2=0;
  718. char pv=FALSE;
  719. int razr=r32;
  720. //printf("sib=%X\n",ctok->sib);
  721.         switch(ctok->sib){
  722.                 case CODE16+2:
  723.                 case CODE32+2: ctok->sib--;
  724.                 case CODE16+1:
  725.                 case CODE32+1: ctok->sib--;
  726.         }
  727.         if(ctok->sib==CODE16){
  728.                 razr=r16;
  729.                 if(am32)block16_32error();
  730.         }
  731.         if(buf==NULL&&strc->bufstr==NULL)return;
  732.         ExpandRm(ctok->rm,ctok->sib,&zoom0,&base0,&idx0);
  733.         if(base0==-1&&idx0!=-1&&zoom0==0){
  734.                 base0=idx0;
  735.                 idx0=-1;
  736.         }
  737.         CheckReg(idx0,base0,&reg1,&reg2,razr);
  738. //      printf("reg1=%d reg2=%d idx0=%d base0=%d zoom0=%d\n",reg1,reg2,idx0,base0,zoom0);
  739.         if(buf!=NULL){
  740.                 if(*buf=='&'){
  741.                         sizeel=1;
  742.                         pv=TRUE;
  743.                         ctok->flag&=~f_reloc;
  744.                 }
  745.                 if((newreg=CheckIDXReg(buf,sizeel,reg1))!=NOINREG){
  746.                         if(newreg!=SKIPREG){
  747.                                 if(razr==r16){
  748.                                         if(newreg!=BX&&newreg!=DI&&newreg!=SI&&newreg!=BP)goto noopt;
  749.                                         if(base0!=-1&&(newreg==BX||newreg==BP))goto noopt;
  750.                                         if(idx0!=-1&&(newreg==DI||newreg==SI))goto noopt;
  751.                                 }
  752.                                 waralreadinitreg(regs[am32][reg1],regs[am32][newreg]);
  753.                                 reg1=newreg;
  754.                         }
  755.                         free(buf);
  756.                         buf=NULL;
  757.                 }
  758.                 else{
  759.                         if(razr==r32){
  760.                                 if((zoom1=CheckZoom(sizeel))){
  761.                                         sizeel=1;
  762.                                         if((newreg=CheckIDXReg(buf,sizeel,reg1))!=NOINREG){
  763.                                                 if(newreg!=SKIPREG){
  764.                                                         waralreadinitreg(regs[1][reg1],regs[1][newreg]);
  765.                                                         reg2=reg1;
  766.                                                         reg1=newreg;
  767.                                                 }
  768.                                                 free(buf);
  769.                                                 buf=NULL;
  770.                                                 goto cont1;
  771.                                         }
  772.                                 }
  773.                         }
  774. noopt:
  775.                         if(razr==r32&&idx0==-1&&base0==-1&&zoom1==0){
  776. ITOK wtok;
  777.                                 wtok=*ctok;
  778.                                 newreg=CheckMassiv(buf,sizeel,reg1,&idx0,&base0,&wtok.number);
  779.                                 *ctok=wtok;
  780. //                              newreg=CheckMassiv(buf,sizeel,reg1);
  781.                         }
  782.                         else newreg=CheckMassiv(buf,sizeel,reg1);
  783.                         if(newreg!=-1){
  784.                                 reg2=reg1;
  785.                                 reg1=newreg;
  786.                         }
  787.                 }
  788.         }
  789.         else{
  790.                 reg2=reg1;
  791.                 reg1=-1;
  792.         }
  793. cont1:
  794. //      printf("reg1=%d reg2=%d idx0=%d base0=%d zoom0=%d\n",reg1,reg2,idx0,base0,zoom0);
  795.         if(strc->bufstr!=NULL){
  796.                 sizeel=strc->size;
  797.                 if((newreg=CheckIDXReg(strc->bufstr,sizeel,reg2))!=NOINREG){
  798.                         if(newreg!=SKIPREG){
  799.                                 if(razr==r16){
  800.                                         if(newreg!=BX&&newreg!=DI&&newreg!=SI&&newreg!=BP)goto noopt2;
  801.                                         if(base0!=-1&&(newreg==BX||newreg==BP))goto noopt2;
  802.                                         if(idx0!=-1&&(newreg==DI||newreg==SI))goto noopt2;
  803.                                 }
  804.                                 waralreadinitreg(regs[am32][reg2],regs[am32][newreg]);
  805.                                 reg2=newreg;
  806.                         }
  807.                         free(strc->bufstr);
  808.                         strc->bufstr=NULL;
  809.                 }
  810.                 else{
  811.                         if(razr==r32&&zoom1==0){
  812.                                 if((zoom2=CheckZoom(sizeel))){
  813.                                         sizeel=1;
  814.                                         if((newreg=CheckIDXReg(strc->bufstr,sizeel,reg2))!=NOINREG){
  815.                                                 if(newreg!=SKIPREG){
  816.                                                         waralreadinitreg(regs[2][reg1],regs[2][newreg]);
  817.                                                         reg2=newreg;
  818.                                                 }
  819.                                                 free(strc->bufstr);
  820.                                                 strc->bufstr=NULL;
  821.                                                 goto cont2;
  822.                                         }
  823.                                 }
  824.                         }
  825. noopt2:
  826.                         if((newreg=CheckMassiv(strc->bufstr,sizeel,reg2))!=-1)reg2=newreg;
  827.                 }
  828. cont2:
  829.                 if(reg1==-1){
  830.                         reg1=reg2;
  831.                         zoom1=zoom2;
  832.                         reg2=-1;
  833.                         zoom2=0;
  834.                 }
  835.         }
  836.         else reg2=-1;
  837. //      printf("reg1=%d reg2=%d idx0=%d base0=%d zoom0=%d\n",reg1,reg2,idx0,base0,zoom0);
  838.         if(base0==-1){
  839.                 if(reg1!=-1&&zoom1==0){
  840.                         base0=reg1;
  841.                         reg1=reg2;
  842.                         zoom1=zoom2;
  843.                         reg2=-1;
  844.                         zoom2=0;
  845.                 }
  846.                 else if(reg2!=-1&&zoom2==0){
  847.                         base0=reg2;
  848.                         reg2=-1;
  849.                 }
  850.         }
  851.         if(idx0==-1){
  852.                 if(zoom1){
  853.                         zoom0=zoom1;
  854.                         zoom1=0;//zoom2;
  855.                         idx0=reg1;
  856.                         reg1=reg2;
  857.                         reg2=-1;
  858.                 }
  859.                 else{
  860.                         if(reg1!=-1){
  861.                                 idx0=reg1;
  862.                                 reg1=reg2;
  863.                                 zoom1=zoom2;
  864.                                 reg2=-1;
  865.                                 zoom2=0;
  866.                         }
  867.                 }
  868.         }
  869. //      printf("reg1=%d reg2=%d idx0=%d base0=%d zoom0=%d\n",reg1,reg2,idx0,base0,zoom0);
  870.         if(reg2!=-1){
  871.                 if(zoom1==0&&zoom2==0){
  872.                         op(3);
  873.                         op(0xC0+reg1*8+reg2);   //add reg1,reg2
  874.                 }
  875.                 else{
  876.                         if(zoom1==0){
  877.                                 op(0x8d);       //lea reg1,[reg1+reg2*zoom2]
  878.                                 op(reg1*8+4);
  879.                                 op((zoom2<<6)+(reg2<<3)+reg1);
  880.                         }
  881.                         else{
  882.                                 op(0x8d);       //lea reg1,[reg2+reg1*zoom1]
  883.                                 op(reg1*8+4);
  884.                                 op((zoom1<<6)+(reg1<<3)+reg2);
  885.                                 zoom1=0;
  886.                         }
  887.                 }
  888.                 ClearReg(reg1);
  889.         }
  890.         if(reg1!=-1){
  891.                 if(base0!=-1){
  892.                         if(zoom1==0){
  893.                                 op(3);
  894.                                 op(0xC0+reg1*8+base0);  //add reg1,base0
  895.                         }
  896.                         else{
  897.                                 op(0x8d);       //lea reg1,[base0+reg1*zoom1]
  898.                                 op(reg1*8+4);
  899.                                 op((zoom1<<6)+(reg1<<3)+base0);
  900.                         }
  901.                 }
  902.                 else if(zoom1){
  903.                         op(0xC1);
  904.                         op(0xE0+reg1);  //shl reg2,zoom2
  905.                         op(zoom1);
  906.                 }
  907.                 base0=reg1;
  908.         }
  909.         if(razr==r32){
  910.                 ctok->sib=CODE32;
  911.                 if(idx0!=-1){
  912.                         ctok->rm=4;
  913.                         if(base0!=-1){
  914.                                 ctok->sib=(zoom0<<6)+(idx0<<3)+base0;
  915.                                 ctok->rm|=rm_mod10;
  916.                         }
  917.                         else ctok->sib=(zoom0<<6)+(idx0<<3)+5;
  918.                 }
  919.                 else{
  920.                         ctok->rm=base0;
  921.                         if(pv==FALSE)ctok->rm|=rm_mod10;
  922.                 }
  923.         }
  924.         else{
  925.                 if(base0==SI||base0==DI){
  926.                         if(idx0==BX||idx0==BP||idx0==-1){
  927.                                 newreg=idx0;
  928.                                 idx0=base0;
  929.                                 base0=newreg;
  930.                         }
  931.                         else{
  932.                                 op(3);
  933.                                 op(0xC0+base0*8+idx0);  //add base0,idx0
  934.                                 idx0=base0;
  935.                                 base0=-1;
  936.                         }
  937.                 }
  938.                 if(idx0==BX||idx0==BP){
  939.                         if(base0==-1){
  940.                                 newreg=idx0;
  941.                                 idx0=base0;
  942.                                 base0=newreg;
  943.                         }
  944.                         else{
  945.                                 op(3);
  946.                                 op(0xC0+base0*8+idx0);  //add base0,idx0
  947.                                 idx0=base0;
  948.                                 base0=-1;
  949.                         }
  950.                 }
  951.                 ctok->rm=CalcRm16(base0,idx0)|rm_mod10;
  952.         }
  953.         if(ctok->post==0&&(ctok->flag&f_reloc)==0)compressoffset(ctok);
  954. }
  955.  
  956. int CheckMassiv(char *&buf,int sizeel,int treg,int *idx,int *base,long *num)
  957. {
  958. ITOK oitok;
  959. SINFO ostr;
  960. unsigned char *oldinput;
  961. unsigned int oldinptr,oldendinptr;
  962. unsigned char bcha;
  963. int otok;
  964. char *ostring;
  965. char *ofsst;
  966. int retcode=-1;
  967.  
  968. //07.09.04 22:45
  969. COM_MOD *ocurmod=cur_mod;
  970.         cur_mod=NULL;
  971. /////////////////
  972.         ostring=BackString((char *)string);
  973.         ofsst=BackString(buf);
  974.         free(buf);
  975.         buf=NULL;
  976.         oldinput=input; //á®åà ­¥ª®â®à ¯¥à¥¬¥­ë¥
  977.         oldinptr=inptr2;
  978.         bcha=cha2;
  979.         oldendinptr=endinptr;
  980.         otok=tok;
  981.         oitok=itok;
  982.         ostr=strinf;
  983.         strinf.bufstr=NULL;
  984.  
  985.         if(idx&&*idx==-1&&*base==-1){
  986.                 char *tbuf;
  987.                 int i;
  988.                 int idx0,base0;
  989.                 long numr;
  990.                 int operand;
  991.                 int startptr,skipvar;
  992.                 int firsttok;
  993.                 i=0;
  994.                 idx0=base0=-1;
  995.                 numr=0;
  996.                 if(*ofsst=='&')i++;
  997.                 tbuf=BackString(ofsst+i);
  998. //              puts(tbuf);
  999.                 input=(unsigned char *)tbuf;
  1000.                 inptr2=1;
  1001.                 cha2=input[0];
  1002.                 endinptr=strlen((char *)input);
  1003.                 operand=tk_plus;
  1004.                 startptr=0;
  1005.                 firsttok=tk_eof;
  1006.                 do{
  1007.                         skipvar=FALSE;
  1008.                         getoperand();
  1009.                         if(operand==tk_plus){
  1010.                                 if(tok==tk_reg32){
  1011.                                         if(itok.number!=treg){
  1012.                                                 skipvar=TRUE;
  1013.                                                 if(idx0==-1)idx0=itok.number;
  1014.                                                 else if(base0==-1)base0=itok.number;
  1015.                                                 else skipvar=FALSE;
  1016.                                         }
  1017.                                         else if(firsttok==tk_eof)firsttok=tk_reg32;
  1018.                                 }
  1019.                                 else if(tok==tk_number){
  1020.                                         numr+=itok.number;
  1021.                                         skipvar=TRUE;
  1022.                                 }
  1023.                                 else if(firsttok==tk_eof)firsttok=tok;
  1024.                         }
  1025.                         if(operand==tk_minus&&tok==tk_number){
  1026.                                 numr-=itok.number;
  1027.                                 skipvar=TRUE;
  1028.                         }
  1029.                         if(skipvar){
  1030.                                 for(;startptr<inptr2-1;startptr++)input[startptr]=' ';
  1031.                         }
  1032.                         startptr=inptr2-1;
  1033.                         nexttok();
  1034.                         if(tok==tk_plus||tok==tk_minus){
  1035.                                 if(firsttok==tk_eof){
  1036.                                         if(tok==tk_minus)break;
  1037.                                         for(;startptr<inptr2-1;startptr++)input[startptr]=' ';
  1038.                                         startptr=inptr2-1;
  1039.                                         firsttok=tok;
  1040.                                 }
  1041.                                 operand=tok;
  1042.                         }
  1043.                         else break;
  1044.                 }while(1);
  1045. //              printf("%s (%u) >%s\n",(startfileinfo+currentfileinfo)->filename,linenumber,tbuf);
  1046.                 if(tok==tk_semicolon/*&&(idx0!=-1||base0!=-1)*/){
  1047.                         *idx=idx0;
  1048.                         *base=base0;
  1049.                         *num+=numr;
  1050.                         free(ofsst);
  1051.                         ofsst=tbuf;
  1052. //                      printf("idx0=%d base0=%d num=%d\n",idx0,base0,numr);
  1053.                 }
  1054.                 else free(tbuf);
  1055.         }
  1056.  
  1057.         input=(unsigned char *)ofsst;
  1058.         inptr2=1;
  1059.         cha2=input[0];
  1060.         if(cha2=='&'){
  1061.                 inptr2=2;
  1062.                 cha2=input[1];
  1063.         }
  1064.         endinptr=strlen((char *)input);
  1065.         getoperand();
  1066.         if(am32&&sizeel==1&&tok==tk_reg32&&itok2.type==tp_stopper)retcode=itok.number;
  1067.         else{
  1068.                 warningreg(regs[am32][treg]);
  1069.                 if((chip==7||chip==8)&&am32==FALSE&&((sizeel>1&&sizeel<6)||sizeel==8||sizeel==9)){
  1070.                 //¨§¡¥¦ âì ®¡à é¥­¨¥ ª ç áâ­®¬ã ॣ¨áâàã
  1071.                         op(0x31);
  1072.                         op(0xC0+treg*9);
  1073.                 }
  1074.                 ofsst=NULL;
  1075.                 if(treg==AX)do_e_axmath(0,(am32+1)*2,&ofsst);
  1076.                 else getintoreg(treg,(am32+1)*2,0,&ofsst);
  1077.                 IDXToReg((char *)input,sizeel,treg);
  1078.         }
  1079.         strinf=ostr;
  1080.         tok=otok;
  1081.         itok=oitok;
  1082.         endoffile=0;
  1083.         free(input);
  1084.         input=oldinput;
  1085.         inptr2=oldinptr;
  1086.         cur_mod=ocurmod;        //07.09.04 22:45
  1087.         cha2=bcha;
  1088.         endinptr=oldendinptr;
  1089.         otok=0;
  1090.         strcpy((char *)string,ostring);
  1091.         free(ostring);
  1092.         if(sizeel>1)RegMulNum(treg,sizeel,(am32+1)*2,0,&otok,0);
  1093.         return retcode;
  1094. }
  1095.  
  1096. void nextchar()
  1097. {
  1098.         if(inptr<endinptr){
  1099.                 cha=input[inptr];
  1100.                 endoffile=0;
  1101.                 if(savestring3)string3[posstr3++]=cha;
  1102.                 inptr++;
  1103.                 precha=0;
  1104.                 if(inptr==endinptr&&cur_mod&&displaytokerrors){
  1105.                         precha=cur_mod->input[cur_mod->inptr];
  1106. //                      printf("cha=%02X\n",cha);
  1107.                 }
  1108.         }
  1109.         else{
  1110.                 if(cur_mod){
  1111.                         if(displaytokerrors){
  1112.                                 inptr=cur_mod->inptr;
  1113.                                 input=cur_mod->input;
  1114. //                              printf("last cha=%02X\n",input[inptr]);
  1115.  
  1116.                                 if(cur_mod->numparamdef)clearregstat();
  1117.  
  1118.                                 endinptr=cur_mod->endinptr;
  1119.                                 linenumber=cur_mod->linenumber;
  1120.                                 currentfileinfo=cur_mod->currentfileinfo;
  1121.                                 COM_MOD *temp=cur_mod;
  1122.                                 cur_mod=cur_mod->next;
  1123.                                 if(temp->freze==FALSE){
  1124.                                         if(temp->paramdef)free(temp->paramdef);
  1125. //                                      if(debug)printf("Free curmod %08X new cur_mod %08X\n",temp,cur_mod);
  1126.                                         free(temp);
  1127.                                 }
  1128. //                              else if(debug)printf("Freze curmod %08X\n",temp);
  1129.                                 nextchar();
  1130. //                              printf("%c\n",cha);
  1131.                                 if(!cur_mod)notdef=TRUE;
  1132.                         }
  1133.                         else{
  1134.                                 cha=cur_mod->input[cur_mod->inptr2];
  1135.                                 cur_mod->inptr2++;
  1136.                         }
  1137.                 }
  1138.                 else{
  1139.                         cha=26;
  1140.                         endoffile++;
  1141.                         if(endoffile>2)unexpectedeof();
  1142.                 }
  1143.         }
  1144. }
  1145.  
  1146. void ScanTok2()
  1147. {
  1148.         inptr2=inptr;
  1149.         linenum2=linenumber;
  1150.         cha2=cha;
  1151.         displaytokerrors=0;
  1152.         tokscan(&tok2,&itok2,string2);
  1153. }
  1154.  
  1155. unsigned int ScanTok3()
  1156. {
  1157. unsigned int oinptr,oline,otok,rtok;
  1158. unsigned char ocha;
  1159. ITOK oitok;
  1160.         ocha=cha;
  1161.         oinptr=inptr;
  1162.         oline=linenumber;
  1163.         otok=tok;
  1164.         oitok=itok;
  1165.         do{
  1166.                 FastTok(1);
  1167.                 if(tok==tk_id||tok==tk_ID){
  1168.                         char disp=displaytokerrors;
  1169.                         displaytokerrors=0;
  1170.                         strcpy((char *)string3,itok.name);
  1171.                         searchtree(&itok,&tok,string3); //NEW 09.06.06 20:29
  1172. //                      searchtree2(definestart,&itok,&tok,string3);
  1173.                         displaytokerrors=disp;
  1174.                 }
  1175.         }while(tok==tk_endline);
  1176.         rtok=tok;
  1177.         tok=otok;
  1178.         cha=ocha;
  1179.         itok=oitok;
  1180.         inptr=oinptr;
  1181.         linenumber=oline;
  1182.         return rtok;
  1183. }
  1184.  
  1185. //extern idrec *crec;
  1186.  
  1187. void nexttok()
  1188. {
  1189. #ifdef DEBUGMODE
  1190. if(debug)puts("start nexttok");
  1191. #endif
  1192.         inptr=inptr2;
  1193.         linenumber=linenum2;
  1194.         cha=cha2;
  1195.         displaytokerrors=1;
  1196.         tokscan(&tok,&itok,string); //à §¡®à ª®¬ ­¤ë
  1197. //      printf("input=%08X inptr=%08X tok=%d %s\n",input,inptr,tok,itok.name);
  1198.         if(tok==tk_dblcolon&&numblocks){
  1199.                 skiplocals=TRUE;
  1200.                 tokscan(&tok,&itok,string); //à §¡®à ª®¬ ­¤ë
  1201.         }
  1202.         ScanTok2();
  1203.         if(tok2==tk_dblcolon&&numblocks){
  1204.                 skiplocals=TRUE;
  1205.                 tokscan(&tok2,&itok2,string2);
  1206.         }
  1207.         if(tok2==tk_tilda){
  1208.                 if(ScanTok3()==tk_number){
  1209.                         tok2=tk_number;
  1210. //                      puts("tok2=tk_tilda tok3=tk_number");
  1211.                 }
  1212.         }
  1213.         linenumber=linenum2;
  1214.         // new !!! 02.04.02 20:22
  1215.         if(tok==tk_int&&idasm==TRUE&&tok2==tk_number){
  1216.                 tok=tk_idasm;
  1217.                 itok.rm=a_int;
  1218.         }
  1219.         // new !!! 02.04.02 20:22
  1220.  
  1221. #ifdef DEBUGMODE
  1222.         if(debug)printdebuginfo();
  1223. #endif
  1224.         if(tok2==tk_number){
  1225.                 if(tok==tk_not){
  1226.                         nexttok();
  1227.                         if(itok.rm!=tk_float&&itok.rm!=tk_double){
  1228.                                 if(scanlexmode==RESLEX){
  1229.                                         if(itok.number)itok.number=0;
  1230.                                         else itok.number=1;
  1231.                                 }
  1232.                                 else itok.lnumber^=-1;
  1233.                         }
  1234.                         else illegalfloat();
  1235.                         return;
  1236.                 }
  1237.                 if(tok==tk_tilda){
  1238. //                      puts("tok=tk_tilda tok2=tk_number");
  1239.                         nexttok();
  1240.                         if(itok.rm!=tk_float&&itok.rm!=tk_double)itok.lnumber=~itok.lnumber;
  1241.                         else illegalfloat();
  1242.                         return;
  1243.                 }
  1244.         }
  1245.         if(idasm==TRUE&&tok==tk_loop&&tok2!=tk_openbracket){
  1246.                 tok=tk_idasm;
  1247.                 itok.rm=a_loop;
  1248.                 return;
  1249.         }
  1250.         if(tok==tk_dollar){
  1251.                 if(itok2.type==tp_opperand||itok2.type==tp_stopper||tok2==tk_dollar){
  1252.                         tok=tk_number;
  1253.                         itok.number=outptr;
  1254.                         if(FixUp)itok.flag|=f_reloc;    //new!!!
  1255.                         return;
  1256.                 }
  1257.  
  1258.                 int qq; //09.07.08 13:27 new
  1259.                 if((qq=CheckAsmName(itok2.name))!=-1){
  1260.                         tok=tk_idasm;
  1261.                         itok.rm=qq;
  1262.                         strcpy(itok.name,itok2.name);
  1263.                         ScanTok2();
  1264.                 }
  1265.  
  1266.         }
  1267.         if(tok>=tk_charvar&&tok<=tk_doublevar){
  1268. localrec *ptr;
  1269.                 ptr=itok.locrec;
  1270.                 switch(itok.type){
  1271.                         case tp_paramvar:
  1272. //                      case tp_ppointer:
  1273. //                      case tp_pfpointer:
  1274.                                 if(ptr->fuse==NOTINITVAR&&tok2==tk_assign&&(!asmparam))warningnotused(itok.name,4);
  1275.                                 goto llq;
  1276.                         case tp_localvar:
  1277. //                      case tp_lpointer:
  1278. //                      case tp_lfpointer:
  1279.                                 if(ptr->fuse==NOTINITVAR&&tok2!=tk_assign){
  1280.                                         if(asmparam)ptr->fuse|=INITVAR;
  1281.                                         else warningusenotintvar(itok.name);
  1282.                                 }
  1283. llq:
  1284.                                 ptr->fuse|=(unsigned char)(tok2==tk_assign?INITVAR:USEDVAR);
  1285.                                 break;
  1286.                 }
  1287. #ifdef OPTVARCONST
  1288.                 if(calcnumber&&CheckConstVar(&itok))tok=tk_number;
  1289. #endif
  1290.         }
  1291. #ifdef OPTVARCONST
  1292.         if(tok2>=tk_charvar&&tok2<=tk_doublevar){
  1293.                 if(calcnumber&&CheckConstVar(&itok2))tok2=tk_number;
  1294.         }
  1295. #endif
  1296.         if(usedirectiv==FALSE&&calcnumber==FALSE)while(tok==tk_question)directive();
  1297. //16.08.04 00:23
  1298.         if(tok==tk_at&&tok2==tk_macro){
  1299.                 nexttok();
  1300.         }
  1301. #ifdef OPTVARCONST
  1302.         displaytokerrors=1;
  1303. #endif
  1304.  
  1305. //      if(crec)printf("num=%08X\n",crec->recnumber);
  1306.  
  1307. }
  1308.  
  1309. void whitespace() //¯à®¯ã᪠­§­ ç é¨å ᨬ¢®«®¢
  1310. {
  1311.         while(isspace(cha)||cha==255||cha==0){
  1312.                 if(cha==13){
  1313.                         linenumber++;
  1314.                         if((dbg&2)&&displaytokerrors&&notdef)startline=(char*)(input+inptr+1);
  1315.                         if(scanlexmode==RESLEX||scanlexmode==DEFLEX||scanlexmode==ASMLEX)break;
  1316.                 }
  1317.                 nextchar();
  1318.         }
  1319. }
  1320.  
  1321. unsigned char convert_char()
  1322. //Returns the value of the current character.  Parses \n and \x00 etc.
  1323. //cha equals the last character used.
  1324. {
  1325. int hold=0;
  1326. int i;
  1327. unsigned char c;
  1328.         if(cha!='\\'){
  1329.                 if(cha==13){
  1330.                         linenumber++;
  1331.                         if((dbg&2)&&displaytokerrors&&notdef)startline=(char*)(input+inptr+1);
  1332.                 }
  1333.                 return(cha);
  1334.         }
  1335.         nextchar();  // move past '\\'
  1336.         switch(cha){
  1337.                 case 'a': return('\a');         // what is \a anyway?
  1338.                 case 'b': return('\b');
  1339.                 case 'f': return('\f');
  1340.                 case 'l': return(10);
  1341.                 case 'n': return(13);
  1342. //              case 'p': return('œ');
  1343.                 case 'r': return(13);
  1344.                 case 't': return('\t');
  1345.                 case 'v': return('\v');
  1346.                 case 'x':
  1347.                         for(i=0;i<2;i++){
  1348.                                 c=cha;
  1349.                                 nextchar();
  1350.                                 hold*=16;
  1351.                                 if(isdigit(cha))hold+=cha-'0';
  1352.                                 else if(isxdigit(cha))hold+=(cha&0x5f)-'7';
  1353.                                 else{
  1354. //                                      expectederror("hexadecimal digit");
  1355.                                         if(savestring3)posstr3--;
  1356.                                         inptr--;
  1357.                                         cha=c;
  1358.                                         break;
  1359.                                 }
  1360.                         }
  1361.                         return (unsigned char)hold;
  1362.                 default:
  1363.                         if(isdigit(cha)){
  1364.                                 hold=cha-'0';
  1365.                                 for(i=0;i<2;i++){
  1366.                                         c=cha;
  1367.                                         nextchar();
  1368.                                         if(isdigit(cha))hold=hold*10+(cha-'0');
  1369.                                         else{
  1370. //                                              expectederror("decimal digit");
  1371.                                                 if(savestring3)posstr3--;
  1372.                                                 inptr--;
  1373.                                                 cha=c;
  1374.                                                 break;
  1375.                                         }
  1376.                                 }
  1377.                                 return (unsigned char)hold;
  1378.                         }
  1379.                         return cha;
  1380.         }
  1381. }
  1382.  
  1383. void convert_string(unsigned char *str)
  1384. {
  1385. int k,j,i;
  1386. unsigned char c;
  1387. unsigned char hold;
  1388.         for(k=0,j=0;;k++,j++){
  1389.                 c=str[k];
  1390.                 if(c=='\\'){
  1391.                         c=str[++k];
  1392.                         switch(c){
  1393.                                 case 'a': hold='\a'; break;     // what is \a anyway?
  1394.                                 case 'b': hold='\b'; break;
  1395.                                 case 'f': hold='\f'; break;
  1396.                                 case 'l': hold=10; break;
  1397.                                 case 'n': str[j++]=13; hold=10; break;
  1398.                                 case 'r': hold=13; break;
  1399.                                 case 't': hold='\t'; break;
  1400.                                 case 'v': hold='\v'; break;
  1401.                                 case 'x':
  1402.                                         hold=0;
  1403.                                         for(i=0;i<2;i++){
  1404.                                                 c=str[++k];
  1405.                                                 hold*=(unsigned char)16;
  1406.                                                 if(isdigit(c))hold+=(unsigned char)(c-'0');
  1407.                                                 else if(isxdigit(c))hold+=(unsigned char)((c&0x5f)-'7');
  1408.                                                 else{
  1409.                                                         k--;
  1410.                                                         break;
  1411.                                                 }
  1412.                                         }
  1413.                                         break;
  1414.                                 default:
  1415.                                         hold=c;
  1416.                                         if(isdigit(c)){
  1417.                                                 hold-='0';
  1418.                                                 for(i=0;i<2;i++){
  1419.                                                         c=str[++k];
  1420.                                                         if(isdigit(c))hold=(unsigned char)(hold*10+(c-'0'));
  1421.                                                         else{
  1422.                                                                 k--;
  1423.                                                                 break;
  1424.                                                         }
  1425.                                                 }
  1426.                                         }
  1427.                         }
  1428.                         str[j]=hold;
  1429.                 }
  1430.                 else str[j]=c;
  1431.                 if(c==0)break;
  1432.         }
  1433. }
  1434.  
  1435. int CheckChar2()
  1436. {
  1437.         if(isalnum(cha)||cha=='_'||cha>=0x80)return TRUE;
  1438.         return FALSE;
  1439. }
  1440.  
  1441. void GetTokString(int *tok4,ITOK *itok4,unsigned char *string4,int useunicode)
  1442. {
  1443. int strptr=0;
  1444.         if(displaytokerrors){
  1445.                 savestring3=TRUE;
  1446.                 posstr3=0;
  1447.         }
  1448. nextstr:
  1449.         nextchar();     //áâப®¢ ï ª®­áâ ­â 
  1450.         while(cha!='\"'&&!endoffile&&strptr<STRLEN-1){
  1451.                 string4[strptr++]=convert_char();
  1452.                 if((char)cha=='n'&&string4[strptr-1]==13){//have to add char 10 for \n value
  1453.                         string4[strptr++]=10;
  1454.                 }
  1455.                 nextchar();
  1456.         }
  1457.         if(displaytokerrors){
  1458.                 savestring3=FALSE;
  1459.                 string3[posstr3-1]=0;
  1460.         }
  1461.         if(strptr>=(STRLEN-1)&&displaytokerrors)preerror("Maximum String Length Exceeded");
  1462.         string4[strptr]=0;
  1463.         *tok4=tk_string;
  1464. //      itok4->number=strptr;
  1465.         itok4->rm=1;    //¥áâì ®à¨£¨­ « áâப¨
  1466.         if(cha!='\"')expected('\"');
  1467.         while(cha!='\"'&&!endoffile)nextchar(); //scan until closing '\"'
  1468.         nextchar();
  1469.         if(dosstring)itok4->flag=dos_term;
  1470.         CheckConvertString((char *)string4);
  1471.         switch(cha){
  1472.                 case 'z':
  1473.                         itok4->flag=zero_term;
  1474.                         nextchar();
  1475.                         break;
  1476.                 case 'n':
  1477.                         itok4->flag=no_term;
  1478.                         nextchar();
  1479.                         break;
  1480.                 case '$':
  1481.                         itok4->flag=dos_term;
  1482.                         nextchar();
  1483.                         break;
  1484.         }
  1485.         CheckConvertString((char *)string4);
  1486.  
  1487. //      10.08.04 22:20
  1488.         whitespace(); //¯à®¯ã᪠­¥§­ ç é¨å ᨬ¢®«®¢
  1489.         if(cha=='\"'){
  1490.                 if(displaytokerrors)savestring3=TRUE;
  1491.                 goto nextstr;
  1492.         }
  1493.  
  1494.         if(useunicode&&displaytokerrors){
  1495.                 char *bak;
  1496.                 bak=BackString((char *)string4);
  1497.                 strptr=MultiByteToWideChar(CP_ACP,MB_PRECOMPOSED,bak,-1,(wchar_t *)string4,STRLEN)-1;
  1498. //              printf("size string=%d\n",strptr);
  1499. //              if(itok4->flag==no_term)strptr--;
  1500.                 strptr*=2;
  1501. //              string4[strptr-2]=string4[strptr-1]=0;
  1502.                 itok4->flag|=s_unicod;
  1503.                 free(bak);
  1504.         }
  1505.         itok4->number=strptr;
  1506. }
  1507.  
  1508. void tokscan(int *tok4,ITOK *itok4,unsigned char *string4)
  1509. // ¯®¨áª ¨¤¥­â¨ä¨ª â®à®¢, ¤¨à¥ªâ¨¢ ...
  1510. {
  1511. int useme;
  1512. unsigned int strptr=0;
  1513. char uppercase=1,next=1;
  1514. //ãáâ ­®¢ª¨ ¯® 㬮«ç ­¨î
  1515. #ifdef DEBUGMODE
  1516. if(debug)printf("start tokscan input=%08X inptr=%08X %c%s\n",input,inptr,cha,input+inptr);
  1517. #endif
  1518.         if(am32==FALSE){
  1519.                 itok4->rm=rm_d16;
  1520.                 itok4->sib=CODE16;
  1521.         }
  1522.         else{
  1523.                 itok4->rm=rm_d32;
  1524.                 itok4->sib=CODE32;
  1525.         }
  1526.         itok4->segm=DS;
  1527.         itok4->lnumber=0;
  1528.         itok4->post=0;
  1529.         itok4->flag=0;
  1530.         itok4->size=0;
  1531.         itok4->rec=NULL;
  1532.         itok4->type=tp_ucnovn;
  1533.         itok4->npointr=0;
  1534.         itok4->name[0]=0;
  1535.         whitespace(); //¯à®¯ã᪠­¥§­ ç é¨å ᨬ¢®«®¢
  1536. //      if(displaytokerrors)printf("%c ",cha);
  1537.         if(isalpha(cha)||(cha=='_')||(cha>=0x80)){      //¨¤¥­â¨ä¨ª â®à
  1538.                 do{
  1539.                         string4[strptr++]=cha;
  1540.                         if(islower(cha))uppercase=0;
  1541.                         nextchar();
  1542.                 }while((strptr<IDLENGTH)&&(CheckChar2()==TRUE));
  1543.                 if(strptr>=IDLENGTH){ //¤«¨­  ¡®«ìè¥ 32
  1544.                         if(displaytokerrors)preerror("Maximum length for an identifier exceeded");
  1545.                         while(CheckChar2()==TRUE)nextchar();    //¤®ç¨â âì á«®¢®
  1546.                         strptr=IDLENGTH-1;      //®¡à¥§ âì ¤® 32
  1547.                 }
  1548.                 if(cha=='~'&&strptr<IDLENGTH-1){
  1549.                         string4[strptr++]=cha;
  1550.                         nextchar();
  1551.                         if(cha!='('){
  1552.                                 inptr--;
  1553.                                 strptr--;
  1554.                                 cha='~';
  1555.                         }
  1556.                 }
  1557.                 string4[strptr]=0;
  1558.                 strcpy(itok4->name,(char *)string4);
  1559. //              if(displaytokerrors)printf("%s (%u) >%s\n",(startfileinfo+currentfileinfo)->filename,linenumber,itok4->name);
  1560. #ifdef DEBUGMODE
  1561.                 if (debug)printf("ID: '%s' cur_mod=%08X prev cur_mod=%08X\n",itok4->name,cur_mod,cur_mod==NULL?0:cur_mod->next);
  1562. #endif
  1563.                 if(scanlexmode==RESLEX){
  1564.                         if(stricmp((char *)string4,"not")==0)*tok4=tk_not;
  1565.                         else if(stricmp((char *)string4,"or")==0)*tok4=tk_or;
  1566.                         else if(stricmp((char *)string4,"xor")==0)*tok4=tk_xor;
  1567.                         else if(stricmp((char *)string4,"and")==0)*tok4=tk_and;
  1568.                         else{
  1569.                                 if(uppercase)*tok4=tk_ID;
  1570.                                 else *tok4=tk_id;
  1571.                                 searchtree(itok4,tok4,string4);
  1572.                                 if(*tok4==tk_id||*tok4==tk_ID){
  1573.                                         if((useme=CheckResName(itok4->name))!=-1){
  1574.                                                 *tok4=tk_rescommand;
  1575.                                                 itok4->number=useme;
  1576.                                         }
  1577.                                 }
  1578.                         }
  1579.                         return;
  1580.                 }
  1581.                 if(uppercase){  //¢¥àå­¨© ॣ¨áâà
  1582.                         if(strptr==1&&string4[0]=='L'&&cha=='"'){
  1583.                                 itok4->name[0]=0;
  1584.                                 GetTokString(tok4,itok4,string4,TRUE);
  1585.                                 return;
  1586.                         }
  1587.                         *tok4=tk_ID;
  1588.                         if(string4[1]=='S'&&strptr>=5&&strptr<=8){
  1589.                                 for(useme=0;useme<ID2S;useme++){        //¯à®¢¥àª  ­  ESBYTE ...
  1590.                                         if(strcmp((char *)string4,id2[useme])==0){
  1591.                                                 *tok4=tk_charvar+useme%DATATYPES;
  1592.                                                 itok4->segm=useme/DATATYPES;
  1593.                                                 itok4->number=0;
  1594.                                                 itok4->post=POINTER;
  1595.                                                 goto yesid;
  1596.                                         }
  1597.                                 }
  1598.                         }
  1599.                 }
  1600.                 else *tok4=tk_id;
  1601.                 if(strptr==2){  //¤«¨­  2 ᨬ¢®«  check for AX, CX, DX, ...
  1602.                         if((string4[0]&0x5f)=='S'&&(string4[1]&0x5f)=='T'){
  1603.                                 if(cha=='('){
  1604.                                         nextchar();
  1605.                                         if(cha>='0'&&cha<='7'){
  1606.                                                 itok4->number=cha-'0';
  1607.                                                 nextchar();
  1608.                                                 if(cha!=')')expected(')');
  1609.                                                 nextchar();
  1610.                                                 *tok4=tk_fpust;
  1611.                                         }
  1612.                                 }
  1613.                                 else{
  1614.                                         itok4->number=0;
  1615.                                         *tok4=tk_fpust;
  1616.                                 }
  1617.                                 return;
  1618.                         }
  1619.                         if(asmparam||*tok4==tk_ID){
  1620.                                 for(useme=0;useme<8;useme++){
  1621.                                         int i;
  1622.                                         if(asmparam)i=stricmp((char *)string4,regs[0][useme]);
  1623.                                         else i=strcmp((char *)string4,regs[0][useme]);
  1624.                                         if(i==0){
  1625.                                                 *tok4=tk_reg;
  1626.                                                 itok4->number=useme;
  1627. extreg:
  1628.                                                 if(cha=='.'){
  1629.                                                         tag_massiv(tok4,itok4,string4);
  1630.                                                         goto yesid;
  1631.                                                 }
  1632.                                                 return;
  1633.                                         }
  1634.                                         if(asmparam)i=stricmp((char *)string4,begs[useme]);
  1635.                                         else i=strcmp((char *)string4,begs[useme]);
  1636.                                         if(i==0){
  1637.                                                 *tok4=tk_beg;
  1638.                                                 itok4->number=useme;
  1639.                                                 return;
  1640.                                         }
  1641.                                 }
  1642.                                 if(string4[1]=='S'||(asmparam&&string4[1]=='s')){
  1643.                                         for(useme=0;useme<6;useme++){ // check for CS, SS, ...
  1644.                                                 if(string4[0]==segs[useme][0]||(asmparam&&(string4[0]&0x5F)==segs[useme][0])){
  1645.                                                         if(cha==':'){
  1646.                                                                 int oinptr=inptr;
  1647.                                                                 unsigned char ocha=cha;
  1648.                                                                 int oline=linenumber;
  1649.                                                                 nextchar();
  1650. /*                                                              switch(cha&(asmparam==FALSE?0xFF:0x5F)){
  1651.                                                                         case 'E':
  1652.                                                                         case 'B':
  1653.                                                                         case 'S':
  1654.                                                                         case 'D':*/
  1655.                                                                                 tokscan(tok4,itok4,string4);
  1656.                                                                                 if(*tok4>=tk_bits&&*tok4<=tk_doublevar){
  1657.                                                                                         itok4->segm=useme;
  1658.                                                                                         goto yesid;
  1659.                                                                                 }
  1660. //                                                              }
  1661.                                                                 inptr=oinptr;
  1662.                                                                 cha=ocha;
  1663.                                                                 linenumber=oline;
  1664.                                                         }
  1665.                                                         *tok4=tk_seg;
  1666.                                                         itok4->number=useme;
  1667.                                                         return;
  1668.                                                 }
  1669.                                         }
  1670.                                 }
  1671.                         }
  1672.                 }
  1673.                 if(strptr==3&&(string4[0]=='E'||(asmparam&&string4[0]=='e'))){// check for EAX, ECX, EDX, ...
  1674.                         for(useme=0;useme<8;useme++){
  1675.                                 int i;
  1676.                                 if(asmparam)i=stricmp((char *)&string4[1],regs[0][useme]);
  1677.                                 else i=strcmp((char *)&string4[1],regs[0][useme]);
  1678.                                 if(i==0){
  1679.                                         *tok4=tk_reg32;
  1680.                                         itok4->number=useme;
  1681. extreg32:
  1682.                                         if(cha=='.'){
  1683.                                                 tag_massiv(tok4,itok4,string4);
  1684.                                                 goto yesid;
  1685.                                         }
  1686.                                         if(cha==':'){
  1687.                                                 int oinptr=inptr;
  1688.                                                 unsigned char ocha=cha;
  1689.                                                 int oline=linenumber;
  1690.                                                 nextchar();
  1691.                                                 tokscan(tok4,itok4,string4);
  1692.                                                 if(*tok4==tk_reg32||*tok4==tk_reg){
  1693.                                                         itok4->number|=useme*256;
  1694.                                                         *tok4=tk_reg64;
  1695.                                                         goto yesid;
  1696.                                                 }
  1697.                                                 inptr=oinptr;
  1698.                                                 cha=ocha;
  1699.                                                 linenumber=oline;
  1700.                                         }
  1701.                                         return;
  1702.                                 }
  1703.                         }
  1704.                 }
  1705.                 if(asmparam){
  1706.                         if((string4[1]&0x5f)=='R'){
  1707.                                 if(string4[2]>='0'&&string4[2]<='7'){
  1708.                                         itok4->number=string4[2]-'0';
  1709.                                         switch((string4[0]&0x5f)){
  1710.                                                 case 'C': *tok4=tk_controlreg; return;// check for CR0, CR1, ...
  1711.                                                 case 'D': *tok4=tk_debugreg; return;//check for DR0, DR1, ...
  1712.                                                 case 'T': *tok4=tk_testreg; return;//check for TR0, TR1, ...
  1713.                                                 default: itok4->number=0; break;
  1714.                                         }
  1715.                                 }
  1716.                         }
  1717.                         else if((*(short *)&string[0]&0x5f5f)==0x4d4d){
  1718.                                 if(string4[2]>='0'&&string4[2]<='7'){
  1719.                                         itok4->number=string4[2]-'0';
  1720.                                         *tok4=tk_mmxreg;
  1721.                                         return;
  1722.                                 }
  1723.                         }
  1724.                         else if((*(short *)&string[1]&0x5f5f)==0x4d4d&&(string4[0]&0x5f)=='X'){
  1725.                                 if(string4[3]>='0'&&string4[3]<='7'){
  1726.                                         itok4->number=string4[3]-'0';
  1727.                                         *tok4=tk_xmmreg;
  1728.                                         return;
  1729.                                 }
  1730.                         }
  1731.                 }
  1732.                 if(useasm==FALSE){
  1733.                         if((useme=FastSearch(id,idofs,2,(char *)string4))!=-1)*tok4=useme;
  1734.                         else if(idasm==TRUE&&(useme=CheckAsmName((char *)string4))!=-1){
  1735.                                 *tok4=tk_idasm;
  1736.                                 itok4->rm=useme;
  1737.                                 return;
  1738.                         }
  1739.                 }
  1740.                 if(*tok4==tk_id||*tok4==tk_ID){
  1741.                         if(cur_mod&&cur_mod->numparamdef&&(displaytokerrors||scanalltoks)){//18.03.05 15:12
  1742. /*                              if(debug&&cur_mod){
  1743.                                         printf("Find %s in %d entries curmod=%08X\n",itok4->name,cur_mod->numparamdef,cur_mod);
  1744.                                         COM_MOD *nmod;
  1745.                                         nmod=cur_mod;
  1746.                                         while(nmod){
  1747.                                                 printf("\tinput=%08X inptr=%08X\n",nmod->input,nmod->inptr);
  1748.                                                 nmod=nmod->next;
  1749.                                         }
  1750.                                 }*/
  1751.                                 if(CheckDefPar(itok4->name)){
  1752.                                         tokscan(tok4,itok4,string4);
  1753.                                         if(displaytokerrors==0){
  1754.                                                 inptr=cur_mod->inptr;
  1755.                                                 input=cur_mod->input;
  1756.                                                 endinptr=cur_mod->endinptr;
  1757.                                                 linenumber=cur_mod->linenumber;
  1758.                                                 currentfileinfo=cur_mod->currentfileinfo;
  1759.                                                 COM_MOD *temp=cur_mod;
  1760.                                                 cur_mod=cur_mod->next;
  1761.                                                 free(temp);
  1762.                                                 nextchar();
  1763.                                         }
  1764. #ifdef DEBUGMODE
  1765.                                         if(debug)printf("1601 tok=%d input=%08X inptr=%08X disp=%d %s %c%40s\n\t%s\n",*tok4,input,inptr,displaytokerrors,itok4->name,cha,input+inptr,""/*input*/);
  1766. #endif
  1767.                                         return;
  1768.                                 }
  1769.                         }
  1770.                         if(searchlocals(itok4,tok4,string4)==FALSE){//¯®¨áª á।¨ «®ª «ì­ëå ¬¥â®ª
  1771.                         //¥á«¨ ­¨ç¥£® ­¥ ­ ©¤¥­® ¯®¨áª ¢ ¤¥à¥¢¥ ¯¥à¥¬¥­ëå
  1772.                                 searchtree(itok4,tok4,string4);
  1773.                                 if(*tok4==tk_endline){
  1774.                                         if(scanlexmode!=DEFLEX){
  1775.                                                 tokscan(tok4,itok4,string4);
  1776. #ifdef DEBUGMODE
  1777.                                                 if(debug)printf("1610 tok=%d input=%08X inptr=%08X disp=%d %s %c%40s\n\t%s\n",*tok4,input,inptr,displaytokerrors,itok4->name,cha,input+inptr,""/*input*/);
  1778. #endif
  1779.                                                 return;
  1780.                                         }
  1781.                                         *tok4=tk_macro;
  1782.                                 }
  1783.                                 if(*tok4==tk_number||*tok4==tk_idasm)return;
  1784.                                 if((*tok4>=tk_bits&&*tok4<=tk_doublevar)||*tok4==tk_pointer){
  1785.                                         if(itok4->rm==rm_d16||itok4->rm==rm_d32){
  1786.                                                 if(am32==FALSE){
  1787.                                                         itok4->rm=rm_d16;
  1788.                                                         itok4->sib=CODE16;
  1789.                                                 }
  1790.                                                 else{
  1791.                                                         itok4->rm=rm_d32;
  1792.                                                         itok4->sib=CODE32;
  1793.                                                 }
  1794.                                         }
  1795.                                         if(itok4->post==DYNAMIC_POST){  //¯à¥®¡à §®¢ âì ¤¨­ ¬¨ç¥áªãî «®ª «ì­ãî ¢ «®ª «ì­ãî
  1796.                                                 if(alignword&&*tok4!=tk_charvar&&*tok4!=tk_bytevar){    //¢ë஢­ïâì ­  ç¥â­ë©  ¤à¥á
  1797.                                                         switch(*tok4){
  1798.                                                                 case tk_intvar:
  1799.                                                                 case tk_wordvar:
  1800.                                                                         if(postsize%2==1)postsize++;
  1801.                                                                         break;
  1802.                                                                 default:
  1803.                                                                         if(postsize%4!=0)postsize+=4-(postsize%4);
  1804.                                                                         break;
  1805.                                                         }
  1806.                                                 }
  1807.                                                 idrec *ptr=itok4->rec;
  1808.                                                 itok4->post=ptr->recpost=1;
  1809.                                                 itok4->number=ptr->recnumber=postsize;
  1810.                                                 if(am32==FALSE&&(postsize+itok4->size)>0xFFFFL)tobigpost();
  1811.                                                 postsize+=itok4->size;
  1812.                                         }
  1813.                                         else if(itok4->post==DYNAMIC_VAR){
  1814.                                                 idrec *ptr=itok4->rec;
  1815.                                                 itok4->post=ptr->recpost=USED_DIN_VAR;
  1816.                                         }
  1817.                                 }
  1818.                         }
  1819.                         if(tok==tk_reg)goto extreg;
  1820.                         if(tok==tk_reg32)goto extreg32;
  1821.                 }
  1822.                 switch(*tok4){
  1823.                         int len;
  1824.                         case tk_dataptr: *tok4=tk_number; itok4->number=outptrdata;
  1825.                                 if(FixUp)itok.flag|=f_reloc;    //new!!!
  1826.                                 break;
  1827.                         case tk_codeptr: *tok4=tk_number; itok4->number=outptr;
  1828.                                 if(FixUp)itok.flag|=f_reloc;    //new!!!
  1829.                                 break;
  1830.                         case tk_postptr: *tok4=tk_number; itok4->number=postsize;       break;
  1831.                         case tk_line: *tok4=tk_number; itok4->number=linenumber; break;
  1832.                         case tk_file:
  1833.                                 *tok4=tk_string;
  1834.                                 strcpy((char *)string4,(startfileinfo+currentfileinfo)->filename);
  1835.                                 itok4->number=strlen((char *)string4);
  1836.                                 break;
  1837.                         case tk_structvar:
  1838.                                 struct idrec *ptrs;
  1839.                                 ptrs=itok4->rec;
  1840. //                              puts(itok4->name);
  1841.                                 dostructvar2(tok4,itok4,(structteg *)ptrs->newid,string4);
  1842.                                 break;
  1843.                         case tk_sizeof:
  1844.                                 dosizeof(itok4);
  1845.                                 if(itok4->post)*tok4=tk_postnumber;
  1846.                                 else *tok4=tk_number;
  1847.                                 break;
  1848.                         case tk_signed:
  1849.                         case tk_unsigned:
  1850.                         case tk_int:
  1851.                         case tk_long:
  1852.                         case tk_short:
  1853.                                 if(itok4->type!=tp_modif){
  1854.                                         GetTypeVar(tok4);
  1855.                                         itok4->type=tp_modif;
  1856.                                 }
  1857.                                 break;
  1858.                         case tk_ID:
  1859. //                              printf("%s %s %d %c\n",itok.name,string4,strptr,cha);
  1860.                                 if(strlen(itok4->name)==1&&itok4->name[0]=='L'&&cha=='"'){
  1861.                                         itok4->name[0]=0;
  1862.                                         GetTokString(tok4,itok4,string4,TRUE);
  1863.                                         return;
  1864.                                 }
  1865.                         case tk_id:
  1866.                                 if(findofset==FALSE){
  1867.                                         struct structteg *tteg;
  1868. //                                      if(displaytokerrors)printf("find teg %s cha=%02X\n",itok4->name,cha);
  1869.                                         if(((tteg=FindTeg(FALSE,itok4->name))!=NULL||
  1870.                                                         (tteg=FindTeg(TRUE,itok4->name))!=NULL)&&(cha=='.'||precha=='.')){
  1871. //                                              if(displaytokerrors)puts("finding");
  1872.                                                 dostructvar2(tok4,itok4,tteg,string4);
  1873. //                                              printf("tok=%d\n",*tok4);
  1874.                                                 if(displaytokerrors&&(*tok4==tk_proc||*tok4==tk_declare||
  1875.                                                                 *tok4==tk_undefproc)&&(itok4->flag&f_static)==0)unknownobj(itok4->name);
  1876.                                         }
  1877.                                 }
  1878.                                 break;
  1879.  
  1880.                 }
  1881.                 if(*tok4==tk_string&&displaytokerrors){
  1882.                         strcpy((char *)string3,(char *)string4);
  1883.                         if(itok4->rm==2){
  1884.                                 convert_string(string4);
  1885.                                 itok4->rm--;
  1886.                         }
  1887.                         if(dosstring)itok.flag=dos_term;
  1888.                 }
  1889. yesid:
  1890.                 if((*tok4>=tk_bits&&*tok4<=tk_doublevar)||*tok4==tk_pointer){
  1891.                         whitespace();//¯à®¯ã᪠­¥§­ ç é¨å ᨬ¢®«®¢
  1892.                         if(cha=='[')calcrm(itok4,*tok4);//®¡à ¡®âª  ¢ëà ¦¥­¨ï ¢ []
  1893.                 }
  1894.                 if(itok4->rm!=rm_d16&&*tok4!=tk_proc&&*tok4!=tk_undefproc&&
  1895.                         *tok4!=tk_apiproc&&*tok4!=tk_declare&&(!(*tok4==tk_pointer&&itok4->type==tk_proc)))
  1896.                         if(itok4->post==0&&(itok4->flag&f_reloc)==0){  // cannot compress if POST var
  1897.                                 compressoffset(itok4);
  1898.                         }
  1899.                 next=0;
  1900.         }
  1901.         else if(isdigit(cha)){//ç¨á« 
  1902.                 inptr--;
  1903.                 itok4->lnumber=scannumber(&itok4->rm);
  1904.                 *tok4=tk_number;
  1905.                 next=0;
  1906.         }
  1907.         else switch(cha){
  1908.                 case '\"':
  1909.                         GetTokString(tok4,itok4,string4,FALSE);
  1910.                         next=0;
  1911.                         break;
  1912.                 case '\'': //ᨬ¢®«ì­ ï ª®­áâ ­â  ¬®¦¥â ¨¬¥âì ¡®«¥¥ 1 ᨬ¢®« 
  1913.                         nextchar();
  1914.                         next=0;
  1915.                         if(scanlexmode==RESLEX){
  1916.                                 *tok4=tk_singlquote;
  1917.                                 break;
  1918.                         }
  1919.                         *tok4=tk_number;
  1920.                         itok4->number=0;
  1921.                         while(cha!='\''&&!endoffile){  // special character
  1922.                                 itok4->lnumber=itok4->lnumber*256+convert_char();
  1923.                                 nextchar();
  1924.                         }
  1925.                         if(cha!='\''){
  1926.                                 if(displaytokerrors)expected('\'');
  1927.                         }
  1928.                         else nextchar();
  1929.                         next=0;
  1930.                         break;
  1931.                 case '-':
  1932.                         nextchar();
  1933.                         switch(cha){
  1934.                                 case '=': *tok4=tk_minusequals; break;  //¬¨­ãá à ¢­®
  1935.                                 case '-': *tok4=tk_minusminus; break;   //¬¨­ãá-¬¨­ãá
  1936.                                 default: *tok4=tk_minus; next = 0; itok4->type=tp_opperand; break;//¬¨­ãá
  1937.                         }
  1938.                         break;
  1939.                 case '+':
  1940.                         nextchar();
  1941.                         switch(cha){
  1942.                                 case '=': *tok4=tk_plusequals; break; //¯«îá à ¢­®
  1943.                                 case '+': *tok4=tk_plusplus; break;     //¯«îá-¯«îá
  1944.                                 default: whitespace();  // spaces allowed between
  1945.                                         if(cha=='-')*tok4=tk_minus;  // optimization of + -
  1946.                                         else{
  1947.                                                 *tok4=tk_plus;                           //¯«îá
  1948.                                                 next=0;
  1949.                                         }
  1950.                                         itok4->type=tp_opperand;
  1951.                                         break;
  1952.                         }
  1953.                         break;
  1954.                 case '*':
  1955.                         nextchar();
  1956.                         switch(cha){
  1957.                                 case '=': *tok4=tk_multequals; break;
  1958.                                 case '-': *tok4=tk_multminus; break;                     //㬭®¦¨âì ¬¨­ãá
  1959.                                 default:
  1960.                                         *tok4=tk_mult;                                                                   //㬭®¦¨âì
  1961.                                         next=0;
  1962.                         }
  1963.                         itok4->type=tp_opperand;
  1964.                         break;
  1965.                 case '/': nextchar();
  1966.                         switch(cha){
  1967.                                 case '*': nextchar(); //ᮬ¥­â à¨©
  1968.                                         useme=1;
  1969.                                         while(!endoffile&&useme>0){
  1970.                                                 whitespace();
  1971.                                                 if(cha=='*'){
  1972.                                                         nextchar();
  1973.                                                         if(cha=='/'){
  1974.                                                                 nextchar();
  1975.                                                                 if(cha=='/')nextchar();
  1976.                                                                 else useme--;
  1977.                                                         }
  1978.                                                         continue;
  1979.                                                 }
  1980.                                                 else if(cha=='/'){
  1981.                                                         nextchar();
  1982.                                                         if(cha=='*')useme++;
  1983.                                                         else if(cha=='/'){
  1984.                                                                 nextchar();
  1985.                                                                 continue;
  1986.                                                         }
  1987.                                                         else continue;
  1988.                                                 }
  1989.                                                 nextchar();
  1990.                                         }
  1991.                                         if(endoffile){
  1992.                                                 *tok4=tk_eof;
  1993.                                                 if(useme>0&&displaytokerrors)unexpectedeof();
  1994.                                         }
  1995.                                         else tokscan(tok4,itok4,string4);
  1996.                                         break;
  1997.                                 case '/':
  1998.                                         do{
  1999.                                                 nextchar();
  2000.                                         }while(!endoffile&&cha!=13);    //áâப  ª®¬¥­â à¨ï
  2001.                                         if(endoffile)*tok4=tk_eof;
  2002.                                         else{
  2003.                                                 if(scanlexmode==DEFLEX)*tok4=tk_endline;
  2004.                                                 else{
  2005.                                                         whitespace();
  2006.                                                         if(cha==13)nextchar();
  2007.                                                         tokscan(tok4,itok4,string4);
  2008.                                                 }
  2009.                                         }
  2010.                                         break;
  2011.                                 case '=': *tok4=tk_divequals; nextchar(); return;
  2012.                                 default:
  2013.                                         whitespace();
  2014.                                         if(cha=='-'){
  2015.                                                 *tok4=tk_divminus;      //¤¥«¥­¨¥
  2016.                                                 nextchar();
  2017.                                         }
  2018.                                         else *tok4=tk_div;
  2019.                                         itok4->type=tp_opperand;
  2020.                                         break;
  2021.                         }
  2022.                         next=0;
  2023.                         break;
  2024.                 case '%':
  2025.                         nextchar();
  2026.                         whitespace();
  2027.                         if(cha=='-')*tok4=tk_modminus;  //®áâ â®ª ®â ¤¥«¥­¨ï
  2028.                         else{
  2029.                                 *tok4=tk_mod;
  2030.                                 next=0;
  2031.                         }
  2032.                         itok4->type=tp_opperand;
  2033.                         break;
  2034.                 case '|':
  2035.                         nextchar();
  2036.                         switch(cha){
  2037.                                 case '=': *tok4=tk_orequals; break; //OR=
  2038.                                 case '|': *tok4=tk_oror; break;                 //OR-OR
  2039.                                 default:
  2040.                                         whitespace();
  2041.                                         if(cha=='-')*tok4=tk_orminus;           //OR-
  2042.                                         else{
  2043.                                                 *tok4=tk_or;
  2044.                                                 if(cha==13)nextchar();                                  //OR
  2045.                                                 next=0;
  2046.                                         }
  2047.                                         itok4->type=tp_opperand;
  2048.                                         break;
  2049.                         }
  2050.                         break;
  2051.                 case '&':
  2052.                         nextchar();
  2053.                         switch(cha){
  2054.                                 case '=': *tok4=tk_andequals; break; //AND=
  2055.                                 case '&': *tok4=tk_andand; break;
  2056.                                 default:
  2057.                                         whitespace();
  2058.                                         if(cha=='-')*tok4=tk_andminus;
  2059.                                         else{
  2060.                                                 *tok4=tk_and;
  2061.                                                 next=0;
  2062.                                         }
  2063.                                         itok4->type=tp_opperand;
  2064.                                         break;
  2065.                         }
  2066.                         break;
  2067.                 case '!':
  2068.                         nextchar();
  2069.                         if(cha=='='){
  2070.                                 *tok4=tk_notequal;              //!=
  2071.                                 itok4->type=tp_compare;
  2072.                         }
  2073.                         else{
  2074.                                 *tok4=tk_not;
  2075.                                 next=0;
  2076.                         }
  2077.                         break;
  2078.                 case '^':
  2079.                         nextchar();
  2080.                         if(cha=='=')*tok4=tk_xorequals;  //XOR=
  2081.                         else{
  2082.                                 whitespace();
  2083.                                 if(cha=='-')*tok4=tk_xorminus;
  2084.                                 else{
  2085.                                         *tok4=tk_xor;
  2086.                                         next=0;
  2087.                                 }
  2088.                                 itok4->type=tp_opperand;
  2089.                         }
  2090.                         break;
  2091.                 case '=':
  2092.                         nextchar();
  2093.                         if(cha=='='){
  2094.                                 *tok4=tk_equalto;  //==
  2095.                                 itok4->type=tp_compare;
  2096.                         }
  2097.                         else{
  2098.                                 *tok4=tk_assign;                                                 //¯à¨á¢®¨âì
  2099.                                 next=0;
  2100.                         }
  2101.                         break;
  2102.                 case '>':
  2103.                         nextchar();
  2104.                         switch(cha){
  2105.                                 case '>':
  2106.                                         nextchar();
  2107.                                         if(cha=='=')*tok4=tk_rrequals; //ᤢ¨£ ¢¯à ¢® á ¯à¨á¢®¥­¨¥¬
  2108.                                         else{
  2109.                                                 whitespace();
  2110.                                                 if(cha=='-')*tok4 = tk_rrminus;
  2111.                                                 else{
  2112.                                                         *tok4=tk_rr;                                                    //ᤢ¨£ ¢¯à ¢®
  2113.                                                         next=0;
  2114.                                                 }
  2115.                                                 itok4->type=tp_opperand;
  2116.                                         }
  2117.                                         break;
  2118.                                 case '<': *tok4=tk_swap; break;                          //®¡¬¥­
  2119.                                 case '=': *tok4=tk_greaterequal; itok4->type=tp_compare; break; //¡®«ìè¥ ¨«¨ à ¢­®
  2120.                                 default: *tok4=tk_greater; next=0; itok4->type=tp_compare; break; //¡®«ìè¥
  2121.                         }
  2122.                         break;
  2123.                 case '<':
  2124.                         nextchar();
  2125.                         switch(cha){
  2126.                                 case '<':
  2127.                                         nextchar();
  2128.                                         if(cha=='=')*tok4=tk_llequals;   //ᤢ¨£ ¢«¥¢® á ¯à¨á¢®¥­¨¥¬
  2129.                                         else{
  2130.                                                 whitespace();
  2131.                                                 if(cha=='-')*tok4=tk_llminus;
  2132.                                                 else{
  2133.                                                         *tok4=tk_ll;                                                             //ᤢ¨£ ¢«¥¢®
  2134.                                                         next=0;
  2135.                                                 }
  2136.                                                 itok4->type=tp_opperand;
  2137.                                         }
  2138.                                         break;
  2139.                                 case '>': *tok4=tk_notequal; itok4->type=tp_compare; break;  //!=
  2140.                                 case '=': *tok4=tk_lessequal; itok4->type=tp_compare; break; //¬¥­ìè¥ ¨«¨ à ¢­®
  2141.                                 default: *tok4=tk_less; next=0; itok4->type=tp_compare; break;//¬¥­ìè¥
  2142.                         }
  2143.                         break;
  2144.                 case '#':
  2145.                         next=0;
  2146.                         nextchar();
  2147.                         findofset=TRUE;
  2148.                         tokscan(tok4,itok4,string4);
  2149.                         findofset=FALSE;
  2150.                         if((useme=GetDirective((char *)string4))!=-1){
  2151.                                 itok4->number=useme;
  2152.                                 *tok4=tk_question;
  2153.                                 break;
  2154.                         }
  2155.                         if(*tok4==tk_dblcolon){
  2156.                                 skiplocals=TRUE;
  2157.                                 tokscan(tok4,itok4,string4);
  2158.                         }
  2159. /*                      char buf[16];
  2160.                         strncpy(buf,(char *)(input+inptr),15);
  2161.                         buf[15]=0;*/
  2162. //              printf("sib=%08X tok=%d rm=%d post=%d number=%d size=%d segm=%d flag=%08X %s\n",itok4->sib,*tok4,itok4->rm,itok4->post,itok4->number,itok4->size,itok4->segm,itok4->flag,itok4->name/*,buf*/);
  2163. //      printf("skiplocals=%d skipfind=%d searchteg=%08X\n",skiplocals,skipfind,searchteg);
  2164.                         switch(*tok4){
  2165.                                 case tk_structvar:
  2166. //                                      printf("%08X %s\n",itok4->sib,itok4->name);
  2167.                                         if((itok4->sib&1)==0){
  2168.                                                 ofsstr(tok4,itok4);
  2169. //              if(displaytokerrors)printf("sib=%08X tok=%d rm=%d post=%d number=%d size=%d segm=%d flag=%08X %s\n",itok4->sib,*tok4,itok4->rm,itok4->post,itok4->number,itok4->size,itok4->segm,itok4->flag,itok4->name/*,buf*/);
  2170.                                                 break;
  2171.                                         }
  2172.                                         itok4->rm=(am32==0?rm_d16:rm_d32);
  2173.                                 case tk_struct:
  2174.                                         *tok4=tk_number;
  2175.                                         if(bufrm){
  2176.                                                 *tok4=tk_rmnumber;
  2177.                                                 if(itok4->type==tp_classvar)itok4->flag|=f_useidx;
  2178.                                         }
  2179.                                         break;
  2180.                                 case tk_apiproc:        //!!!16.12.06 23:06
  2181.                                         itok4->rm=tk_undefofs;
  2182.                                         *tok4=tk_apioffset;
  2183.                                         if(FixUp)itok4->flag|=f_reloc;  //new!!! 27.06.05 22:25
  2184.                                         strcpy((char *)string4,itok4->name);
  2185. //                      printf("sib=%08X tok=%d rm=%d post=%d number=%d size=%d segm=%d %s\n",itok4->sib,*tok4,itok4->rm,itok4->post,itok4->number,itok4->size,itok4->segm,itok4->name/*,buf*/);
  2186.                                         break;
  2187.                                 case tk_proc:
  2188.                                 case tk_interruptproc:
  2189.                                         if(cha=='.')goto structofs;
  2190. procofs:
  2191.                                         if(itok4->segm!=NOT_DYNAMIC){
  2192.                                                 if(displaytokerrors){
  2193.                                                         idrec *ptr=itok4->rec;
  2194.                                                         itok4->segm=ptr->recsegm=DYNAMIC_USED;
  2195.                                                 }
  2196.                                                 itok4->rm=*tok4=tk_undefofs;    //ᬥ饭¨¥ ¥é¥ ­¥ ¨§¢¥áâ­®© ¬¥âª¨
  2197.                                                 itok4->number=0;
  2198. //                                              if(FixUp)itok4->flag|=f_reloc;  //new!!! 27.06.05 22:25
  2199.                                         }
  2200.                                         else{
  2201.                                                 *tok4=tk_number;
  2202.                                                 itok4->segm=CS;//(splitdata==FALSE)?DS:CS;
  2203. //                                              if(FixUp)itok4->flag|=f_reloc;
  2204.                                         }
  2205.                                         if(FixUp)itok4->flag|=f_reloc;  //new!!! 27.06.05 22:25
  2206.                                         strcpy((char *)string4,itok4->name);
  2207. //                      printf("sib=%08X tok=%d rm=%d post=%d number=%d size=%d segm=%d %s\n",itok4->sib,*tok4,itok4->rm,itok4->post,itok4->number,itok4->size,itok4->segm,itok4->name/*,buf*/);
  2208.                                         break;
  2209.                                 case tk_id:
  2210.                                 case tk_ID:
  2211. structofs:
  2212.                                         struct structteg *tteg;
  2213.                                         if(((tteg=FindTeg(FALSE,itok4->name))!=NULL||
  2214.                                                         (tteg=FindTeg(TRUE,itok4->name))!=NULL)/*&&cha=='.'*/){
  2215.                                                 dostructvar2(tok4,itok4,tteg,string4);
  2216. //                      printf("sib=%08X tok=%d rm=%d post=%d number=%d size=%d %s\n",itok4->sib,*tok4,itok4->rm,itok4->post,itok4->number,itok4->size,itok4->name/*,buf*/);
  2217.  
  2218.                                                 if(*tok4==tk_proc)goto procofs;//04.10.04 14:25
  2219.  
  2220.                                                 if(*tok4==tk_declare)goto undefofs;     //24.09.04 00:33
  2221. //                                              printf("tok=%d segm=%d %s\n",*tok4,itok4->segm,itok4->name);
  2222.                                                 if(strinf.bufstr){
  2223.                                                         *tok4=tk_rmnumber;
  2224.                                                         if(itok4->type==tp_classvar)itok4->flag|=f_useidx;
  2225.                                                 }
  2226.                                                 else{
  2227.                                                         if(FixUp&&*tok4==tk_proc)itok4->flag|=f_reloc;  //new!!!
  2228.                                                         else itok4->flag&=~f_reloc;
  2229. //                                                      else itok4->flag&=!f_reloc; 16.08.04 18:51
  2230.  
  2231. //30.09.04 20:22
  2232.                                                         if(itok4->post){
  2233.                                                                 *tok4=tk_postnumber;
  2234.                                                                 itok4->rm=tk_undefofs;
  2235.                                                         }
  2236.                                                         else
  2237. /////
  2238.  
  2239.                                                          *tok4=tk_number;
  2240.                                                 }
  2241.                                         }
  2242.                                         else{
  2243. undefofs:
  2244.                                                 itok4->rm=*tok4=tk_undefofs;    //ᬥ饭¨¥ ¥é¥ ­¥ ¨§¢¥áâ­®© ¬¥âª¨
  2245.                                                 itok4->number=0;
  2246.                                                 if(FixUp)itok4->flag|=f_reloc;  //new!!!
  2247.                                         }
  2248.                                 case tk_number:
  2249.                                 case tk_rmnumber:
  2250.                                         break;
  2251.                                 case tk_reg:
  2252.                                 case tk_reg32:
  2253.                                         itok4->rm=RegToRM(itok4->number,*tok4)/*|rm_mod10*/;
  2254.                                         *tok4=(am32==0?tk_wordvar:tk_dwordvar);//tk_rmnumber;
  2255.                                         itok4->number=0;
  2256.                                         break;
  2257.                                 default:
  2258.                                         if(cha=='.')goto structofs;
  2259.                                         if((*tok4>=tk_bits&&*tok4<=tk_doublevar)||tok==tk_pointer){
  2260. #ifdef OPTVARCONST
  2261.                                                 if(displaytokerrors)ClearVarByNum(itok4);
  2262. #endif
  2263.                                                 switch(itok4->type){
  2264.                                                         case tp_localvar:
  2265.                                                         case tp_paramvar:
  2266. localrec *ptr;
  2267.                                                                 ptr=itok4->locrec;
  2268.                                                                 ptr->fuse|=(unsigned char)(INITVAR|USEDVAR);
  2269.                                                                 break;
  2270.                                                         case tk_proc:
  2271.                                                                 itok4->rm=itok4->sib;
  2272.                                                                 itok4->sib=am32==0?CODE16:CODE32;
  2273.                                                                 break;
  2274.                                                 }
  2275.                                                 itok4->size=GetVarSize(*tok4);
  2276.                                                 if((itok4->sib==CODE16&&itok4->rm==rm_d16)||
  2277.                                                                 (itok4->sib==CODE32&&itok4->rm==rm_d32)){
  2278.                                                         if(itok4->post==0){
  2279.                                                                 *tok4=tk_number;
  2280.                                                                 itok4->segm=DS;
  2281.                                                                 if(FixUp)itok4->flag|=f_reloc;
  2282.                                                                 itok4->rm=am32==FALSE?tk_word:tk_dword;
  2283.                                                         }
  2284.                                                         else{
  2285.                                                                 *tok4=tk_postnumber;
  2286.                                                                 itok4->rm=tk_undefofs;
  2287.                                                         }
  2288.                                                 }
  2289.                                                 else{
  2290.                                                         *tok4=tk_rmnumber;
  2291.                                                         if(itok4->type==tp_classvar)itok4->flag|=f_useidx;
  2292.                                                 }
  2293.                                         }
  2294.                                         else{
  2295.                                                 itok4->rm=*tok4=tk_undefofs;    //ᬥ饭¨¥ ¥é¥ ­¥ ¨§¢¥áâ­®© ¬¥âª¨
  2296.                                                 itok4->number=0;
  2297.                                                 strcpy((char *)string4,itok4->name);
  2298.                                         }
  2299.                                         break;
  2300.                         }
  2301.                         itok4->type=tp_ofs;
  2302. //                      if(displaytokerrors)printf("name=%s tok=%d post=%d flag=%08X rm=%d\n",itok4->name,*tok4,itok4->post,itok4->flag,itok4->rm);
  2303.                         break;
  2304.                 case '(':
  2305.                         if(*(unsigned short *)&(input[inptr])==
  2306. #ifdef _WC_
  2307.                                 ')E'
  2308. #else
  2309.                                 'E)'
  2310. #endif
  2311.                                 ||
  2312.                                         (*(unsigned short *)&(input[inptr])==
  2313. #ifdef _WC_
  2314.                                 ')e'
  2315. #else
  2316.                                 'e)'
  2317. #endif
  2318.                                         )){
  2319.                                 for(useme=0;useme<8;useme++){
  2320.                                         int i;
  2321.                                         if(asmparam)i=strnicmp((char *)input+inptr+2,regs[0][useme],2);
  2322.                                         else i=strncmp((char *)input+inptr+2,regs[0][useme],2);
  2323.                                         if(i==0){
  2324.                                                 inptr+=4;
  2325.                                                 nextchar();
  2326.                                                 itok4->number=useme;
  2327.                                                 if(am32){
  2328.                                                         *tok4=tk_reg32;
  2329.                                                         goto extreg32;
  2330.                                                 }
  2331.                                                 *tok4=tk_reg;
  2332.                                                 goto extreg;
  2333.                                         }
  2334.                                 }
  2335.                         }
  2336.                         *tok4=tk_openbracket;
  2337.                         break;
  2338.                 case ':':
  2339.                         nextchar();
  2340.                         if(cha!=':'){
  2341.                                 next=0;
  2342.                                 *tok4=tk_colon;
  2343.                         }
  2344.                         else *tok4=tk_dblcolon;
  2345.                         break;
  2346.                 case ';': itok4->type=tp_stopper; *tok4=tk_semicolon;   break;
  2347.                 case ')': itok4->type=tp_stopper; *tok4=tk_closebracket; break;
  2348.                 case '{': *tok4=tk_openbrace; break;
  2349.                 case '}': itok4->type=tp_stopper; *tok4=tk_closebrace; break;
  2350.                 case '[': *tok4=tk_openblock; break;
  2351.                 case ']': itok4->type=tp_stopper; *tok4=tk_closeblock; break;
  2352.                 case ',': itok4->type=tp_stopper; *tok4=tk_camma; break;
  2353.                 case '.':
  2354.                         next=0;
  2355.                         nextchar();
  2356.                         if(cha!='.'){
  2357.                                 *tok4=tk_period;
  2358.                                 break;
  2359.                         }
  2360.                         nextchar();
  2361.                         if(cha!='.'){
  2362.                                 badtoken();
  2363.                                 nextchar();
  2364.                                 tokscan(tok4,itok4,string4);
  2365.                                 break;
  2366.                         }
  2367.                         nextchar();
  2368.                         *tok4=tk_multipoint;
  2369.                         break;
  2370.                 case '@': *tok4=tk_at; break;
  2371.                 case '$': *tok4=tk_dollar; break;
  2372.                 case '?':
  2373.                         nextchar();
  2374.                         tokscan(tok4,itok4,string4);
  2375.                         *tok4=tk_question;
  2376.                         itok4->number=GetDirective((char *)string4);
  2377.                         return;
  2378.                 case '~': *tok4=tk_tilda; break;
  2379.                 case 26: *tok4=tk_eof; return;
  2380.                 case 13: *tok4=tk_endline; break;
  2381.                 case '\\':
  2382.                         nextchar();
  2383.                         if(cha==13){
  2384.                                 tokscan(tok4,itok4,string4);
  2385.                                 if(*tok4==tk_endline)tokscan(tok4,itok4,string4);
  2386.                                 return;
  2387.                         }
  2388.                 default:
  2389.                         badtoken();
  2390.                         nextchar();
  2391.                         tokscan(tok4,itok4,string4);
  2392.                         return;
  2393.         }
  2394.         if(next)nextchar();
  2395. #ifdef DEBUGMODE
  2396.         if(debug)printf("2172 tok=%d input=%08X inptr=%08X disp=%d %s %X %s\n",*tok4,input,inptr,displaytokerrors,itok4->name,cha,input+inptr);
  2397. #endif
  2398. }
  2399.  
  2400.  
  2401. void NewMod(int numipar)
  2402. {
  2403. COM_MOD *newm;
  2404. int oline;
  2405. int numpar=0,ns,i,size,nsize;
  2406. char *buf=NULL;
  2407.         newm=(COM_MOD *)MALLOC(sizeof(COM_MOD));
  2408.         newm->numparamdef=numipar;
  2409.         newm->freze=FALSE;
  2410.         size=0;
  2411.         whitespace();
  2412.         if(cha=='('){
  2413.                 nextchar();
  2414.                 whitespace();
  2415.                 if(cha!=')'){
  2416.                         inptr--;
  2417.                         oline=linenumber;
  2418.                         for(i=inptr,ns=1;ns>0;i++){     //¯®¨áª ¯ à ¬¥â஢
  2419.                                 switch(input[i]){
  2420.                                         case '(': ns++; break;
  2421.                                         case ')': ns--; break;
  2422.                                         case ',':
  2423.                                                 if(ns==1){
  2424.                                                         numpar++;
  2425.                                                         nsize=i-inptr;
  2426.                                                         if(!buf)buf=(char *)MALLOC(nsize+1);
  2427.                                                         else buf=(char *)REALLOC(buf,size+nsize+1);
  2428.                                                         strncpy(buf+size,(char *)(input+inptr),nsize);
  2429.                                                         buf[size+nsize]=0;
  2430.                                                         strbtrim(buf+size);
  2431. //                                                      puts(buf+size);
  2432.                                                         size+=strlen(buf+size)+1;
  2433.                                                         inptr+=nsize+1;
  2434.                                                 }
  2435.                                                 break;
  2436.                                         case '/':
  2437.                                                 i=skipcomment(i);
  2438.                                                 break;
  2439.                                         case '"':
  2440.                                         case 0x27:
  2441.                                                 i=skipstring(i,input[i]);
  2442.                                                 break;
  2443.                                 }
  2444.                                 if((unsigned int)i>=endinptr){
  2445.                                         unexpectedeof();
  2446.                                         break;
  2447.                                 }
  2448.                         }
  2449.                         linenumber=oline;
  2450.                         numpar++;
  2451.                         nsize=i-inptr;
  2452.                         if(!buf)buf=(char *)MALLOC(nsize);
  2453.                         else buf=(char *)REALLOC(buf,size+nsize);
  2454.                         strncpy(buf+size,(char *)(input+inptr),nsize-1);
  2455.                         buf[size+nsize-1]=0;
  2456.                         strbtrim(buf+size);
  2457. //                                                      puts(buf+size);
  2458.                         inptr=i;
  2459.                 }
  2460.                 if(numipar>numpar)missingpar(itok.name);
  2461.                 else if(numipar<numpar)extraparam(itok.name);
  2462.                 newm->numparamdef=numpar;
  2463.         }
  2464.         else inptr--;
  2465.         newm->input=input;
  2466.         newm->inptr2=newm->inptr=inptr;
  2467.         newm->endinptr=endinptr;
  2468.         newm->linenumber=linenumber;
  2469.         newm->currentfileinfo=currentfileinfo;
  2470.         newm->paramdef=buf;
  2471.         newm->next=cur_mod;
  2472.         cur_mod=newm;
  2473. //      if(debug)printf("New curmod %08X numpar=%d input=%08X prev curmod=%08X\n",cur_mod,numipar,input,cur_mod->next);
  2474.         nextchar();
  2475. /*      char *temp=buf;
  2476.         for(i=0;i<numpar;i++){
  2477.                 nsize=strlen(temp)+1;
  2478.                 puts(temp);
  2479.                 temp+=nsize;
  2480.         }*/
  2481. }
  2482.  
  2483. void BackMod()
  2484. {
  2485.         if(cur_mod){
  2486.                 inptr=cur_mod->inptr;
  2487.                 inptr2=cur_mod->inptr2;
  2488.                 input=cur_mod->input;
  2489.                 endinptr=cur_mod->endinptr;
  2490.                 linenumber=cur_mod->linenumber;
  2491.                 currentfileinfo=cur_mod->currentfileinfo;
  2492.                 cur_mod=cur_mod->next;
  2493.                 cha2=input[inptr2];
  2494.         }
  2495. }
  2496.  
  2497. char *FindDefPar(char *name,COM_MOD *cmod)
  2498. {
  2499. char *temp;
  2500. int i,numpar,nsize=0;
  2501.         numpar=cmod->numparamdef;
  2502.         temp=cmod->declareparamdef;
  2503. //      if(debug)printf("check for %s\n",name);
  2504.         for(i=0;i<numpar;i++){
  2505.                 nsize=strlen(temp)+1;
  2506. //              if(debug)printf("\t%s\n",temp);
  2507.                 if(strcmp(name,temp)==0){
  2508.                         temp=cmod->paramdef;
  2509.                         for(;i>0;i--){
  2510.                                 temp+=strlen(temp)+1;
  2511.                         }
  2512.                         return temp;
  2513.                 }
  2514.                 temp+=nsize;
  2515.         }
  2516.         return NULL;
  2517. }
  2518.  
  2519. int CheckDefPar(char *name)
  2520. {
  2521. char *temp,*nname;
  2522. COM_MOD *fmod;
  2523.         fmod=cur_mod;
  2524.         nname=name;
  2525.         while((temp=FindDefPar(nname,fmod))!=NULL){
  2526.                 nname=temp;
  2527.                 if(fmod->next==NULL)break;
  2528.                 fmod=fmod->next;
  2529.         }
  2530.         if(fmod==cur_mod&&temp==NULL)return FALSE;
  2531.         SetNewStr(nname);
  2532.         return TRUE;
  2533. }
  2534.  
  2535. void SetNewStr(char *name)
  2536. {
  2537. COM_MOD *fmod;
  2538.         fmod=(COM_MOD *)MALLOC(sizeof(COM_MOD));
  2539.         fmod->next=cur_mod;
  2540.         fmod->numparamdef=0;
  2541.         fmod->paramdef=NULL;
  2542.         fmod->freze=FALSE;
  2543.         fmod->input=input;
  2544.         fmod->inptr2=fmod->inptr=inptr-1;
  2545.         fmod->endinptr=endinptr;
  2546.         fmod->linenumber=linenumber;
  2547.         fmod->currentfileinfo=currentfileinfo;
  2548.         cur_mod=fmod;
  2549. //      if(debug)printf("new curmod %08X prev cur_mod=%08X old input %08X %s\n",cur_mod,cur_mod->next,input,name);
  2550.         input=(unsigned char*)(name);
  2551.         inptr=1;
  2552.         cha=input[0];
  2553.         endinptr=strlen(name)+1;
  2554. }
  2555.  
  2556. int searchtree2(idrec *fptr,ITOK *itok4,int *tok4,unsigned char *string4)
  2557. //¯®¨áª ¢ ¤¥à¥¢¥ ¯¥à¥¬¥­ëå
  2558. {
  2559. struct idrec *ptr;
  2560. int cmpresult;
  2561.         for(ptr=fptr;ptr!=NULL;){
  2562.                 if((cmpresult=strcmp(ptr->recid,(char *)string4))==0){
  2563.                         if(scanlexmode==RESLEX&&ptr->rectok!=tk_number&&ptr->rectok!=tk_string)break;
  2564.                         itok4->lnumber=ptr->reclnumber;
  2565.                         itok4->rm=ptr->recrm;
  2566.                         *tok4=ptr->rectok;
  2567.                         itok4->post=ptr->recpost;
  2568.                         itok4->segm=ptr->recsegm;
  2569.                         itok4->flag|=ptr->flag;
  2570.                         itok4->size=ptr->recsize;
  2571.                         itok4->sib=ptr->recsib;
  2572.                         itok4->rec=ptr;
  2573.                         itok4->type=ptr->type;
  2574.                         itok4->npointr=ptr->npointr;
  2575. //                      if(debug)printf("Find: tok=%d\n",*tok4);
  2576.                         if(displaytokerrors){
  2577.                                 ptr->count++;
  2578. //                              printf("%s notdoneprestuff=%d tok=%d segm=%d\n",itok4->name,notdoneprestuff,*tok4,itok4->segm);
  2579.                                 if(notdoneprestuff==2&&*tok4==tk_proc&&itok4->segm==DYNAMIC)AddDynamicList(ptr);
  2580.                         }
  2581.                         if(*tok4==tk_macro){
  2582. //                                      printf("tok=%d %s %s\n",*tok4,itok4->name,input);
  2583.                                 if(dirmode==dm_if)return TRUE;
  2584.                                 if(scanlexmode==DEFLEX||scanlexmode==DEFLEX2)*tok4=tk_id;
  2585.                                 else if(displaytokerrors){
  2586.                                         NewMod(itok4->size);
  2587.                                         notdef=FALSE;
  2588.                                         cur_mod->declareparamdef=ptr->newid;
  2589.                                         input=(unsigned char*)(ptr->sbuf);
  2590.                                         inptr=1;
  2591.                                         cha=input[0];
  2592.                                         endinptr=strlen((char *)input);
  2593. //                                      if(debug)printf("New cur_mod tok=%d numpar=%d %s %s\n",*tok4,cur_mod->numparamdef,itok4->name,input);
  2594. //                                      debug=TRUE;
  2595.                                         clearregstat();
  2596.                                         *tok4=tk_endline;
  2597.                                         return TRUE;
  2598.                                 }
  2599.                         }
  2600.                         else if(ptr->newid){
  2601.                                 switch(*tok4){
  2602.                                         case tk_string:
  2603.                                                 memcpy((char *)string4,ptr->newid,itok4->number);
  2604.                                                 if(displaytokerrors&&itok4->rm==1&&ptr->sbuf)strcpy((char *)string3,ptr->sbuf);
  2605.                                                 break;
  2606.                                         case tk_structvar:
  2607.                                                 itok4->segm=0;
  2608.                                                 if(ptr->recpost==DYNAMIC_POST){
  2609.                                                         ptr->recpost=itok4->post=1;
  2610.                                                         if(alignword){  //¢ë஢­ïâì ­  ç¥â­ë©  ¤à¥á
  2611.                                                                 if(postsize%2==1)postsize++;
  2612.                                                         }
  2613.                                                         itok4->number=ptr->recnumber=postsize;
  2614.                                                         if(am32==FALSE&&(ptr->recsize+postsize)>0xFFFFL)tobigpost();
  2615.                                                         postsize+=ptr->recsize;
  2616.                                                 }
  2617.                                                 else if(ptr->recpost==DYNAMIC_VAR)itok4->post=ptr->recpost=USED_DIN_VAR;
  2618.                                                 return TRUE;
  2619.                                         case tk_proc:
  2620.                                         case tk_apiproc:
  2621.                                         case tk_declare:
  2622.                                         case tk_undefproc:
  2623.                                                 strcpy((char *)string4,ptr->newid);
  2624.                                                 break;
  2625.                                         default:
  2626.                                                 if(scanlexmode==DEFLEX2){
  2627.                                                         *tok4=tk_id;
  2628.                                                         return TRUE;
  2629.                                                 }
  2630.                                                 strcpy((char *)string4,ptr->newid);
  2631.                                                 if(strcmp((char *)string4,ptr->recid)!=0){       // see if ID has changed
  2632. //                                                      searchtree2(fptr,itok4,tok4,string4);  // search again
  2633.                                                         searchtree(itok4,tok4,string4);  // search again
  2634.                                                         switch(*tok4){
  2635.                                                                 case tk_proc:
  2636.                                                                 case tk_apiproc:
  2637.                                                                 case tk_declare:
  2638.                                                                 case tk_undefproc:
  2639.                                                                         strcpy(itok4->name,ptr->recid); //¨¬ï ­ã¦­® ¤«ï undefine
  2640.                                                                         break;
  2641.                                                                 default:
  2642.                                                                         strncpy(itok4->name,(char *)string4,IDLENGTH-1);        //¨¬ï ­ã¦­® ¤«ï undefine
  2643.                                                                         break;
  2644.                                                         }
  2645.                                                         return TRUE;
  2646.                                                 }
  2647.                                                 break;
  2648.                                 }
  2649.                         }
  2650.                         else string4[0]=0;
  2651.                         strcpy(itok4->name,ptr->recid); //¨¬ï ­ã¦­® ¤«ï undefine
  2652.                         if(displaytokerrors)ptr->count++;
  2653.                         break;
  2654.                 }
  2655.                 else if(cmpresult<0)ptr=ptr->left;
  2656.                 else ptr=ptr->right;
  2657.         }
  2658.         if(ptr==NULL)return FALSE;
  2659.         else return TRUE;
  2660. }
  2661.  
  2662. int searchtree(ITOK *itok4,int *tok4,unsigned char *string4)
  2663. {
  2664. int retval=FALSE;
  2665.         if(skipfind==FALSE){
  2666.                 if(staticlist)retval=searchtree2(staticlist,itok4,tok4,string4);
  2667.                 if(!retval)retval=searchtree2(treestart,itok4,tok4,string4);
  2668.                 if(!retval){
  2669.                         if((retval=searchtree2(definestart,itok4,tok4,string4))==TRUE){
  2670.                                 if(scanlexmode==DEFLEX2)*tok4=tk_id;
  2671.                         }
  2672.                 }
  2673.         }
  2674.         return retval;
  2675. }
  2676.  
  2677. void AddDynamicList(idrec *ptr)
  2678. {
  2679. //      printf("Add dinamic list %s %08X seg=%d tok=%d\n",ptr->recid,ptr,ptr->recsegm,ptr->rectok);
  2680.         if(DynamicList==NULL){
  2681.                 sizeDL=STEPDL;
  2682.                 DynamicList=(volatile idrec **)MALLOC(sizeof(idrec **)*sizeDL);
  2683.                 countDP=0;
  2684.         }
  2685.         else if(sizeDL==(countDP+1)){
  2686.                 sizeDL+=STEPDL;
  2687.                 DynamicList=(volatile idrec **)REALLOC(DynamicList,sizeof(idrec **)*sizeDL);
  2688.         }
  2689.         for(int i=0;i<countDP;i++)if(ptr==DynamicList[i])return;
  2690.         DynamicList[countDP]=ptr;
  2691.         countDP++;
  2692. }
  2693.  
  2694.  
  2695. void docals(struct idrec *ptr)
  2696. /* extract any procedures required from interal library and insert any
  2697.          dynamic procedures that have been called.*/
  2698. {
  2699.         if(ptr!=NULL){
  2700. //              printf("%s\n",ptr->recid);
  2701.                 tok=ptr->rectok;
  2702.                 if(sdp_mode==FALSE&&(ptr->flag&f_export)!=0&&tok==tk_proc){
  2703.                         if(lexport==NULL){
  2704.                                 lexport=(struct listexport *)MALLOC(sizeof(struct listexport));
  2705.                                 lexport->address=ptr->recnumber;
  2706.                                 strcpy(lexport->name,ptr->recid);
  2707.                                 numexport=1;
  2708.                         }
  2709.                         else{
  2710.                                 int cmpname,i;
  2711.                                 for(i=0;i<numexport;i++){
  2712.                                         if((cmpname=strcmp(ptr->recid,(lexport+i)->name))<=0)break;
  2713.                                 }
  2714.                                 if(cmpname!=0){
  2715.                                         lexport=(struct listexport *)REALLOC(lexport,sizeof(struct listexport)*(numexport+1));
  2716.                                         if(cmpname<0){
  2717.                                                 for(int j=numexport;j>i;j--){
  2718.                                                         memcpy(&(lexport+j)->address,&(lexport+j-1)->address,sizeof(struct listexport));
  2719.                                                 }
  2720.                                         }
  2721.                                         numexport++;
  2722.                                         (lexport+i)->address=ptr->recnumber;
  2723.                                         strcpy((lexport+i)->name,ptr->recid);
  2724.                                 }
  2725.                         }
  2726.                 }
  2727.                 if(!(ptr->flag&f_extern)){
  2728.                         if(tok==tk_undefproc){
  2729.                                 strcpy(itok.name,ptr->recid);
  2730.                                 if(sdp_mode){
  2731.                                         int boutptr=outptr;
  2732.                                         int i;
  2733.                                         if((ptr->flag&f_typeproc)==tp_fastcall){
  2734.                                                 if((i=includeit(1))!=-1){
  2735.                                                         if(updatecall((unsigned int)ptr->recnumber,boutptr,0)>0){
  2736.                                                                 ptr->rectok=tk_proc;
  2737.                                                                 ptr->recnumber=boutptr; // record location placed
  2738.                                                                 ptr->recrm=i;
  2739.                                                                 ptr->count++;
  2740.                                                         }
  2741.                                                 }
  2742.                                         }
  2743.                                         else{
  2744.                                                 if((i=includeproc())!=-1){
  2745.                                                         if(updatecall((unsigned int)ptr->recnumber,boutptr,0)>0){
  2746.                                                                 ptr->rectok=tk_proc;
  2747.                                                                 ptr->recnumber=boutptr; // record location placed
  2748.                                                                 ptr->recrm=i;
  2749.                                                                 ptr->count++;
  2750.                                                         }
  2751.                                                 }
  2752.                                         }
  2753.                                 }
  2754.                                 else{
  2755.                                         if(updatecall((unsigned int)ptr->recnumber,outptr,0)>0){
  2756.                                                 ptr->recnumber=outptr;  // record location placed
  2757.                                                 linenumber=ptr->line;
  2758.                                                 currentfileinfo=ptr->file;
  2759.                                                 if((ptr->flag&f_typeproc)==tp_fastcall){
  2760.                                                         if(includeit(1)==-1)thisundefined(itok.name);
  2761.                                                 }
  2762.                                                 else{
  2763.                                                         if(includeproc()==-1)thisundefined(itok.name);
  2764.                                                 }
  2765.                                                 ptr->rectok=tk_proc;
  2766.                                                 ptr->count++;
  2767.                                         }
  2768.                                 }
  2769.                         }
  2770.                         else if(tok==tk_proc){
  2771. //                              printf("%08X %s\n",ptr->recpost,ptr->recid);
  2772.                                 itok.segm=ptr->recsegm;
  2773.                                 if(itok.segm==DYNAMIC_USED){
  2774. //                              printf("%08X %s\n",ptr->recpost,ptr->recid);
  2775. //                                      if(updatecall((unsigned int)ptr->recnumber,outptr,0)>0){
  2776.                                         itok.number=ptr->recnumber;
  2777.                                         itok.flag=ptr->flag;
  2778.                                         itok.post=ptr->recpost;
  2779.                                         strcpy(itok.name,ptr->recid);
  2780.                                         if(ptr->newid==NULL)string[0]=0;
  2781.                                         else strcpy((char *)string,(char *)ptr->newid);
  2782.                                         itok.rm=ptr->recrm;
  2783.                                         itok.size=ptr->recsize;
  2784.                                         itok.rec=ptr;
  2785.                                         insert_dynamic();
  2786. //                                      }
  2787.                                 }
  2788.                         }
  2789. //                      else printf("tok=%d %s\n",tok,ptr->recid);
  2790.                 }
  2791.                 docals(ptr ->left);
  2792.                 docals(ptr ->right);
  2793.         }
  2794. }
  2795.  
  2796. void docalls2()
  2797. {
  2798. //      puts("start docalls2");
  2799.         docals(treestart);
  2800.         for(unsigned int i=0;i<totalmodule;i++)docals((startfileinfo+i)->stlist);
  2801. //      puts("end docalls2");
  2802. }
  2803.  
  2804. void docalls()  /* attempt to declare undefs from library and dynamic proc's */
  2805. {
  2806. int numdinproc;
  2807. //      puts("start docalls");
  2808.         notdoneprestuff=2;
  2809.         docalls2();
  2810.         while(DynamicList!=NULL){
  2811.                 idrec *ptr;
  2812.                 numdinproc=0;
  2813. //              printf("%d dinamic proc\n",countDP);
  2814.                 for(int i=0;i<countDP;i++){
  2815.                         ptr=(idrec *)DynamicList[i];
  2816.                         tok=ptr->rectok;
  2817.                         itok.segm=ptr->recsegm;
  2818. //                      printf("%d %08X seg=%d tok=%d %s\n",i+1,ptr,itok.segm,ptr->rectok,ptr->recid);
  2819.                         if(itok.segm==DYNAMIC_USED){
  2820.                                 itok.number=ptr->recnumber;
  2821.                                 itok.flag=ptr->flag;
  2822.                                 strcpy(itok.name,ptr->recid);
  2823.                                 if(ptr->newid==NULL)string[0]=0;
  2824.                                 else strcpy((char *)string,(char *)ptr->newid);
  2825.                                 itok.rm=ptr->recrm;
  2826.                                 itok.size=ptr->recsize;
  2827.                                 itok.rec=ptr;
  2828.                                 insert_dynamic();
  2829.                                 numdinproc++;
  2830.                         }
  2831.                 }
  2832.                 docalls2();
  2833.                 if(numdinproc==0)break;
  2834.         }
  2835.         free(DynamicList);
  2836.         DynamicList=NULL;
  2837.         countDP=0;
  2838. //      puts("end docalls");
  2839. }
  2840.  
  2841. void CreatParamDestr(idrec *ptrs)
  2842. {
  2843.         if(am32==FALSE){
  2844.                 structadr.rm=rm_d16;
  2845.                 structadr.sib=CODE16;
  2846.         }
  2847.         else{
  2848.                 structadr.rm=rm_d32;
  2849.                 structadr.sib=CODE32;
  2850.         }
  2851.         structadr.segm=DS;
  2852.         structadr.number=ptrs->recnumber;
  2853.         structadr.flag=0;
  2854.         structadr.size=0;       //addofs
  2855.         structadr.rec=NULL;
  2856.         structadr.type=tp_ucnovn;
  2857.         structadr.npointr=0;
  2858.         structadr.post=ptrs->recpost;
  2859.         if(ptrs->recsegm==USEDSTR)structadr.sib++;
  2860.         if(structadr.post==LOCAL){
  2861.                 if(ESPloc&&am32){
  2862.                         structadr.rm=rm_mod10|rm_sib;
  2863.                         structadr.sib=0x24;
  2864.                         structadr.number+=addESP;
  2865.                 }
  2866.                 else{
  2867.                         structadr.rm=rm_mod10|(am32==FALSE?rm_BP:rm_EBP);
  2868.                 }
  2869.                 structadr.segm=SS;
  2870.                 compressoffset(&structadr);
  2871.         }
  2872. }
  2873.  
  2874. void CallDestr(idrec *ptr)
  2875. {
  2876. int oinptr2;
  2877. char ocha2;
  2878. int oldendinptr=endinptr;
  2879. unsigned char odbg;
  2880. int otok,otok2;
  2881. unsigned char *oinput;
  2882. ITOK oitok;     //18.08.04 19:07
  2883.         oinptr2=inptr2;
  2884.         ocha2=cha2;
  2885.         odbg=dbg;
  2886.         dbg=0;
  2887.         otok=tok;
  2888.         otok2=tok2;
  2889.         oitok=itok;     //18.08.04 19:07
  2890.         oinput=input;
  2891.         string[0]=0;
  2892.         if(ptr->newid)strcpy((char *)string,ptr->newid);
  2893.         itok.type=ptr->type;
  2894.         itok.npointr=ptr->npointr;
  2895.         itok.rm=ptr->recrm;
  2896.         itok.flag=ptr->flag;
  2897.         itok.rec=ptr;
  2898.         strcpy(itok.name,ptr->recid);
  2899.         itok.number=ptr->recnumber;
  2900.         tok=ptr->rectok;
  2901.         itok.post=ptr->recpost;
  2902.         itok.segm=ptr->recsegm;
  2903.         itok.sib=ptr->recsib;
  2904.         ptr->count++;
  2905.         if(itok.segm==DYNAMIC)AddDynamicList(ptr);
  2906.         tok2=tk_openbracket;
  2907.         input=(unsigned char*)"();";
  2908.         inptr2=1;
  2909.         cha2='(';
  2910.         endinptr=3;
  2911.         docommand();
  2912.         tok=otok;
  2913.         input=oinput;
  2914.         inptr2=oinptr2;
  2915.         cha2=ocha2;
  2916.         tok2=otok2;
  2917.         endinptr=oldendinptr;
  2918.         dbg=odbg;
  2919.         itok=oitok;//18.08.04 19:07
  2920. }
  2921.  
  2922. elementteg *FindOneDestr(structteg *searcht)
  2923. {
  2924. elementteg *bazael=searcht->baza,*retrez=NULL;
  2925. idrec *ptrs;
  2926. int i;
  2927. /// new!
  2928.         for(i=0;i<searcht->numoper;i++){
  2929.                 ptrs=(bazael+i)->rec;
  2930.                 if((bazael+i)->tok==tk_proc&&(ptrs->flag&fs_destructor)!=0)return(bazael+i);
  2931.         }
  2932.         for(i=0;i<searcht->numoper;i++){
  2933.                 ptrs=(bazael+i)->rec;
  2934.                 if((bazael+i)->tok==tk_baseclass
  2935.                                 ||(bazael+i)->tok==tk_struct  //new 20.06.05 21:32
  2936.                                 ){
  2937.                         if((retrez=FindOneDestr((structteg *)ptrs))!=NULL)break;
  2938.                 }
  2939.         }
  2940.         return retrez;
  2941. }
  2942.  
  2943. void Destructor(idrec *ptrs)
  2944. {
  2945. char name[IDLENGTH];
  2946. struct elementteg *bazael;
  2947. int addofs;
  2948. structteg *tteg;
  2949.         tteg=(structteg *)ptrs->newid;
  2950.         sprintf(name,"%s~",tteg->name);
  2951.         if((bazael=FindClassEl(tteg,(unsigned char *)name,&addofs,NULL))==NULL){
  2952.                 if((bazael=FindOneDestr(tteg))==NULL)preerror("destructor not defined");
  2953.         }
  2954.         if(ptrs->recsize)CreatParamDestr(ptrs);
  2955.         else structadr.sib=THIS_ZEROSIZE;
  2956.         CallDestr(bazael->rec);
  2957. }
  2958.  
  2959. void RunNew(int size)
  2960. {
  2961. char buf[128];
  2962. int oinptr2;
  2963. char ocha2;
  2964. int oldendinptr=endinptr;
  2965. unsigned char odbg;
  2966. int otok,otok2;
  2967. unsigned char *oinput;
  2968. oinptr2=inptr2;
  2969. ocha2=cha2;
  2970. odbg=dbg;
  2971.         sprintf(buf,"__new(%u);}",size);
  2972.         dbg=0;
  2973.         otok=tok;
  2974.         otok2=tok2;
  2975.         oinput=input;
  2976.         input=(unsigned char*)buf;
  2977.         inptr2=1;
  2978.         cha2='_';
  2979.         tok=tk_openbrace;
  2980.         endinptr=strlen(buf);
  2981.         doblock();
  2982.         tok=otok;
  2983.         tok2=otok2;
  2984.         input=oinput;
  2985.         inptr2=oinptr2;
  2986.         cha2=ocha2;
  2987.         endinptr=oldendinptr;
  2988.         dbg=odbg;
  2989. }
  2990.  
  2991. void donew()
  2992. {
  2993. structteg *tteg;
  2994. elementteg *bazael;
  2995. int addofs=0;
  2996. struct idrec *ptr;
  2997.         nexttok();
  2998.         if((tteg=FindTeg(FALSE))==NULL&&(tteg=FindTeg(TRUE))==NULL){
  2999.                 tegnotfound();
  3000. er:
  3001.                 while(tok2!=tk_semicolon&&tok!=tk_eof)nexttok();
  3002.                 return;
  3003.         }
  3004. //      printf("flag=%08X\n",tteg->flag);
  3005.         if((tteg->flag&fs_constructor)==0){
  3006.                 RunNew(tteg->size);
  3007.                 goto er;
  3008.         }
  3009.         bazael=FindClassEl(tteg,(unsigned char *)tteg->name,&addofs,NULL);
  3010.         structadr.sib=THIS_NEW;
  3011.         structadr.number=tteg->size;
  3012.         ptr=bazael->rec;
  3013.         string[0]=0;
  3014.         if(ptr->newid!=NULL)strcpy((char *)string,ptr->newid);
  3015.         itok.type=ptr->type;
  3016.         itok.npointr=ptr->npointr;
  3017.         itok.rm=ptr->recrm;
  3018.         itok.flag=ptr->flag;
  3019.         itok.rec=ptr;
  3020.         strcpy(itok.name,ptr->recid);
  3021.         itok.number=ptr->recnumber;
  3022.         tok=ptr->rectok;
  3023.         itok.post=ptr->recpost;
  3024.         itok.segm=ptr->recsegm;
  3025.         itok.sib=ptr->recsib;
  3026.         ptr->count++;
  3027.         if(itok.segm==DYNAMIC)AddDynamicList(ptr);
  3028. //      docommand();
  3029.         if(dbg)AddLine();
  3030.         int oflag=current_proc_type;
  3031.         current_proc_type&=~f_static;
  3032.         if(tok==tk_proc)doanyproc();
  3033.         else doanyundefproc();
  3034.         current_proc_type=oflag;
  3035. }
  3036.  
  3037. void dodelete()
  3038. {
  3039. int addofs=0;
  3040. int oinptr,oinptr2;
  3041. char ocha2;
  3042. int oldendinptr=endinptr;
  3043. unsigned char odbg;
  3044. unsigned char *oinput;
  3045. structteg *tteg=NULL;
  3046. elementteg *bazael;
  3047. char buf[128];
  3048.         getoperand();
  3049.         if(tok==tk_structvar){
  3050.                 oinptr=tok2;
  3051. //              if((itok.flag&fs_useconstr)!=0){
  3052.                         if((itok.flag&fs_destructor)!=0){
  3053.                                 Destructor(itok.rec);
  3054.                         }
  3055.                         else if(itok.rec->newid&&AskUseDestr((structteg *)itok.rec->newid))Destructor(itok.rec);
  3056. //              }
  3057.                 if(oinptr!=tk_semicolon)nexttok();
  3058.         }
  3059.         else{
  3060.                 ITOK wtok;
  3061.                 char *wbuf;
  3062.                 wbuf=bufrm;
  3063.                 bufrm=NULL;
  3064.                 wtok=itok;
  3065.                 SINFO wstr;
  3066.                 wstr=strinf;
  3067.                 strinf.bufstr=NULL;
  3068.                 getinto_e_ax(0,tok,&wtok,wbuf,&wstr,(am32+1)*2);
  3069.                 bufrm=NULL;
  3070.                 strinf.bufstr=NULL;
  3071.                 if(tok2!=tk_semicolon){
  3072.                         nexttok();
  3073.                         if((tteg=FindTeg(FALSE))==NULL&&(tteg=FindTeg(TRUE))==NULL){
  3074.                                 tegnotfound();
  3075.                                 while(tok!=tk_semicolon&&tok!=tk_eof)nexttok();
  3076.                                 return;
  3077.                         }
  3078.                 }
  3079.                 oinptr2=inptr2;
  3080.                 ocha2=cha2;
  3081.                 odbg=dbg;
  3082.                 dbg=0;
  3083.                 oinput=input;
  3084.                 int oflag=current_proc_type;
  3085.                 current_proc_type&=~f_static;
  3086.                 if(tteg){
  3087.                         structadr.number=0;
  3088.                         if((tteg->flag&fs_destructor)!=0){
  3089.                                 op(0x50);
  3090.                                 addESP+=am32==FALSE?2:4;
  3091.                                 sprintf(buf,"%s~",tteg->name);
  3092.                                 bazael=FindClassEl(tteg,(unsigned char *)buf,&addofs,NULL);
  3093.  
  3094.                                 structadr.sib=THIS_REG;
  3095.                                 structadr.rm=AX;
  3096.                                 structadr.size=addofs;  // ???? 19.08.04 12:54 ­¨£¤¥ ­¥ ¨á¯®«ì§ã¥âáï
  3097.                                 CallDestr(bazael->rec);
  3098.                                 addESP-=am32==FALSE?2:4;
  3099.                                 op(0x58);
  3100.                         }
  3101.                         else if(AskUseDestr(tteg)){
  3102.                                 bazael=FindOneDestr(tteg);
  3103.                                 op(0x50);
  3104.                                 addESP+=am32==FALSE?2:4;
  3105.                                 structadr.sib=THIS_REG;
  3106.                                 structadr.rm=AX;
  3107.                                 structadr.size=0;//addofs;
  3108.                                 CallDestr(bazael->rec);
  3109.                                 addESP-=am32==FALSE?2:4;
  3110.                                 op(0x58);
  3111.                         }
  3112.                 }
  3113.                 input=(unsigned char*)"__delete((E)AX);}";
  3114.                 inptr2=1;
  3115.                 cha2='_';
  3116.                 endinptr=strlen((char *)input);
  3117.                 tok=tk_openbrace;
  3118.                 doblock();
  3119.                 input=oinput;
  3120.                 inptr2=oinptr2;
  3121.                 cha2=ocha2;
  3122.                 endinptr=oldendinptr;
  3123.                 dbg=odbg;
  3124.                 current_proc_type=oflag;
  3125.         }
  3126.         nextseminext();
  3127. }
  3128.  
  3129. int AskUseDestr(structteg *searcht)
  3130. {
  3131. elementteg *bazael=searcht->baza;
  3132.         if((searcht->flag&fs_destructor)!=0)return TRUE;
  3133.         for(int i=0;i<searcht->numoper;i++){
  3134. //              printf("tok=%d\n",(bazael+i)->tok);
  3135.                 if((bazael+i)->tok==tk_baseclass
  3136.                                 ||(bazael+i)->tok==tk_struct    //new 20.06.05 21:33
  3137.                                 ){
  3138.                         if(AskUseDestr((structteg *)(bazael+i)->rec))return TRUE;
  3139.                 }
  3140.         }
  3141.         return FALSE;
  3142. }
  3143.  
  3144. void AutoDestructor()
  3145. {
  3146. struct localrec *ptrs;
  3147. int calldestruct=FALSE;
  3148. int zerosize=FALSE;
  3149. treelocalrec *ftlr;
  3150.         for(ftlr=tlr;ftlr!=NULL;ftlr=ftlr->next){
  3151.                 for(ptrs=ftlr->lrec;ptrs!=NULL;ptrs=ptrs->rec.next){
  3152.                         if(ptrs->rec.rectok==tk_structvar){
  3153.                                 if((ptrs->rec.flag&fs_destructor)!=0||AskUseDestr((structteg *)ptrs->rec.newid)){
  3154.                                         if(!calldestruct){
  3155.                                                 calldestruct=TRUE;
  3156.                                                 if(ptrs->rec.recsize==0||returntype==tk_void)zerosize=TRUE;
  3157.                                                 else{
  3158.                                                         op66(r32);
  3159.                                                         op(0x50);
  3160.                                                         addESP+=4;
  3161.                                                 }
  3162.                                         }
  3163.                                         Destructor(&ptrs->rec);
  3164.                                 }
  3165.                         }
  3166.                 }
  3167.         }
  3168.         if(calldestruct&&zerosize==FALSE){
  3169.                 op66(r32);
  3170.                 op(0x58);
  3171.                 addESP-=4;
  3172.         }
  3173. }
  3174.  
  3175. elementteg *FindClassEl(structteg *searcht,unsigned char *string4,int *addofs,
  3176.         structteg *subteg)
  3177. {
  3178. struct elementteg *bazael=searcht->baza;
  3179. int numclass=0;
  3180. void **listclass;
  3181. //11.08.04 22:54
  3182. char name[IDLENGTH];
  3183.         strcpy(name,searcht->name);
  3184.  
  3185.         for(unsigned int i=0;i<searcht->numoper;i++){
  3186.                 if((bazael+i)->tok==tk_baseclass){
  3187.                         if(!numclass)listclass=(void **)MALLOC(sizeof(void **));
  3188.                         else listclass=(void **)REALLOC(listclass,sizeof(void **)*(numclass+1));
  3189.                         listclass[numclass]=(void *)(bazael+i)->nteg;
  3190.                         numclass++;
  3191.                         continue;
  3192.                 }
  3193.                 if(strcmp((bazael+i)->name,(char *)string4)==0){
  3194.                         if(subteg&&subteg!=searcht)continue;
  3195.                         if(numclass)free(listclass);
  3196. //11.08.04 22:54
  3197.                         strcpy((char *)string4,name);
  3198.  
  3199.                         return (bazael+i);
  3200.                 }
  3201.         }
  3202.         if(numclass){
  3203. structteg *ssubteg=subteg;
  3204.                 for(int i=numclass-1;i>=0;i--){
  3205.                         structteg *s=(structteg *)listclass[i];
  3206.                         if(subteg==searcht)ssubteg=s;
  3207.                         if((bazael=FindClassEl(s,string4,addofs,ssubteg))!=NULL){
  3208.                                 i--;
  3209.                                 while(i>=0){
  3210.                                         s=(structteg *)listclass[i];
  3211.                                         *addofs+=s->size;
  3212.                                         i--;
  3213.                                 }
  3214.                                 free(listclass);
  3215.                                 return bazael;
  3216.                         }
  3217.                 }
  3218.                 free(listclass);
  3219.         }
  3220.         return NULL;
  3221. }
  3222.  
  3223. int CallDestructor(structteg *searcht)
  3224. {
  3225. elementteg *bazael=searcht->baza;
  3226. idrec *ptrs;
  3227.         for(int i=0;i<searcht->numoper;i++){
  3228.                 ptrs=(bazael+i)->rec;
  3229.                 if((searcht->flag&fs_destructor)==0){
  3230.                         if((bazael+i)->tok==tk_baseclass){
  3231.                                 if(CallDestructor((structteg *)ptrs))return TRUE;
  3232.                         }
  3233.                 }
  3234.                 else if((bazael+i)->tok==tk_proc&&(ptrs->flag&fs_destructor)!=0){
  3235.                         structadr.sib=THIS_PARAM;
  3236.                         structadr.number=0;//addofs;
  3237.                         CallDestr(ptrs);
  3238.                         return TRUE;
  3239.                 }
  3240.         }
  3241.         return FALSE;
  3242. }
  3243.  
  3244. void CopyTok(int *tok4,ITOK *itok4,idrec *ptr)
  3245. {
  3246.         itok4->number=ptr->recnumber;
  3247.         itok4->rm=ptr->recrm;
  3248.         *tok4=ptr->rectok;
  3249.         itok4->post=ptr->recpost;
  3250.         itok4->segm=ptr->recsegm;
  3251.         itok4->flag=ptr->flag;
  3252.         itok4->size=ptr->recsize;
  3253.         itok4->sib=ptr->recsib;
  3254.         itok4->rec=ptr;
  3255.         itok4->type=ptr->type;
  3256.         itok4->npointr=ptr->npointr;
  3257. }
  3258.  
  3259. int searchlocals(ITOK *itok4,int *tok4,unsigned char *string4)
  3260. //¯®¨áª «®ª «ì­ëå ¯¥à¥¬¥­ëå á¢ï§ ­®£® ᯨ᪠
  3261. {
  3262.         if(skiplocals){
  3263.                 skiplocals=FALSE;
  3264.                 return FALSE;
  3265.         }
  3266.         if(skipfind==LOCAL)return FALSE;
  3267. treelocalrec *ftlr;
  3268. struct localrec *ptr;
  3269.         for(ftlr=tlr;ftlr!=NULL;ftlr=ftlr->next){
  3270.                 for(ptr=ftlr->lrec;ptr!=NULL;ptr=ptr->rec.next){
  3271. //                      puts(ptr->rec.recid);
  3272.                         if(strcmp(ptr->rec.recid,(char *)string4)==0){
  3273.                                 itok4->number=ptr->rec.recnumber;
  3274.                                 *tok4=ptr->rec.rectok;
  3275.                                 itok4->locrec=ptr;
  3276.                                 if(displaytokerrors){
  3277.                                         if(mapfile){
  3278.                                                 if(ptr->li.count==0)ptr->li.usedfirst=linenumber;
  3279.                                                 else ptr->li.usedlast=linenumber;
  3280.                                                 ptr->li.count++;
  3281.                                         }
  3282.                                         if(*tok4==tk_structvar)ptr->rec.count++;
  3283.                                 }
  3284. //                              printf("type=%d num=%08X %s\n",ptr->rec.type,ptr->rec.recnumber,ptr->rec.recid);
  3285.                                 if(ptr->rec.type==tp_postvar){
  3286.                                         itok4->segm=DS;
  3287.                                         itok4->flag=ptr->rec.flag;
  3288.                                         itok4->size=ptr->rec.recsize;
  3289.                                         itok4->rm=(am32==FALSE?rm_d16:rm_d32);
  3290.                                         itok4->npointr=ptr->rec.npointr;
  3291.                                         itok4->type=tp_localvar;
  3292.                                         itok4->post=1;
  3293.                                         if(*tok4==tk_structvar){
  3294.                                                 itok4->rec=&ptr->rec;
  3295.                                                 itok4->post=ptr->rec.recpost;
  3296. //                                              itok4->segm=0;
  3297.                                         }
  3298.                                         return TRUE;
  3299.                                 }
  3300.                                 if(ptr->rec.type==tp_gvar){
  3301.                                         itok4->number=0;
  3302.                                         itok4->rm=(am32==FALSE?rm_d16:rm_d32);
  3303.                                         itok4->segm=DS;
  3304.                                         itok4->size=ptr->rec.recsize;
  3305.                                         itok4->npointr=ptr->rec.npointr;
  3306.                                         itok4->type=ptr->rec.recsib;    //????01.09.05 15:58
  3307.                                         itok4->post=USED_DIN_VAR;
  3308.                                         if(ptr->rec.recpost==DYNAMIC_VAR)ptr->rec.recpost=USED_DIN_VAR;
  3309.                                         itok4->rec=&ptr->rec;
  3310.                                         ptr->fuse=USEDVAR;
  3311.                                         if(*tok4==tk_structvar){
  3312.                                                 itok4->number=ptr->rec.recnumber;
  3313.                                                 itok4->flag|=ptr->rec.flag;
  3314.                                         }
  3315.                                         return TRUE;
  3316.                                 }
  3317.                                 itok4->type=ptr->rec.type;
  3318.                                 if(ptr->rec.type==tp_paramvar||ptr->rec.type==tp_localvar){
  3319.                                         if(ESPloc&&am32){
  3320.                                                 itok4->rm=rm_mod10|rm_sib;
  3321.                                                 itok4->sib=0x24;
  3322.                                                 if(ptr->rec.type==tp_paramvar)itok4->number+=localsize+addESP;
  3323.                                                 else itok4->number+=-4+addESP;
  3324.                                         }
  3325.                                         else itok4->rm=rm_mod10|(am32==FALSE?rm_BP:rm_EBP);
  3326.                                         itok4->segm=SS;
  3327.                                         itok4->npointr=ptr->rec.npointr;
  3328.                                         if(ptr->rec.npointr){
  3329.                                                 itok4->type=(unsigned short)*tok4-tk_charvar+tk_char;
  3330.                                                 *tok4=tk_pointer;
  3331.                                         }
  3332.                                         if(*tok4==tk_structvar){
  3333.                                                 itok4->rec=&ptr->rec;
  3334.                                                 itok4->post=ptr->rec.recpost;
  3335.                                                 itok4->segm=0;
  3336.                                         }
  3337.                                 }
  3338.                                 else if(!(ptr->rec.rectok==tk_locallabel||ptr->rec.rectok==tk_number)){
  3339.                                         internalerror("Bad *tok4 value in searchlocals");
  3340.                                 }
  3341.                                 itok4->size=ptr->rec.recsize;
  3342.                                 itok4->flag=ptr->rec.flag;
  3343.                                 return TRUE;
  3344.                         }
  3345.                 }
  3346.         }
  3347.         if(searchteg){
  3348. struct elementteg *bazael;
  3349. int addofs=0;
  3350. structteg *subteg=NULL;
  3351.                 if(cha==':'&&cha2==':'){
  3352.                         nextchar();
  3353.                         nextchar();
  3354.                         if((subteg=FindTeg(TRUE,itok4->name))==NULL&&displaytokerrors)undefclass(itok4->name);
  3355.                         tokscan(tok4,itok4,string4);
  3356.                         whitespace();
  3357.                 }
  3358.                 if(destructor){
  3359.                         destructor=FALSE;
  3360.                         strcat((char *)string4,"~");
  3361.                 }
  3362.                 if((bazael=FindClassEl(searchteg,string4,&addofs,subteg))!=NULL){
  3363.                         *tok4=bazael->tok;
  3364.                         itok4->type=tp_classvar;
  3365. //                      printf("tok=%d bazael->rec=%08X %s\n",*tok4,bazael->rec,itok4->name);
  3366.                         if(*tok4==tk_proc||*tok4==tk_pointer){
  3367.                                 idrec *ptr=bazael->rec;
  3368.                                 if(strchr(itok4->name,'@')==NULL){
  3369.                                         strcat(itok4->name,"@");
  3370.                                         strcat(itok4->name,(char *)string4);
  3371.                                 }
  3372. //                              }
  3373. //                      printf("tok=%d %s %s\n",*tok4,ptr->recid,ptr->newid);
  3374.                                 if(*tok4==tk_proc&&ptr->newid!=NULL)strcpy((char *)string4,ptr->newid);
  3375.                                 CopyTok(tok4,itok4,bazael->rec);
  3376.                                 structadr.sib=THIS_PARAM;
  3377.                                 structadr.number=0;//addofs;
  3378.                                 if(displaytokerrors){
  3379.                                         ptr->count++;
  3380.                                         if(*tok4==tk_proc){
  3381.                                                 if(itok4->segm==DYNAMIC)AddDynamicList(ptr);
  3382.                                         }
  3383.                                 }
  3384.                                 if(*tok4==tk_pointer)goto locvar;
  3385.                         }
  3386.                         else if(*tok4==tk_struct){
  3387.                                 *tok4=tk_structvar;
  3388. //                              printf("teg=%08X\n",bazael->nteg);
  3389.                                 dostructvar2(tok4,itok4,(structteg *)bazael->nteg,string4);
  3390.                                 if(*tok4==tk_structvar){
  3391.                                         itok4->rec=(idrec *)bazael->nteg;
  3392.                                         itok4->number+=(itok4->post==0?0:itok4->rm*((structteg *)bazael->nteg)->size);
  3393.                                         itok4->size=(itok4->post==0?bazael->numel:1)*((structteg *)bazael->nteg)->size;
  3394.  
  3395.                                         itok4->number+=bazael->ofs+addofs;
  3396.                                         if(displaytokerrors){
  3397.                                                 if(strinf.bufstr!=NULL)free(strinf.bufstr);
  3398.                                                 strinf.bufstr=(char *)MALLOC(7);
  3399.                                                 strcpy(strinf.bufstr,"&this;");
  3400.                                                 strinf.size=1;
  3401.                                         }
  3402. //                                      itok4->flag|=f_useidx;
  3403. //                                      if(itok4->sib>=CODE16)itok4->sib++;
  3404.                                         return TRUE;
  3405.  
  3406.                                 }
  3407.                                 else if(*tok4==tk_proc){
  3408.                                         structadr.sib=THIS_PARAM;
  3409.                                         structadr.number+=bazael->ofs+addofs;
  3410.  
  3411.                                         if(itok4->sib>=CODE16)itok4->sib++;
  3412.                                         return TRUE;
  3413.                                 }
  3414.  
  3415.                                 goto locvar;;
  3416.                         }
  3417.                         else{
  3418.                                 if(bazael->rec){        //static var
  3419.                                         CopyTok(tok4,itok4,bazael->rec);
  3420.                                         return TRUE;
  3421.                                 }
  3422.  
  3423. locvar:
  3424.                                 itok4->number+=bazael->ofs+addofs;
  3425.                                 if(displaytokerrors){
  3426.                                         if(bufrm!=NULL)free(bufrm);
  3427.                                         bufrm=(char *)MALLOC(7);
  3428.                                         strcpy(bufrm,"&this;");
  3429.                                 }
  3430. //                              itok4->flag|=f_useidx;
  3431.                                 if(itok4->sib>=CODE16)itok4->sib++;
  3432. //                      printf("sib=%08X tok=%d rm=%d post=%d number=%d size=%d %s\n",itok4->sib,*tok4,itok4->rm,itok4->post,itok4->number,itok4->size,string4);
  3433.                         }
  3434.                         return TRUE;
  3435.                 }
  3436.         }
  3437.         return FALSE;
  3438. }
  3439.  
  3440. void dostructvar2(int *tok4,ITOK *itok4,struct structteg *tteg,unsigned char *string4)  //à §¡®à áâàãªâãà ­  ¯¥à¥¬¥­­ë¥ ¨ áâàãªâãàë
  3441. {
  3442. struct elementteg *bazael;
  3443. int numel=0;
  3444. int usenumstruct=FALSE;
  3445. int sopenb;
  3446. long cnum;
  3447. ITOK cstok;
  3448. char *cstring;
  3449. char c=0;
  3450. int i;
  3451. structteg *subteg=NULL;
  3452.         structadr=*itok4;
  3453. //      bazael=tteg->baza;
  3454.         whitespace();//¯à®¯ã᪠­¥§­ ç é¨å ᨬ¢®«®¢
  3455.         cstring=(char *)MALLOC(STRLEN);
  3456.         if(cha=='['){   //[     ­®¬¥à áâàãªâãàë
  3457.                 usenumstruct=TRUE;
  3458.                 nextchar();
  3459.                 sopenb=inptr;
  3460.                 unsigned char bcha=cha;
  3461.                 tokscan(&i,&cstok,(unsigned char *)cstring);
  3462.                 if(bufrm){
  3463.                         free(bufrm);
  3464.                         bufrm=NULL;
  3465.                 }
  3466.                 if(i==tk_number){       //ç¨á«®¢®©
  3467.                         ITOK dstok;
  3468.                         memcpy(&dstok,itok4,sizeof(ITOK));
  3469.                         calcnum(&i,&cstok,cstring,&cnum);
  3470.                         memcpy(itok4,&dstok,sizeof(ITOK));
  3471.                         if(i!=tk_closeblock)goto notnum;
  3472.                         numel=cnum;
  3473.                 }
  3474.                 else{
  3475. notnum:
  3476. //new!!!
  3477.                         if(displaytokerrors){
  3478.                                 if(itok4->segm==USEDSTR)preerror("only once possible use variable an index structure");
  3479.  
  3480. //                              if(itok4->segm==USEDSTR&&displaytokerrors)preerror("only once possible use variable an index structure");
  3481.                                 itok4->segm=USEDSTR;
  3482.                                 SRBackBuf(0);
  3483.                                 AddBackBuf(sopenb,bcha);
  3484.                                 CharToBackBuf(';');
  3485.                                 CharToBackBuf(0);
  3486.                                 if(cha!=']')blockerror();
  3487.                                 if(strinf.bufstr!=NULL)free(strinf.bufstr);//internalerror("Previous block was not used");
  3488.                                 strinf.bufstr=(char *)REALLOC(BackTextBlock,SizeBackBuf+1);
  3489.                                 SRBackBuf(1);
  3490.                                 nextchar();
  3491. //new!!!
  3492.                         }
  3493.                         else{
  3494.                                 do{
  3495.                                         tokscan(&i,&cstok,(unsigned char *)cstring);
  3496.                                         if(i==tk_eof)break;
  3497.                                 }while(i!=tk_closeblock);
  3498.                         }
  3499.  
  3500.                         c=1;
  3501.                         strinf.size=tteg->size;
  3502.                 }
  3503.                 itok4->flag|=f_useidx;
  3504.                 whitespace();//¯à®¯ã᪠­¥§­ ç é¨å ᨬ¢®«®¢
  3505.         }
  3506.         if(cha=='.'){
  3507.                 int fdestr=FALSE;
  3508.                 nextchar();
  3509.                 if(cha=='~'){
  3510.                         nextchar();
  3511.                         fdestr=TRUE;
  3512.                 }
  3513.                 skipfind=LOCAL;
  3514.                 do{
  3515.                         tokscan(&i,&cstok,(unsigned char *)cstring);
  3516. //                      puts(cstok.name);
  3517.                         if(cha=='.')searchtree2(definestart,&cstok,&i,(unsigned char *)cstring);
  3518.                 }while(i==tk_endline);
  3519.                 whitespace();
  3520.                 if(cha==':'){
  3521.                         nextchar();
  3522.                         if(cha!=':')expectederror("::");
  3523.                         nextchar();
  3524.                         if((subteg=FindTeg(TRUE,cstok.name))==NULL&&displaytokerrors)undefclass(cstok.name);
  3525.                         tokscan(&i,&cstok,(unsigned char *)cstring);
  3526.                         whitespace();
  3527.                 }
  3528.                 skipfind=FALSE;
  3529.                 int addofs=0;
  3530.                 if(fdestr)strcat(cstok.name,"~");
  3531.                 if((bazael=FindClassEl(tteg,(unsigned char *)cstok.name,&addofs,subteg))==NULL){
  3532.                         if(displaytokerrors)unknownstruct(cstok.name,tteg->name);
  3533.                         *tok4=tk_number;
  3534.                         free(cstring);
  3535.                         return;
  3536.                 }
  3537.                 free(cstring);
  3538.                 *tok4=bazael->tok;
  3539.                 itok4->size=bazael->numel*GetVarSize(*tok4);
  3540.                 cnum=(c==0?tteg->size*numel:0);
  3541.                 if((itok4->flag&f_extern)!=0)itok4->number+=((bazael->ofs+cnum)<<16);
  3542.                 else itok4->number+=bazael->ofs+cnum;
  3543.                 if(*tok4==tk_struct){
  3544.                         *tok4=tk_structvar;
  3545.                         itok4->size=bazael->numel*((structteg *)bazael->nteg)->size;
  3546.                         dostructvar2(tok4,itok4,(structteg *)bazael->nteg,string4);
  3547.                         return;
  3548.                 }
  3549.                 if((itok4->flag&f_extern)!=0)itok4->number+=addofs<<16;
  3550.                 else itok4->number+=addofs;
  3551. //              printf("tok=%d %s\n",*tok4,bufrm);
  3552.                 if(*tok4==tk_proc||*tok4==tk_pointer){
  3553.                         idrec *ptr;//=NULL;
  3554.                         if(*tok4==tk_proc){
  3555.                                 if(am32==FALSE){
  3556.                                         structadr.rm=rm_d16;
  3557.                                         structadr.sib=CODE16;
  3558.                                 }
  3559.                                 else{
  3560.                                         structadr.rm=rm_d32;
  3561.                                         structadr.sib=CODE32;
  3562.                                 }
  3563.                                 structadr.segm=DS;
  3564.                                 structadr.number=itok4->number;
  3565. //                              structadr.number=0;
  3566.                                 structadr.flag=0;
  3567.                                 structadr.size=addofs;
  3568.                                 structadr.type=tp_ucnovn;
  3569.                                 structadr.npointr=0;
  3570.                                 structadr.post=itok4->post;
  3571.                                 structadr.rec=(structadr.post==USED_DIN_VAR?itok4->rec:NULL);
  3572.                                 if(itok4->segm==USEDSTR)structadr.sib++;
  3573.                                 if(structadr.post==LOCAL){
  3574.                                         if(ESPloc&&am32){
  3575.                                                 structadr.rm=rm_mod10|rm_sib;
  3576.                                                 structadr.sib=0x24;     //???
  3577.                                                 structadr.number+=addESP;
  3578.                                         }
  3579.                                         else{
  3580.                                                 structadr.rm=rm_mod10|(am32==FALSE?rm_BP:rm_EBP);
  3581.                                         }
  3582.                                         structadr.segm=SS;
  3583.                                         compressoffset(&structadr);
  3584.                                         if(tteg->size==0)structadr.sib=THIS_ZEROSIZE;   //14.11.05 13:51
  3585.                                 }
  3586. /*                              if(strcmp(bazael->name,tteg->name)==0&&itok4->rec){     //¢ë§®¢ ª®­áâàãªâ®à 
  3587.                                         ptr=itok4->rec;
  3588. //                                      printf("constructor %08X\n",ptr);
  3589.                                 }*/
  3590.                         }
  3591. //                      if(ptr)printf("new address constructor %08X\n",bazael->rec);
  3592.                         ptr=bazael->rec;
  3593.                         itok4->type=ptr->type;
  3594.                         itok4->npointr=ptr->npointr;
  3595.                         itok4->rm=ptr->recrm;
  3596.                         itok4->flag=ptr->flag;
  3597.                         itok4->rec=ptr;
  3598.                         strcpy(itok4->name,ptr->recid);
  3599.                         if(*tok4==tk_pointer){
  3600. //                              puts("Check this code");
  3601.                                 string4[0]=0;
  3602.                                 if(ptr->newid!=NULL)strcpy((char *)string4,ptr->newid);
  3603.                                 *tok4=ptr->rectok;
  3604. //!!!
  3605.                                 if(itok4->type==tk_proc&&cha!='('){
  3606.                                         itok4->type=(am32==FALSE?tk_wordvar:tk_dwordvar);
  3607.                                         goto notbit;
  3608.                                 }
  3609.  
  3610.                                 if(itok4->type!=tk_proc)goto notbit;
  3611. //                              printf("post=%08X %s\n",itok4->post,itok4->name);
  3612.                                 if(itok4->post==LOCAL){
  3613.                                         if(ESPloc&&am32){
  3614.                                                 itok4->rm=rm_mod10|rm_sib;
  3615.                                                 itok4->sib=0x24;
  3616.                                                 itok4->number+=addESP;
  3617.                                         }
  3618.                                         else{
  3619.                                                 itok4->sib=rm_mod10|(am32==FALSE?rm_BP:rm_EBP); //???rm
  3620.                                         }
  3621.                                         itok4->segm=SS;
  3622.                                         itok4->post=FALSE;
  3623.                                 }
  3624.                                 else{
  3625.                                         itok4->sib=(am32==FALSE?rm_d16:rm_d32); //ãáâ ­®¢ª¨ ¯® 㬮«ç ­¨î
  3626.                                         itok4->segm=DS;
  3627.                                 }
  3628. //                              itok4->post=0;
  3629.                                 itok4->flag|=f_useidx;
  3630.                                 return;
  3631.                         }
  3632.                         itok4->number=ptr->recnumber;
  3633.                         *tok4=ptr->rectok;
  3634.                         itok4->post=ptr->recpost;
  3635.                         itok4->segm=ptr->recsegm;
  3636.                         itok4->sib=ptr->recsib;
  3637.                         itok4->size=ptr->recsize;       //11.08.04 00:24
  3638. //11.09.04 00:28
  3639.                         if(strchr(itok4->name,'@')==NULL){
  3640.                                 strcat(itok4->name,"@");
  3641.                                 strcat(itok4->name,(char *)string4);
  3642.                         }
  3643.                         string4[0]=0;
  3644.                         if(ptr->newid!=NULL)strcpy((char *)string4,ptr->newid);
  3645. ////////////////////
  3646.  
  3647. //                      printf("tok=%d num=%d %s\n",*tok4,itok4->number,itok4->name);
  3648.                         if(displaytokerrors){
  3649.                                 ptr->count++;
  3650.                                 if(*tok4==tk_proc&&itok4->segm==DYNAMIC)AddDynamicList(ptr);
  3651.                                 if(*tok4!=tk_proc&&*tok4!=tk_undefproc&&*tok4!=tk_declare)thisundefined(ptr->recid,FALSE);
  3652.                         }
  3653.                         return;
  3654.                 }
  3655. //              if((itok4->flag&f_extern)!=0)itok4->number+=addofs;
  3656. //              else itok4->number+=addofs;
  3657.                 if(*tok4==tk_bits){
  3658.                         itok4->flag|=f_useidx;
  3659.                         itok4->number+=bazael->bit.ofs/8;
  3660.                         if((bazael->bit.ofs%8)==0){
  3661.                                 switch(bazael->bit.siz){
  3662.                                         case 8:
  3663.                                                 *tok4=tk_bytevar;
  3664.                                                 goto notbit;
  3665.                                         case 16:
  3666.                                                 *tok4=tk_wordvar;
  3667.                                                 goto notbit;
  3668.                                         case 32:
  3669.                                                 *tok4=tk_dwordvar;
  3670.                                                 goto notbit;
  3671.                                 }
  3672.                         }
  3673.                         itok4->bit.siz=bazael->bit.siz;
  3674.                         itok4->bit.ofs=bazael->bit.ofs%8;
  3675.                 }
  3676.                 else if(bazael->rec){   //static var
  3677.                         CopyTok(tok4,itok4,bazael->rec);
  3678.                         return;
  3679.                 }
  3680. notbit:
  3681.                 itok4->sib=cstok.sib;
  3682.                 if(itok4->post==LOCAL){
  3683.                         if(ESPloc&&am32){
  3684.                                 itok4->rm=rm_mod10|rm_sib;
  3685. //                              printf("sib=%x tok=%d name=%s\n",itok4->sib,*tok4,itok4->name);
  3686.                                 itok4->sib=0x24;
  3687.                                 itok4->number+=addESP;
  3688.                         }
  3689.                         else{
  3690.                                 itok4->rm=rm_mod10|(am32==FALSE?rm_BP:rm_EBP);
  3691.                                 if(itok4->segm==USEDSTR&&itok4->sib>=CODE16)itok4->sib++;
  3692.                         }
  3693.                         itok4->segm=SS;
  3694.                         itok4->post=FALSE;
  3695.                         itok4->flag=f_useidx;
  3696.                 }
  3697.                 else{
  3698.                         itok4->rm=(am32==FALSE?rm_d16:rm_d32);  //ãáâ ­®¢ª¨ ¯® 㬮«ç ­¨î
  3699.                         if(itok4->segm==USEDSTR&&itok4->sib>=CODE16)itok4->sib++;
  3700.                         itok4->segm=DS;
  3701.                         itok4->flag=FixUp|f_useidx;
  3702.                 }
  3703.                 return;
  3704.         }
  3705. //      itok4->size=(numel==0?bazael->numel:1)*((structteg *)bazael->nteg)->size;
  3706. //      itok4->rec=(idrec *)tteg;
  3707.         itok4->rm=numel;
  3708.         itok4->post=usenumstruct;
  3709.         free(cstring);
  3710. }
  3711.  
  3712. void dosizeof(ITOK *itok4)      //®¯à §­ ç¥­¨¥ sizeof
  3713. {
  3714. struct structteg *tteg;
  3715. int i,brase=FALSE;
  3716. ITOK cstok;
  3717.         whitespace();//¯à®¯ã᪠­¥§­ ç é¨å ᨬ¢®«®¢
  3718.         itok4->number=0;
  3719.         if(cha=='('){
  3720.                 nextchar();
  3721.                 brase=TRUE;
  3722.         }
  3723. //      if((cha!='(')&&(displaytokerrors))expected('(');
  3724. //      nextchar();
  3725.         cstok.name[0]=0;
  3726. //      if(displaytokerrors)puts("start sizeof");
  3727.         tokscan(&i,&cstok,string2);
  3728. //      if(displaytokerrors)printf("tok=%d findoffset=%d %s\n",i,findofset,cstok.name);
  3729.         if(i==tk_dblcolon&&numblocks){
  3730.                 skiplocals=TRUE;
  3731.                 tokscan(&i,&cstok,string2);
  3732.         }
  3733.         if(strcmp(cstok.name,"__CODESIZE")==0){
  3734.                 itok4->post=CODE_SIZE+am32;
  3735.         }
  3736.         else if(strcmp(cstok.name,"__DATASIZE")==0){
  3737.                 itok4->post=DATA_SIZE+am32;
  3738.         }
  3739.         else if(strcmp(cstok.name,"__POSTSIZE")==0){
  3740.                 itok4->post=POST_SIZE+am32;
  3741.         }
  3742.         else if(strcmp(cstok.name,"__STACKSIZE")==0){
  3743.                 itok4->post=STACK_SIZE+am32;
  3744.         }
  3745.         else{
  3746.                 switch(i){
  3747.                         case tk_char:
  3748.                         case tk_byte:
  3749.                         case tk_beg:
  3750.                                 itok4->number=1;
  3751.                                 break;
  3752.                         case tk_int:
  3753.                         case tk_word:
  3754.                         case tk_reg:
  3755.                         case tk_seg:
  3756.                                 itok4->number=2;
  3757.                                 break;
  3758.                         case tk_float:
  3759.                         case tk_reg32:
  3760.                         case tk_long:
  3761.                         case tk_dword:
  3762.                                 itok4->number=4;
  3763.                                 break;
  3764.                         case tk_double:
  3765.                         case tk_qword:
  3766.                                 itok4->number=8;
  3767.                                 break;
  3768.                         case tk_string:
  3769.                                 itok4->number=cstok.number;
  3770.                                 if(/*itok4->*/cstok.flag!=no_term)itok4->number++;
  3771.                                 break;
  3772.                         case tk_bits:
  3773.                                 itok4->number=cstok.bit.siz;
  3774.                                 break;
  3775.                         case tk_proc:
  3776.                         case tk_charvar:
  3777.                         case tk_bytevar:
  3778.                         case tk_intvar:
  3779.                         case tk_wordvar:
  3780.                         case tk_longvar:
  3781.                         case tk_dwordvar:
  3782.                         case tk_floatvar:
  3783.                         case tk_structvar:
  3784.                         case tk_qwordvar:
  3785.                         case tk_doublevar:
  3786.                         case tk_interruptproc:
  3787.                                 if(cstok.size==0)if(displaytokerrors)preerror("unknown size");
  3788.                                 itok4->number=cstok.size;
  3789.                                 break;
  3790.                         default:
  3791.                                 if((tteg=FindTeg(FALSE,cstok.name))!=NULL||(tteg=FindTeg(TRUE,cstok.name))!=NULL){
  3792.                                         if(cha=='.'){
  3793.                                                 dostructvar2(&i,itok4,tteg,string2);
  3794.                                                 itok4->number=itok4->size;
  3795.                                                 if(bufrm){
  3796.                                                         free(bufrm);
  3797.                                                         bufrm=NULL;
  3798.                                                 }
  3799.                                         }
  3800.                                         else itok4->number=tteg->size;
  3801.                                         itok4->flag=0;
  3802.                                         break;
  3803.                                 }
  3804.                                 if(strcmp("file",(char *)string2)==0){
  3805.                                         displaytokerrors=1;
  3806.                                         tokscan(&i,&cstok,string2);
  3807.                                         if(i==tk_string){
  3808.                                                 struct stat statbuf;
  3809.                                                 if(stat((char *)string3,&statbuf)!=0)unableopenfile((char *)string3);
  3810.                                                 else itok4->number=statbuf.st_size;
  3811.                                         }
  3812.                                         else stringexpected();
  3813.                                 }
  3814.                                 else if(displaytokerrors)preerror("illegal use of sizeof");
  3815.                                 break;
  3816.                 }
  3817.         }
  3818.         whitespace();//¯à®¯ã᪠­¥§­ ç é¨å ᨬ¢®«®¢
  3819.         if(brase){
  3820.                 if(cha!=')'&&displaytokerrors)expected(')');
  3821.                 nextchar();
  3822.         }
  3823. }
  3824.  
  3825. void ofsstr(int *tok4,ITOK *itok4)
  3826. {
  3827. struct structteg *tteg;
  3828. int newreg=(idxregs[4]==255?idxregs[0]:idxregs[4]);     //14.06.06 20:06
  3829. int poststr;
  3830. int flagstr;
  3831.         if(itok4->type==tp_classvar){
  3832.                 tteg=(structteg *)itok4->rec;
  3833.                 poststr=0;
  3834.                 flagstr=f_useidx;
  3835.         }
  3836.         else{
  3837. struct idrec *ptrs;
  3838.                 ptrs=itok4->rec;
  3839.                 tteg=(structteg *)ptrs->newid;
  3840.                 poststr=ptrs->recpost;
  3841.                 flagstr=ptrs->flag;
  3842.         }
  3843.         if(tteg==NULL){
  3844.                 if(displaytokerrors){
  3845.                         unknowntagstruct(itok4->name);
  3846.                 }
  3847.                 return;
  3848.         }
  3849.         if(strinf.bufstr==NULL&&itok4->post==TRUE)itok4->number+=(tteg->size*(itok4->rm));
  3850.         itok4->size=tteg->size;
  3851.         itok4->sib=(am32==FALSE?CODE16:CODE32);
  3852.         char ocha=cha;
  3853.         int binptr=inptr;
  3854.         if(poststr==LOCAL){
  3855.                 itok4->rm=rm_mod10;
  3856.                 if(strinf.bufstr==NULL){
  3857.                         if(ESPloc&&am32){
  3858.                                 itok4->rm|=rm_sib;
  3859.                                 itok4->sib=0x24;
  3860.                         }
  3861.                         else{
  3862.                                 itok4->rm|=(am32==FALSE?rm_BP:rm_EBP);
  3863.                         }
  3864.                 }
  3865.                 else{
  3866.                         if(displaytokerrors){
  3867.                                 if((newreg=CheckIDXReg(strinf.bufstr,strinf.size,idxregs[0]))!=NOINREG){
  3868.                                         if(newreg==SKIPREG){
  3869.                                                 newreg=idxregs[0];
  3870.                                         }
  3871.                                         else{
  3872.                                                 if(am32==FALSE&&newreg!=DI)goto noopt1;
  3873.                                                 waralreadinitreg(regs[am32][idxregs[0]],regs[am32][newreg]);
  3874.                                         }
  3875.                                         free(strinf.bufstr);
  3876.                                         strinf.bufstr=NULL;
  3877.                                         goto cont1;
  3878.                                 }
  3879.                                 newreg=idxregs[0];
  3880. noopt1:
  3881.                                 CheckMassiv(strinf.bufstr,strinf.size,idxregs[0]);
  3882. cont1: ;
  3883.                         }
  3884.                         if(am32==FALSE)itok4->rm|=CalcRm16(BP,newreg);
  3885.                         else{
  3886.                                 itok4->sib=(newreg<<3)+(ESPloc?ESP:EBP);
  3887.                                 itok4->rm=4|rm_mod10;
  3888.                         }
  3889.                 }
  3890.                 itok4->segm=SS;
  3891.                 if(ESPloc&&am32)itok4->number+=addESP;
  3892. //              else itok4->number-=localsize;
  3893.                 *tok4=tk_rmnumber;
  3894.                 if(itok4->type==tp_classvar)itok4->flag|=f_useidx;
  3895.                 itok4->post=FALSE;
  3896.                 compressoffset(itok4);
  3897.         }
  3898.         else{
  3899.                 itok4->post=poststr;
  3900.                 if(strinf.bufstr==NULL){
  3901.                         itok4->rm=(am32==FALSE?rm_d16:rm_d32);  //ãáâ ­®¢ª¨ ¯® 㬮«ç ­¨î
  3902.                         if(itok4->post!=0)*tok4=tk_postnumber;
  3903.                         else *tok4=tk_number;
  3904.                 }
  3905.                 else{
  3906.                         if(displaytokerrors){
  3907.                                 if((newreg=CheckIDXReg(strinf.bufstr,strinf.size,idxregs[0]))!=NOINREG){
  3908.                                         if(newreg==SKIPREG){
  3909.                                                 newreg=idxregs[0];
  3910.                                         }
  3911.                                         else{
  3912.                                                 if(am32==FALSE&&newreg!=DI&&newreg!=BX)goto noopt2;
  3913.                                                 waralreadinitreg(regs[am32][idxregs[0]],regs[am32][newreg]);
  3914.                                         }
  3915.                                         free(strinf.bufstr);
  3916.                                         strinf.bufstr=NULL;
  3917.                                         goto cont2;
  3918.                                 }
  3919.                                 newreg=(idxregs[4]==255?idxregs[0]:idxregs[4]); //14.06.06 20:06
  3920. noopt2:
  3921.                                 CheckMassiv(strinf.bufstr,strinf.size,(idxregs[4]==255?idxregs[0]:idxregs[4]));
  3922. cont2: ;
  3923.                         }
  3924.                         itok4->rm=RegToRM(newreg,(am32==FALSE?tk_reg:tk_reg32))|rm_mod10;
  3925.                         *tok4=tk_rmnumber;
  3926.                 }
  3927.                 itok4->segm=DS;
  3928.         }
  3929.         if(itok4->post==0&&(itok4->flag&f_reloc)==0){  // cannot compress if POST var
  3930.                 compressoffset(itok4);
  3931.         }
  3932. //      compressoffset(itok4);
  3933.         itok4->flag|=flagstr;
  3934.         inptr=binptr;
  3935.         cha=ocha;
  3936. }
  3937.  
  3938. void AddUndefOff(int segm,char *ostring)        //§ ä¨ªá¨à®¢ âì ®¡à é¥­¨¥ ª ¥é¥ ­¥ ®¡ê¥­ë¬ ¨¬¥­ ¬
  3939. /*segm - ᥣ¬¥­â ®âªã¤  ¨¤¥â ®¡à é¥­¨¥
  3940.  0 - ᥣ¬¥­â ª®¤ 
  3941.  1 - ᥣ¬¥­â ¤ ­­ëå
  3942.  2 - ᥣ¬¥­â ª®¤ , ­® ¡¥§ § ­¥á¥­¨ï ¢ â ¡«¨æã ¯¥à¥¬¥é¥­¨©
  3943.  3 - ᥣ¬¥­â ¤ ­­ëå, ­® ¡¥§ § ­¥á¥­¨ï ¢ â ¡«¨æã ¯¥à¥¬¥é¥­¨©
  3944. */
  3945. {
  3946. UNDEFOFF *curptr;
  3947.         if(undefoffstart==NULL){        //¥á«¨ ¥é¥ ­¥ ¡ë«® ­¥¨§¢ ¬¥â®ª
  3948.                 undefoffstart=(UNDEFOFF *)MALLOC(sizeof(UNDEFOFF));
  3949.                 memset(undefoffstart,0,sizeof(UNDEFOFF));
  3950.                 strcpy(undefoffstart->name,ostring);
  3951.         }
  3952.         for(curptr=undefoffstart;;curptr=curptr->next){
  3953.                 if(strcmp(curptr->name,ostring)==0){    //à ­¥¥ 㦥 ®¡à é «¨áì ª ­¥©
  3954.                         //â ¡«¨æ  ®¡à é¥­¨© ª undef
  3955.                         if(curptr->pos==NULL)curptr->pos=(IOFS *)MALLOC(sizeof(IOFS)*(curptr->num+1));
  3956.                         else curptr->pos=(IOFS *)REALLOC(curptr->pos,sizeof(IOFS)*(curptr->num+1));
  3957.                         (curptr->pos+curptr->num)->ofs=segm==0?outptr:outptrdata;
  3958.                         (curptr->pos+curptr->num)->dataseg=(unsigned char)segm;
  3959.                         (curptr->pos+curptr->num)->line=linenumber;
  3960.                         (curptr->pos+curptr->num)->file=currentfileinfo;
  3961.                         curptr->num++;
  3962.                         return;
  3963.                 }
  3964.                 if(curptr->next==NULL)break;    //ª®­¥æ ᯨ᪠
  3965.         }
  3966.         curptr=curptr->next=(UNDEFOFF *)MALLOC(sizeof(UNDEFOFF));       //­®¢ ï undef
  3967.         memset(curptr,0,sizeof(UNDEFOFF));
  3968.         strcpy(curptr->name,ostring);
  3969.         curptr->num=1;
  3970.         curptr->pos=(IOFS *)MALLOC(sizeof(IOFS));
  3971.         curptr->pos->ofs=segm==0?outptr:outptrdata;
  3972.         curptr->pos->dataseg=(unsigned char)segm;
  3973.         curptr->pos->line=linenumber;
  3974.         curptr->pos->file=currentfileinfo;
  3975. }
  3976.  
  3977. int CheckUseAsUndef(unsigned char *name)
  3978. {
  3979. UNDEFOFF *curptr;
  3980. int count=0;
  3981.         if(undefoffstart==NULL)return 0;        //­¥ ¡ë«® ®¡à é¥­¨© ª undef
  3982.         for(curptr=undefoffstart;;curptr=curptr->next){
  3983.                 if(strcmp(curptr->name,(char *)name)==0){       //­ è«¨
  3984.                         count=curptr->num;
  3985.                         break;
  3986.                 }
  3987.                 if(curptr->next==NULL)break;
  3988.         }
  3989.         return count;
  3990. }
  3991.  
  3992. int FindOff(unsigned char *name,int base)       //¯®¨áª ááë«®ª ­  ⥪ã饥 ¨¬ï
  3993. {
  3994. /*-----------------13.08.00 23:48-------------------
  3995.  ¯à®á¬®âà¥âì ¯à®æ¥¤ãà㠯ਠ¢¢®¤¥ à §¤¥«¥­¨ï ¤ ­­ëå ¨ ª®¤ 
  3996.         --------------------------------------------------*/
  3997. UNDEFOFF *curptr,*prev;
  3998. unsigned char segm;
  3999. unsigned int ofs,valofs;
  4000. int count=0;
  4001.         if(undefoffstart==NULL)return 0;        //­¥ ¡ë«® ®¡à é¥­¨© ª undef
  4002.         for(curptr=undefoffstart;;curptr=curptr->next){
  4003.                 if(strcmp(curptr->name,(char *)name)==0){       //­ è«¨
  4004.                         for(int i=0;i<curptr->num;i++){
  4005.                                 ofs=(curptr->pos+i)->ofs;
  4006.                                 segm=(curptr->pos+i)->dataseg;
  4007.                                 if(base==DS&&dynamic_flag){     //¡ë«® ®¡à é¥­¨¥ ª ¤¨­ ¬¨ç¥áª¨¬ ¨­¨æ. ¯¥à¥¬¥­­ë¬
  4008.                                         CheckPosts();
  4009.                                         (postbuf+posts)->type=(unsigned short)(am32==0?DIN_VAR:DIN_VAR32);
  4010.                                         (postbuf+posts)->num=(int)itok.rec;
  4011.                                         (postbuf+posts)->loc=ofs;
  4012.                                 }
  4013.                                 else{
  4014.                                         if((segm&1)==0||modelmem==TINY){        //¢ ᥣ¬¥­â¥ ª®¤ 
  4015.                                                 if(base!=VARPOST){
  4016. //                                                      if(am32==FALSE)valofs=*(unsigned short *)&output[ofs];
  4017. //                                                      else valofs=*(unsigned long *)&output[ofs];
  4018. //                                                      valofs+=(base==CS?outptr:outptrdata);
  4019.                                                         valofs=(base==CS?outptr:outptrdata);
  4020.                                                 }
  4021.                                                 else valofs=postsize;
  4022.                                                 if(am32==FALSE)*(unsigned short *)&output[ofs]+=(unsigned short)valofs;
  4023.                                                 else *(unsigned long *)&output[ofs]+=valofs;
  4024.                                         }
  4025.                                         else{
  4026.                                                 if(am32==FALSE)*(unsigned short *)&outputdata[ofs]+=(unsigned short)(base==CS?outptr:outptrdata);
  4027.                                                 else *(unsigned long *)&outputdata[ofs]+=(unsigned long)(base==CS?outptr:outptrdata);
  4028.                                         }
  4029.                                         if((FixUp!=FALSE&&(segm&2)==0)/*||base==VARPOST*/){
  4030.                                                 CheckPosts();
  4031.                                                 (postbuf+posts)->type=(unsigned char)
  4032. //                                                              (base==VARPOST?(am32==FALSE?POST_VAR:POST_VAR32):
  4033.                                                                         ((segm&1)==0?(am32==FALSE?FIX_VAR:FIX_VAR32):
  4034.                                                                         (am32==FALSE?FIX_CODE:FIX_CODE32)
  4035. //                                                                      )
  4036.                                                                         );
  4037.                                                 (postbuf+posts)->loc=ofs;
  4038.                                                 posts++;
  4039.                                         }
  4040.                                         if(base==VARPOST){
  4041.                                                 unsigned int i;
  4042.                                                 for(i=0;i<posts;i++){
  4043.                                                         if(ofs==(postbuf+i)->loc)break;
  4044.                                                 }
  4045.                                                 if(i==posts){
  4046.                                                         CheckPosts();
  4047.                                                         posts++;
  4048.                                                         (postbuf+i)->loc=ofs;
  4049.                                                 }
  4050.                                                 (postbuf+i)->type=(unsigned char)(am32==FALSE?POST_VAR:POST_VAR32);
  4051.                                         }
  4052.                                 }
  4053.                         }
  4054.                         free(curptr->pos);
  4055.                         if(undefoffstart->next==NULL)undefoffstart=NULL;
  4056.                         else if(undefoffstart==curptr)undefoffstart=curptr->next;
  4057.                         else{
  4058.                                 for(prev=undefoffstart;prev->next!=curptr;prev=prev->next);
  4059.                                 prev->next=curptr->next;
  4060.                         }
  4061.                         count=curptr->num;
  4062.                         free(curptr);
  4063.                         break;
  4064.                 }
  4065.                 if(curptr->next==NULL)break;
  4066.         }
  4067.         return count;
  4068. }
  4069.  
  4070. int FindUseName(char *name)     //¯®¨áª ááë«®ª ­  ⥪ã饥 ¨¬ï
  4071. {
  4072. UNDEFOFF *curptr;
  4073.         if(undefoffstart){
  4074.                 for(curptr=undefoffstart;;curptr=curptr->next){
  4075.                         if(strcmp(curptr->name,(char *)name)==0){       //­ è«¨
  4076.                                 return curptr->num;
  4077.                         }
  4078.                         if(curptr->next==NULL)break;
  4079.                 }
  4080.         }
  4081.         return 0;
  4082. }
  4083.  
  4084. int GetDirective(char *str)
  4085. {
  4086.         int i;
  4087.         i=FastSearch(dirlist,ofsdir,1,str);
  4088. //      printf("i=%d %s\n",i,str);
  4089.         if(i!=-1&&i<d_end1&&notdoneprestuff!=TRUE&&displaytokerrors!=0){
  4090.                 char buf[80];
  4091.                 sprintf(buf,"Too late to change %s",str);
  4092.                 preerror(buf);
  4093.         }
  4094.         return i;
  4095. }
  4096.  
  4097. int FastSearch(unsigned char *list,short *ofs,int type,char *str)
  4098. {
  4099.         if((strlen(str)-1)>0){
  4100. short offs=-1;
  4101. unsigned char c;
  4102.                 c=str[0];
  4103.                 switch(type){
  4104.                         case 0:
  4105.                                 if(c>='A'&&c<='Z')offs=ofs[c-'A'];
  4106.                                 break;
  4107.                         case 1:
  4108.                                 if(c=='D')offs=ofs[0];
  4109.                                 else if(c>='a'&&c<='z')offs=ofs[c-0x60];
  4110.                                 break;
  4111.                         case 2:
  4112.                                 if(c=='_')offs=ofs[26];
  4113.                                 else if(c>='a'&&c<='z')offs=ofs[c-'a'+27];
  4114.                                 else offs=ofs[c-'A'];
  4115.                                 break;
  4116.                         case 3:
  4117.                                 if(c>='a'&&c<='z')offs=ofs[c-0x61];
  4118.                                 break;
  4119.                 }
  4120. //                                      if(type==0)printf("%s\n",str);
  4121.                 if(offs!=-1){
  4122.                         for(unsigned char *ii=(unsigned char *)(list+offs);;ii++){
  4123.                                 short types;
  4124.                                 if((types=*(short *)&*ii)==-1)break;
  4125.                                 ii+=2;
  4126.                                 unsigned char c=*ii;
  4127.                                 int i;
  4128.                                 i=1;
  4129.                                 while(c==str[i]){
  4130.                                         if(c==0)return types;
  4131.                                         ii++;
  4132.                                         i++;
  4133.                                         c=*ii;
  4134.                                 }
  4135.                                 if(c>str[i])break;
  4136.                                 while(*ii!=0)ii++;
  4137.                         }
  4138.                 }
  4139.         }
  4140.         return -1;
  4141. }
  4142.  
  4143. /*-----------------05.01.00 22:56-------------------
  4144.   ¡®â  á® áâàãªâãà ¬¨
  4145.         --------------------------------------------------*/
  4146.  
  4147. int GetVarSize(int var)
  4148. {
  4149.         switch(var){
  4150.                 case tk_reg:
  4151.                 case tk_intvar:
  4152.                 case tk_seg:
  4153.                 case tk_wordvar: return 2;
  4154.                 case tk_bits:
  4155.                 case tk_charvar:
  4156.                 case tk_beg:
  4157.                 case tk_bytevar: return 1;
  4158.                 case tk_pointer:
  4159.                         if(am32==0)return 2;
  4160.                 case tk_longvar:
  4161.                 case tk_dwordvar:
  4162.                 case tk_reg32:
  4163.                 case tk_floatvar: return 4;
  4164.                 case tk_doublevar:
  4165.                 case tk_qwordvar: return 8;
  4166.                 default:
  4167.                         if(am32)return 4;
  4168.         }
  4169.         return 2;
  4170. }
  4171.  
  4172. unsigned long getsizebit(int size)
  4173. {
  4174. unsigned long num;
  4175.         nexttok();
  4176.         if(tok!=tk_number)numexpected();
  4177.         num=doconstdwordmath();
  4178.         if(num>(unsigned int)(size*8))preerror("Bit field to large");
  4179.         return num;
  4180. }
  4181.  
  4182. int GetFirstDestr(structteg *searcht)
  4183. {
  4184. elementteg *bazael=searcht->baza;
  4185. idrec *ptrs;
  4186.         if((searcht->flag&fs_destructor)!=0)return TRUE;
  4187.         for(int i=0;i<searcht->numoper;i++){
  4188.                 ptrs=(bazael+i)->rec;
  4189.                 if((bazael+i)->tok==tk_baseclass){
  4190.                         if(GetFirstDestr((structteg *)ptrs))return TRUE;
  4191.                 }
  4192.         }
  4193.         return FALSE;
  4194. }
  4195.  
  4196. void AddTegToTree(structteg *newteg,int Global)
  4197. {
  4198. struct structteg *tteg;
  4199. int i;
  4200.         tteg=(Global==TRUE?tegtree:ltegtree);
  4201.         if(tteg==NULL)(Global==TRUE?tegtree:ltegtree)=newteg;
  4202.         else{
  4203.                 while(((i=strcmp(tteg->name,newteg->name))<0&&tteg->left!=NULL)||(i>0&&tteg->right!=NULL))
  4204.                         tteg=(i<0?tteg->left:tteg->right);
  4205.                 (i<0?tteg->left:tteg->right)=newteg;
  4206.         }
  4207. }
  4208.  
  4209. int IsClass(structteg *searcht)
  4210. {
  4211. elementteg *bazael=searcht->baza;
  4212.         if((searcht->flag&fs_destructor)!=0)return TRUE;
  4213.         for(int i=0;i<searcht->numoper;i++){
  4214.                 if((bazael+i)->tok==tk_baseclass)return TRUE;
  4215. //                      if(IsClass((structteg *)(bazael+i)->rec))return TRUE;
  4216.                 else if((bazael+i)->tok==tk_proc){
  4217.                         if((bazael+i)->rec&&((bazael+i)->rec->flag&f_classproc))return TRUE;
  4218.                 }
  4219.         }
  4220.         return FALSE;
  4221. }
  4222.  
  4223. struct structteg *CreatTeg(int Global,int useunion,int noname)  //ᮧ¤ âì ­®¢ë© ⥣
  4224. {
  4225. struct structteg *newteg,*tteg;
  4226. struct elementteg *bazael;
  4227. int ssize=0,numel=0,localtok,size,numt,nameid=FALSE,tsize;
  4228. int bitofs=0,bitsize=0,i,type;
  4229. int isdestr=FALSE,isbase=0;
  4230. int unionsize=0;
  4231.         newteg=(struct structteg *)MALLOC(sizeof(struct structteg));
  4232.         newteg->left=newteg->right=NULL;
  4233.         newteg->baza=NULL;
  4234.         newteg->flag=useunion;
  4235.         newteg->name[0]=0;
  4236.         if(tok==tk_ID||tok==tk_id){
  4237.                 strcpy(newteg->name,itok.name);
  4238.                 AddTegToTree(newteg,Global);
  4239.                 nexttok();
  4240.                 nameid=TRUE;
  4241.         }
  4242.         if(tok==tk_colon){
  4243.                 nexttok();
  4244.                 do{
  4245.                         if((tteg=FindTeg(TRUE))==NULL)undefclass(itok.name);
  4246.                         else{
  4247.                                 size=tteg->size;
  4248.                                 if(numel==0)bazael=(struct elementteg *)MALLOC(sizeof(struct elementteg));
  4249.                                 else bazael=(struct elementteg *)REALLOC(bazael,sizeof(struct elementteg)*(numel+1));
  4250.                                 for(i=0;i<numel;i++){
  4251.                                         if(strcmp((bazael+i)->name,itok.name)==0){
  4252.                                                 sprintf((char *)string,"Dublicate base class '%s'",itok.name);
  4253.                                                 preerror((char *)string);
  4254.                                         }
  4255.                                 }
  4256.                                 strcpy((bazael+numel)->name,itok.name);
  4257.                                 (bazael+numel)->tok=tk_baseclass;
  4258.                                 (bazael+numel)->ofs=ssize;
  4259.                                 (bazael+numel)->numel=1;
  4260.                                 ssize+=size;
  4261.                                 (bazael+numel)->nteg=tteg;
  4262.                                 numel++;
  4263.                                 isbase++;
  4264.                         }
  4265.                         nexttok();
  4266.                         if(tok==tk_openbrace)break;
  4267.                         expecting(tk_camma);
  4268.                 }while(tok!=tk_eof);
  4269.                 if(useunion)preerror("union cannot have a base type");
  4270.         }
  4271.         expecting(tk_openbrace);
  4272.         while(tok!=tk_closebrace&&tok!=tk_eof){
  4273.                 int oflag,orm,npointr;
  4274.                 int utestInitVar=FALSE;
  4275.                 orm=tokens;
  4276.                 npointr=oflag=0;
  4277.                 type=variable;
  4278.                 if(tok==tk_tilda){
  4279.                         newteg->flag|=fs_destructor;
  4280.                         oflag|=fs_destructor;
  4281. //                      oflag=newteg->flag;
  4282.                         nexttok();
  4283.                         isdestr=TRUE;
  4284.                 }
  4285. //13.09.04 00:08
  4286.                 if(tok==tk_static){
  4287.                         oflag|=f_static;
  4288.                         nexttok();
  4289.                 }
  4290. /////////////
  4291.                 switch(tok){
  4292.                         case tk_int: orm=tok; localtok=tk_intvar; size=2; break;
  4293.                         case tk_word: orm=tok; localtok=tk_wordvar; size=2; break;
  4294.                         case tk_char: orm=tok; localtok=tk_charvar; size=1; break;
  4295.                         case tk_byte: orm=tok; localtok=tk_bytevar; size=1; break;
  4296.                         case tk_long: orm=tok; localtok=tk_longvar; size=4; break;
  4297.                         case tk_dword: orm=tok; localtok=tk_dwordvar; size=4; break;
  4298.                         case tk_float: orm=tok; localtok=tk_floatvar; size=4; break;
  4299.                         case tk_qword: orm=tok; localtok=tk_qwordvar; size=8; break;
  4300.                         case tk_double: orm=tok; localtok=tk_doublevar; size=8; break;
  4301.                         case tk_union:
  4302.                                 nexttok();
  4303.                                 i=FALSE;
  4304.                                 if(bitofs&&(!useunion)){
  4305.                                         ssize+=(bitofs+7)/8;
  4306.                                         bitofs=0;
  4307.                                 }
  4308.                                 if(tok==tk_openbrace)i=TRUE;
  4309.                                 if((tteg=CreatTeg(Global,TRUE,i))!=NULL){
  4310.                                         if(tok==tk_semicolon){
  4311.                                                 if(numel==0)bazael=(struct elementteg *)MALLOC(sizeof(struct elementteg)*tteg->numoper);
  4312.                                                 else bazael=(struct elementteg *)REALLOC(bazael,sizeof(struct elementteg)*(numel+tteg->numoper));
  4313.                                                 for(i=0;i<tteg->numoper;i++)(tteg->baza+i)->ofs+=ssize;
  4314.                                                 memcpy((elementteg *)(bazael+numel),tteg->baza,sizeof(struct elementteg)*tteg->numoper);
  4315.                                                 tsize=tteg->size;
  4316.                                                 if(useunion==FALSE)ssize+=tsize;
  4317.                                                 else if(unionsize<(unsigned int)(tsize))unionsize=tsize;
  4318.                                                 numel+=tteg->numoper;
  4319.                                                 free(tteg->baza);
  4320.                                                 free(tteg);
  4321.                                                 size=0;
  4322.                                                 nexttok();
  4323.                                                 break;
  4324.                                         }
  4325.                                         else{
  4326.                                                 tsize=size=tteg->size;
  4327.                                                 localtok=tk_struct;
  4328.                                                 goto dproc2;
  4329.                                         }
  4330.                                 }
  4331.                                 else declareunion();
  4332.                                 break;
  4333.                         case tk_struct:
  4334.                                 nexttok();
  4335.                         case tk_id:
  4336.                         case tk_ID:
  4337.                                 if(bitofs&&(!useunion)){
  4338.                                         ssize+=(bitofs+7)/8;
  4339.                                         bitofs=0;
  4340.                                 }
  4341.                                 i=0;
  4342.                                 if(tok==tk_openbrace||tok2==tk_openbrace){
  4343.                                         if(tok==tk_openbrace)i=TRUE;
  4344.                                         if((tteg=CreatTeg(Global,FALSE,i))!=NULL){
  4345.                                                 if(tok!=tk_semicolon){
  4346.                                                         tsize=size=tteg->size;
  4347.                                                         localtok=tk_struct;
  4348. //                                                      printf("tok=%d %s\n",tok,itok.name);
  4349.                                                         goto dproc2;
  4350.                                                 }
  4351.                                                 else{
  4352.                                                         if(numel==0)bazael=(struct elementteg *)MALLOC(sizeof(struct elementteg)*tteg->numoper);
  4353.                                                         else bazael=(struct elementteg *)REALLOC(bazael,sizeof(struct elementteg)*(numel+tteg->numoper));
  4354.                                                         for(i=0;i<tteg->numoper;i++)(tteg->baza+i)->ofs+=ssize;
  4355.                                                         memcpy((elementteg *)(bazael+numel),tteg->baza,sizeof(struct elementteg)*tteg->numoper);
  4356.                                                         tsize=tteg->size;
  4357.                                                         if(useunion==FALSE)ssize+=tsize;
  4358.                                                         else if(unionsize<(unsigned int)(tsize))unionsize=tsize;
  4359.                                                         numel+=tteg->numoper;
  4360.                                                         free(tteg->baza);
  4361.                                                         free(tteg);
  4362.                                                         size=0;
  4363.                                                         nexttok();
  4364.                                                         break;
  4365.                                                 }
  4366.                                         }
  4367.                                         datatype_expected();
  4368.                                 }
  4369.                                 if(strcmp(itok.name,newteg->name)==0&&tok2==tk_openbracket){
  4370.                                         if(oflag==0){
  4371.                                                 newteg->flag|=fs_constructor;
  4372.                                                 oflag|=fs_constructor;
  4373.                                                 orm=am32==FALSE?tk_word:tk_dword;
  4374.                                         }
  4375.                                         else if(oflag==fs_destructor){
  4376.                                                 strcat(itok.name,"~");
  4377.                                                 orm=tk_void;
  4378.                                         }
  4379.                                         goto dproc2;
  4380.                                 }
  4381.                                 if((tteg=FindTeg(FALSE))!=NULL||(tteg=FindTeg(TRUE))!=NULL){
  4382.                                         if(tok2==tk_mult){
  4383.                                                 while(tok2==tk_mult)nexttok();
  4384.                                                 if(am32){
  4385.                                                         localtok=tk_dwordvar;
  4386.                                                         size=4;
  4387.                                                         orm=tk_dword;
  4388.                                                 }
  4389.                                                 else{
  4390.                                                         localtok=tk_wordvar;
  4391.                                                         size=2;
  4392.                                                         orm=tk_word;
  4393.                                                 }
  4394.                                                 warpointerstruct();
  4395.                                         }
  4396.                                         else{
  4397.                                                 size=tteg->size;
  4398.                                                 localtok=tk_struct;
  4399.                                         }
  4400.                                         goto locvar;
  4401.         //                              break;
  4402.                                 }
  4403.                         default:
  4404.                                 skipfind=LOCAL; //§ ¯à¥â¨âì ¯®¨áª ¢ £«®¡ «ì­®¬ ¨ «®ª «ì­®¬ ᯨ᪥
  4405.                                 utestInitVar=TRUE;
  4406.                                 if((i=testInitVar())==FALSE||i==2){     //®¯à¥¤¥«¥­¨¥ ¯à®æ¥¤ãàë ¯®ª  ­¥ ®¡à ¡ â뢠¥¬
  4407.                                         skipfind=FALSE; //à §à¥è¨âì ¯®¨áª
  4408.                                         FindEndLex();
  4409.                                         datatype_expected();
  4410.                                         nexttok();
  4411.                                         size=0;
  4412.                                         break;
  4413.                                 }
  4414.                                 oflag|=itok.flag;
  4415.                                 npointr=itok.npointr;
  4416.                                 if(itok.npointr)itok.rm=(am32==TRUE?tk_dword:tk_word);
  4417.                                 orm=itok.rm;
  4418.                                 if(tok2==tk_openbracket&&strcmp(itok.name,newteg->name)==0){
  4419.                                         newteg->flag|=fs_constructor;
  4420.                                         oflag|=fs_constructor;
  4421.                                         if(orm==tokens)orm=am32==FALSE?tk_word:tk_dword;
  4422.                                 }
  4423. /*                              if(tok==tk_openbracket){
  4424.                                         if(itok.npointr)orm=am32==FALSE?tk_word:tk_dword;
  4425.                                         npointr=0;
  4426.                                         nexttok();
  4427.                                         while(tok==tk_mult){    //㪠§ â¥«ì ­  ¯à®æ¥¤ãàã
  4428.                                                 npointr++;
  4429.                                                 nexttok();
  4430.                                         }
  4431.                                         type=pointer;
  4432.                                 }*/
  4433.                                 goto dproc2;
  4434.                 }
  4435.                 if(size!=0){
  4436. locvar:
  4437.                         do{
  4438.                                 tsize=size;
  4439.                                 skipfind=LOCAL; //§ ¯à¥â¨âì ¯®¨áª ¢ £«®¡ «ì­®¬ ¨ «®ª «ì­®¬ ᯨ᪥
  4440.                                 nexttok();
  4441.                                 if(tok==tk_colon){
  4442.                                         numt=getsizebit(size);
  4443.                                         if(numt==0)numt=size*8-bitofs%(size*8); //(am32==0?16:32)-bitofs%(am32==0?16:32);
  4444.                                         bitofs+=numt;
  4445.                                         continue;
  4446.                                 }
  4447. dproc2:
  4448.                                 if(numel==0)bazael=(struct elementteg *)MALLOC(sizeof(struct elementteg));
  4449.                                 else bazael=(struct elementteg *)REALLOC(bazael,sizeof(struct elementteg)*(numel+1));
  4450.                                 if(tok!=tk_ID&&tok!=tk_id){
  4451.                                         utestInitVar=TRUE;
  4452.                                         if(testInitVar()==FALSE){       //®¯à¥¤¥«¥­¨¥ ¯à®æ¥¤ãàë ¯®ª  ­¥ ®¡à ¡ â뢠¥¬
  4453.                                                 idalreadydefined();
  4454.                                         }
  4455.                                         else{
  4456.                                                 oflag|=itok.flag;
  4457.                                                 npointr=itok.npointr;
  4458.                                                 if(itok.npointr)itok.rm=(am32==TRUE?tk_dword:tk_word);
  4459.                                                 if(itok.rm!=tokens)orm=itok.rm;
  4460.                                                 if(tok==tk_openbracket){
  4461.                                                         if(itok.npointr)orm=am32==FALSE?tk_word:tk_dword;
  4462.                                                         npointr=0;
  4463.                                                         nexttok();
  4464.                                                         while(tok==tk_mult){    //㪠§ â¥«ì ­  ¯à®æ¥¤ãàã
  4465.                                                                 npointr++;
  4466.                                                                 nexttok();
  4467.                                                         }
  4468.                                                         type=pointer;
  4469.                                                 }
  4470.                                                 for(i=0;i<numel;i++){
  4471.                                                         if(strcmp((bazael+i)->name,itok.name)==0)idalreadydefined();
  4472.                                                 }
  4473.                                                 strcpy((bazael+numel)->name,itok.name);
  4474.                                                 if(tok2==tk_openbracket&&strcmp(itok.name,newteg->name)==0){
  4475.                                                         newteg->flag|=fs_constructor;
  4476.                                                         oflag|=fs_constructor;
  4477.                                                         if(orm==tokens)orm=am32==FALSE?tk_word:tk_dword;
  4478.                                                 }
  4479.                                                 nexttok();
  4480.                                                 if(tok==tk_openbracket||type==pointer)goto dproc;
  4481.                                                 if(npointr){
  4482.                                                         idrec *nrec;
  4483.                                                         nrec=(bazael+numel)->rec=(idrec *)MALLOC(sizeof(idrec));
  4484.                                                         strcpy(nrec->recid,(bazael+numel)->name);//᪮¯¨à ­ §¢ ­¨¥
  4485.                                                         nrec->newid=NULL;
  4486.                                                         nrec->npointr=(unsigned short)npointr;
  4487.                                                         nrec->flag=oflag;
  4488.                                                         nrec->line=linenumber;
  4489.                                                         nrec->file=currentfileinfo;
  4490.                                                         nrec->rectok=(bazael+numel)->tok=tk_pointer;
  4491.                                                         nrec->type=(unsigned short)orm;
  4492.                                                         tsize=2;
  4493.                                                         if(am32||(oflag&f_far))tsize=4;
  4494.                                                         goto endelteg;
  4495.                                                 }
  4496.                                                 else unuseableinput();
  4497.                                         }
  4498.                                 }
  4499.                                 else{
  4500.                                         for(i=0;i<numel;i++){
  4501.                                                 if(strcmp((bazael+i)->name,itok.name)==0){
  4502.                                                         idalreadydefined();
  4503.                                                         FindEndLex();
  4504.                                                         break;
  4505.                                                 }
  4506.                                         }
  4507.                                         strcpy((bazael+numel)->name,itok.name/*(char *)string*/);
  4508.                                         if(tok2==tk_openbracket&&utestInitVar==FALSE){
  4509.                                                 if(tok==tk_id)oflag|=(comfile==file_w32?tp_stdcall:tp_pascal);  //⨯ ¯à®æ ¯® 㬮«ç ­¨î
  4510.                                                 else oflag=tp_fastcall;
  4511.                                         }
  4512. //                                      printf("tok=%d %s\n",tok,itok.name);
  4513.                                         nexttok();
  4514.                                         if(tok==tk_colon){
  4515.                                                 numt=getsizebit(size);
  4516.                                                 if(numt==0)preerror("Bit fields must contain at least one bit");
  4517.                                                 (bazael+numel)->ofs=ssize;
  4518.                                                 (bazael+numel)->tok=tk_bits;
  4519.                                                 (bazael+numel)->bit.siz=numt;
  4520.                                                 (bazael+numel)->bit.ofs=bitofs;
  4521.                                                 if(useunion==FALSE)bitofs+=numt;
  4522.                                                 else if(numt>bitsize)bitsize=numt;
  4523. //                                              printf("n=%d size=%d %s\n",numel,numt,(bazael+numel)->name);
  4524.                                         }
  4525.                                         else if(tok==tk_openbracket){
  4526. dproc:
  4527.                                                 idrec *nrec;
  4528.                                                 param[0]=0;
  4529.                                                 if(type==pointer)expecting(tk_closebracket);
  4530.                                                 else{
  4531.                                                         if(npointr){
  4532.                                                                 orm=am32==FALSE?tk_word:tk_dword;
  4533.                                                                 npointr=0;
  4534.                                                         }
  4535.                                                 }
  4536.                                                 skipfind=FALSE; //à §à¥è¨âì ¯®¨áª
  4537.                                                 expecting(tk_openbracket);
  4538.                                                 if((oflag&f_typeproc)==tp_fastcall)declareparamreg();
  4539.                                                 else declareparamstack();
  4540.                                                 skipfind=LOCAL;
  4541.                                                 nrec=(bazael+numel)->rec=(idrec *)MALLOC(sizeof(idrec));
  4542.                                                 strcpy(nrec->recid,(bazael+numel)->name);//᪮¯¨à ­ §¢ ­¨¥
  4543.                                                 nrec->newid=NULL;
  4544. //                                              printf("name=%s param=%s\n",nrec->recid,param);
  4545.                                                 if(param[0]!=0)nrec->newid=BackString((char *)param);
  4546.                                                 if(orm==tokens)orm=am32==FALSE?tk_word:tk_dword;//tk_void;
  4547.                                                 nrec->npointr=(unsigned short)npointr;
  4548.                                                 nrec->recrm=orm;
  4549.                                                 nrec->flag=oflag;
  4550.                                                 nrec->line=linenumber;
  4551.                                                 nrec->file=currentfileinfo;
  4552.                                                 nrec->count=0;
  4553.                                                 nrec->recpost=0;//itok.post;
  4554.                                                 nrec->recsize=0;//itok.size;
  4555.                                                 nrec->recsib=(am32==TRUE?CODE32:CODE16);//itok.sib;
  4556.                                                 nrec->sbuf=NULL;
  4557.                                                 if(npointr){
  4558.                                                         nrec->rectok=(bazael+numel)->tok=tk_pointer;
  4559.                                                         nrec->type=tk_proc;
  4560.                                                         nrec->recsib=am32==FALSE?rm_d16:rm_d32;
  4561.                                                         tsize=2;
  4562.                                                         if(am32||(oflag&f_far))tsize=4;
  4563.                                                         if(bitofs&&(!useunion)){
  4564.                                                                 ssize+=(bitofs+7)/8;
  4565.                                                                 bitofs=0;
  4566.                                                         }
  4567.                                                         tsize=Align(tsize,strpackcur);  //new 16.03.05 14:21
  4568.                                                         nrec->recnumber=(bazael+numel)->ofs=ssize;
  4569.                                                         if(useunion==FALSE)ssize+=tsize;
  4570.                                                         else if(unionsize<(unsigned int)(tsize))unionsize=tsize;
  4571.                                                 }
  4572.                                                 else{
  4573.                                                         (bazael+numel)->tok=tk_proc;
  4574.                                                         nrec->rectok=tk_declare;
  4575.                                                         nrec->type=tp_ucnovn;
  4576.                                                         nrec->recsegm=NOT_DYNAMIC;
  4577.                                                         (bazael+numel)->ofs=0;
  4578.                                                         nrec->recnumber=secondcallnum++;
  4579.                                                         nrec->flag|=f_classproc;
  4580.                                                 }
  4581.                                                 (bazael+numel)->numel=1;
  4582.                                                 nexttok();
  4583.                                                 if(tok==tk_openbracket)IsUses(nrec);
  4584. //                                              printf("name=%s post=%08X\n",nrec->recid,nrec->recpost);
  4585.                                         }
  4586.                                         else{
  4587.                                                 (bazael+numel)->rec=NULL;
  4588.                                                 (bazael+numel)->tok=localtok;
  4589. endelteg:
  4590.                                                 if(bitofs&&(!useunion)){
  4591.                                                         ssize+=(bitofs+7)/8;
  4592.                                                         bitofs=0;
  4593.                                                 }
  4594.                                                 (bazael+numel)->ofs=ssize;
  4595.                                                 numt=1;
  4596.                                                 if(tok==tk_openblock){//[
  4597.                                                         skipfind=FALSE;
  4598.                                                         nexttok();
  4599.                                                         numt=doconstlongmath();
  4600.                                                         expecting(tk_closeblock);
  4601.                                                         skipfind=LOCAL;
  4602.                                                 }
  4603.                                                 (bazael+numel)->numel=numt;
  4604. //                                              printf("%d: unionsize=%d elemsize=%d\n",numel,unionsize,tsize*numt);
  4605.                                                 if((oflag&f_static)){
  4606.                                                         idrec *nrec;
  4607.                                                         nrec=(bazael+numel)->rec=(idrec *)MALLOC(sizeof(idrec));
  4608.                                                         strcpy(nrec->recid,(bazael+numel)->name);//᪮¯¨à ­ §¢ ­¨¥
  4609.                                                         nrec->line=linenumber;
  4610.                                                         nrec->file=currentfileinfo;
  4611.                                                         nrec->count=0;
  4612.                                                         nrec->sbuf=NULL;
  4613.                                                         nrec->recsize=tsize*numt;
  4614.                                                         nrec->recsegm=DS;
  4615.                                                         if(localtok==tk_struct){
  4616.                                                                 nrec->recsib=0;
  4617.                                                                 nrec->newid=(char *)tteg;
  4618.                                                                 (bazael+numel)->tok=nrec->rectok=tk_structvar;
  4619.                                                                 nrec->flag=/*flag|*/tteg->flag;
  4620.                                                                 if(FixUp)nrec->flag|=f_reloc;
  4621.                                                                 nrec->recrm=numt;
  4622.                                                         }
  4623.                                                         else{
  4624.                                                                 nrec->newid=NULL;
  4625.                                                                 nrec->npointr=(unsigned short)npointr;
  4626.                                                                 nrec->recrm=(am32==FALSE?rm_d16:rm_d32);
  4627.                                                                 if(FixUp)oflag|=f_reloc;
  4628.                                                                 nrec->flag=oflag;
  4629.                                                                 nrec->recsib=(am32==TRUE?CODE32:CODE16);//itok.sib;
  4630.                                                                 nrec->rectok=localtok;
  4631.                                                                 nrec->type=tp_ucnovn;
  4632.                                                         }
  4633.                                                         if(tok==tk_assign){
  4634.                                                                 skipfind=FALSE; //à §à¥è¨âì ¯®¨áª
  4635.                                                                 nrec->recpost=0;
  4636.                                                                 if(localtok==tk_struct){
  4637.                                                                         if(alignword)alignersize+=AlignCD(DS,2);        //¢ë஢­ïâì
  4638.                                                                         nrec->recnumber=outptrdata;     // ¤à¥á ­ ç «  áâàãªâãàë
  4639.                                                                         i=initstructvar(tteg,numt);
  4640.                                                                         if(numt==0){
  4641.                                                                                 numt=i/tteg->size;
  4642.                                                                                 if((i%tteg->size)!=0){
  4643.                                                                                         numt++;
  4644.                                                                                         i=tteg->size-(i%tteg->size);
  4645.                                                                                         for(;i!=0;i--)opd(0);
  4646.                                                                                         i=numt*tteg->size;
  4647.                                                                                 }
  4648.                                                                                 nrec->recrm=numel;
  4649.                                                                                 nrec->recsize=i;
  4650.                                                                         }
  4651.                                                                         datasize+=i;
  4652.                                                                 }
  4653.                                                                 else{
  4654.                                                                         if(alignword)alignersize+=AlignCD(DS,tsize);
  4655.                                                                         nrec->recnumber=outptrdata;
  4656.                                                                         initglobalvar(orm,numt,tsize,variable);
  4657.                                                                         datasize+=tsize*numt;
  4658.                                                                 }
  4659.                                                         }
  4660.                                                         else{
  4661.                                                                 nrec->recpost=1;
  4662.                                                                 if(localtok==tk_struct){
  4663.                                                                         if(numt==0){
  4664.                                                                                 ZeroMassiv();
  4665.                                                                                 break;
  4666.                                                                         }
  4667.                                                                 }
  4668.                                                                 if(alignword){  //¢ë஢­ïâì ­  ç¥â­ë©  ¤à¥á
  4669.                                                                         if(postsize%2==1)postsize++;
  4670.                                                                         if(tsize==4&&postsize%4!=0)postsize+=2;
  4671.                                                                 }
  4672.                                                                 nrec->recnumber=postsize;
  4673.                                                                 AddPostData(numt*tteg->size);
  4674.                                                         }
  4675.                                                 }
  4676.                                                 else{
  4677.                                                         tsize=Align(tsize*numt,strpackcur);     //new 16.03.05 14:21
  4678.                                                         if(useunion==FALSE)ssize+=tsize;
  4679.                                                         else if(unionsize<(unsigned int)tsize)unionsize=tsize;
  4680.                                                         if(localtok==tk_struct)(bazael+numel)->nteg=tteg;
  4681.                                                 }
  4682.                                         }
  4683.                                         if(useunion)bitofs=0;
  4684.                                         numel++;
  4685.                                 }
  4686.                                 newteg->size=ssize+unionsize;
  4687.                         }while(tok==tk_camma);
  4688.                         skipfind=FALSE; //à §à¥è¨âì ¯®¨áª
  4689.                         seminext();
  4690.                 }
  4691.         };//while(tok!=tk_closebrace&&tok!=tk_eof);
  4692.         if(bitofs&&useunion==FALSE)ssize+=(bitofs+7)/8;
  4693.         else if(bitsize&&((unsigned int)((bitsize+7)/8)>unionsize))unionsize=(bitsize+7)/8;
  4694. //      printf("bitofs=%d size=%d\n",bitofs,ssize);
  4695.         if(isdestr==FALSE&&isbase>1){
  4696.                 char *buf=(char *)MALLOC(16);
  4697.                 strcpy(buf,"(){");
  4698.                 int j;
  4699.                 for(i=0,j=0;i<isbase;i++){
  4700.                         if(GetFirstDestr((structteg *)(bazael+i)->nteg))j++;
  4701.                 }
  4702.                 if(j>1){
  4703.                         strcat(buf,"};");
  4704. int oflag,oinptr2;
  4705. char ocha2;
  4706. int oldendinptr=endinptr;
  4707. char *oinput;
  4708. idrec *nrec;
  4709.                         oinptr2=inptr2;
  4710.                         ocha2=cha2;
  4711.                         oinput=(char*)input;
  4712.                         string[0]=0;
  4713.                         newteg->flag|=fs_destructor;
  4714.                         strcpy(itok.name,newteg->name);
  4715.                         if(CidOrID()==tk_ID)oflag=tp_fastcall;
  4716.                         else oflag=(comfile==file_w32?tp_stdcall:tp_pascal);
  4717.                         bazael=(struct elementteg *)REALLOC(bazael,sizeof(struct elementteg)*(numel+1));
  4718.                         strcpy((bazael+numel)->name,itok.name);
  4719.                         strcat((bazael+numel)->name,"~");
  4720.                         itok.rec=nrec=(bazael+numel)->rec=(idrec *)MALLOC(sizeof(idrec));
  4721.                         strcpy(nrec->recid,itok.name);//᪮¯¨à ­ §¢ ­¨¥
  4722.                         nrec->newid=NULL;
  4723.                         itok.npointr=nrec->npointr=0;
  4724.                         itok.rm=nrec->recrm=tk_void;
  4725.                         itok.flag=nrec->flag=fs_destructor|oflag|f_classproc;
  4726.                         nrec->line=linenumber;
  4727.                         nrec->file=currentfileinfo;
  4728.                         nrec->count=0;
  4729.                         itok.post=nrec->recpost=0;
  4730.                         itok.size=nrec->recsize=0;
  4731.                         itok.sib=nrec->recsib=(am32==TRUE?CODE32:CODE16);
  4732.                         nrec->sbuf=NULL;
  4733.                         (bazael+numel)->tok=tk_proc;
  4734.                         tok=nrec->rectok=tk_declare;
  4735.                         itok.type=nrec->type=tp_ucnovn;
  4736.                         itok.segm=nrec->recsegm=NOT_DYNAMIC;
  4737.                         (bazael+numel)->ofs=0;
  4738.                         itok.number=nrec->recnumber=secondcallnum++;
  4739.                         (bazael+numel)->numel=1;
  4740.                         numel++;
  4741.                         input=(unsigned char*)buf;
  4742.                         inptr2=1;
  4743.                         cha2='(';
  4744.                         endinptr=strlen(buf);
  4745.                         searchteg=newteg;
  4746.                         dynamic_proc();
  4747.                         searchteg=NULL;
  4748.                         input=(unsigned char*)oinput;
  4749.                         inptr2=oinptr2;
  4750.                         cha2=ocha2;
  4751.                         endinptr=oldendinptr;
  4752.                 }
  4753.                 free(buf);
  4754.         }
  4755.         newteg->size=ssize+unionsize;
  4756.         newteg->numoper=numel;
  4757.         newteg->baza=bazael;
  4758.         nexttok();
  4759.         if(noname==FALSE&&nameid==FALSE){
  4760.                 if(tok==tk_ID||tok==tk_id){
  4761.                         strcpy(newteg->name,itok.name);
  4762.                         AddTegToTree(newteg,Global);
  4763.                 }
  4764.                 else{
  4765.                         notstructname();
  4766.                         if(newteg->baza)free(newteg->baza);
  4767.                         free(newteg);
  4768.                         newteg=NULL;
  4769.                 }
  4770.         }
  4771.         return newteg;
  4772. }
  4773.  
  4774. struct structteg * FindTeg(int Global,char *name)       //­ ©â¨ ⥣
  4775. {
  4776. struct structteg *tteg;
  4777. int i;
  4778. char *tn;
  4779.         if((tn=strchr(name,'@'))!=NULL)*tn=0;
  4780.         tteg=(Global==TRUE?tegtree:ltegtree);
  4781.         while(tteg&&(i=strcmp(tteg->name,name))!=0)tteg=(i<0?tteg->left:tteg->right);
  4782.         return tteg;
  4783. }
  4784.  
  4785. unsigned int SaveVal(unsigned long long val,int type)
  4786. {
  4787. unsigned int loop=0;
  4788.         switch(type){
  4789.                 case tk_bytevar:
  4790.                 case tk_charvar:
  4791.                         opd(val);
  4792.                         break;
  4793.                 case tk_wordvar:
  4794.                 case tk_intvar:
  4795.                         outwordd(val);
  4796.                         loop++;
  4797.                         break;
  4798.                 case tk_dwordvar:
  4799.                 case tk_longvar:
  4800.                 case tk_floatvar:
  4801.                         outdwordd(val);
  4802.                         loop+=3;
  4803.                         break;
  4804.                 case tk_qwordvar:
  4805.                 case tk_doublevar:
  4806.                         outqwordd(val);
  4807.                         loop+=7;
  4808.                         break;
  4809.                 case tk_pointer:
  4810.                         if(am32){
  4811.                                 outdwordd(val);
  4812.                                 loop+=3;
  4813.                         }
  4814.                         else{
  4815.                                 outwordd(val);
  4816.                                 loop++;
  4817.                         }
  4818.                         break;
  4819.                 case tk_proc:
  4820.                         loop--;
  4821.                         break;
  4822.                 default: internalerror("Bad type variable");
  4823.         }
  4824.         return loop;
  4825. }
  4826.  
  4827. void FillTeg(unsigned long long val,unsigned int numel,struct structteg *tteg)
  4828. /*-----------------03.10.99 00:20-------------------
  4829.  § ¯®«­¨âì áâàãªâãàã ®¤¨­ ª®¢ë¬¨ ¢¥«¨ç¨­ ¬¨
  4830.  --------------------------------------------------*/
  4831. {
  4832. struct elementteg *elem=tteg->baza;
  4833. int bitofs=0;
  4834. unsigned int startstruct;
  4835.         if(dbg&2)AddDataLine(1/*,variable*/);
  4836.         for(unsigned int j=0;j<numel;j++){
  4837.                 startstruct=outptrdata;
  4838.                 for(unsigned int c=0;c<tteg->numoper;c++){
  4839.                         if((elem+c)->ofs)outptrdata=startstruct+(elem+c)->ofs;
  4840.                         if(splitdata==FALSE)outptr=outptrdata;
  4841.                         int type=(elem+c)->tok;
  4842.                         if(type==tk_bits){
  4843.                                 opb(val,(elem+c)->bit.ofs,(elem+c)->bit.siz);
  4844.                                 bitofs=(elem+c)->bit.ofs+(elem+c)->bit.siz;
  4845.                         }
  4846.                         else{
  4847.                                 if(bitofs){
  4848.                                         CorrectOfsBit(bitofs);
  4849.                                         bitofs=0;
  4850.                                 }
  4851.                                 for(unsigned int i=0;i<(elem+c)->numel;i++){
  4852.                                         if(type==tk_struct||type==tk_baseclass){
  4853.                                                 FillTeg(val,(elem+c)->numel,(struct structteg *)(elem+c)->nteg);
  4854.                                                 break;
  4855.                                         }
  4856.                                         SaveVal(val,type);
  4857.                                 }
  4858.                         }
  4859.                 }
  4860.         }
  4861.         if(bitofs)CorrectOfsBit(bitofs);
  4862. }
  4863.  
  4864. unsigned int Fill2Teg(unsigned int numel,struct structteg *tteg)
  4865. /*-----------------03.10.99 00:20-------------------
  4866.  § ¯®«­¨âì áâàãªâãàã ¢¥«¨ç¨­ ¬¨
  4867.  --------------------------------------------------*/
  4868. {
  4869. unsigned long long hold;
  4870. struct elementteg *elem=tteg->baza;
  4871. unsigned int tnumel=0;  //­®¬¥à ¥«¥¬¥­â  ®¤­®£® ⨯ 
  4872. unsigned int ttype=0;   //­®¬¥à í«¥¬¥­â  áâàãªâãàë
  4873. unsigned int nums=0;    //­®¬¥à ª®¯¨¨ áâàãªâãàë
  4874. unsigned int loop=0;    //§ ¯®«­¥­ë© à §¬¥à
  4875. int type=tokens;
  4876. int bitofs=0;
  4877. unsigned int startstruct=outptrdata;
  4878.         scanalltoks=FALSE;
  4879.         for(;;){
  4880.                 hold=0;
  4881.                 if(tnumel==(elem+ttype)->numel||type==tk_bits){
  4882.                         tnumel=0;
  4883.                         ttype++;
  4884.                         if(ttype==tteg->numoper){
  4885.                                 ttype=0;
  4886.                                 nums++;
  4887.                                 startstruct=outptrdata;
  4888.                                 if(nums==numel){
  4889.                                         scanalltoks=TRUE;
  4890.                                         return loop;
  4891.                                 }
  4892.                         }
  4893.                         loop=(elem+ttype)->ofs;
  4894.                         outptrdata=startstruct+loop;
  4895.                         if(splitdata==FALSE)outptr=outptrdata;
  4896.                         loop+=tteg->size*nums;
  4897.                 }
  4898.                 tnumel++;
  4899.                 type=(elem+ttype)->tok;
  4900. //              puts((elem+ttype)->name);
  4901.                 if(type==tk_struct||type==tk_baseclass){
  4902.                         tnumel=(elem+ttype)->numel;
  4903.                         loop+=Fill2Teg((elem+ttype)->numel,(struct structteg *)(elem+ttype)->nteg);
  4904.                         if(tok==tk_closebrace)break;
  4905.                         continue;
  4906.                 }
  4907.                 if(type==tk_proc)continue;
  4908.                 if((elem+ttype)->rec&&((elem+ttype)->rec->flag&f_static))continue;
  4909.                 if(dbg&2)AddDataLine((char)GetVarSize(type)/*,variable*/);
  4910. loopsw:
  4911.                 int htok=tok;
  4912. //              printf("tok=%d\n",tok);
  4913.                 switch(tok){
  4914.                         case tk_camma:
  4915.                                 hold=0;
  4916.                                 goto strl3;
  4917.                         case tk_postnumber:
  4918.                                 (itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
  4919.                                 itok.flag=0;
  4920. //                                      goto strl1;
  4921.                         case tk_undefofs:
  4922. //                                      AddUndefOff(1,itok.name);
  4923. //strl1:
  4924.                                 tok=tk_number;
  4925.                                 if(htok==tk_undefofs)AddUndefOff(3,itok.name);
  4926.                                 hold+=doconstdwordmath();
  4927.                                 if(tok==tk_plus&&tok2==tk_postnumber&&htok!=tk_undefofs){
  4928.                                         nexttok();
  4929.                                         goto loopsw;
  4930.                                 }
  4931.                                 goto strl2;
  4932.                         case tk_minus:
  4933.                         case tk_number:
  4934.                                 if(type==tk_bytevar||type==tk_wordvar||type==tk_dwordvar||type==tk_bits||type==tk_pointer){
  4935.                                         hold=doconstdwordmath();
  4936.                                 }
  4937.                                 else if(type==tk_charvar||type==tk_intvar||type==tk_longvar){
  4938.                                         hold=doconstlongmath();
  4939.                                 }
  4940.                                 else if(type==tk_floatvar)hold=doconstfloatmath();
  4941.                                 else if(type==tk_doublevar)hold=doconstdoublemath();
  4942.                                 else if(type==tk_qwordvar)hold=doconstqwordmath();
  4943. //                              printf("tok=%d num=%08X\n",tok,hold);
  4944. strl2:
  4945.                                 if((postnumflag&f_reloc)!=0)AddReloc();
  4946. strl3:
  4947.                                 if(type==tk_bits){
  4948.                                         opb(hold,(elem+ttype)->bit.ofs,(elem+ttype)->bit.siz);
  4949.                                         bitofs=(elem+ttype)->bit.ofs+(elem+ttype)->bit.siz;
  4950.                                 }
  4951.                                 else{
  4952.                                         if(bitofs){
  4953.                                                 CorrectOfsBit(bitofs);
  4954.                                                 loop+=(bitofs+7)/8;
  4955.                                                 bitofs=0;
  4956.                                         }
  4957.                                         loop+=SaveVal(hold,type);
  4958.                                 }
  4959.                                 break;
  4960.                         case tk_string:
  4961.                                 if(type==tk_bytevar||type==tk_charvar){
  4962.                                         unsigned int i;
  4963.                                         if((unsigned int)itok.number<(elem+ttype)->numel)i=itok.number;
  4964.                                         else i=(elem+ttype)->numel;
  4965.                                         tnumel=0;
  4966.                                         for(;tnumel<i;tnumel++){
  4967.                                                 opd(string[tnumel]);
  4968.                                         }
  4969.                                         if(tnumel<(elem+ttype)->numel){
  4970.                                                 switch(itok.flag&3){
  4971.                                                         case zero_term:
  4972.                                                                 if(itok.flag&s_unicod)opd(0);
  4973.                                                                 opd(0);
  4974.                                                                 tnumel++;
  4975.                                                                 break;
  4976.                                                         case dos_term:
  4977.                                                                 if(itok.flag&s_unicod)opd(0);
  4978.                                                                 opd('$');
  4979.                                                                 tnumel++;
  4980.                                                                 break;
  4981.                                                 }
  4982.                                                 while(tnumel<(elem+ttype)->numel){
  4983.                                                         opd(aligner);
  4984.                                                         tnumel++;
  4985.                                                 }
  4986.                                         }
  4987.                                         loop+=tnumel-1;
  4988.                                         nexttok();
  4989.                                         break;
  4990.                                 }
  4991.                                 if(am32==FALSE){
  4992.                                         outwordd(addpoststring());
  4993.                                         if(type==tk_longvar||type==tk_dwordvar){
  4994.                                                 loop+=2;
  4995.                                                 outword(0);
  4996.                                         }
  4997.                                         loop++;
  4998.                                 }
  4999.                                 else{
  5000.                                         if(type==tk_intvar||type==tk_wordvar)dwordvalexpected();
  5001.                                         outdwordd(addpoststring());
  5002.                                         loop+=3;
  5003.                                 }
  5004.                                 nexttok();
  5005.                                 break;
  5006.                         default:
  5007.                                 numexpected();
  5008.                                 nexttok();
  5009.                                 break;
  5010.                 }
  5011.                 loop++;
  5012.                 if(tok==tk_closebrace)break;
  5013. //              printf("tok=%d\n",tok);
  5014.                 expecting(tk_camma);
  5015.         }
  5016.         scanalltoks=TRUE;
  5017.         if(bitofs){
  5018.                 CorrectOfsBit(bitofs);
  5019.                 loop+=(bitofs+7)/8;
  5020.         }
  5021.         return loop;
  5022. }
  5023.  
  5024. unsigned int initstructvar(structteg *tteg,int numel)
  5025. {
  5026. unsigned int loop=0;
  5027.         nexttok();
  5028.         switch(tok){    //§ ¯®«­¨âì ¢¥«¨ç¨­ ¬¨
  5029.                 case tk_minus:
  5030.                 case tk_number:
  5031.                         if(numel==0)ZeroMassiv();
  5032.                         FillTeg(doconstqwordmath(),numel,tteg);
  5033.                         loop=numel*tteg->size;
  5034.                         break;
  5035.                 case tk_from:   //áç¨â âì ä ©« á ¤ ­­ë¬¨
  5036.                         nexttok();
  5037.                         loop=dofrom();
  5038.                         for(;loop<tteg->size*numel;loop++)opd(aligner);
  5039.                         nexttok();
  5040.                         break;
  5041.                 case tk_extract:        //áç¨â âì äà £¬¥­â ä ©«  á ¤ ­­ë¬¨
  5042.                         nexttok();
  5043.                         loop=doextract();
  5044.                         for(;loop<tteg->size*numel;loop++)opd(aligner);
  5045.                         break;
  5046.                 case tk_openbrace:      //¬ áᨢ ¤ ­­ëå
  5047.                         nexttok();
  5048.                         loop=Fill2Teg(numel,tteg);
  5049.                         for(;loop<tteg->size*numel;loop++)opd(aligner);
  5050.                         if(tok!=tk_closebrace){
  5051.                                 preerror("extra parameter at initialization of structure");
  5052.                                 while(tok!=tk_closebrace&&tok!=tk_eof)nexttok();
  5053.                         }
  5054.                         nexttok();
  5055.                         break;
  5056.                 default:
  5057. //                      printf("tok=%d\n",tok);
  5058.                         numexpected(); nexttok(); break;
  5059.         }
  5060.         return loop;
  5061. }
  5062.  
  5063. void InitStruct2(unsigned int flag,structteg *tteg)     //¨­¨æ¨ «¨§¨à®¢ âì £«®¡ «ì­ãî áâàãªâãàã
  5064. {
  5065. struct idrec *newrec=NULL,*ptr;
  5066. int numel,count;
  5067. char done=0,dynamic;
  5068. unsigned int loop;
  5069.         while(tok!=tk_eof&&done==0){
  5070.                 loop=0;
  5071. //              printf("3 tok=%d %s\n",tok,itok.name);
  5072.                 switch(tok){
  5073.                         case tk_id:
  5074.                         case tk_ID:     //¨­¨æ¨ «¨§¨à®¢ âì áâàãªâãàã
  5075. //¢ë¤¥«¨âì ¯ ¬ïâì ¯®¤ ­®¢ãî áâàãªâ
  5076.                                 newrec=(struct idrec *)MALLOC(sizeof(struct idrec));
  5077.  
  5078. //                              if(strcmp(itok.name,"ccchrg")==0)printf("rec=%08X teg=%08X size=%X %s\n",newrec,tteg,sizeof(idrec),itok.name);
  5079.  
  5080.                                 ptr=((flag&f_static)==0?treestart:staticlist);  //­ ç «® ¤¥à¥¢ 
  5081.                                 if(ptr==NULL)((flag&f_static)==0?treestart:staticlist)=newrec;//­ ç «® ¤¥à¥¢ 
  5082.                                 else{   //¯®¨áª áâப¨ ¢ ¤¥à¥¢¥
  5083.                                         while(((numel=strcmp(ptr->recid,itok.name))<0&&ptr->left!=NULL)||(numel>0&&ptr->right!=NULL)){
  5084.                                                 ptr=(numel<0?ptr->left:ptr->right);
  5085.                                         }
  5086.                                         (numel<0?ptr->left:ptr->right)=newrec;  //áâப  ¬¥­ìè¥
  5087.                                 }
  5088.                                 newrec->recsib=0;
  5089.                                 strcpy(newrec->recid,itok.name);//᪮¯¨à ­ §¢ ­¨¥
  5090.                                 newrec->newid=(char *)tteg;
  5091.                                 newrec->left=NULL;
  5092.                                 newrec->right=NULL;
  5093.                                 newrec->rectok=tk_structvar;
  5094.                                 newrec->flag=flag|tteg->flag;
  5095.                                 newrec->line=linenumber;
  5096.                                 newrec->file=currentfileinfo;
  5097.                                 newrec->type=tp_gvar;
  5098.                                 if(FixUp)newrec->flag|=f_reloc;
  5099.                                 numel=1;
  5100.                                 nexttok();
  5101.                                 if(tok==tk_openblock){//[
  5102.                                         nexttok();
  5103.                                         if(tok!=tk_closeblock)numel=doconstlongmath();  //ç¨á«® í«¥¬¥­â®¢
  5104.                                         else numel=0;
  5105.                                         expecting(tk_closeblock);//]
  5106.                                 }
  5107.                                 newrec->recrm=numel;
  5108.                                 newrec->recsize=numel*tteg->size;
  5109.                                 dynamic=FALSE;
  5110.                                 if(tok==tk_assign||notpost==TRUE){//=
  5111.                                         if(useStartup==TRUE&&tok!=tk_assign&&numel!=0){
  5112.                                                 if(SaveStruct(numel*tteg->size,newrec)==TRUE)break;
  5113.                                         }
  5114.                                         if(alignword&&(!dynamic_flag))alignersize+=AlignCD(DS,2);       //¢ë஢­ïâì
  5115. //                                      NotPostUnion();
  5116.                                         itok.rec=newrec;
  5117.                                         if((count=FindOff((unsigned char *)newrec->recid,DS))==0){
  5118.                                                 if(dynamic_flag)dynamic=DYNAMIC_VAR;
  5119.                                         }
  5120.                                         else if(dynamic_flag)dynamic=USED_DIN_VAR;
  5121.                                         newrec->recnumber=(dynamic==0?outptrdata:0);    // ¤à¥á ­ ç «  áâàãªâãàë
  5122.                                         newrec->recpost=dynamic;
  5123.                                         if(notpost==TRUE&&tok!=tk_assign){
  5124.                                                 if(numel==0)ZeroMassiv();
  5125.                                                 for(;loop<tteg->size*numel;loop++)opd(aligner);
  5126.                                                 datasize+=loop;
  5127.                                                 break;
  5128.                                         }
  5129.                                         if(dynamic)newrec->sbuf=dynamic_var();
  5130.                                         else{
  5131.                                                 loop=initstructvar(tteg,numel);
  5132.                                                 if(numel==0){
  5133.                                                         numel=loop/tteg->size;
  5134.                                                         if((loop%tteg->size)!=0){
  5135.                                                                 numel++;
  5136.                                                                 int i=tteg->size-(loop%tteg->size);
  5137.                                                                 for(;i!=0;i--)opd(0);
  5138.                                                                 loop=numel*tteg->size;
  5139.                                                         }
  5140.                                                         newrec->recrm=numel;
  5141.                                                         newrec->recsize=loop;
  5142.                                                 }
  5143.                                                 datasize+=loop;
  5144.                                         }
  5145.                                 }
  5146.                                 else{
  5147.                                         if(numel==0){
  5148.                                                 ZeroMassiv();
  5149.                                                 break;
  5150.                                         }
  5151.                                         if(CheckUseAsUndef((unsigned char *)newrec->recid)==0&&dynamic_flag)dynamic=TRUE;
  5152.                                         switch(tok){    //­¥¨­¨æ¨ «¨§¨à®¢ ­­ë¥
  5153.                                                 default: expected(';');
  5154.                                                 case tk_semicolon: done=1;//    ;
  5155.                                                 case tk_camma:   //, post global type
  5156. //                                                      long longpostsize;
  5157.                                                         if(useStartup==TRUE){
  5158.                                                                 if(SaveStruct(numel*tteg->size,newrec)==TRUE){
  5159.                                                                         nexttok();
  5160.                                                                         break;
  5161.                                                                 }
  5162.                                                         }
  5163.                                                         newrec->recpost=dynamic+1;
  5164.                                                         loop=numel*tteg->size;
  5165.                                                         if((flag&f_extern)==0&&dynamic==0){
  5166.                                                                 if(alignword){  //¢ë஢­ïâì ­  ç¥â­ë©  ¤à¥á
  5167.                                                                         if(postsize%2==1)postsize++;
  5168.                                                                 }
  5169.                                                                 newrec->recnumber=postsize;
  5170.                                                         }
  5171.                                                         else newrec->recnumber=externnum++;
  5172.                                                         count=FindOff((unsigned char *)newrec->recid,VARPOST);
  5173.                                                         if((flag&f_extern)==0&&dynamic==0)
  5174.                                                                         /*-----------------10.09.02 23:21-------------------
  5175.                                                                          íâ®â ¢ë§®¢ ¤®«¦¥­ ¡ëâì ¯®á«¥ FindOff
  5176.                                                                                 --------------------------------------------------*/
  5177.                                                                         AddPostData(loop);
  5178.                                                         nexttok();
  5179.                                                         break;
  5180.                                         }
  5181.                                 }
  5182.                                 newrec->count=count;
  5183.                                 break;
  5184.                         case tk_proc:
  5185.                         case tk_qwordvar:
  5186.                         case tk_doublevar:
  5187.                         case tk_floatvar:
  5188.                         case tk_dwordvar:
  5189.                         case tk_longvar:
  5190.                         case tk_charvar:
  5191.                         case tk_intvar:
  5192.                         case tk_bytevar:
  5193.                         case tk_wordvar: idalreadydefined(); nexttok(); break;
  5194.                         default:
  5195.                                 if(newrec)expected(';');
  5196.                                 else errstruct();
  5197.                                 FindStopTok();
  5198.                         case tk_semicolon: done=1;
  5199.                         case tk_camma: nexttok(); break;
  5200.                 }
  5201.         }
  5202.         dopoststrings();
  5203. }
  5204.  
  5205. void InitStruct()       //¨­¨æ¨ «¨§¨à®¢ âì £«®¡ «ì­ãî áâàãªâãàã
  5206. {
  5207. struct structteg *tteg;
  5208. unsigned int flag;
  5209. //if(debug)puts("start init struct");
  5210.         flag=itok.flag;
  5211.         if(fstatic){
  5212.                 flag|=f_static;
  5213.                 fstatic=FALSE;
  5214.         }
  5215.         if(tok==tk_struct)nexttok();
  5216.         else if(tok2!=tk_id&&tok2!=tk_ID){
  5217.                 if(tok2==tk_dblcolon){
  5218.                         itok.flag=f_classproc;
  5219.                         itok.rm=am32==FALSE?tk_word:tk_dword;//tk_void;
  5220.                         itok.npointr=0;
  5221.                         doclassproc(0/*comfile==file_w32?tk_stdcall:tk_pascal 18.10.05 10:52*/);
  5222.                         return;
  5223.                 }
  5224.                 notstructname();
  5225.         }
  5226.         tteg=FindTeg(TRUE);
  5227.         if(tteg==NULL){
  5228.                 if(tok==tk_openbrace||tok2==tk_openbrace||tok==tk_colon||tok2==tk_colon)
  5229.                                 tteg=CreatTeg(TRUE);    //­ ©â¨ ¨«¨ ᮧ¤ âì ⥣
  5230.                 else{
  5231.                         while(tok!=tk_semicolon&&tok!=tk_eof)nexttok();
  5232.                         tegnotfound();
  5233.                         return;
  5234.                 }
  5235.         }
  5236.         else{
  5237.                 if(tok2==tk_openbrace)idalreadydefined();
  5238.                 nexttok();
  5239.         }
  5240.         InitStruct2(flag,tteg);
  5241. }
  5242.  
  5243. unsigned long LocalStruct2(int flag,int *localline,int binptr,char bcha,structteg *tteg)        //¨­¨æ¨ «¨§¨à®¢ âì «®ª «ì­ãî áâàãªâãàã
  5244. {
  5245. int numel,first=FALSE;
  5246. struct localrec *newrec;
  5247. unsigned long size=0;
  5248.         skipfind=TRUE;  //§ ¯à¥â¨âì ¨áª âì ¢ £«®¡ «ì­®¬ ¤¥à¥¢¥
  5249.         do{
  5250.                 if(first!=FALSE){
  5251.                         binptr=inptr2;
  5252.                         bcha=cha2;
  5253.                         nexttok();
  5254.                 }
  5255.                 first=TRUE;
  5256.                 if(tok!=tk_ID&&tok!=tk_id)idalreadydefined();
  5257.                 else{   //¨­¨æ¨ «¨§¨à®¢ âì áâàãªâãàã
  5258.                         numel=1;
  5259.                         newrec=addlocalvar((char *)string,tk_structvar,localsize);
  5260.                         newrec->rec.newid=(char *)tteg;
  5261.                         newrec->rec.flag=tteg->flag;
  5262.                         newrec->rec.type=tp_localvar;
  5263.                         nexttok();
  5264.                         if(tok==tk_openblock){//[
  5265.                                 skipfind=FALSE;
  5266.                                 nexttok();
  5267.                                 numel=doconstlongmath();        //ç¨á«® í«¥¬¥­â®¢
  5268.                                 skipfind=TRUE;
  5269.                                 expecting(tk_closeblock);//]
  5270.                         }
  5271.                         newrec->rec.recrm=numel;
  5272.                         size=numel*tteg->size;
  5273.                         newrec->rec.recsize=size;
  5274.                         if(flag&f_static){
  5275. //                              if(bcha==0)not_union_static();
  5276.                                 if(tok==tk_assign){
  5277. //                                      newrec->rec.rectok=tk_structvar;
  5278.                                         newrec->rec.recnumber=0;
  5279.                                         newrec->rec.recpost=DYNAMIC_VAR;
  5280. //                                      newrec->rec.recsize=tteg->size;
  5281. //                                      newrec->rec.recrm=numel;
  5282.                                         newrec->rec.line=linenumber;
  5283.                                         newrec->rec.file=currentfileinfo;
  5284.                                         newrec->rec.npointr=0;
  5285.                                         newrec->rec.sbuf=dynamic_var();
  5286.                                         newrec->rec.recsib=newrec->rec.type=tp_gvar;
  5287.                                 }
  5288.                                 else{
  5289.                                         newrec->rec.recpost=TRUE;
  5290.                                         if(alignword){  //¢ë஢­ïâì ­  ç¥â­ë©  ¤à¥á
  5291.                                                 if(postsize%2==1)postsize++;
  5292.                                         }
  5293.                                         newrec->rec.recnumber=postsize;
  5294.                                         AddPostData(size);
  5295.                                 }
  5296.                                 size=0;
  5297.                         }
  5298.                         else{
  5299.                                 size=Align(size,(am32==FALSE?2:4));
  5300.                                 newrec->rec.recpost=LOCAL;
  5301.                                 newrec->rec.recnumber=-localsize-size;
  5302. //                              localsize+=size;
  5303.                                 if(tok==tk_assign){
  5304.                                         if(*localline==0)*localline=linenumber;
  5305.                                         AddBackBuf(binptr,bcha);
  5306.                                 }
  5307.                         }
  5308.                 }
  5309.                 localsize+=size;
  5310.         }while(tok==tk_camma);
  5311.         skipfind=FALSE; //§ ¯à¥â¨âì ¨áª âì ¢ £«®¡ «ì­®¬ ¤¥à¥¢¥
  5312. //      localsize+=size;
  5313.         itok.name[0]=0;
  5314.         seminext();
  5315.         return size;
  5316. }
  5317.  
  5318. unsigned long LocalStruct(int flag,int *localline)      //¨­¨æ¨ «¨§¨à®¢ âì «®ª «ì­ãî áâàãªâãàã
  5319. {
  5320. struct structteg *tteg;
  5321. int binptr;
  5322. char bcha;
  5323. structteg *osearchteg;
  5324.         osearchteg=searchteg;
  5325.         searchteg=NULL;
  5326.         skipfind=TRUE;  //§ ¯à¥â¨âì ¨áª âì ¢ £«®¡ «ì­®¬ ¤¥à¥¢¥
  5327.         if(tok==tk_struct)nexttok();
  5328.         binptr=inptr2;
  5329.         bcha=cha2;
  5330.         if((tteg=FindTeg(FALSE))==NULL&&(tteg=FindTeg(TRUE))==NULL){
  5331.                 skipfind=FALSE;
  5332.                 if(tok==tk_openbrace||tok2==tk_openbrace){
  5333.                         tteg=CreatTeg(FALSE);   //­ ©â¨ ¨«¨ ᮧ¤ âì ⥣
  5334.                 }
  5335.                 else{
  5336.                         while(tok!=tk_semicolon&&tok!=tk_eof)nexttok();
  5337.                         tegnotfound();
  5338.                         searchteg=osearchteg;
  5339.                         return 0;
  5340.                 }
  5341.         }
  5342.         else{
  5343.                 searchteg=osearchteg;
  5344.                 if(tok2==tk_openbrace){
  5345.                         idalreadydefined();
  5346.                         SkipBlock2();
  5347.                         return 0;
  5348.                 }
  5349.                 nexttok();
  5350.                 if(tok!=tk_id&&tok!=tk_ID){
  5351.                         notstructname();
  5352.                         FindStopTok();
  5353.                         return 0;
  5354.                 }
  5355.         }
  5356.         searchteg=osearchteg;
  5357.         return LocalStruct2(flag,localline,binptr,bcha,tteg);
  5358. }
  5359.  
  5360. void dostruct()
  5361. {
  5362. struct structteg *tteg;
  5363. int numel;
  5364. int usenumstr;
  5365. SINFO rstr;
  5366. char *ofsst=NULL;
  5367. int oneloop=FALSE;
  5368. unsigned long hnum;
  5369. unsigned int num,sized=0,sign=FALSE;
  5370. unsigned long adr;
  5371. int localstr=FALSE;
  5372. int poststr;
  5373. int flagstr;
  5374. struct idrec *ptrs;
  5375.         if(tok2==tk_assign){
  5376.                 switch(ScanTok3()){
  5377.                         case tk_proc:
  5378.                         case tk_apiproc:
  5379.                         case tk_undefproc:
  5380.                         case tk_declare:
  5381.                                 ptrs=itok.rec;
  5382.                                 if(ptrs->recpost==LOCAL){
  5383.                                         if(ESPloc&&am32){
  5384.                                                 itok.rm=rm_mod10|rm_sib;
  5385.                                                 itok.sib=0x24;
  5386.                                                 itok.number+=addESP;
  5387.                                         }
  5388.                                         else{
  5389.                                                 itok.rm=rm_mod10|(am32==FALSE?rm_BP:rm_EBP);
  5390.                                         }
  5391.                                         itok.segm=SS;
  5392.                                         itok.post=0;
  5393.                                         compressoffset(&itok);
  5394.                                 }
  5395.                                 else{
  5396.                                         itok.segm=DS;
  5397.                                         itok.rm=(am32==FALSE?rm_d16:rm_d32);    //ãáâ ­®¢ª¨ ¯® 㬮«ç ­¨î
  5398.                                         itok.post=ptrs->recpost;
  5399.                                 }
  5400.                                 itok.sib=(am32==FALSE?CODE16:CODE32);
  5401.                                 itok.flag=ptrs->flag;
  5402.                                 switch(itok.size){
  5403.                                         case 1:
  5404.                                                 tok=tk_bytevar;
  5405.                                                 dobytevar(0);
  5406.                                                 break;
  5407.                                         case 2:
  5408.                                         case 3:
  5409.                                                 tok=tk_wordvar;
  5410.                                                 do_d_wordvar(0,r16);
  5411.                                                 break;
  5412.                                         case 4:
  5413.                                         case 5:
  5414.                                         case 6:
  5415.                                         case 7:
  5416.                                                 tok=tk_dwordvar;
  5417.                                                 do_d_wordvar(0,r32);
  5418.                                                 break;
  5419.                                         default:
  5420.                                                 tok=tk_qwordvar;
  5421.                                                 doqwordvar();
  5422.                                                 break;
  5423.                                 }
  5424.                                 return;
  5425.                 }
  5426.         }
  5427.         adr=itok.number;
  5428.         numel=itok.rm;  //ç¨á«® áâàãªâãà
  5429.         usenumstr=itok.post;    //¡ë«® 㪠§ ­¨¥ ­®¬¥à  áâàãªâãàë
  5430.         if(itok.type==tp_classvar){
  5431.                 tteg=(structteg *)itok.rec;
  5432.                 poststr=0;
  5433.                 flagstr=f_useidx;
  5434.         }
  5435.         else{
  5436.                 ptrs=itok.rec;
  5437.                 tteg=(structteg *)ptrs->newid;
  5438.                 if(ptrs->recpost==LOCAL)localstr=TRUE;
  5439.                 poststr=ptrs->recpost;
  5440.                 flagstr=ptrs->flag;
  5441.         }
  5442.         rstr=strinf;
  5443.         strinf.bufstr=NULL;
  5444.         num=itok.size;
  5445. //      if(bufrm)printf("num=%d %s\n",adr,bufrm);
  5446.         nexttok();
  5447.         if(tok==tk_assign){
  5448.                 getoperand();
  5449. int starts=0;   //ᬥ饭¨¥ § ¯®«­¥­¨ï ¢ áâàãªâãà¥
  5450.                 if(tok==tk_int||tok==tk_word){
  5451.                         sized=2;
  5452.                         getoperand();
  5453.                 }
  5454.                 else if(tok==tk_long||tok==tk_dword){
  5455.                         sized=4;
  5456.                         getoperand();
  5457.                 }
  5458.                 else if(tok==tk_char||tok==tk_byte){
  5459.                         sized=1;
  5460.                         getoperand();
  5461.                 }
  5462.                 switch(tok){
  5463.                         case tk_charvar:
  5464.                         case tk_bytevar:
  5465.                         case tk_intvar:
  5466.                         case tk_wordvar:
  5467.                         case tk_longvar:
  5468.                         case tk_dwordvar:
  5469.                                 int razr,retreg;
  5470.                                 ITOK wtok;
  5471.                                 char *wbuf;
  5472.                                 wbuf=bufrm;
  5473.                                 bufrm=NULL;
  5474.                                 wtok=itok;
  5475.                                 SINFO wstr;
  5476.                                 wstr=strinf;
  5477.                                 strinf.bufstr=NULL;
  5478.                                 if((retreg=CheckIDZReg(itok.name,AX,razr=GetVarSize(tok)))!=NOINREG){
  5479.                                         GenRegToReg(AX,retreg,razr);
  5480.                                         IDZToReg(itok.name,AX,razr);
  5481.                                         if(bufrm){
  5482.                                                 free(bufrm);
  5483.                                                 bufrm=NULL;
  5484.                                         }
  5485.                                         if(strinf.bufstr){
  5486.                                                 free(strinf.bufstr);
  5487.                                                 strinf.bufstr=NULL;
  5488.                                         }
  5489.                                         if(sized){
  5490.                                                 switch(razr){
  5491.                                                         case r8: tok=tk_beg; break;
  5492.                                                         case r16: tok=tk_reg; break;
  5493.                                                         case r32: tok=tk_reg32; break;
  5494.                                                 }
  5495.                                                 itok.number=0;
  5496.                                                 goto convr;
  5497.                                         }
  5498.                                         break;
  5499.                                 }
  5500.                                 IDZToReg(itok.name,AX,razr);
  5501.                                 if(sized==0){
  5502.                                         switch(tok){
  5503.                                                 case tk_charvar:
  5504.                                                 case tk_bytevar:
  5505.                                                         getintoal(tok,&wtok,wbuf,&wstr);
  5506.                                                         sized=1;
  5507.                                                         break;
  5508.                                                 case tk_intvar:
  5509.                                                         sign=TRUE;
  5510.                                                 case tk_wordvar:
  5511.                                                         getinto_e_ax(sign,tok,&wtok,wbuf,&wstr,r16);
  5512.                                                         sized=2;
  5513.                                                         break;
  5514.                                                 case tk_longvar:
  5515.                                                         sign=TRUE;
  5516.                                                 case tk_dwordvar:
  5517.                                                         getinto_e_ax(sign,tok,&wtok,wbuf,&wstr,r32);
  5518.                                                         sized=4;
  5519.                                                         break;
  5520.                                         }
  5521.                                 }
  5522.                                 else{
  5523. convr:
  5524.                                         switch(sized){
  5525.                                                 case 1:
  5526.                                                         getintoal(tok,&wtok,wbuf,&wstr);
  5527.                                                         break;
  5528.                                                 case 2:
  5529.                                                         getinto_e_ax(0,tok,&wtok,wbuf,&wstr,r16);
  5530.                                                         break;
  5531.                                                 case 4:
  5532.                                                         getinto_e_ax(0,tok,&wtok,wbuf,&wstr,r32);
  5533.                                                         break;
  5534.                                         }
  5535.                                 }
  5536.                                 if(usenumstr!=FALSE){
  5537. //                                      num/=ptrs->recrm;       //㪠§ ­ ­®¬¥à áâàãªâãàë - §­ ç¨â ­¥ ¢á¥
  5538.                                         num=tteg->size;
  5539.                                         if(strinf.bufstr==NULL)starts=num*numel;
  5540.                                 }
  5541.                                 num/=sized;
  5542.                                 goto fillstr;
  5543.                         case tk_minus:
  5544.                                 nexttok();
  5545.                                 if(tok!=tk_number){
  5546.                                         errstruct();
  5547.                                         break;
  5548.                                 }
  5549.                                 itok.number=-itok.number;
  5550.                         case tk_number:
  5551.                                 if(sized==0){
  5552.                                         sized=4;
  5553.                                         if(itok.number<65536)sized=2;
  5554.                                         if(itok.number<256)sized=1;
  5555.                                 }
  5556.                                 if(usenumstr!=FALSE){
  5557. //                                      num/=ptrs->recrm;       //㪠§ ­ ­®¬¥à áâàãªâãàë - §­ ç¨â ­¥ ¢á¥
  5558.                                         num=tteg->size;
  5559.                                         if(strinf.bufstr==NULL)starts=num*numel;
  5560.                                 }
  5561.                                 if(strinf.bufstr==NULL){
  5562.                                         if(optimizespeed==TRUE){
  5563.                                                 if(sized==1&&(num%2)==0){
  5564.                                                         sized=2;
  5565.                                                         itok.number=(itok.number&255)|((itok.number<<8)&0xFF00);
  5566.                                                 }
  5567.                                                 if(chip>2&&sized==2&&(num%4)==0){
  5568.                                                         sized=4;
  5569.                                                         itok.number=(itok.number&0xFFFF)|(itok.number<<16);
  5570.                                                 }
  5571.                                         }
  5572.                                         else{
  5573.                                                 if(am32==FALSE){
  5574.                                                         if(sized==1&&((num<7&&(num%2)==0)||(itok.number==0&&num==8))){
  5575.                                                                 sized=2;
  5576.                                                                 itok.number=(itok.number&255)|((itok.number<<8)&0xFF00);
  5577.                                                         }
  5578.                                                 }
  5579.                                                 else if(chip>2&&sized!=4&&(num%4)==0&&itok.number==0)sized=4;
  5580.                                         }
  5581.                                 }
  5582.                                 num/=sized;
  5583.                                 if(num==1){
  5584.                                         oneloop++;
  5585.                                         hnum=itok.number;
  5586.                                 }
  5587.                                 else if(num==2&&sized==2&&chip>2){
  5588.                                         oneloop++;
  5589.                                         hnum=(itok.number&0xFFFF)|(itok.number<<16);
  5590.                                         sized=4;
  5591.                                         num=1;
  5592.                                 }
  5593.                                 else if(num==4&&sized==1&&chip>2){
  5594.                                         oneloop++;
  5595.                                         itok.number&=255;
  5596.                                         hnum=itok.number|(itok.number<<8)|(itok.number<<16)|(itok.number<<24);
  5597.                                         sized=4;
  5598.                                         num=1;
  5599.                                 }
  5600.                                 else{
  5601.                                         if(sized==1){
  5602.                                                 if(itok.number==0)outword(0x00B0);
  5603.                                                 else{
  5604.                                                         op(0xB0);
  5605.                                                         op(itok.number);
  5606.                                                 }
  5607.                                                 ConstToReg(itok.number,AX,r8);
  5608.                                         }
  5609.                                         else MovRegNum(sized,0,itok.number,EAX);
  5610.                                 }
  5611. fillstr:
  5612. //                              itok.number=ptrs->recnumber;
  5613.                                 itok.number=adr;
  5614.                                 if(rstr.bufstr==NULL)itok.number+=starts;
  5615.                                 itok.sib=(am32==FALSE?CODE16:CODE32);
  5616.                                 if(localstr){
  5617.                                         if(comfile!=file_w32&&oneloop==FALSE){
  5618.                                                 pushss();
  5619.                                                 popes();
  5620.                                         }
  5621.                                         if(ESPloc&&am32){
  5622.                                                 itok.rm=rm_mod10|rm_sib;
  5623.                                                 itok.sib=0x24;
  5624.                                                 itok.number+=addESP;
  5625.                                         }
  5626.                                         else{
  5627.                                                 itok.rm=rm_mod10|(am32==FALSE?rm_BP:rm_EBP);
  5628.                                         }
  5629.                                         itok.segm=SS;
  5630.                                         tok=tk_rmnumber;
  5631.                                         itok.post=0;
  5632.                                         itok.size=tteg->size;
  5633.                                         compressoffset(&itok);
  5634.                                         if(rstr.bufstr!=NULL)CheckAllMassiv(bufrm,2,&rstr,&itok,EDI,EDX);
  5635.                                 }
  5636.                                 else{
  5637.                                         if(comfile!=file_w32&&oneloop==FALSE){
  5638.                                                 pushds();
  5639.                                                 popes();
  5640.                                         }
  5641.                                         itok.post=poststr;
  5642.                                         itok.segm=DS;
  5643.                                         itok.rm=(am32==FALSE?rm_d16:rm_d32);    //ãáâ ­®¢ª¨ ¯® 㬮«ç ­¨î
  5644.                                         itok.rec=NULL;//ptrs;
  5645.                                         if(rstr.bufstr==NULL){
  5646.                                                 if(itok.post!=0)tok=tk_postnumber;
  5647.                                                 else tok=tk_number;
  5648.                                         }
  5649.                                         else{
  5650. //                                              printf("bufrm=%s rstr=%s\n",bufrm,rstr.bufstr);
  5651.                                                 CheckAllMassiv(bufrm,2,&rstr,&itok,EDI,EDX);
  5652. //                                              puts("end rm");
  5653.                                                 tok=tk_rmnumber;
  5654.                                                 itok.size=tteg->size;           // ???? trap
  5655.                                         }
  5656.                                 }
  5657.                                 itok.flag=flagstr;
  5658.                                 if(oneloop){
  5659.                                         switch(sized){
  5660.                                                 case 1:
  5661.                                                         outseg(&itok,2);
  5662.                                                         op(0xC6);
  5663.                                                         op(itok.rm);
  5664.                                                         outaddress(&itok);
  5665.                                                         op(hnum);
  5666.                                                         break;
  5667.                                                 case 2:
  5668.                                                 case 4:
  5669.                                                         op66(sized);
  5670.                                                         if(hnum==0){
  5671.                                                                 outseg(&itok,2);
  5672.                                                                 op(0x83);
  5673.                                                                 op(itok.rm+0x20);
  5674.                                                                 outaddress(&itok);
  5675.                                                                 op(0);
  5676.                                                                 break;
  5677.                                                         }
  5678.                                                         if((sized==4&&hnum==0xFFFFFFFF)||(sized==2&&hnum==0xFFFF)){
  5679.                                                                 outseg(&itok,2);
  5680.                                                                 op(0x83);
  5681.                                                                 op(itok.rm+0x8);
  5682.                                                                 outaddress(&itok);
  5683.                                                                 op(0xFF);
  5684.                                                                 break;
  5685.                                                         }
  5686.                                                         if(optimizespeed==0&&sized==4&&short_ok(hnum,TRUE)){
  5687.                                                                 op(0x6A);
  5688.                                                                 op(hnum);       //push short number
  5689.                                                                 op66(sized);
  5690.                                                                 outseg(&itok,2);
  5691.                                                                 op(0x8f);
  5692.                                                                 op(itok.rm);
  5693.                                                                 outaddress(&itok);
  5694.                                                                 break;
  5695.                                                         }
  5696.                                                         outseg(&itok,2);
  5697.                                                         op(0xC7);       //mov word[],number
  5698.                                                         op(itok.rm);
  5699.                                                         outaddress(&itok);
  5700.                                                         if(sized==2)outword(hnum);
  5701.                                                         else outdword(hnum);
  5702.                                                         break;
  5703.                                         }
  5704.                                 }
  5705.                                 else{
  5706.                                         warningreg(regs[am32][DI]);
  5707.                                         getintoreg_32(DI,(am32+1)*2,0,&ofsst);
  5708.                                         if(num<=2||(num<=4&&(!optimizespeed))){
  5709.                                                 for(unsigned int i=0;i<num;i++){
  5710.                                                         if(sized==1)stosb();
  5711.                                                         else if(sized==2)stosw();
  5712.                                                         else stosd();
  5713.                                                 }
  5714.                                         }
  5715.                                         else{
  5716.                                                 MovRegNum((am32+1)*2,0,num,ECX);
  5717.                                                 warningreg(regs[am32][CX]);
  5718.                                                 ConstToReg(0,ECX,(am32+1)*2);
  5719.                                                 op(0xF3);  // REPZ
  5720.                                                 if(sized==1)stosb();
  5721.                                                 else if(sized==2)stosw();
  5722.                                                 else stosd();
  5723.                                         }
  5724.                                 }
  5725.                                 nexttok();
  5726.                                 break;
  5727.                         case tk_structvar:
  5728. struct structteg *tteg2;
  5729. int numel2;
  5730. int usenumstr2;
  5731. unsigned int num2;
  5732. int localstr2;
  5733. int poststr2;
  5734. int flagstr2;
  5735. //      adr=itok.number;
  5736.  
  5737.                                 localstr2=FALSE;
  5738.                                 numel2=itok.rm; //ç¨á«® áâàãªâãà
  5739.                                 usenumstr2=itok.post;   //¡ë«® 㪠§ ­¨¥ ­®¬¥à  áâàãªâãàë
  5740.                                 if(itok.type==tp_classvar){
  5741.                                         tteg2=(structteg *)itok.rec;
  5742.                                         poststr2=0;
  5743.                                         flagstr2=f_useidx;
  5744.                                 }
  5745.                                 else{
  5746. struct idrec *ptrs;
  5747.                                         ptrs=itok.rec;
  5748.                                         tteg2=(structteg *)ptrs->newid;
  5749.                                         if(ptrs->recpost==LOCAL)localstr2=TRUE;
  5750.                                         poststr2=ptrs->recpost;
  5751.                                         flagstr2=ptrs->flag;
  5752.                                 }
  5753.                                 num2=itok.size;
  5754. //                              ptrs2=itok.rec;
  5755. //                              tteg2=(structteg *)ptrs2->newid;
  5756. //                              numel2=itok.rm; //ç¨á«® áâàãªâãà
  5757. //                              num2=tteg2->size;
  5758.                                 if(usenumstr2!=FALSE){
  5759.                                         num2=tteg->size;
  5760.                                         if(strinf.bufstr==NULL)starts=num2*numel2;
  5761.                                 }
  5762. //                              if(itok.post==FALSE)num2*=ptrs2->recrm; //­¥ 㪠§ ­ ­®¬¥à áâàãªâãàë - §­ ç¨â ¢á¥
  5763. //                              else if(strinf.bufstr==NULL)starts=num2*numel2;
  5764.                                 if(strinf.bufstr==NULL)itok.number+=starts;
  5765.                                 itok.sib=(am32==FALSE?CODE16:CODE32);
  5766.                                 if(localstr2){
  5767.                                         itok.rm=rm_mod10;
  5768.                                         if(strinf.bufstr==NULL){
  5769.                                                 if(ESPloc&&am32){
  5770.                                                         itok.rm|=rm_sib;
  5771.                                                         itok.sib=0x24;
  5772.                                                 }
  5773.                                                 else{
  5774.                                                         itok.rm|=(am32==FALSE?rm_BP:rm_EBP);
  5775.                                                 }
  5776.                                         }
  5777.                                         else{
  5778.                                                 CheckAllMassiv(bufrm,2,&strinf);
  5779.                                                 if(am32==FALSE)itok.rm|=rm_BPSI;
  5780.                                                 else{
  5781.                                                         itok.sib=(ESPloc?0x34:0x35);
  5782.                                                         itok.rm=4|rm_mod10;
  5783.                                                 }
  5784.                                         }
  5785.                                         itok.segm=SS;
  5786.                                         if(ESPloc&&am32)itok.number+=addESP;
  5787. //                                      else itok.number-=localsize;
  5788.                                         tok=tk_rmnumber;
  5789.                                         itok.size=tteg2->size;
  5790.                                         itok.post=0;
  5791.                                         compressoffset(&itok);
  5792.                                 }
  5793.                                 else{
  5794.                                         itok.post=poststr2;
  5795.                                         itok.rm=(am32==FALSE?rm_d16:rm_d32);    //22.11.04 09:22//ãáâ ­®¢ª¨ ¯® 㬮«ç ­¨î
  5796.                                         if(strinf.bufstr==NULL){
  5797.                                                 if(itok.post==TRUE)tok=tk_postnumber;
  5798.                                                 else tok=tk_number;
  5799.                                         }
  5800.                                         else{
  5801.                                                 CheckAllMassiv(bufrm,2,&strinf);
  5802.                                                 itok.rm=rm_mod10|(am32==FALSE?rm_SI:6);
  5803.                                                 tok=tk_rmnumber;
  5804.                                                 itok.size=tteg2->size;
  5805.                                         }
  5806.                                         itok.segm=DS;
  5807.                                 }
  5808. ///!new
  5809.                                 itok.flag=flagstr2;
  5810.                                 warningreg(regs[am32][SI]);
  5811. ///!new
  5812. //                              printf("tok=%d rm=%08X %s",tok,itok.rm,itok.name);
  5813.                                 getintoreg_32(SI,(am32+1)*2,0,&ofsst);
  5814.                                 ClearReg(SI);
  5815.                                 num=tteg->size;
  5816.                                 starts=0;
  5817.                                 if(usenumstr==FALSE)num*=tteg->size;    //ptrs->recrm;  //­¥ 㪠§ ­ ­®¬¥à áâàãªâãàë - §­ ç¨â ¢á¥
  5818.                                 else if(rstr.bufstr==NULL)starts=num*numel;
  5819.                                 itok.number=adr;//ptrs->recnumber;
  5820.                                 if(rstr.bufstr==NULL)itok.number+=starts;
  5821.                                 itok.sib=(am32==FALSE?CODE16:CODE32);
  5822.                                 if(localstr){
  5823. //                              if(ptrs->recpost==LOCAL){
  5824.                                         if(ESPloc&&am32){
  5825.                                                 itok.rm=rm_mod10|rm_sib;
  5826.                                                 itok.sib=0x24;
  5827.                                                 itok.number+=addESP;
  5828.                                         }
  5829.                                         else{
  5830.                                                 itok.rm=rm_mod10|(am32==FALSE?rm_BP:rm_EBP);
  5831.                                         }
  5832.                                         itok.segm=SS;
  5833.                                         tok=tk_rmnumber;
  5834.                                         itok.size=tteg->size;
  5835.                                         itok.post=0;
  5836.                                         compressoffset(&itok);
  5837.                                         if(rstr.bufstr!=NULL)CheckAllMassiv(bufrm,2,&rstr,&itok,EDI,EDX);
  5838.                                 }
  5839.                                 else{
  5840.                                         itok.post=poststr;//ptrs->recpost;
  5841.                                         itok.segm=DS;
  5842.                                         itok.rm=(am32==FALSE?rm_d16:rm_d32);    //ãáâ ­®¢ª¨ ¯® 㬮«ç ­¨î
  5843.                                         if(rstr.bufstr==NULL){
  5844.                                                 if(itok.post==TRUE)tok=tk_postnumber;
  5845.                                                 else tok=tk_number;
  5846.                                         }
  5847.                                         else{
  5848.                                                 CheckAllMassiv(bufrm,2,&rstr,&itok,EDI,EDX);
  5849.                                                 tok=tk_rmnumber;
  5850.                                                 itok.size=tteg->size;
  5851.                                         }
  5852.                                 }
  5853. ///!new
  5854.                                 itok.flag=flagstr;//ptrs->flag;
  5855.                                 warningreg(regs[am32][DI]);
  5856.                                 if(num2>num)warnsize();
  5857.                                 ClearReg(DI);
  5858. ///!new
  5859.                                 usenumstr2=DS;
  5860.                                 if(poststr2==LOCAL)usenumstr2=SS;
  5861.                                 getintoreg_32(DI,(am32+1)*2,0,&ofsst);
  5862.                                 num=num2;
  5863.                                 sized=1;
  5864.                                 if(optimizespeed){
  5865.                                         if((num%2)==0)sized=2;
  5866.                                         if(chip>2&&(num%4)==0)sized=4;
  5867.                                 }
  5868.                                 else{
  5869.                                         if(am32==FALSE){
  5870.                                                 if((num%2)==0)sized=2;
  5871.                                         }
  5872.                                         else{
  5873.                                                 if(chip>2&&(num%4)==0)sized=4;
  5874.                                         }
  5875.                                 }
  5876.                                 num/=sized;
  5877. ///!new
  5878.                                 if(num<=2||(num<=4&&(!optimizespeed&&usenumstr2!=SS))){
  5879.                                         for(unsigned int i=0;i<num;i++){
  5880.                                                 if(usenumstr2==SS)op(0x36);
  5881.                                                 if(sized==1)movsb();
  5882.                                                 else if(sized==2)movsw();
  5883.                                                 else movsd();
  5884.                                         }
  5885.                                 }
  5886.                                 else{
  5887. ///!new
  5888.                                         MovRegNum((am32+1)*2,0,num,ECX);
  5889.                                         warningreg(regs[am32][CX]);
  5890.                                         ConstToReg(0,ECX,(am32+1)*2);
  5891.                                         if(comfile!=file_w32){
  5892.                                                 if(poststr)pushss();
  5893. //                                              if(ptrs->recpost==LOCAL)pushss();
  5894.                                                 else pushds();
  5895.                                                 popes();
  5896.                                         }
  5897.                                         op(0xF3);  // REPZ
  5898.                                         if(usenumstr2==SS)op(0x36);
  5899.                                         if(sized==1)movsb();
  5900.                                         else if(sized==2)movsw();
  5901.                                         else movsd();
  5902.                                 }
  5903.                                 break;
  5904.                         default: errstruct();
  5905.                 }
  5906.         }
  5907.         else{
  5908.                 nexttok();
  5909.                 errstruct();
  5910.         }
  5911.         if(ofsst)free(ofsst);
  5912. }
  5913.  
  5914. int SaveStruct(int size,idrec *newrec)
  5915. {
  5916. int i=0;
  5917.         if((startStartup+size)<endStartup){
  5918.                 if(alignword){  //¢ë஢­ïâì ­  ç¥â­ë©  ¤à¥á
  5919.                         if(startStartup%2==1)i=1;
  5920.                 }
  5921.                 if((startStartup+size+i)<=endStartup){
  5922.                         startStartup+=i;
  5923.                         newrec->recnumber=startStartup; // ¤à¥á ­ ç «  áâàãªâãàë
  5924.                         newrec->recpost=FALSE;
  5925.                         startStartup+=size;
  5926.                         return TRUE;
  5927.                 }
  5928.         }
  5929.         return FALSE;
  5930. }
  5931.  
  5932. int CheckAsmName(char *name)
  5933. {
  5934. char buf[IDLENGTH];
  5935.         strcpy(buf,name);
  5936.         strupr(buf);
  5937.         return FastSearch((unsigned char *)asmMnem,ofsmnem,0,buf);
  5938. }
  5939.  
  5940. void FastTok(int mode,int *tok4,ITOK *itok4)
  5941. {
  5942. int useme;
  5943. int next=1;
  5944.         *tok4=tokens;
  5945.         itok4->type=tp_ucnovn;
  5946.         whitespace(); //¯à®¯ã᪠­¥§­ ç é¨å ᨬ¢®«®¢
  5947.         if(isalpha(cha)||(cha=='_')||cha>=0x80){        //¨¤¥­â¨ä¨ª â®à
  5948.                 if(mode==1){
  5949.                         int i=0;
  5950.                         do{
  5951.                                 itok4->name[i++]=cha;
  5952.                                 nextchar();
  5953.                         }while(CheckChar2()==TRUE&&i<IDLENGTH);
  5954.                         if(i==IDLENGTH)i--;
  5955.                         itok4->name[i]=0;
  5956.                 }
  5957.                 while(CheckChar2()==TRUE)nextchar();    //¤®ç¨â âì á«®¢®
  5958.                 *tok4=tk_id;
  5959.                 return;
  5960.         }
  5961.         if(isdigit(cha)){//ç¨á« 
  5962.                 if(mode==1){
  5963.                         inptr--;
  5964.                         itok4->lnumber=scannumber(&itok4->rm);
  5965.                 }
  5966.                 else{
  5967.                         do{
  5968.                                 nextchar();
  5969.                         }while(isdigit(cha));
  5970.                 }
  5971.                 *tok4=tk_number;
  5972.                 return;
  5973.         }
  5974.         else switch(cha){
  5975.                 case '\"':
  5976.                         nextchar();     //áâப®¢ ï ª®­áâ ­â 
  5977.                         while(cha!='\"'&&!endoffile){
  5978.                                 convert_char();
  5979.                                 nextchar();
  5980.                         }
  5981.                         *tok4=tk_string;
  5982.                         break;
  5983.                 case '\'': //ᨬ¢®«ì­ ï ª®­áâ ­â  ¬®¦¥â ¨¬¥âì ¡®«¥¥ 1 ᨬ¢®« 
  5984.                         nextchar();
  5985.                         while(cha!='\''&&!endoffile){  // special character
  5986.                                 convert_char();
  5987.                                 nextchar();
  5988.                         }
  5989.                         break;
  5990.                 case '/': nextchar();
  5991.                         switch(cha){
  5992.                                 case '*': nextchar(); //ᮬ¥­â à¨©
  5993.                                         useme=1;
  5994.                                         if(mode==2)itok4->number=inptr-2;
  5995.                                         while(!endoffile&&useme>0){
  5996.                                                 whitespace();
  5997.                                                 if(cha=='*'){
  5998.                                                         nextchar();
  5999.                                                         if(cha=='/')useme--;
  6000.                                                         else continue;
  6001.                                                 }
  6002.                                                 else if(cha=='/'){
  6003.                                                         nextchar();
  6004.                                                         if(cha=='*')useme++;
  6005.                                                         else continue;
  6006.                                                 }
  6007.                                                 nextchar();
  6008.                                         }
  6009.                                         if(mode==2)*tok4=tk_comment2;
  6010.                                         else FastTok(mode,tok4,itok4);
  6011.                                         if(endoffile)*tok4=tk_eof;
  6012.                                         return;
  6013.                                 case '/':
  6014.                                         if(mode==2)itok4->number=inptr-2;
  6015.                                         do{
  6016.                                                 nextchar();
  6017.                                         }while(!endoffile&&cha!=13);    //áâப  ª®¬¥­â à¨ï
  6018.                                         if(endoffile)*tok4=tk_eof;
  6019.                                         if(mode==2)*tok4=tk_comment1;
  6020.                                         else FastTok(mode,tok4,itok4);
  6021.                                         return;
  6022.                         }
  6023.                         break;
  6024.                 case '#':
  6025.                 case '?':
  6026.                         nextchar();
  6027. //                      tokscan(&tok,&itok,string);
  6028.                         FastTok(1,tok4,itok4);
  6029. //                      if((itok.number=GetDirective((char *)string))!=-1){
  6030.                         if(*tok4==tk_id&&(itok4->number=GetDirective(itok4->name))!=-1){
  6031.                                 *tok4=tk_question;
  6032.                         }
  6033.                         return;
  6034.                 case ';': *tok4=tk_semicolon;   break;
  6035.                 case '[': *tok4=tk_openblock; break;
  6036.                 case ']': *tok4=tk_closeblock; break;
  6037.                 case '(': *tok4=tk_openbracket; break;
  6038.                 case ')': *tok4=tk_closebracket; break;
  6039.                 case '{': *tok4=tk_openbrace; break;
  6040.                 case '}': *tok4=tk_closebrace; break;
  6041.                 case ',': *tok4=tk_camma; break;
  6042.                 case ':': *tok4=tk_colon; break;
  6043.                 case 26: *tok4=tk_eof; return;
  6044.                 case 13: *tok4=tk_endline; break;
  6045.                 case '\\':
  6046.                         nextchar();
  6047.                         if(cha==13){
  6048.                                 FastTok(mode,tok4,itok4);
  6049.                                 if(tok==tk_endline)FastTok(mode,tok4,itok4);
  6050.                                 return;
  6051.                         }
  6052.                         break;
  6053.                 case '!':
  6054.                         nextchar();
  6055.                         if(cha=='='){
  6056.                                 *tok4=tk_notequal;              //!=
  6057.                                 itok4->type=tp_compare;
  6058.                         }
  6059.                         else{
  6060.                                 *tok4=tk_not;
  6061.                                 next=0;
  6062.                         }
  6063.                         break;
  6064.                 case '=':
  6065.                         nextchar();
  6066.                         if(cha=='='){
  6067.                                 *tok4=tk_equalto;  //==
  6068.                                 itok4->type=tp_compare;
  6069.                         }
  6070.                         else{
  6071.                                 *tok4=tk_assign;                                                 //¯à¨á¢®¨âì
  6072.                                 next=0;
  6073.                         }
  6074.                         break;
  6075.                 case '>':
  6076.                         nextchar();
  6077.                         switch(cha){
  6078.                                 case '>':
  6079.                                         nextchar();
  6080.                                         if(cha=='=')*tok4=tk_rrequals; //ᤢ¨£ ¢¯à ¢® á ¯à¨á¢®¥­¨¥¬
  6081.                                         else{
  6082.                                                 *tok4=tk_rr;                                                    //ᤢ¨£ ¢¯à ¢®
  6083.                                                 next=0;
  6084.                                                 itok4->type=tp_opperand;
  6085.                                         }
  6086.                                         break;
  6087.                                 case '<': *tok4=tk_swap; break;                          //®¡¬¥­
  6088.                                 case '=': *tok4=tk_greaterequal; itok4->type=tp_compare; break; //¡®«ìè¥ ¨«¨ à ¢­®
  6089.                                 default: *tok4=tk_greater; next=0; itok4->type=tp_compare; break; //¡®«ìè¥
  6090.                         }
  6091.                         break;
  6092.                 case '<':
  6093.                         nextchar();
  6094.                         switch(cha){
  6095.                                 case '<':
  6096.                                         nextchar();
  6097.                                         if(cha=='=')*tok4=tk_llequals;   //ᤢ¨£ ¢«¥¢® á ¯à¨á¢®¥­¨¥¬
  6098.                                         else{
  6099.                                                 *tok4=tk_ll;                                                             //ᤢ¨£ ¢«¥¢®
  6100.                                                 next=0;
  6101.                                                 itok4->type=tp_opperand;
  6102.                                         }
  6103.                                         break;
  6104.                                 case '>': *tok4=tk_notequal; itok4->type=tp_compare; break;  //!=
  6105.                                 case '=': *tok4=tk_lessequal; itok4->type=tp_compare; break; //¬¥­ìè¥ ¨«¨ à ¢­®
  6106.                                 default: *tok4=tk_less; next=0; itok4->type=tp_compare; break;//¬¥­ìè¥
  6107.                         }
  6108.                         break;
  6109.         }
  6110.         if(next)nextchar();
  6111. }
  6112.  
  6113. void FindDirectiv()
  6114. //ã᪮७­ë© ¯®¨áª ¤¨à¥ªâ¨¢ë
  6115. {
  6116.         inptr=inptr2;
  6117.         cha=cha2;
  6118.         linenumber=linenum2;
  6119.         do{
  6120.                 FastTok(0);
  6121.         }while(tok!=tk_question&&tok!=tk_eof);
  6122.         inptr2=inptr;
  6123.         cha2=cha;
  6124.         linenum2=linenumber;
  6125. }
  6126.  
  6127. unsigned long long scannumber(int *rm)
  6128. {
  6129. int useme=0,binnum=0;
  6130. unsigned char c;
  6131. unsigned long long number=0;
  6132.         *rm=tokens;
  6133.         for(int i=inptr;;i++){
  6134.                 c=input[i];
  6135.                 unsigned char cc=c&(unsigned char)0x5f;
  6136.                 if(cc>='A'&&cc<='F'){
  6137.                         if(cc=='B'&&binnum==1)binnum++;
  6138.                         else binnum=3;
  6139.                         useme=3;
  6140.                 }
  6141.                 else if(c<'0'||c>'9'){
  6142.                         if(useme==0&&c=='.'&&input[i+1]!='.'){  //float
  6143.                                 binnum=3;
  6144.                                 useme++;
  6145.                                 *rm=tk_double;
  6146.                                 *(double *)&number=atof((char *)&input[inptr]);
  6147. //                              printf("float=%f %08X\n",*(float *)&number,*(long *)&number);
  6148.                                 inptr=i+1;
  6149.                                 do{
  6150.                                         nextchar();
  6151.                                 }while(isdigit(cha));
  6152.                                 if((cha&0x5f)!='E')break;
  6153.                                 nextchar();
  6154.                                 if(isdigit(cha)||cha=='-'){
  6155.                                         do{
  6156.                                                 nextchar();
  6157.                                         }while(isdigit(cha));
  6158.                                 }
  6159.                                 break;
  6160.                         }
  6161.                         else if(cc=='H'){       //hex
  6162.                                 useme=2;
  6163.                                 binnum=3;
  6164.                                 break;
  6165.                         }
  6166.                         break;
  6167.                 }
  6168.                 else if(c<'2'&&(binnum==0||binnum==2))binnum++;
  6169.         }
  6170.         if(binnum==2)goto cbinnum;
  6171.         if(useme!=1){
  6172.                 nextchar();
  6173.                 if(useme==2)goto hexnum;
  6174.                 if(cha=='0'){
  6175.                         nextchar();
  6176.                         switch(cha&0x5f){
  6177.                                 case 'X':        // hexadecimal number
  6178.                                         nextchar();
  6179. hexnum:
  6180.                                         while(isxdigit(cha)){
  6181.                                                 number*=16;
  6182.                                                 if(isdigit(cha))number+=cha-'0';
  6183.                                                 else number+=(cha&0x5f)-'7';
  6184.                                                 nextchar();
  6185.                                         }
  6186.                                         if(useme==2)nextchar();
  6187.                                         useme++;
  6188.                                         break;
  6189.                                 case 'B':       // binary number
  6190. cbinnum:
  6191.                                         nextchar();
  6192.                                         while(cha=='0'||cha=='1'){
  6193.                                                 number=number*2+(cha-'0');
  6194.                                                 nextchar();
  6195.                                         }
  6196.                                         if(binnum==2)nextchar();
  6197.                                         else useme++;
  6198.                                         break;
  6199.                                 case 'O':       // octal number
  6200.                                         nextchar();
  6201.                                         while(cha>='0'&&cha<='7'){
  6202.                                                 number=number*8+(cha-'0');
  6203.                                                 nextchar();
  6204.                                         }
  6205.                                         useme++;
  6206.                                         break;
  6207.                         }
  6208.                 }
  6209.                 if(useme==0||useme==3){         // decimal number
  6210.                         while(isdigit(cha)){
  6211.                                 number=number*10+(cha-'0');
  6212.                                 nextchar();
  6213.                         }
  6214.                 }
  6215.         }
  6216.         c=(unsigned char)(cha&0x5F);
  6217.         if(c=='I'){
  6218.                 if(input[inptr]=='6'&&input[inptr+1]=='4'){
  6219.                         inptr+=2;
  6220.                         nextchar();
  6221.                         *rm=tk_qword;
  6222.                 }
  6223.         }
  6224.         else if(c=='L'||c=='U'||c=='F'||c=='Q'){
  6225.                 if(c=='L')*rm=tk_dword;
  6226.                 if(c=='F'){
  6227.                         *rm=tk_float;
  6228.                         *(float *)&number=*(double *)&number;
  6229.                 }
  6230.                 if(c=='Q')*rm=tk_qword;
  6231.                 nextchar();
  6232.                 c=(unsigned char)(cha&0x5F);
  6233.                 if(c=='L'||c=='U'){
  6234.                         if(c=='L')*rm=tk_dword;
  6235.                         nextchar();
  6236.                 }
  6237.         }
  6238.         if(*rm==tokens){
  6239.                 if(number<256)*rm=tk_byte;
  6240.                 else if(number<65536)*rm=tk_word;
  6241.                 else if(number<0x100000000LL)*rm=tk_dword;
  6242.                 else *rm=tk_qword;
  6243.         }
  6244.         return number;
  6245. }
  6246.  
  6247. void tag_massiv(int *tok4,ITOK *itok4,unsigned char *string4)
  6248. {
  6249. struct structteg *tteg;
  6250. int number,tok,rm;
  6251.         tok=*tok4;
  6252.         number=itok4->number;
  6253.         nextchar();
  6254. //14.09.04 18:52
  6255.         do{
  6256.                 FastTok(1,tok4,itok4);
  6257.                 strcpy((char *)string4,itok4->name);
  6258.                 searchtree2(definestart,itok4,tok4,string4);
  6259.         }while(*tok4==tk_endline);
  6260. ///////////////////
  6261. //      printf("tok=%d %s\n",*tok4,itok4->name);
  6262.         char *tn;
  6263.         if((tn=strchr(itok4->name,'@'))!=NULL)*tn=0;
  6264.         if((tteg=FindTeg(FALSE,itok4->name))!=NULL||(tteg=FindTeg(TRUE,itok4->name))!=NULL){
  6265. //      printf("tok=%d %s\n",*tok4,itok4->name);
  6266.                 itok4->number=0;
  6267.                 dostructvar2(tok4,itok4,tteg,string4);
  6268.                 rm=RegToRM(number,tok);
  6269. //      printf("tok=%d rm=%d %s\n",*tok4,itok4->rm,itok4->name);
  6270.                 if(*tok4==tk_pointer&&itok4->type==tk_proc){
  6271.                         itok4->sib=rm|rm_mod10;
  6272.                         itok4->flag&=~f_reloc;
  6273.                 }
  6274.                 else if(*tok4!=tk_proc&&*tok4!=tk_declare/*&&(itok4->flag&f_static)==0 íä䥪⠤®¡ ¢«¥­¨ï ॣà¨áâà */){
  6275.                         itok4->rm=rm_mod10|rm;
  6276.                         itok4->flag&=~f_reloc;
  6277.                 }
  6278.                 if(*tok4==tk_proc||*tok4==tk_declare||*tok4==tk_undefproc){
  6279.                         structadr.sib=THIS_REG;
  6280.                         structadr.rm=number;
  6281.                 }
  6282.                 else if(*tok4==tk_id||*tok4==tk_ID||*tok4==tk_structvar){
  6283.                         *tok4=tk_rmnumber;
  6284.                         itok4->segm=(splitdata==FALSE)?DS:CS;
  6285.                         itok4->post=0;
  6286.                 }
  6287.                 if(bufrm&&strcmp(bufrm,"&this;")==0){
  6288.                         free(bufrm);
  6289.                         bufrm=NULL;
  6290.                 }
  6291. //      printf("tok=%d rm=%d post=%d %s\n",*tok4,itok4->rm,itok4->post,itok4->name);
  6292. //      if(strinf.bufstr)puts(strinf.bufstr);
  6293.         }
  6294.         else if(displaytokerrors){
  6295.                 unknowntagstruct(itok4->name);
  6296.                 *tok4=tk_number;
  6297.         }
  6298. }
  6299.  
  6300. int RegToRM(int number,int tok4)
  6301. {
  6302. int rm;
  6303.         if(displaytokerrors){
  6304.                 if(am32==FALSE&&tok4==tk_reg32)regBXDISIBPexpected();
  6305.                 else if(am32&&tok4==tk_reg)reg32expected();
  6306.         }
  6307.         if(am32==FALSE){
  6308.                 switch(number){
  6309.                         case BX:
  6310.                                 rm=rm_BX;
  6311.                                 break;
  6312.                         case DI:
  6313.                                 rm=rm_DI;
  6314.                                 break;
  6315.                         case SI:
  6316.                                 rm=rm_SI;
  6317.                                 break;
  6318.                         case BP:
  6319.                                 rm=rm_BP;
  6320.                                 break;
  6321.                         default:
  6322.                                 if(displaytokerrors)regBXDISIBPexpected();
  6323.                                 break;
  6324.                 }
  6325.         }
  6326.         else rm=number;
  6327.         return rm;
  6328. }
  6329.  
  6330. int CheckResName(char *name)
  6331. {
  6332. char buf[IDLENGTH];
  6333.         strcpy(buf,name);
  6334.         strlwr(buf);
  6335.         return FastSearch((unsigned char *)resMnem,ofsres,3,buf);
  6336. }
  6337.  
  6338. int GetTokVar2()
  6339. {
  6340. ITOK cstok;
  6341. int i;
  6342. unsigned char ocha=cha;
  6343. unsigned int oinptr=inptr;
  6344. int oline=linenumber;
  6345. char odisplay=displaytokerrors;
  6346.         displaytokerrors=0;
  6347.         tokscan(&i,&cstok,string2);
  6348.         displaytokerrors=odisplay;
  6349.         switch(i){
  6350.                 case tk_number:
  6351.                         cha=ocha;
  6352.                         inptr=oinptr;
  6353.                         linenumber=oline;
  6354.                 case tk_int:
  6355.                 case tk_char:
  6356.                 case tk_long:
  6357.                 case tk_short:
  6358.                 case tk_byte:
  6359.                 case tk_word:
  6360.                 case tk_dword:
  6361.                 case tk_signed:
  6362.                 case tk_unsigned:
  6363.                 return i;
  6364.         }
  6365.         cha=ocha;
  6366.         inptr=oinptr;
  6367.         linenumber=oline;
  6368.         return 0;
  6369. }
  6370.  
  6371. void GetTypeVar(int *tok4)
  6372. {
  6373. static int use=0;
  6374. int i;
  6375.         if(use)return;
  6376.         use=1;
  6377.         i=GetTokVar2();
  6378.         if(*tok4==tk_signed){
  6379.                 if(i==tk_char||i==tk_int||i==tk_long){
  6380.                         *tok4=i;
  6381.                         i=GetTokVar2();
  6382.                         if(*tok4==tk_long){
  6383.                                 if(i==tk_long)*tok4=tk_qword;
  6384.                                 else if(i!=tk_int&&i!=0&&displaytokerrors)unknowntype();
  6385.                         }
  6386.                         if(*tok4==tk_int&&am32)*tok4=tk_long;
  6387.                 }
  6388.                 else if(i==tk_short){
  6389.                         i=GetTokVar2();
  6390.                         *tok4=tk_int;
  6391.                         if(i!=0&&i!=tk_int&&displaytokerrors)unknowntype();
  6392.                 }
  6393.                 else if(i==0)*tok4=(am32==0?tk_int:tk_long);
  6394.                 else if(displaytokerrors)unknowntype();
  6395.         }
  6396.         else if(*tok4==tk_unsigned){
  6397.                 switch(i){
  6398.                         case tk_char:
  6399.                                 *tok4=tk_byte;
  6400.                                 break;
  6401.                         case tk_int:
  6402.                                 *tok4=(am32==0?tk_word:tk_dword);
  6403.                                 break;
  6404.                         case tk_long:
  6405.                                 *tok4=tk_dword;
  6406.                                 i=GetTokVar2();
  6407.                                 if(i==tk_long)*tok4=tk_qword;
  6408.                                 else if(i!=tk_int&&i!=0&&displaytokerrors)unknowntype();
  6409.                                 break;
  6410.                         case tk_short:
  6411.                                 *tok4=tk_word;
  6412.                                 i=GetTokVar2();
  6413.                                 if(i!=0&&i!=tk_int&&displaytokerrors)unknowntype();
  6414.                                 break;
  6415.                         case 0:
  6416.                                 *tok4=(am32==0?tk_word:tk_dword);
  6417.                                 break;
  6418.                         default:
  6419.                                 if(displaytokerrors)unknowntype();
  6420.                 }
  6421.         }
  6422.         else if(i==tk_int&&(*tok4==tk_long||*tok4==tk_short))*tok4=i;
  6423.         else if(*tok4==tk_short)*tok4=tk_int;
  6424.         else if(*tok4==tk_int&&(!(idasm==TRUE&&i==tk_number))&&am32)*tok4=tk_long;
  6425.         else if(i==tk_long&& *tok4==tk_long)*tok4=tk_qword;
  6426.         use=0;
  6427. }
  6428.  
  6429. int CheckDef()
  6430. {
  6431. int otok;
  6432.         if(skipfind!=LOCAL)return FALSE;
  6433.         switch(tok2){
  6434.                 case tk_semicolon:
  6435.                 case tk_assign:
  6436.                 case tk_openblock:
  6437.                 case tk_openbracket:
  6438.                 case tk_camma:
  6439.                 case tk_openbrace:
  6440.                         return FALSE;
  6441.         }
  6442.         otok=tok;
  6443.         searchtree2(definestart,&itok,&tok,string);
  6444.         if(tok==otok)return FALSE;
  6445.         return TRUE;
  6446. }
  6447.  
  6448. /* end of TOKA.C */
  6449.