Subversion Repositories Kolibri OS

Rev

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

  1. #define _POINTER_
  2.  
  3.  
  4.  
  5. #include "tok.h"
  6.  
  7.  
  8.  
  9. void dopointerproc()
  10.  
  11. {
  12.  
  13. unsigned int snum;
  14.  
  15. int razr=r16;
  16.  
  17. ITOK wtok;
  18.  
  19. char *wbuf;
  20.  
  21. SINFO wstr;
  22.  
  23.         if(am32)razr=r32;
  24.  
  25.         itok.rm=itok.sib;
  26.  
  27.         itok.sib=am32==0?CODE16:CODE32;
  28.  
  29.         if((FixUp)
  30.  
  31.  
  32.  
  33.         &&((itok.rm==rm_d32&&am32)||(itok.rm==rm_d16&&am32==0)))//16.07.04 16:01
  34.  
  35.         //18.08.04 18:03  itok.rm==rm_d32 was itok.rm==CODE32
  36.  
  37.  
  38.  
  39.         itok.flag|=f_reloc;
  40.  
  41.         else compressoffset(&itok);
  42.  
  43.         wstr=strinf;
  44.  
  45.         strinf.bufstr=NULL;
  46.  
  47.         wtok=itok;
  48.  
  49.         wbuf=bufrm;
  50.  
  51.         bufrm=NULL;
  52.  
  53.         unsigned int oaddESP=addESP;
  54.  
  55.         if(wtok.npointr<2){
  56.  
  57.                 itok.flag&=~f_far;
  58.  
  59. //              itok.post=0;
  60.  
  61.                 snum=initparamproc();
  62.  
  63.                 CheckAllMassiv(wbuf,razr,&wstr,&wtok);
  64.  
  65.                 outseg(&wtok,2);
  66.  
  67.                 op(0xFF); op(0x10+wtok.rm+((wtok.flag&f_far)!=0?8:0));
  68.  
  69.                 outaddress(&wtok);
  70.  
  71.         }
  72.  
  73.         else{
  74.  
  75. int reg=BX;
  76.  
  77.                 getpointeradr(&wtok,wbuf,&wstr,wtok.npointr-1,am32==0?r16:r32,reg);
  78.  
  79.                 snum=initparamproc();
  80.  
  81.                 op66(razr);
  82.  
  83.                 op(0xFF);
  84.  
  85.                 op(0xD0+reg);   /* CALL reg with stack params */
  86.  
  87.         }
  88.  
  89.         if((wtok.flag&f_typeproc)==tp_cdecl)CorrectStack(snum);
  90.  
  91.         else addESP=oaddESP;
  92.  
  93.         clearregstat(0);
  94.  
  95. }
  96.  
  97.  
  98.  
  99. void dopointer()
  100.  
  101. {
  102.  
  103.         if(itok.type==tk_proc){
  104.  
  105.                 if(tok2==tk_openbracket){
  106.  
  107.                         dopointerproc();
  108.  
  109.                         nexttok();
  110.  
  111.                         return;
  112.  
  113.                 }
  114.  
  115.                 itok.rm=itok.sib;
  116.  
  117.                 itok.sib=am32==0?CODE16:CODE32;
  118.  
  119.                 compressoffset(&itok);
  120.  
  121.         }
  122.  
  123. int razr=r16;
  124.  
  125.         if(am32||(itok.flag&f_far))razr=r32;
  126.  
  127.         do_d_wordvar(0,razr);
  128.  
  129. }
  130.  
  131.  
  132.  
  133. void getpointeradr(ITOK *gstok,char *&gbuf,SINFO *gstr,int numpointer,int razr, int reg)
  134.  
  135. {
  136.  
  137.         if(gstok->flag&f_far){
  138.  
  139.                 CheckAllMassiv(gbuf,4,gstr,gstok);
  140.  
  141.                 outseg(gstok,2);
  142.  
  143.                 op(0xC4);
  144.  
  145.                 op(gstok->rm+8*reg);
  146.  
  147.                 outaddress(gstok);
  148.  
  149.                 itok.segm=ES;
  150.  
  151.                 itok.sib=CODE16;
  152.  
  153.                 if(reg==BX)itok.rm=rm_BX;
  154.  
  155.                 else if(reg==SI)itok.rm=rm_SI;
  156.  
  157.                 else if(reg==DI)itok.rm=rm_DI;
  158.  
  159.                 warningreg(segs[0]);
  160.  
  161.         }
  162.  
  163.         else{
  164.  
  165.                 int retreg;
  166.  
  167.                 if((gstok->flag&f_useidx)==0&&(retreg=CheckIDZReg(gstok->name,reg,razr))!=NOINREG){
  168.  
  169.                         if(am32==0&&retreg!=BX&&retreg!=SI&&retreg!=DI){
  170.  
  171.                                 GenRegToReg(reg,retreg,razr);
  172.  
  173.                                 IDZToReg(gstok->name,reg,razr);
  174.  
  175.                         }
  176.  
  177.                         else if(retreg!=SKIPREG)reg=retreg;
  178.  
  179.                         if(gbuf){
  180.  
  181.                                 free(gbuf);
  182.  
  183.                                 gbuf=NULL;
  184.  
  185.                         }
  186.  
  187.                         if(gstr->bufstr){
  188.  
  189.                                 free(gstr->bufstr);
  190.  
  191.                                 gstr->bufstr=NULL;
  192.  
  193.                         }
  194.  
  195.                         goto nomov;
  196.  
  197.                 }
  198.  
  199.                 if((gstok->flag&f_useidx))IDZToReg(gstok->name,reg,razr);
  200.  
  201.                 CheckAllMassiv(gbuf,razr,gstr,gstok);
  202.  
  203.                 outseg(gstok,2);
  204.  
  205.                 op(0x8B);
  206.  
  207.                 op(reg*8+gstok->rm);
  208.  
  209.                 outaddress(gstok);
  210.  
  211. nomov:
  212.  
  213.                 itok.segm=DS;
  214.  
  215.                 if(am32==0){
  216.  
  217.                         itok.sib=CODE16;
  218.  
  219.                         if(reg==BX)itok.rm=rm_BX;
  220.  
  221.                         else if(reg==SI)itok.rm=rm_SI;
  222.  
  223.                         else if(reg==DI)itok.rm=rm_DI;
  224.  
  225.                 }
  226.  
  227.                 else{
  228.  
  229.                         itok.sib=CODE32;
  230.  
  231.                         itok.rm=reg;
  232.  
  233.                 }
  234.  
  235.         }
  236.  
  237.         itok.post=0;
  238.  
  239.         itok.number=0;
  240.  
  241.         itok.flag=gstok->flag&(!f_reloc);
  242.  
  243.         warningreg(regs[am32][reg]);
  244.  
  245.         while(numpointer){
  246.  
  247.                 outseg(&itok,2);
  248.  
  249.                 op(0x8B);
  250.  
  251.                 op(itok.rm+reg*8);
  252.  
  253.                 outaddress(&itok);
  254.  
  255.                 numpointer--;
  256.  
  257.         }
  258.  
  259. }
  260.  
  261.  
  262.  
  263. void dovalpointer()
  264.  
  265. {
  266.  
  267. int sign=0,rettype,pointr,razr=r8;
  268.  
  269. int rrettype;
  270.  
  271. int numpointer=0;
  272.  
  273. int hnumber=0;
  274.  
  275. //int i=0;
  276.  
  277. int reg=BX;
  278.  
  279. int npointr=0;
  280.  
  281.         do{
  282.  
  283.                 nexttok();
  284.  
  285.                 numpointer++;
  286.  
  287.         }while(tok==tk_mult);
  288.  
  289. ITOK wtok;
  290.  
  291. char *wbuf;
  292.  
  293. SINFO wstr;
  294.  
  295. unsigned char ocha;
  296.  
  297. unsigned int oinptr;
  298.  
  299. unsigned int olinenum;
  300.  
  301. int otok2;
  302.  
  303.         wstr=strinf;
  304.  
  305.         strinf.bufstr=NULL;
  306.  
  307.         wtok=itok;
  308.  
  309.         wbuf=bufrm;
  310.  
  311.         bufrm=NULL;
  312.  
  313.         if(numpointer==itok.npointr){
  314.  
  315.                 switch(itok.type){
  316.  
  317.                         case tk_qword:
  318.  
  319.                         case tk_double:
  320.  
  321.                                 razr+=4;
  322.  
  323.                         case tk_dword:
  324.  
  325.                         case tk_float:
  326.  
  327.                                 razr+=2;
  328.  
  329.                         case tk_word:
  330.  
  331.                                 razr++;
  332.  
  333.                                 break;
  334.  
  335.                         case tk_long:
  336.  
  337.                                 razr+=2;
  338.  
  339.                         case tk_int:
  340.  
  341.                                 razr++;
  342.  
  343.                         case tk_char:
  344.  
  345.                                 sign=1;
  346.  
  347.                                 break;
  348.  
  349.                 }
  350.  
  351.                 rrettype=rettype=itok.type;
  352.  
  353.                 oinptr=inptr2;
  354.  
  355.                 ocha=cha2;
  356.  
  357.                 olinenum=linenumber;
  358.  
  359.                 otok2=tok2;
  360.  
  361.                 nexttok();
  362.  
  363.                 if(tok==tk_assign){
  364.  
  365.                         nexttok();
  366.  
  367.                         convert_type(&sign,(int *)&rettype,&pointr);
  368.  
  369.                         while(tok==tk_mult){
  370.  
  371.                                 nexttok();
  372.  
  373.                                 npointr++;
  374.  
  375.                         }
  376.  
  377.                         if(npointr>itok.npointr)unuseableinput();
  378.  
  379.                         if(tok2==tk_assign){
  380.  
  381.                                 hnumber=MultiAssign(razr,USEALLREG,npointr);
  382.  
  383.                                 if(reg==hnumber)reg=DI;
  384.  
  385.                                 goto getfromax;
  386.  
  387.                         }
  388.  
  389.                 }
  390.  
  391.                 linenumber=linenum2=olinenum;
  392.  
  393.                 cha2=ocha;
  394.  
  395.                 inptr2=oinptr;
  396.  
  397.                 tok2=otok2;
  398.  
  399.                 itok=wtok;
  400.  
  401.                 if(itok.type==tk_proc){
  402.  
  403.                         dopointer();
  404.  
  405.                         return;
  406.  
  407.                 }
  408.  
  409.                 getpointeradr(&itok,wbuf,&wstr,numpointer-1,razr,reg);
  410.  
  411.                 tok=tk_charvar+itok.type-tk_char;
  412.  
  413.                 switch(itok.type){
  414.  
  415.                         case tk_long:
  416.  
  417.                         case tk_dword:
  418.  
  419.                         case tk_int:
  420.  
  421.                         case tk_word:
  422.  
  423.                                 do_d_wordvar(sign,razr);
  424.  
  425.                                 return;
  426.  
  427.                         case tk_char:
  428.  
  429.                         case tk_byte:
  430.  
  431.                                 dobytevar(sign);
  432.  
  433.                                 return;
  434.  
  435.                         case tk_float:
  436.  
  437.                                 dofloatvar();
  438.  
  439.                                 return;
  440.  
  441.                         case tk_qword:
  442.  
  443.                                 doqwordvar();
  444.  
  445.                                 return;
  446.  
  447.                         case tk_double:
  448.  
  449. //                              dodoublevar();
  450.  
  451.                                 return;
  452.  
  453.                 }
  454.  
  455. getfromax:
  456.  
  457.                 convert_returnvalue(rrettype,rettype);
  458.  
  459. ITOK otok=itok;
  460.  
  461.                 getpointeradr(&wtok,wbuf,&wstr,numpointer-1,razr,reg);
  462.  
  463.                 switch(rrettype){
  464.  
  465.                         case tk_char:
  466.  
  467.                         case tk_byte:
  468.  
  469.                                 outseg(&itok,2);
  470.  
  471.                                 op(0x88);
  472.  
  473.                                 op(itok.rm+hnumber*8);  //[reg]=AL
  474.  
  475.                                 break;
  476.  
  477.                         case tk_int:
  478.  
  479.                         case tk_word:
  480.  
  481.                         case tk_long:
  482.  
  483.                         case tk_dword:
  484.  
  485.                         case tk_qword:
  486.  
  487.                                 op66(razr);
  488.  
  489.                                 outseg(&itok,2);
  490.  
  491.                                 op(0x89);
  492.  
  493.                                 op(itok.rm+hnumber*8); // MOV [rmword],AX
  494.  
  495.                                 break;
  496.  
  497.                         case tk_float:
  498.  
  499.                                 outseg(&itok,2);        //fstp var
  500.  
  501.                                 op(0xd9);
  502.  
  503.                                 op(itok.rm+0x18);
  504.  
  505.                                 fwait3();
  506.  
  507.                                 break;
  508.  
  509.                         case tk_double:
  510.  
  511.                                 outseg(&itok,2);        //fstpq var
  512.  
  513.                                 op(0xdd);
  514.  
  515.                                 op(itok.rm+0x18);
  516.  
  517.                                 fwait3();
  518.  
  519.                                 break;
  520.  
  521.                 }
  522.  
  523.                 itok=otok;
  524.  
  525.         }
  526.  
  527.         else if(numpointer<itok.npointr){
  528.  
  529.                 razr=r16;
  530.  
  531.                 rettype=tk_word;
  532.  
  533.                 if(am32||(itok.flag&f_far)){
  534.  
  535.                         razr=r32;
  536.  
  537.                         rettype=tk_dword;
  538.  
  539.                 }
  540.  
  541.                 rrettype=rettype;
  542.  
  543.                 doreg_32(AX,razr);
  544.  
  545.                 goto getfromax;
  546.  
  547.         }
  548.  
  549.         else unuseableinput();
  550.  
  551. }
  552.  
  553.  
  554.  
  555.