Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. #define _REGOPT_
  2.  
  3.  
  4.  
  5. #include "tok.h"
  6.  
  7.  
  8.  
  9. unsigned char optinitreg=TRUE;
  10.  
  11. int OptNameIDX(char *name,char *nam,int size);
  12.  
  13. int getnumber(char *buf,unsigned long *num,int *typenum=NULL);
  14.  
  15. int convertrazr(int *reg,int razr);
  16.  
  17.  
  18.  
  19. enum{
  20.  
  21.         t_undef,
  22.  
  23.         t_const,
  24.  
  25.         t_string,
  26.  
  27.         t_id,
  28.  
  29. };
  30.  
  31.  
  32.  
  33. enum{
  34.  
  35.         razr_8l,
  36.  
  37.         razr_8h,
  38.  
  39.         razr_16,
  40.  
  41.         razr_32
  42.  
  43. };
  44.  
  45.  
  46.  
  47. REGISTERSTAT *regstat;
  48.  
  49.  
  50.  
  51. #ifdef OPTVARCONST
  52.  
  53. void CompareLVIC(BLVIC *bak);
  54.  
  55. void FreeLVIC(BLVIC *bak);
  56.  
  57. BLVIC *BakLVIC();
  58.  
  59. void CopyLVIC(BLVIC *bak);
  60.  
  61. #endif
  62.  
  63.  
  64.  
  65. void KillRegLec(int reg)
  66.  
  67. {
  68.  
  69.         KillVar(regs[0][reg]);
  70.  
  71.         KillVar(regs[1][reg]);
  72.  
  73.         if(reg<4){
  74.  
  75.                 KillVar(begs[reg]);
  76.  
  77.                 KillVar(begs[reg+4]);
  78.  
  79.         }
  80.  
  81. }
  82.  
  83.  
  84.  
  85. void ClearReg(int reg)
  86.  
  87. {
  88.  
  89.         if(optinitreg==FALSE)return;
  90.  
  91.         (regstat+reg)->type=t_undef;
  92.  
  93. REGEQVAR *curv,*nextv;
  94.  
  95.         curv=(regstat+reg)->next;
  96.  
  97.         while(curv){
  98.  
  99.                 nextv=curv->next;
  100.  
  101.                 free(curv);
  102.  
  103.                 curv=nextv;
  104.  
  105.         }
  106.  
  107.         (regstat+reg)->next=NULL;
  108.  
  109. //      printf("clear reg %d\n",reg);
  110.  
  111.         KillRegLec(reg);
  112.  
  113. }
  114.  
  115.  
  116.  
  117. void clearregstat(int regs)
  118.  
  119. {
  120.  
  121.         if(optinitreg==FALSE)return;
  122.  
  123.         for(int i=0;i<8;i++){
  124.  
  125.                 if((regs&(1<<i))==0){
  126.  
  127.                         (regstat+i)->type=t_undef;
  128.  
  129. REGEQVAR *curv,*nextv;
  130.  
  131.                         curv=(regstat+i)->next;
  132.  
  133.                         while(curv){
  134.  
  135.                                 nextv=curv->next;
  136.  
  137.                                 free(curv);
  138.  
  139.                                 curv=nextv;
  140.  
  141.                         }
  142.  
  143.                         (regstat+i)->next=NULL;
  144.  
  145.                 }
  146.  
  147.         }
  148.  
  149. }
  150.  
  151.  
  152.  
  153. void initregstat()
  154.  
  155. {
  156.  
  157.         regstat=(REGISTERSTAT *)MALLOC(sizeof(REGISTERSTAT)*8);
  158.  
  159.         for(int i=0;i<8;i++)(regstat+i)->next=NULL;
  160.  
  161.         clearregstat();
  162.  
  163. }
  164.  
  165.  
  166.  
  167. void deinitregstat()
  168.  
  169. {
  170.  
  171.         if(regstat){
  172.  
  173.                 clearregstat();
  174.  
  175.                 free(regstat);
  176.  
  177.         }
  178.  
  179.         regstat=NULL;
  180.  
  181. }
  182.  
  183.  
  184.  
  185. REGISTERSTAT *BakRegStat()
  186.  
  187. {
  188.  
  189. REGISTERSTAT *bakregstat;
  190.  
  191. #ifndef OPTVARCONST
  192.  
  193.         if(optinitreg==FALSE)return NULL;
  194.  
  195.         bakregstat=(REGISTERSTAT *)MALLOC(sizeof(REGISTERSTAT)*8);
  196.  
  197. #else
  198.  
  199.         bakregstat=(REGISTERSTAT *)MALLOC(sizeof(REGISTERSTAT)*8+sizeof(BLVIC *));
  200.  
  201.         (bakregstat+8)->bakvic=BakLVIC();
  202.  
  203. #endif
  204.  
  205.         memcpy(bakregstat,regstat,sizeof(REGISTERSTAT)*8);
  206.  
  207. REGEQVAR *cur,*news;
  208.  
  209.         for(int i=0;i<8;i++){
  210.  
  211.                 if((bakregstat+i)->next){
  212.  
  213.                         cur=(REGEQVAR *)MALLOC(sizeof(REGEQVAR));
  214.  
  215.                         memcpy(cur,(bakregstat+i)->next,sizeof(REGEQVAR));
  216.  
  217.                         (bakregstat+i)->next=cur;
  218.  
  219.                         while(cur->next){
  220.  
  221.                                 news=(REGEQVAR *)MALLOC(sizeof(REGEQVAR));
  222.  
  223.                                 memcpy(news,cur->next,sizeof(REGEQVAR));
  224.  
  225.                                 cur->next=news->next;
  226.  
  227.                         }
  228.  
  229.                 }
  230.  
  231.         }
  232.  
  233.         return bakregstat;
  234.  
  235. }
  236.  
  237.  
  238.  
  239. void CopyRegStat(REGISTERSTAT *bak)
  240.  
  241. {
  242.  
  243. #ifndef OPTVARCONST
  244.  
  245.         if(optinitreg==FALSE||bak==NULL)return;
  246.  
  247. #else
  248.  
  249.         if(bak==NULL)return;
  250.  
  251.         CopyLVIC((bak+8)->bakvic);
  252.  
  253. #endif
  254.  
  255.         memcpy(regstat,bak,sizeof(REGISTERSTAT)*8);
  256.  
  257. REGEQVAR *cur,*news;
  258.  
  259.         for(int i=0;i<8;i++){
  260.  
  261.                 if((regstat+i)->next){
  262.  
  263.                         cur=(REGEQVAR *)MALLOC(sizeof(REGEQVAR));
  264.  
  265.                         memcpy(cur,(regstat+i)->next,sizeof(REGEQVAR));
  266.  
  267.                         (regstat+i)->next=cur;
  268.  
  269.                         while(cur->next){
  270.  
  271.                                 news=(REGEQVAR *)MALLOC(sizeof(REGEQVAR));
  272.  
  273.                                 memcpy(news,cur->next,sizeof(REGEQVAR));
  274.  
  275.                                 cur->next=news->next;
  276.  
  277.                         }
  278.  
  279.                 }
  280.  
  281.         }
  282.  
  283. }
  284.  
  285.  
  286.  
  287. void ClearRegBak(int reg,REGISTERSTAT *regst)
  288.  
  289. {
  290.  
  291. REGEQVAR *curv,*nextv;
  292.  
  293.         (regst+reg)->type=t_undef;
  294.  
  295.         curv=(regst+reg)->next;
  296.  
  297.         while(curv){
  298.  
  299.                 nextv=curv->next;
  300.  
  301.                 free(curv);
  302.  
  303.                 curv=nextv;
  304.  
  305.         }
  306.  
  307.         (regst+reg)->next=NULL;
  308.  
  309. }
  310.  
  311.  
  312.  
  313. void AddRegVar(int reg, int razr,ITOK *itok4)
  314.  
  315. {
  316.  
  317.         if(optinitreg==FALSE||(itok4->flag&f_useidx)!=0)return;
  318.  
  319. REGEQVAR *cur,*news;
  320.  
  321.         cur=(REGEQVAR *)MALLOC(sizeof(REGEQVAR));
  322.  
  323.         cur->razr=convertrazr(&reg,razr);
  324.  
  325.         cur->next=NULL;
  326.  
  327.         strcpy(cur->name,itok4->name);
  328.  
  329.         if((regstat+reg)->next==NULL)(regstat+reg)->next=cur;
  330.  
  331.         else{
  332.  
  333.                 news=(regstat+reg)->next;
  334.  
  335.                 while(news->next)news=news->next;
  336.  
  337.                 news->next=cur;
  338.  
  339.         }
  340.  
  341. }
  342.  
  343.  
  344.  
  345. int GetRegVar(ITOK *itok4)
  346.  
  347. {
  348.  
  349.         if(optinitreg==FALSE||(itok4->flag&f_useidx)!=0)return 0;
  350.  
  351. int retval=0;
  352.  
  353.         for(int i=0;i<8;i++){
  354.  
  355. REGEQVAR *cur;
  356.  
  357.                 cur=(regstat+i)->next;
  358.  
  359.                 while(cur){
  360.  
  361.                         if(strcmp(itok4->name,cur->name)==0){
  362.  
  363.                                 retval|=(1<<i);
  364.  
  365.                                 break;
  366.  
  367.                         }
  368.  
  369.                         cur=cur->next;
  370.  
  371.                 }
  372.  
  373.         }
  374.  
  375.         return retval;
  376.  
  377. }
  378.  
  379.  
  380.  
  381. void FreeStat(REGISTERSTAT *bak)
  382.  
  383. {
  384.  
  385. #ifndef OPTVARCONST
  386.  
  387.         if(optinitreg==FALSE||bak==NULL)return;
  388.  
  389. #else
  390.  
  391.         if(bak==NULL)return;
  392.  
  393.         FreeLVIC((bak+8)->bakvic);
  394.  
  395. #endif
  396.  
  397.         for(int i=0;i<8;i++)ClearRegBak(i,bak);
  398.  
  399.         free(bak);
  400.  
  401. }
  402.  
  403.  
  404.  
  405. void CompareRegStat(REGISTERSTAT *bak)
  406.  
  407. {
  408.  
  409. #ifndef OPTVARCONST
  410.  
  411.         if(optinitreg==FALSE||bak==NULL)return;
  412.  
  413. #else
  414.  
  415.         if(bak==NULL)return;
  416.  
  417.         CompareLVIC((bak+8)->bakvic);
  418.  
  419. #endif
  420.  
  421.         for(int i=0;i<8;i++){
  422.  
  423.                 if((regstat+i)->type==t_undef||(regstat+i)->type!=(bak+i)->type||
  424.  
  425.                                 ((regstat+i)->type==t_id&&strcmp((regstat+i)->id,(bak+i)->id)!=0))ClearRegBak(i,bak);
  426.  
  427.         }
  428.  
  429. }
  430.  
  431.  
  432.  
  433. int convertrazr(int *reg,int razr)
  434.  
  435. {
  436.  
  437. int nr;
  438.  
  439.         if(razr==r8){
  440.  
  441.                 if(*reg<4)nr=razr_8l;
  442.  
  443.                 else{
  444.  
  445.                         nr=razr_8h;
  446.  
  447.                         *reg-=4;
  448.  
  449.                 }
  450.  
  451.         }
  452.  
  453.         else if(razr==r16)nr=razr_16;
  454.  
  455.         else nr=razr_32;
  456.  
  457.         return nr;
  458.  
  459. }
  460.  
  461.  
  462.  
  463. void ConstToReg(unsigned long num,int reg,int razr)
  464.  
  465. {
  466.  
  467. char buf[64];
  468.  
  469.         if(optinitreg){
  470.  
  471.                 sprintf(buf,"%ld",num);
  472.  
  473.                 IDZToReg(buf,reg,razr);
  474.  
  475.         }
  476.  
  477. }
  478.  
  479.  
  480.  
  481. void GenRegToReg(int regd,int regs,int razr)
  482.  
  483. {
  484.  
  485.         switch(razr){
  486.  
  487.                 case r8:
  488.  
  489.                         op(0x88);
  490.  
  491.                         op(128+64+regs*8+regd);
  492.  
  493.                         break;
  494.  
  495.                 case r16:
  496.  
  497.                 case r32:
  498.  
  499.                         op66(razr);
  500.  
  501.                         op(0x89);
  502.  
  503.                         op(128+64+regs*8+regd);
  504.  
  505.                         break;
  506.  
  507.         }
  508.  
  509. }
  510.  
  511.  
  512.  
  513. int CheckIDZReg(char *name,int reg,int razr)
  514.  
  515. /*
  516.  
  517.  name -  ¤à¥á áâப¨
  518.  
  519.  */
  520.  
  521. {
  522.  
  523. int nr;
  524.  
  525. int retreg=NOINREG;
  526.  
  527. int i;
  528.  
  529.         if(optinitreg==FALSE||razr>r32)return NOINREG;
  530.  
  531.         nr=convertrazr(&reg,razr);
  532.  
  533.         for(i=0;i<8;i++){
  534.  
  535. //printf("%d type=%d razr=%d %s\n",i,(regstat+i)->type,(regstat+i)->razr,(regstat+i)->id);
  536.  
  537.                 if((regstat+i)->type==t_id){
  538.  
  539.                         if((regstat+i)->razr==nr||(razr==r8&&((regstat+i)->razr==razr_8l||
  540.  
  541.                                         (regstat+i)->razr==razr_8h))){
  542.  
  543.                                 if(strcmp(name,(regstat+i)->id)==0){
  544.  
  545.                                         if(i==reg&&nr==(regstat+i)->razr){
  546.  
  547.                                                 if(/*razr==r8&&*/nr==razr_8h)reg+=4;
  548.  
  549.                                                 waralreadinit(razr==r8?begs[reg]:regs[razr/4][reg]);
  550.  
  551. //                                      printstatreg();
  552.  
  553.                                                 return SKIPREG;
  554.  
  555.                                         }
  556.  
  557.                                         retreg=i;
  558.  
  559.                                 }
  560.  
  561.                         }
  562.  
  563.                 }
  564.  
  565. REGEQVAR *cur;
  566.  
  567.                 cur=(regstat+i)->next;
  568.  
  569.                 while(cur){
  570.  
  571.                         if(cur->razr==nr||(razr==r8&&(cur->razr==razr_8l||cur->razr==razr_8h))){
  572.  
  573.                                 if(strcmp(name,cur->name)==0){
  574.  
  575.                                         if(i==reg&&nr==cur->razr){
  576.  
  577.                                                 if(nr==razr_8h)reg+=4;
  578.  
  579.                                                 waralreadinit(razr==r8?begs[reg]:regs[razr/4][reg]);
  580.  
  581.                                                 return SKIPREG;
  582.  
  583.                                         }
  584.  
  585.                                         retreg=i;
  586.  
  587.                                         break;
  588.  
  589.                                 }
  590.  
  591.                         }
  592.  
  593.                         cur=cur->next;
  594.  
  595.                 }
  596.  
  597.         }
  598.  
  599.         if(retreg!=NOINREG){
  600.  
  601.                 if(razr==r8){
  602.  
  603.                         if((regstat+retreg)->razr==razr_8h)retreg+=4;
  604.  
  605.                         if(nr==razr_8h)reg+=4;
  606.  
  607.                         waralreadinitreg(begs[reg],begs[retreg]);
  608.  
  609.                 }
  610.  
  611.                 else waralreadinitreg(regs[razr/4][reg],regs[razr/4][retreg]);
  612.  
  613.         }
  614.  
  615.         return retreg;
  616.  
  617. }
  618.  
  619.  
  620.  
  621. void IDZToReg(char *name,int reg,int razr)
  622.  
  623. /*
  624.  
  625.  name -  ¤à¥á áâப¨
  626.  
  627.  */
  628.  
  629. {
  630.  
  631. int nr;
  632.  
  633.         if(optinitreg==FALSE||name==NULL||razr>r32)return;
  634.  
  635.         nr=convertrazr(&reg,razr);
  636.  
  637.         ClearReg(reg);
  638.  
  639.         (regstat+reg)->type=t_id;
  640.  
  641.         (regstat+reg)->razr=nr;
  642.  
  643.         strcpy((regstat+reg)->id,name);
  644.  
  645.         KillRegLec(reg);
  646.  
  647. }
  648.  
  649.  
  650.  
  651. int GetRegNumber(int reg,unsigned long *num,int razr)
  652.  
  653. {
  654.  
  655. int nr;
  656.  
  657.         nr=convertrazr(&reg,razr);
  658.  
  659.         if(optinitreg!=FALSE&&razr<=r32&&(regstat+reg)->type==t_id&&
  660.  
  661.                         (regstat+reg)->razr==nr){
  662.  
  663.                 if(isdigit((regstat+reg)->id[0])){
  664.  
  665.                         if(getnumber((regstat+reg)->id,num))return reg;
  666.  
  667.                 }
  668.  
  669.         }
  670.  
  671.         return NOINREG;
  672.  
  673. }
  674.  
  675.  
  676.  
  677. int GetNumberR(int sreg,unsigned long *num,int razr,unsigned long number)
  678.  
  679. {
  680.  
  681. int nr;
  682.  
  683. int reg,rreg=NOINREG;
  684.  
  685. unsigned long dnum=0xffffffff;
  686.  
  687. unsigned long nnum;
  688.  
  689.         if(optinitreg!=FALSE&&razr<=r32){
  690.  
  691.                 for(reg=0;reg<8;reg++){
  692.  
  693.                         if(reg==sreg)continue;
  694.  
  695.                         nr=convertrazr(&reg,razr);
  696.  
  697.                         if((regstat+reg)->type==t_id&&(regstat+reg)->razr==nr){
  698.  
  699. //                              printf("reg=%d %s\n",reg,(regstat+reg)->id);
  700.  
  701.                                 if(isdigit((regstat+reg)->id[0])){
  702.  
  703.                                         if(getnumber((regstat+reg)->id,num)){
  704.  
  705.                                                 if(*num==number)return reg;
  706.  
  707.                                                 if(*num>number&&(*num-number)<dnum){
  708.  
  709.                                                         dnum=*num-number;
  710.  
  711.                                                         nnum=*num;
  712.  
  713.                                                         rreg=reg;
  714.  
  715.                                                 }
  716.  
  717.                                                 else if((number-*num)<dnum){
  718.  
  719.                                                         dnum=number-*num;
  720.  
  721.                                                         nnum=*num;
  722.  
  723.                                                         rreg=reg;
  724.  
  725.                                                 }
  726.  
  727.                                         }
  728.  
  729.                                 }
  730.  
  731.                         }
  732.  
  733.                 }
  734.  
  735.                 *num=nnum;
  736.  
  737.         }
  738.  
  739.         return rreg;
  740.  
  741. }
  742.  
  743.  
  744.  
  745. int getnumber(char *buf,unsigned long *num,int *typenum)
  746.  
  747. {
  748.  
  749. int temp2;
  750.  
  751. unsigned char *oinput;
  752.  
  753. unsigned int oinptr,oendinptr;
  754.  
  755. int retcode=FALSE;
  756.  
  757.         oinptr=inptr;
  758.  
  759.         oinput=input;
  760.  
  761.         oendinptr=endinptr;
  762.  
  763.         input = (unsigned char*)buf;
  764.  
  765.         inptr=0;
  766.  
  767.         endinptr=256;
  768.  
  769.         *num=scannumber(typenum==NULL?&temp2:typenum);
  770.  
  771.         if(cha==0)retcode=TRUE;
  772.  
  773.         inptr=oinptr;
  774.  
  775.         input=oinput;
  776.  
  777.         endinptr=oendinptr;
  778.  
  779.         return retcode;
  780.  
  781. }
  782.  
  783.  
  784.  
  785. char *GetLecsem(int stop1,int stop2,int type)
  786.  
  787. {
  788.  
  789. int oinptr,oinptr2;
  790.  
  791. char ocha;
  792.  
  793. int oline;
  794.  
  795. char nam[SIZEIDREG];
  796.  
  797. int i,j;
  798.  
  799. ITOK oitok;
  800.  
  801. int otok;
  802.  
  803. char c;
  804.  
  805. int pinptr;
  806.  
  807.         switch(tok2){
  808.  
  809.                 case tk_string:
  810.  
  811.                 case tk_proc:
  812.  
  813.                 case tk_apiproc:
  814.  
  815.                 case tk_undefproc:
  816.  
  817.                 case tk_declare:
  818.  
  819.                         return NULL;
  820.  
  821.         }
  822.  
  823.         oinptr=inptr;
  824.  
  825.         oinptr2=inptr=inptr2;
  826.  
  827.         ocha=cha;
  828.  
  829.         cha=cha2;
  830.  
  831.         oline=linenumber;
  832.  
  833.         otok=tok;
  834.  
  835.         oitok=itok;
  836.  
  837.         i=0;
  838.  
  839.         do{
  840.  
  841.                 pinptr=inptr;
  842.  
  843.                 FastTok(0);
  844.  
  845.                 while(tok==tk_closebracket&&i){
  846.  
  847.                         i--;
  848.  
  849.                         pinptr=inptr;
  850.  
  851.                         FastTok(0);
  852.  
  853.                 }
  854.  
  855.                 if(tok==tk_openbracket)i++;
  856.  
  857.         }while(tok!=stop1&&tok!=stop2&&tok!=tk_eof&&itok.type!=type);
  858.  
  859.         if(pinptr)pinptr--;
  860.  
  861.         i=0;
  862.  
  863.         if(cha2>' '){
  864.  
  865.                 nam[0]=cha2;
  866.  
  867.                 i++;
  868.  
  869.         }
  870.  
  871.         for(j=0;i<SIZEIDREG;i++){
  872.  
  873.                 do{
  874.  
  875.                         c=input[j+oinptr2];
  876.  
  877.                         j++;
  878.  
  879.                 }while(c<=0x20);
  880.  
  881.                 if((oinptr2+j)>pinptr)break;
  882.  
  883.                 nam[i]=c;
  884.  
  885.         }
  886.  
  887.         inptr2=oinptr2;
  888.  
  889.         inptr=oinptr;
  890.  
  891.         cha=ocha;
  892.  
  893.         linenumber=oline;
  894.  
  895.         tok=otok;
  896.  
  897.         itok=oitok;
  898.  
  899.         if(i==SIZEIDREG)return NULL;
  900.  
  901.         c=nam[0];
  902.  
  903.         if(c==';'||c==','||c==')'||c=='}')return NULL;
  904.  
  905.         nam[i]=0;
  906.  
  907.         return BackString(nam);
  908.  
  909. }
  910.  
  911.  
  912.  
  913. void GetEndLex(int stop1,int stop2,int type)
  914.  
  915. {
  916.  
  917. int i=0;
  918.  
  919. int oscanlexmode;
  920.  
  921.         if(bufrm){
  922.  
  923.                 free(bufrm);
  924.  
  925.                 bufrm=NULL;
  926.  
  927.         }
  928.  
  929.         if(strinf.bufstr){
  930.  
  931.                 free(strinf.bufstr);
  932.  
  933.                 strinf.bufstr=NULL;
  934.  
  935.         }
  936.  
  937.         oscanlexmode=scanlexmode;
  938.  
  939.         scanlexmode=DEFLEX;
  940.  
  941.         while(tok2!=stop1&&tok2!=stop2&&tok2!=tk_eof&&itok2.type!=type){
  942.  
  943.                 nexttok();
  944.  
  945.                 while(tok==tk_closebracket&&i){
  946.  
  947.                         i--;
  948.  
  949.                         nexttok();
  950.  
  951.                 }
  952.  
  953.                 if(tok==tk_openbracket)i++;
  954.  
  955.                 if(bufrm){
  956.  
  957.                         free(bufrm);
  958.  
  959.                         bufrm=NULL;
  960.  
  961.                 }
  962.  
  963.                 if(strinf.bufstr){
  964.  
  965.                         free(strinf.bufstr);
  966.  
  967.                         strinf.bufstr=NULL;
  968.  
  969.                 }
  970.  
  971.         }
  972.  
  973. //      retoldscanmode(oscanlexmode);
  974.  
  975.         scanlexmode=oscanlexmode;
  976.  
  977. //      printf("tok2=%d type2=%d\n",tok2,itok2.type);
  978.  
  979. }
  980.  
  981.  
  982.  
  983. void IDXToReg(char *name,int size,int reg)
  984.  
  985. /*
  986.  
  987.  name -  ¤à¥á ­ ç « 
  988.  
  989.  size - à §¬¥à­®áâì
  990.  
  991.  */
  992.  
  993. {
  994.  
  995. int nr;
  996.  
  997. char nam[SIZEIDREG];
  998.  
  999.         if(optinitreg==FALSE)return;
  1000.  
  1001.         nr=(am32==0?razr_16:razr_32);
  1002.  
  1003.         ClearReg(reg);
  1004.  
  1005.         if(OptNameIDX(name,nam,size)==TRUE){
  1006.  
  1007.                 (regstat+reg)->type=t_id;
  1008.  
  1009.                 (regstat+reg)->razr=nr;
  1010.  
  1011.                 strcpy((regstat+reg)->id,nam);
  1012.  
  1013.         }
  1014.  
  1015.         KillRegLec(reg);
  1016.  
  1017. }
  1018.  
  1019.  
  1020.  
  1021. int OptNameIDX(char *name,char *nam,int size)
  1022.  
  1023. {
  1024.  
  1025. int i,j;
  1026.  
  1027. int maxlen=SIZEIDREG;
  1028.  
  1029.         j=0;
  1030.  
  1031.         if(name[j]=='&'){
  1032.  
  1033.                 size=1;
  1034.  
  1035.                 j++;
  1036.  
  1037.         }
  1038.  
  1039.         if(size>1)maxlen-=10;
  1040.  
  1041.         for(i=0;;i++){
  1042.  
  1043.                 if(i==maxlen)return FALSE;
  1044.  
  1045.                 char c;
  1046.  
  1047.                 do{
  1048.  
  1049.                         c=name[j];
  1050.  
  1051.                         j++;
  1052.  
  1053.                 }while(c<=0x20&&c!=0);
  1054.  
  1055.                 if(c==0||c==';')break;
  1056.  
  1057.                 nam[i]=c;
  1058.  
  1059.         }
  1060.  
  1061.         nam[i]=0;
  1062.  
  1063.         if(size>1)sprintf(nam+i,"*%d",size);
  1064.  
  1065.         return TRUE;
  1066.  
  1067. }
  1068.  
  1069.  
  1070.  
  1071. int CheckIDXReg(char *name,int size,int reg)
  1072.  
  1073. /*
  1074.  
  1075.  name -  ¤à¥á ­ ç « 
  1076.  
  1077.  size - à §¬¥à­®áâì
  1078.  
  1079.  */
  1080.  
  1081. {
  1082.  
  1083. int nr;
  1084.  
  1085. char nam[SIZEIDREG];
  1086.  
  1087. int retreg=NOINREG;
  1088.  
  1089. int i;
  1090.  
  1091.         if(optinitreg==FALSE)return NOINREG;
  1092.  
  1093.         nr=(am32==0?razr_16:razr_32);
  1094.  
  1095.         if(OptNameIDX(name,nam,size)==TRUE){
  1096.  
  1097.                 for(i=0;i<8;i++){
  1098.  
  1099.                         if((regstat+i)->type==t_id&&(regstat+i)->razr==nr){
  1100.  
  1101.                                 if(strcmp(nam,(regstat+i)->id)==0){
  1102.  
  1103.                                         if(i==reg){
  1104.  
  1105. //                                      printf("%s %s\n",nam,(regstat+i)->id);
  1106.  
  1107.                                                 waralreadinit(regs[am32][reg]);
  1108.  
  1109.                                                 return SKIPREG;
  1110.  
  1111.                                         }
  1112.  
  1113.                                         retreg=i;
  1114.  
  1115.                                 }
  1116.  
  1117.                         }
  1118.  
  1119. REGEQVAR *cur;
  1120.  
  1121.                         cur=(regstat+i)->next;
  1122.  
  1123.                         while(cur){
  1124.  
  1125.                                 if(cur->razr==nr&&strcmp(nam,cur->name)==0){
  1126.  
  1127.                                         if(i==reg){
  1128.  
  1129.                                                 waralreadinit(regs[am32][reg]);
  1130.  
  1131.                                                 return SKIPREG;
  1132.  
  1133.                                         }
  1134.  
  1135.                                         retreg=i;
  1136.  
  1137.                                         break;
  1138.  
  1139.                                 }
  1140.  
  1141.                                 cur=cur->next;
  1142.  
  1143.                         }
  1144.  
  1145.                 }
  1146.  
  1147.         }
  1148.  
  1149.         return retreg;
  1150.  
  1151. }
  1152.  
  1153.  
  1154.  
  1155. int RegToReg(int regd,int regs,int razr)
  1156.  
  1157. {
  1158.  
  1159. int nr,nrs;
  1160.  
  1161.         if(optinitreg==FALSE)return NOINREG;
  1162.  
  1163.         nrs=convertrazr(&regs,razr);
  1164.  
  1165.         nr=convertrazr(&regd,razr);
  1166.  
  1167.         if(razr==r8&&nrs!=nr&&regs==regd)goto noreg;
  1168.  
  1169.         if(nrs==nr&&(regstat+regd)->type==(regstat+regs)->type&&
  1170.  
  1171.                         (regstat+regs)->type!=t_undef&&(regstat+regd)->razr==(regstat+regs)->razr){
  1172.  
  1173.                 if(strcmp((regstat+regd)->id,(regstat+regs)->id)==0)return SKIPREG;
  1174.  
  1175.         }
  1176.  
  1177. noreg:
  1178.  
  1179.         ClearReg(regd);
  1180.  
  1181.         memcpy((regstat+regd),(regstat+regs),sizeof(REGISTERSTAT));
  1182.  
  1183. REGEQVAR *cur,*news;
  1184.  
  1185.         if((regstat+regd)->next){
  1186.  
  1187.                 cur=(REGEQVAR *)MALLOC(sizeof(REGEQVAR));
  1188.  
  1189.                 memcpy(cur,(regstat+regd)->next,sizeof(REGEQVAR));
  1190.  
  1191.                 (regstat+regd)->next=cur;
  1192.  
  1193.                 while(cur->next){
  1194.  
  1195.                         news=(REGEQVAR *)MALLOC(sizeof(REGEQVAR));
  1196.  
  1197.                         memcpy(news,cur->next,sizeof(REGEQVAR));
  1198.  
  1199.                         cur->next=news->next;
  1200.  
  1201.                 }
  1202.  
  1203.         }
  1204.  
  1205.         (regstat+regd)->razr=nr;
  1206.  
  1207.         return NOINREG;;
  1208.  
  1209. }
  1210.  
  1211.  
  1212.  
  1213. int RegSwapReg(int reg1,int reg2,int razr)
  1214.  
  1215. {
  1216.  
  1217. int nr,nrs;
  1218.  
  1219. REGISTERSTAT temp;
  1220.  
  1221.         if(optinitreg==FALSE)return NOINREG;
  1222.  
  1223.         nrs=convertrazr(&reg2,razr);
  1224.  
  1225.         nr=convertrazr(&reg1,razr);
  1226.  
  1227.         if((regstat+reg1)->type&&(regstat+reg1)->razr>nr)ClearReg(reg1);
  1228.  
  1229.         if((regstat+reg2)->type&&(regstat+reg2)->razr>nrs)ClearReg(reg2);
  1230.  
  1231.         if((regstat+reg1)->razr<razr_16&&nrs>=razr_16)ClearReg(reg1);
  1232.  
  1233.         if((regstat+reg2)->razr<razr_16&&nr>=razr_16)ClearReg(reg2);
  1234.  
  1235.         if(razr==r8&&nrs!=nr&&reg1==reg2)goto noreg;
  1236.  
  1237.         if((regstat+reg1)->type==(regstat+reg2)->type&&
  1238.  
  1239.                         (regstat+reg2)->type!=r_undef&&(regstat+reg1)->razr==(regstat+reg2)->razr){
  1240.  
  1241.                 if(strcmp((regstat+reg1)->id,(regstat+reg2)->id)==0)return SKIPREG;
  1242.  
  1243.         }
  1244.  
  1245. noreg:
  1246.  
  1247.         KillRegLec(reg1);
  1248.  
  1249.         KillRegLec(reg2);
  1250.  
  1251.         memcpy(&temp,(regstat+reg1),sizeof(REGISTERSTAT));
  1252.  
  1253.         memcpy((regstat+reg1),(regstat+reg2),sizeof(REGISTERSTAT));
  1254.  
  1255.         memcpy((regstat+reg2),&temp,sizeof(REGISTERSTAT));
  1256.  
  1257.         return NOINREG;;
  1258.  
  1259. }
  1260.  
  1261.  
  1262.  
  1263. void KillVar(char *name)
  1264.  
  1265. /*-----------------22.04.03 15:51-------------------
  1266.  
  1267.  ¯®¨áª ¯¥à¥¬¥­­®© ¢ ॣ¨áâà å ¨ ¥á«¨ ­ ©¤¥­ , â®
  1268.  
  1269.  ã¡à âì ¨­¨æ¨ «¨§ æ¨î ॣ¨áâà 
  1270.  
  1271. --------------------------------------------------*/
  1272.  
  1273. {
  1274.  
  1275. char *pstr,*nam;
  1276.  
  1277. int len;
  1278.  
  1279.         if(optinitreg==FALSE)return;
  1280.  
  1281.         len=strlen(name);
  1282.  
  1283.         for(int i=0;i<8;i++){
  1284.  
  1285.                 if((regstat+i)->type==t_id){
  1286.  
  1287.                         pstr=(regstat+i)->id;
  1288.  
  1289.                         for(;;){
  1290.  
  1291.                                 if((nam=strstr(pstr,name))!=NULL){
  1292.  
  1293.                                         char c;
  1294.  
  1295.                                         c=nam[len];
  1296.  
  1297.                                         if(c!='_'&&(!isalpha(c))){
  1298.  
  1299.                                                 if(nam!=pstr){
  1300.  
  1301.                                                         c=nam[-1];
  1302.  
  1303.                                                         if(c=='_'||isalpha(c))goto novar;
  1304.  
  1305.                                                 }
  1306.  
  1307.                                                 ClearReg(i);
  1308.  
  1309.                                                 break;
  1310.  
  1311.                                         }
  1312.  
  1313.                                 }
  1314.  
  1315.                                 else break;
  1316.  
  1317. novar:
  1318.  
  1319.                                 pstr=nam+1;
  1320.  
  1321.                         }
  1322.  
  1323.                 }
  1324.  
  1325. restart:
  1326.  
  1327.                 if((regstat+i)->next){
  1328.  
  1329. REGEQVAR *cur,*prev;
  1330.  
  1331.                         cur=(regstat+i)->next;
  1332.  
  1333.                         if(strcmp(cur->name,name)==0){
  1334.  
  1335.                                 (regstat+i)->next=cur->next;
  1336.  
  1337. //                              printf("kill '%s'\n",name);
  1338.  
  1339.                                 free(cur);
  1340.  
  1341.                                 goto restart;
  1342.  
  1343.                         }
  1344.  
  1345.                         prev=cur;
  1346.  
  1347.                         cur=cur->next;
  1348.  
  1349.                         while(cur){
  1350.  
  1351.                                 if(strcmp(cur->name,name)==0){
  1352.  
  1353.                                         prev->next=cur->next;
  1354.  
  1355.                                         free(cur);
  1356.  
  1357.                                         cur=prev->next;
  1358.  
  1359.                                 }
  1360.  
  1361.                                 else{
  1362.  
  1363.                                         prev=cur;
  1364.  
  1365.                                         cur=cur->next;
  1366.  
  1367.                                 }
  1368.  
  1369.                         }
  1370.  
  1371.                 }
  1372.  
  1373.         }
  1374.  
  1375. }
  1376.  
  1377.  
  1378.  
  1379. /*-----------------16.06.05 23:45-------------------
  1380.  
  1381.  ‡ ¬¥­  ¯¥à¥¬¥­­ëå ª®­áâ ­â ¬¨
  1382.  
  1383.         --------------------------------------------------*/
  1384.  
  1385. #ifdef OPTVARCONST
  1386.  
  1387.  
  1388.  
  1389. BLVIC *mainvic;
  1390.  
  1391. unsigned char replasevar=TRUE;
  1392.  
  1393. //void updnum(int tok4,long long *num);
  1394.  
  1395.  
  1396.  
  1397. #define MAXSIZEVIC 64
  1398.  
  1399. int cursizevic=0;
  1400.  
  1401. LVIC *listvic=NULL;
  1402.  
  1403.  
  1404.  
  1405. void CreateMainLVIC()
  1406.  
  1407. {
  1408.  
  1409.         mainvic=(BLVIC *)MALLOC(sizeof(BLVIC));
  1410.  
  1411.         listvic=mainvic->listvic=(LVIC *)MALLOC(sizeof(LVIC)*MAXSIZEVIC);
  1412.  
  1413.         cursizevic=mainvic->sizevic=MAXSIZEVIC;
  1414.  
  1415. }
  1416.  
  1417.  
  1418.  
  1419. void KillMainLVIC()
  1420.  
  1421. {
  1422.  
  1423.         free(listvic);
  1424.  
  1425.         free(mainvic);
  1426.  
  1427.         listvic=NULL;
  1428.  
  1429. }
  1430.  
  1431.  
  1432.  
  1433. BLVIC *BakLVIC()
  1434.  
  1435. {
  1436.  
  1437. BLVIC *bakvic;
  1438.  
  1439.         if(replasevar==0)return NULL;
  1440.  
  1441.         bakvic=(BLVIC *)MALLOC(sizeof(BLVIC));
  1442.  
  1443.         bakvic->listvic=(LVIC *)MALLOC(sizeof(LVIC)*cursizevic);
  1444.  
  1445.         bakvic->sizevic=cursizevic;
  1446.  
  1447.         memcpy(bakvic->listvic,listvic,sizeof(LVIC)*cursizevic);
  1448.  
  1449.         return bakvic;
  1450.  
  1451. }
  1452.  
  1453.  
  1454.  
  1455. void CopyLVIC(BLVIC *bak)
  1456.  
  1457. {
  1458.  
  1459.         if(bak==NULL)return;
  1460.  
  1461.         if(cursizevic<bak->sizevic){
  1462.  
  1463.                 listvic=(LVIC *)REALLOC(listvic,sizeof(LVIC)*bak->sizevic);
  1464.  
  1465.         }
  1466.  
  1467.         memcpy(listvic,bak->listvic,sizeof(LVIC)*bak->sizevic);
  1468.  
  1469.         if(cursizevic>bak->sizevic){
  1470.  
  1471.                 for(int i=bak->sizevic;i<cursizevic;i++)(listvic+i)->rec=NULL;
  1472.  
  1473.         }
  1474.  
  1475.         else cursizevic=bak->sizevic;
  1476.  
  1477. }
  1478.  
  1479.  
  1480.  
  1481. void FreeLVIC(BLVIC *bak)
  1482.  
  1483. {
  1484.  
  1485.         if(bak==NULL)return;
  1486.  
  1487.         free(bak->listvic);
  1488.  
  1489.         free(bak);
  1490.  
  1491. }
  1492.  
  1493.  
  1494.  
  1495. void CompareLVIC(BLVIC *bak)
  1496.  
  1497. {
  1498.  
  1499. LVIC *bvic;
  1500.  
  1501.         if(bak==NULL)return;
  1502.  
  1503.         for(int i=0;i<bak->sizevic;i++){
  1504.  
  1505.                 if((bak->listvic+i)->rec != NULL){
  1506.  
  1507.                         bvic=bak->listvic+i;
  1508.  
  1509.                         int j;
  1510.  
  1511.                         for(j=0;j<cursizevic;j++){
  1512.  
  1513.                                 if((listvic+j)->rec==bvic->rec){
  1514.  
  1515.                                         if((listvic+j)->lnumber!=bvic->lnumber)bvic->rec=NULL;
  1516.  
  1517.                                         break;
  1518.  
  1519.                                 }
  1520.  
  1521.                         }
  1522.  
  1523.                         if(j==cursizevic)bvic->rec=NULL;
  1524.  
  1525.                 }
  1526.  
  1527.         }
  1528.  
  1529. }
  1530.  
  1531.  
  1532.  
  1533. void ClearLVIC()
  1534.  
  1535. {
  1536.  
  1537.         memset(listvic,0,cursizevic*sizeof(LVIC));
  1538.  
  1539. /*      printf("%s(%d)> Init table LVIC\n",
  1540.  
  1541.                 startfileinfo==NULL?"":(startfileinfo+currentfileinfo)->filename,
  1542.  
  1543.                 linenumber);*/
  1544.  
  1545. }
  1546.  
  1547.  
  1548.  
  1549. int Const2Var(ITOK *itok4,long long num,int typenum)
  1550.  
  1551. {
  1552.  
  1553. int i;
  1554.  
  1555. int freevic=-1;
  1556.  
  1557.         if(replasevar&&itok4->rec&&(itok4->flag&f_useidx)==0){
  1558.  
  1559.                 if((typenum==tk_word||typenum==tk_dword)&&num<256)typenum=tk_byte;
  1560.  
  1561.                 for(i=0;i<cursizevic;i++){
  1562.  
  1563.                         if((listvic+i)->rec==itok4->rec)break;
  1564.  
  1565.                         if(freevic==-1&&(listvic+i)->rec==NULL)freevic=i;
  1566.  
  1567.                 }
  1568.  
  1569.                 if(i==cursizevic){
  1570.  
  1571.                         if(freevic==-1){
  1572.  
  1573.                                 cursizevic+=MAXSIZEVIC;
  1574.  
  1575.                                 listvic=(LVIC *)REALLOC(listvic,sizeof(LVIC)*cursizevic);
  1576.  
  1577.                                 for(freevic=cursizevic-1;freevic>i;freevic--)(listvic+freevic)->rec=NULL;
  1578.  
  1579.                         }
  1580.  
  1581.                         else i=freevic;
  1582.  
  1583.                 }
  1584.  
  1585.                 else if((listvic+i)->contype==typenum&&(listvic+i)->lnumber==num)return FALSE;
  1586.  
  1587.                 (listvic+i)->rec=itok4->rec;
  1588.  
  1589.                 (listvic+i)->contype=typenum;
  1590.  
  1591.                 (listvic+i)->lnumber=num;
  1592.  
  1593.                 switch(itok4->type){
  1594.  
  1595.                         case tp_localvar:
  1596.  
  1597.                         case tp_paramvar:
  1598.  
  1599.                                 (listvic+i)->typevar=tp_localvar;
  1600.  
  1601.                                 break;
  1602.  
  1603.                         case tp_postvar:
  1604.  
  1605.                         case tp_gvar:
  1606.  
  1607.                                 (listvic+i)->typevar=tp_gvar;
  1608.  
  1609.                                 break;
  1610.  
  1611.                         default:
  1612.  
  1613.                                 (listvic+i)->typevar=itok4->type;
  1614.  
  1615.                                 break;
  1616.  
  1617.                 }
  1618.  
  1619. /*              printf("%s(%d)> %s var '%s' by num=%u type=%d\n",
  1620.  
  1621.                         startfileinfo==NULL?"":(startfileinfo+currentfileinfo)->filename,
  1622.  
  1623.                         linenumber,
  1624.  
  1625.                         freevic==-1?"Update":"Add",
  1626.  
  1627.                         itok4->name,
  1628.  
  1629.                         (listvic+i)->number,
  1630.  
  1631.                         typenum);*/
  1632.  
  1633.         }
  1634.  
  1635.         return TRUE;
  1636.  
  1637. }
  1638.  
  1639.  
  1640.  
  1641. void Const2VarRec(LVIC *varconst)
  1642.  
  1643. {
  1644.  
  1645. int i;
  1646.  
  1647. int freevic=-1;
  1648.  
  1649.         if(replasevar==0)return;
  1650.  
  1651.         for(i=0;i<cursizevic;i++){
  1652.  
  1653.                 if((listvic+i)->rec==varconst->rec)break;
  1654.  
  1655.                 if(freevic==-1&&(listvic+i)->rec==NULL)freevic=i;
  1656.  
  1657.         }
  1658.  
  1659.         if(i==cursizevic){
  1660.  
  1661.                 if(freevic==-1){
  1662.  
  1663.                         cursizevic+=MAXSIZEVIC;
  1664.  
  1665.                         listvic=(LVIC *)REALLOC(listvic,sizeof(LVIC)*cursizevic);
  1666.  
  1667.                         for(freevic=cursizevic-1;freevic>i;freevic--)(listvic+freevic)->rec=NULL;
  1668.  
  1669.                 }
  1670.  
  1671.                 else i=freevic;
  1672.  
  1673.         }
  1674.  
  1675.         (listvic+i)->rec=varconst->rec;
  1676.  
  1677.         (listvic+i)->contype=varconst->contype;
  1678.  
  1679.         (listvic+i)->lnumber=varconst->lnumber;
  1680.  
  1681.         switch(varconst->rec->type){
  1682.  
  1683.                 case tp_localvar:
  1684.  
  1685.                 case tp_paramvar:
  1686.  
  1687.                         (listvic+i)->typevar=tp_localvar;
  1688.  
  1689.                         break;
  1690.  
  1691.                 case tp_postvar:
  1692.  
  1693.                 case tp_gvar:
  1694.  
  1695.                         (listvic+i)->typevar=tp_gvar;
  1696.  
  1697.                         break;
  1698.  
  1699.                 default:
  1700.  
  1701.                         (listvic+i)->typevar=varconst->rec->type;
  1702.  
  1703.                         break;
  1704.  
  1705.         }
  1706.  
  1707. }
  1708.  
  1709.  
  1710.  
  1711. void ClearVarByNum(ITOK *itok4)
  1712.  
  1713. {
  1714.  
  1715.         if(replasevar&&itok4->rec&&(itok4->flag&f_useidx)==0){
  1716.  
  1717.                 for(int i=0;i<cursizevic;i++){
  1718.  
  1719.                         if((listvic+i)->rec==itok4->rec){
  1720.  
  1721.                                 (listvic+i)->rec=NULL;
  1722.  
  1723. /*                              printf("%s(%d)> Clear by constant var '%s'\n",
  1724.  
  1725.                                         startfileinfo==NULL?"":(startfileinfo+currentfileinfo)->filename,
  1726.  
  1727.                                         linenumber,
  1728.  
  1729.                                         itok4->name);*/
  1730.  
  1731.                                 break;
  1732.  
  1733.                         }
  1734.  
  1735.                 }
  1736.  
  1737.         }
  1738.  
  1739. }
  1740.  
  1741.  
  1742.  
  1743. int UpdVarConst(ITOK *itok4,long long num,int typenum,int operand)
  1744.  
  1745. {
  1746.  
  1747. int retcode=FALSE;
  1748.  
  1749. int i;
  1750.  
  1751.         if(replasevar==0||itok4->rec==NULL||(itok4->flag&f_useidx)!=0)return TRUE;
  1752.  
  1753.         for(i=0;i<cursizevic;i++){
  1754.  
  1755.                 if((listvic+i)->rec==itok4->rec){
  1756.  
  1757. //                      printf("%s(%d)> Modif var '%s' by num=%u ",startfileinfo==NULL?"":(startfileinfo+currentfileinfo)->filename,linenumber,itok4->name,(listvic+i)->number);
  1758.  
  1759.                         switch(operand){
  1760.  
  1761.                                 case tk_plusequals:
  1762.  
  1763.                                 case tk_plusplus: operand=tk_plus; break;
  1764.  
  1765.                                 case tk_minusequals:
  1766.  
  1767.                                 case tk_minusminus: operand=tk_minus; break;
  1768.  
  1769.                                 case tk_xorequals: operand=tk_xor; break;
  1770.  
  1771.                                 case tk_andequals: operand=tk_and; break;
  1772.  
  1773.                                 case tk_orequals: operand=tk_or; break;
  1774.  
  1775.                                 case tk_multequals: operand=tk_mult; break;
  1776.  
  1777.                                 case tk_divequals: operand=tk_div; break;
  1778.  
  1779.                                 case tk_rrequals: operand=tk_rr; break;
  1780.  
  1781.                                 case tk_llequals: operand=tk_ll; break;
  1782.  
  1783.                                 case tk_numsign:
  1784.  
  1785.                                         if((listvic+i)->contype==tk_float)(listvic+i)->number|=0x80000000;
  1786.  
  1787.                                         else if((listvic+i)->contype==tk_double)(listvic+i)->lnumber|=0x8000000000000000LL;
  1788.  
  1789.                                         else (listvic+i)->lnumber=-(listvic+i)->lnumber;
  1790.  
  1791.                                         return TRUE;;
  1792.  
  1793.                                 case tk_not:
  1794.  
  1795.                                         (listvic+i)->lnumber=~(listvic+i)->lnumber;
  1796.  
  1797.                                         return TRUE;;
  1798.  
  1799.                         }
  1800.  
  1801.                         switch((listvic+i)->contype){
  1802.  
  1803.                                 case tk_char:
  1804.  
  1805.                                 case tk_int:
  1806.  
  1807.                                 case tk_long:
  1808.  
  1809.                                         retcode=calclongnumber(&(listvic+i)->number,num,operand);
  1810.  
  1811.                                         break;
  1812.  
  1813.                                 case tk_byte:
  1814.  
  1815.                                 case tk_word:
  1816.  
  1817.                                 case tk_dword:
  1818.  
  1819.                                         retcode=calcdwordnumber((unsigned long *)&(listvic+i)->number,num,operand);
  1820.  
  1821.                                         break;
  1822.  
  1823.                                 case tk_qword:
  1824.  
  1825.                                         retcode=calcqwordnumber((unsigned long long *)&(listvic+i)->lnumber,num,operand);
  1826.  
  1827.                                         break;
  1828.  
  1829.                                 case tk_float:
  1830.  
  1831.                                         retcode=calcfloatnumber(&(listvic+i)->fnumber,*(float *) &num,operand);
  1832.  
  1833.                                         break;
  1834.  
  1835.                                 case tk_double:
  1836.  
  1837.                                         retcode=calcdoublenumber(&(listvic+i)->dnumber,*(double *) &num,operand);
  1838.  
  1839.                                         break;
  1840.  
  1841.                         }
  1842.  
  1843. /*                      if(retcode)printf("new num=%u\n",(listvic+i)->number);
  1844.  
  1845.                         else{
  1846.  
  1847.                                 puts("error");
  1848.  
  1849.                                 (listvic+i)->rec=NULL;
  1850.  
  1851.                         }                       */
  1852.  
  1853.                         break;
  1854.  
  1855.                 }
  1856.  
  1857.         }
  1858.  
  1859.         return TRUE;
  1860.  
  1861. }
  1862.  
  1863.  
  1864.  
  1865. void FreeGlobalConst()
  1866.  
  1867. {
  1868.  
  1869.         if(replasevar==0)return;
  1870.  
  1871.         for(int i=0;i<cursizevic;i++){
  1872.  
  1873.                 if((listvic+i)->rec!=NULL&&(listvic+i)->typevar!=tp_localvar){
  1874.  
  1875.                         (listvic+i)->rec=NULL;
  1876.  
  1877. /*                      printf("%s(%d)> Clear global constant var\n",
  1878.  
  1879.                                         startfileinfo==NULL?"":(startfileinfo+currentfileinfo)->filename,
  1880.  
  1881.                                         linenumber);*/
  1882.  
  1883.                 }
  1884.  
  1885.         }
  1886.  
  1887. }
  1888.  
  1889.  
  1890.  
  1891. int CheckRegToConst(int reg,ITOK *itok4,int razr)
  1892.  
  1893. {
  1894.  
  1895. unsigned long num;
  1896.  
  1897. int typenum;
  1898.  
  1899. int nr;
  1900.  
  1901.         nr=convertrazr(&reg,razr);
  1902.  
  1903.         if(replasevar&&optinitreg!=FALSE&&razr<=r32&&(regstat+reg)->type==t_id&&
  1904.  
  1905.                         (regstat+reg)->razr>=nr){
  1906.  
  1907.                 if(isdigit((regstat+reg)->id[0])){
  1908.  
  1909.                         if(getnumber((regstat+reg)->id,&num,&typenum)){
  1910.  
  1911.                                 Const2Var(itok4,num,typenum);
  1912.  
  1913.                                 return TRUE;
  1914.  
  1915.                         }
  1916.  
  1917.                 }
  1918.  
  1919.         }
  1920.  
  1921.         return FALSE;
  1922.  
  1923. }
  1924.  
  1925.  
  1926.  
  1927. int CheckUpdRegToConst(int reg,ITOK *itok4,int operand,int razr)
  1928.  
  1929. {
  1930.  
  1931. unsigned long num;
  1932.  
  1933. int typenum;
  1934.  
  1935. int nr;
  1936.  
  1937.         nr=convertrazr(&reg,razr);
  1938.  
  1939.         if(replasevar&&optinitreg!=FALSE&&razr<=r32&&(regstat+reg)->type==t_id&&
  1940.  
  1941.                         (regstat+reg)->razr>=nr){
  1942.  
  1943.                 if(isdigit((regstat+reg)->id[0])){
  1944.  
  1945.                         if(getnumber((regstat+reg)->id,&num,&typenum))return UpdVarConst(itok4,num,typenum,operand);
  1946.  
  1947.                 }
  1948.  
  1949.         }
  1950.  
  1951.         return FALSE;
  1952.  
  1953. }
  1954.  
  1955.  
  1956.  
  1957. int SwapVarConst(ITOK *itok2,ITOK *itok4)
  1958.  
  1959. {
  1960.  
  1961. int i;
  1962.  
  1963. int fir=-1,sec=-1;
  1964.  
  1965. LVIC tempvic;
  1966.  
  1967.         if(replasevar==0)return TRUE;
  1968.  
  1969.         if(itok4->rec==NULL||(itok4->flag&f_useidx)!=0)sec=-2;
  1970.  
  1971.         if(itok2->rec==NULL||(itok2->flag&f_useidx)!=0){
  1972.  
  1973.                 if(sec==-2)return TRUE;
  1974.  
  1975.                 fir=-2;
  1976.  
  1977.         }
  1978.  
  1979.         for(i=0;i<cursizevic;i++){
  1980.  
  1981.                 if(sec==-1&&(listvic+i)->rec==itok4->rec)sec=i;
  1982.  
  1983.                 else if(fir==-1&&(listvic+i)->rec==itok2->rec)fir=i;
  1984.  
  1985.         }
  1986.  
  1987.         if(sec==-2)sec=-1;
  1988.  
  1989.         if(fir==-2)fir=-1;
  1990.  
  1991.         if(sec!=-1&&fir!=-1){
  1992.  
  1993.                 memcpy(&tempvic,listvic+fir,sizeof(LVIC));
  1994.  
  1995.                 memcpy(listvic+fir,listvic+sec,sizeof(LVIC));
  1996.  
  1997.                 memcpy(listvic+sec,&tempvic,sizeof(LVIC));
  1998.  
  1999.         }
  2000.  
  2001.         else if(sec==-1&&fir!=-1)(listvic+fir)->rec=itok4->rec;
  2002.  
  2003.         else if(fir==-1&&sec!=-1)(listvic+sec)->rec=itok2->rec;
  2004.  
  2005.         return TRUE;
  2006.  
  2007. }
  2008.  
  2009.  
  2010.  
  2011. int SwapVarRegConst(int reg,ITOK *itok4,int razr)
  2012.  
  2013. {
  2014.  
  2015. int i;
  2016.  
  2017. int freevic=-1;
  2018.  
  2019. unsigned long num;
  2020.  
  2021. int typenum;
  2022.  
  2023. int nr;
  2024.  
  2025. int numinreg=FALSE;
  2026.  
  2027.         nr=convertrazr(&reg,razr);
  2028.  
  2029.         if(replasevar&&itok4->rec&&(itok4->flag&f_useidx)==0&&optinitreg!=FALSE&&razr<=r32&&
  2030.  
  2031.                         (regstat+reg)->type==t_id&&(regstat+reg)->razr>=nr){
  2032.  
  2033.                 for(i=0;i<cursizevic;i++){
  2034.  
  2035.                         if((listvic+i)->rec==itok4->rec)break;
  2036.  
  2037.                         if(freevic==-1&&(listvic+i)->rec==NULL)freevic=i;
  2038.  
  2039.                 }
  2040.  
  2041.                 if(isdigit((regstat+reg)->id[0])){
  2042.  
  2043.                         if(getnumber((regstat+reg)->id,&num,&typenum)){ //æ¨äà  ¢ ॣ¨áâà¥
  2044.  
  2045.                                 if(i!=cursizevic)ConstToReg((listvic+i)->lnumber,reg,razr);     //­®¢ãî ¢ ॣ¨áâà
  2046.  
  2047.                                 else{
  2048.  
  2049.                                         if(freevic==-1){
  2050.  
  2051.                                                 cursizevic+=MAXSIZEVIC;
  2052.  
  2053.                                                 listvic=(LVIC *)REALLOC(listvic,sizeof(LVIC)*cursizevic);
  2054.  
  2055.                                                 for(freevic=cursizevic-1;freevic>i;freevic--)(listvic+freevic)->rec=NULL;
  2056.  
  2057.                                         }
  2058.  
  2059.                                         else i=freevic;
  2060.  
  2061.                                 }
  2062.  
  2063.                                 (listvic+i)->rec=itok4->rec;    //æ¨äàã ¢ ¯¥à¥¬¥­­ãî
  2064.  
  2065.                                 (listvic+i)->contype=typenum;
  2066.  
  2067.                                 (listvic+i)->lnumber=num;
  2068.  
  2069.                                 switch(itok4->type){
  2070.  
  2071.                                         case tp_localvar:
  2072.  
  2073.                                         case tp_paramvar:
  2074.  
  2075.                                                 (listvic+i)->typevar=tp_localvar;
  2076.  
  2077.                                                 break;
  2078.  
  2079.                                         case tp_postvar:
  2080.  
  2081.                                         case tp_gvar:
  2082.  
  2083.                                                 (listvic+i)->typevar=tp_gvar;
  2084.  
  2085.                                                 break;
  2086.  
  2087.                                         default:
  2088.  
  2089.                                                 (listvic+i)->typevar=itok4->type;
  2090.  
  2091.                                                 break;
  2092.  
  2093.                                 }
  2094.  
  2095. /*                              printf("%s(%d)> %s var '%s' by num=%u type=%d\n",
  2096.  
  2097.                                         startfileinfo==NULL?"":(startfileinfo+currentfileinfo)->filename,
  2098.  
  2099.                                         linenumber,
  2100.  
  2101.                                         freevic==-1?"Update":"Add",
  2102.  
  2103.                                         itok4->name,
  2104.  
  2105.                                         (listvic+i)->number,
  2106.  
  2107.                                         typenum);*/
  2108.  
  2109.                         }
  2110.  
  2111.                 }
  2112.  
  2113.                 else{   //­¥â æ¨äàë ¢ ॣ¨áâà¥
  2114.  
  2115.                         if(i!=cursizevic){      //æ¨äà  ¢ ¯¥à¥¬¥­­®©
  2116.  
  2117.                                 ConstToReg((listvic+i)->lnumber,reg,razr);      //⥯¥àì ¢ ॣ¨áâà¥
  2118.  
  2119.                                 (listvic+i)->rec=NULL;  //  ¢¯¥à¥¬¥­­®© 㦥 ­¥â
  2120.  
  2121.                         }
  2122.  
  2123.                 }
  2124.  
  2125.         }
  2126.  
  2127.         return TRUE;
  2128.  
  2129. }
  2130.  
  2131.  
  2132.  
  2133. int CheckConstVar(ITOK *itok4)
  2134.  
  2135. {
  2136.  
  2137.         if(replasevar==FALSE||itok4->rec==NULL||(itok4->flag&f_useidx)!=0)return FALSE;
  2138.  
  2139.         if(itok4->rec&&(itok4->flag&f_useidx)==0){
  2140.  
  2141.                 for(int i=0;i<cursizevic;i++){
  2142.  
  2143.                         if((listvic+i)->rec==itok4->rec){
  2144.  
  2145.                                 itok4->lnumber=(listvic+i)->lnumber;
  2146.  
  2147.                                 itok4->rm=(listvic+i)->contype;
  2148.  
  2149.                                 itok4->flag=0;
  2150.  
  2151.                                 warreplasevar(itok4->name);
  2152.  
  2153.                                 return TRUE;
  2154.  
  2155.  
  2156.  
  2157.                         }
  2158.  
  2159.                 }
  2160.  
  2161.         }
  2162.  
  2163.         return FALSE;
  2164.  
  2165. }
  2166.  
  2167.  
  2168.  
  2169. int CheckConstVar2(ITOK *itok4,long long *num,int *typenum)
  2170.  
  2171. {
  2172.  
  2173. //      if(replasevar==FALSE||itok4->rec==NULL||(itok4->flag&f_useidx)!=0)return FALSE;
  2174.  
  2175.         if(replasevar&&itok4->rec&&(itok4->flag&f_useidx)==0){
  2176.  
  2177.                 for(int i=0;i<cursizevic;i++){
  2178.  
  2179.                         if((listvic+i)->rec==itok4->rec){
  2180.  
  2181.                                 *num=(listvic+i)->lnumber;
  2182.  
  2183.                                 *typenum=(listvic+i)->contype;
  2184.  
  2185. //                              warreplasevar(itok4->name);
  2186.  
  2187.                                 return TRUE;
  2188.  
  2189.  
  2190.  
  2191.                         }
  2192.  
  2193.                 }
  2194.  
  2195.         }
  2196.  
  2197.         return FALSE;
  2198.  
  2199. }
  2200.  
  2201.  
  2202.  
  2203. /*
  2204.  
  2205. void updnum(int tok4,long long *num)
  2206.  
  2207. {
  2208.  
  2209.         switch(tok4){
  2210.  
  2211.                 case tk_charvar:
  2212.  
  2213.                 case tk_bytevar:
  2214.  
  2215.                         *num=*num&0xff;
  2216.  
  2217.                         break;
  2218.  
  2219.                 case tk_intvar:
  2220.  
  2221.                 case tk_wordvar:
  2222.  
  2223.                         *num=*num&0xffff;
  2224.  
  2225.                         break;
  2226.  
  2227.                 case tk_longvar:
  2228.  
  2229.                 case tk_dwordvar:
  2230.  
  2231.                         *num=*num&0xffffffff;
  2232.  
  2233.                         break;
  2234.  
  2235.  
  2236.  
  2237.         }
  2238.  
  2239. }
  2240.  
  2241.  */
  2242.  
  2243.  
  2244.  
  2245. void CheckConstVar3(int *tok4,ITOK *itok4,int razr)
  2246.  
  2247. {
  2248.  
  2249. long long lnum;
  2250.  
  2251. int rm;
  2252.  
  2253.         if(replasevar==FALSE||itok4->rec==NULL||(itok4->flag&f_useidx)!=0)return;
  2254.  
  2255.         if(*tok4>=tk_charvar&&*tok4<=tk_doublevar){
  2256.  
  2257.                 if((optimizespeed||itok4->type==tp_gvar||itok4->type==tp_postvar||
  2258.  
  2259.                                 itok4->number>127||(int)(itok4->number)<-127)&&CheckConstVar(itok4)){
  2260.  
  2261.                         switch(*tok4){
  2262.  
  2263.                                 case tk_charvar:
  2264.  
  2265.                                 case tk_bytevar:
  2266.  
  2267.                                         itok4->lnumber=itok4->lnumber&0xff;
  2268.  
  2269.                                         break;
  2270.  
  2271.                                 case tk_intvar:
  2272.  
  2273.                                 case tk_wordvar:
  2274.  
  2275.                                         itok4->lnumber=itok4->lnumber&0xffff;
  2276.  
  2277.                                         break;
  2278.  
  2279.                                 case tk_longvar:
  2280.  
  2281.                                 case tk_dwordvar:
  2282.  
  2283.                                         itok4->lnumber=itok4->lnumber&0xffffffff;
  2284.  
  2285.                                         break;
  2286.  
  2287.  
  2288.  
  2289.                         }
  2290.  
  2291. //                      updnum(*tok4,&itok4->lnumber);
  2292.  
  2293. //                      printf("tok=%d num=%d %s\n",*tok4,itok.number,itok.name);
  2294.  
  2295.                         *tok4=tk_number;
  2296.  
  2297.                 }
  2298.  
  2299.                 else{
  2300.  
  2301.                         if(CheckConstVar2(itok4,&lnum,&rm)){
  2302.  
  2303.                                 if(short_ok(lnum,razr==r32?TRUE:FALSE)){
  2304.  
  2305.                                         itok4->lnumber=lnum;
  2306.  
  2307.                                         itok4->rm=rm;
  2308.  
  2309.                                         *tok4=tk_number;
  2310.  
  2311.                                         itok4->flag=0;
  2312.  
  2313.                                         warreplasevar(itok4->name);
  2314.  
  2315.                                 }
  2316.  
  2317.                         }
  2318.  
  2319.                 }
  2320.  
  2321.         }
  2322.  
  2323. }
  2324.  
  2325.  
  2326.  
  2327. #endif
  2328.  
  2329.