parserfp.c

frasr200的win 版本源码(18.21),使用make文件,使用的vc版本较低,在我的环境下编译有问题! 很不错的分形程序代码!

         if (fgf(cvtptrx-1) == fStkPush2 ){
#ifdef TESTFP
            stopmsg (0, "*push lod (sub) -> (*plodsub),stk+=2" );
#endif
            --cvtptrx;
            opp(cvtptrx) = opp(cvtptrx+1); /* fix opptrs */
            stkcnt += 2; /* push was deleted so adj. stkcnt */
            ffptr = fStkPLodSub;
         }
         else {
#ifdef TESTFP
            stopmsg (0, "*lod (sub) -> (*lodsub)" );
#endif
            ffptr = fStkLodSub;
         }
      }
      else if (prevfptr == fStkLodReal || prevfptr == fStkLodRealC ){
         --cvtptrx; /* {? *lodreal (sub) } */
         if (fgf(cvtptrx-1) == fStkPush2 ){
#ifdef TESTFP
            stopmsg (0, "*push lodreal (sub) -> (*lodrealsub),stk+=2" );
#endif
            --cvtptrx;
            stkcnt += 2;	/* push eliminated */
            opp(cvtptrx) = opp(cvtptrx+1); /* fix opptrs */
         }
         else {
#ifdef TESTFP
            stopmsg (0, "*lodreal (sub) -> (*lodrealsub)" );
#endif
         }
         ffptr = fStkLodRealSub;
      }
   }
   else if (ffptr == fStkMul ){
      if (prevfptr == fStkLodDup ){
         /* found {loddup ? (*mul) } */
         if (fgf(--cvtptrx) == fStkPush2 ){
#ifdef TESTFP
            stopmsg (0, "loddup *push (mul) -> (*lodsqr),stk+=2" );
#endif
            stkcnt += 2; /* eliminate this push */
            --cvtptrx;	/* prev is a LodDup */
         }
         else {
#ifdef TESTFP
            stopmsg (0, "*loddup (mul) -> (*lodsqr)" );
#endif
         }
         ffptr = fStkLodSqr;
      }
      else if (prevfptr == fStkStoDup ){ /* no pushes here, 4 on stk. */
#ifdef TESTFP
         stopmsg (0, "stodup (mul) -> (*stosqr0)" );
#endif
         --cvtptrx;
         ffptr = fStkStoSqr0; /* dont save lastsqr here ever */
      }
      else if (prevfptr == fStkLod ){
         --cvtptrx; /* {lod *? (mul) } */
         if (fgf(cvtptrx) == fStkPush2 ){ /* {lod *push (mul) } */
            --cvtptrx; /* {? *lod push (mul) } */
            if(fgf(cvtptrx-1) == fStkPush2 ){
#ifdef TESTFP
               stopmsg (0, "push *lod push (mul) -> push4 (*lodmul)" );
#endif
               fgf(cvtptrx-1) = fStkPush4;
            }
            else {
#ifdef TESTFP
               stopmsg (0, "op *lod push (mul) -> op pusha (*lodmul)" );
#endif
               opp(cvtptrx+1) = opp(cvtptrx); /* fix operand ptr */
               fgf(cvtptrx) = fStkPush2a;
               opp(cvtptrx++) = NO_OPERAND;
            }
         }
         else {
#ifdef TESTFP
            stopmsg (0, "*lod (mul) -> (*lodmul)" );
#endif
         }
         ffptr = fStkLodMul;
      }
      else if (prevfptr == fStkLodReal || prevfptr == fStkLodRealC ){
         --cvtptrx; /* found {lodreal *? (mul) } */
         if (fgf(cvtptrx) == fStkPush2 ){
#ifdef TESTFP
            stopmsg (0, "lodreal *push2 (mul) -> (*lodrealmul),stk+=2" );
#endif
            --cvtptrx;
            stkcnt += 2;	/* stack ends with TWO_FREE, not 4 */
         }
         else {
#ifdef TESTFP
            stopmsg (0, "*lodreal (mul) }-> {(*lodrealmul)" );
#endif
         }
         ffptr = fStkLodRealMul;
      }
      else if (prevfptr == fStkLodLT && fgf(cvtptrx-1) != fStkPull2 ){
         /* this shortcut fails if {Lod LT Pull Mul } found */
#ifdef TESTFP
         stopmsg (0, "LodLT (*Mul) -> (*LodLTMul)" );
#endif
         --cvtptrx; /* never { lod LT Push Mul } here */
         ffptr = fStkLodLTMul;
      }
      else if (prevfptr == fStkLodLTE && fgf(cvtptrx-1) != fStkPull2 ){
#ifdef TESTFP
         stopmsg (0, "LodLTE (*mul) -> (*LodLTEmul)" );
#endif
         --cvtptrx;
         ffptr = fStkLodLTEMul;
      }
   }
   else if (ffptr == fStkClr1 && prevfptr == fStkSto ){
#ifdef TESTFP
         stopmsg (0, "sto (*clr1) -> (*stoclr1)" );
#endif
      --cvtptrx;
      ffptr = fStkStoClr1;
   }
   else if (ffptr == fStkDiv ){
      if (prevfptr == fStkLodRealC && vsp < MAX_ARGS - 1 ){
         /* have found a divide by a real constant */
         /*  and there is space to create a new one */
         /* {lodrealc ? (*div) } */
         --cvtptrx; /* change '/ const' to '* 1/const' */
         if (fgf(cvtptrx) == fStkPush2 ){
#ifdef TESTFP
            stopmsg (0, "lodrealc *push (div) -> (*lodrealmul),stk+=2" );
#endif
            --cvtptrx;
            stkcnt += 2;
         }
         else {
#ifdef TESTFP
            stopmsg (0, "*lodrealc (div) -> {(*lodrealmul)" );
#endif
         }
         v[vsp].s = (void near *)0; /* this constant has no name */
         v[vsp].len = 0;
         v[vsp].a.d.x = 1.0 / Load[LodPtr-1]->d.x;
         v[vsp].a.d.y = 0.0;
         opp(cvtptrx) = (void near *)&v[vsp++].a; /* isn't C fun! */
         ffptr = fStkLodRealMul;
      }
   }
   else if (ffptr == fStkReal ){
      if (prevfptr == fStkLod ){
#ifdef TESTFP
         stopmsg (0, "lod (*real) -> (*lodreal)" );
#endif
         --cvtptrx;
         ffptr = fStkLodReal;
      }
      else if (stkcnt < MAX_STACK ){
#ifdef TESTFP
         stopmsg (0, "(*real) -> (*real2)" );
#endif
         ffptr = fStkReal2;
      }
   }
   else if (ffptr == fStkImag && prevfptr == fStkLod ){
#ifdef TESTFP
         stopmsg (0, "lod (*imag) -> lodimag" );
#endif
      --cvtptrx;
      ffptr = fStkLodImag;
   }
   else if (ffptr == fStkConj && prevfptr == fStkLod ){
#ifdef TESTFP
         stopmsg (0, "lod (*conj) -> (*lodconj)" );
#endif
      --cvtptrx;
      ffptr = fStkLodConj;
   }
   else if (ffptr == fStkMod && stkcnt < MAX_STACK ){
#ifdef TESTFP
      stopmsg (0, "(*mod) -> (*mod2)" );
#endif
      ffptr = fStkMod2; /* use faster version if room on stack */
      if (prevfptr == fStkLod ){
#ifdef TESTFP
         stopmsg (0, "lod (*mod2) -> (*lodmod2)" );
#endif
         --cvtptrx;
         ffptr = fStkLodMod2;
      }
      else if (prevfptr == fStkSto || prevfptr == fStkSto2 ){
#ifdef TESTFP
         stopmsg (0, "sto (*mod2) -> (*stomod2)" );
#endif
         --cvtptrx;
         ffptr = fStkStoMod2;
      }
      else if (prevfptr == fStkLodSub ){
#ifdef TESTFP
         stopmsg (0, "lodsub (*mod2) -> (*lodsubmod)" );
#endif
         --cvtptrx;
         ffptr = fStkLodSubMod;
      }
   }
   else if (ffptr == fStkFlip ){
      if (prevfptr == fStkReal || prevfptr == fStkReal2 ){
#ifdef TESTFP
         stopmsg (0, "real (*flip) -> (*realflip)" );
#endif
         --cvtptrx;
         ffptr = fStkRealFlip;
      }
      else if (prevfptr == fStkImag ){
#ifdef TESTFP
         stopmsg (0, "imag (*flip) -> (*imagflip)" );
#endif
         --cvtptrx;
         ffptr = fStkImagFlip;
      }
      else if (prevfptr == fStkLodReal ){
#ifdef TESTFP
         stopmsg (0, "lodreal (*flip) -> (*lodrealflip)" );
#endif
         --cvtptrx;
         ffptr = fStkLodRealFlip;
      }
      else if (prevfptr == fStkLodImag ){
#ifdef TESTFP
         stopmsg (0, "lodimag (*flip) -> (*lodimagflip)" );
#endif
         --cvtptrx;
         ffptr = fStkLodImagFlip;
      }
   }
   else if (ffptr == fStkAbs ){
      if (prevfptr == fStkLodReal ){
#ifdef TESTFP
         stopmsg (0, "lodreal (*abs) -> (*lodrealabs)" );
#endif
         --cvtptrx;
         ffptr = fStkLodRealAbs;
      }
      else if (prevfptr == fStkLodImag ){
#ifdef TESTFP
         stopmsg (0, "lodimag (*abs) -> (*lodimagabs)" );
#endif
         --cvtptrx;
         ffptr = fStkLodImagAbs;
      }
   }
   else if (ffptr == fStkSqr ){
      if (prevfptr == fStkLod && fgf(cvtptrx-1) != fStkPush2 ){
#ifdef TESTFP
         stopmsg (0, "lod (*sqr) -> (*lodsqr)" );
#endif
         --cvtptrx;
         ffptr = fStkLodSqr; /* assume no need to save lastsqr */
         if (lastsqrused) {
#ifdef TESTFP
            stopmsg (0, "(*lodsqr) -> (*lodsqr2)" );
#endif
            ffptr = fStkLodSqr2; /* lastsqr is being used */
         }
      }
      else if (prevfptr == fStkSto2 ){
#ifdef TESTFP
         stopmsg (0, "sto2 (*sqr) -> (*stosqr0)" );
#endif
         --cvtptrx;
         ffptr = fStkStoSqr0; /* assume no need to save lastsqr */
         if (lastsqrused) {
#ifdef TESTFP
            stopmsg (0, "(*stosqr0) -> (*stosqr)" );
#endif
            ffptr = fStkStoSqr; /* save lastsqr */
         }
      }
      else {
         if (!lastsqrused) {
#ifdef TESTFP
            stopmsg (0, "(*sqr) -> (*sqr0)" );
#endif
            ffptr = fStkSqr0; /* don't save lastsqr */
         }
      }
   }
   else if (ffptr == fStkLTE && ( prevfptr == fStkLod
         || prevfptr == fStkLodReal || prevfptr == fStkLodRealC ) ){
#ifdef TESTFP
      stopmsg(0, "Lod (*LTE) -> (*LodLTE)" );
#endif
      --cvtptrx;
      ffptr = fStkLodLTE;
   }
   else if (ffptr == fStkLT && ( prevfptr == fStkLod
         || prevfptr == fStkLodReal || prevfptr == fStkLodRealC ) ){
#ifdef TESTFP
      stopmsg(0, "Lod (*LT) -> (*LodLT)" );
#endif
      --cvtptrx;
      ffptr = fStkLodLT;
   }
   else if (ffptr == fStkGT && ( prevfptr == fStkLod
         || prevfptr == fStkLodReal || prevfptr == fStkLodRealC ) ){
#ifdef TESTFP
      stopmsg(0, "Lod (*GT) -> (*LodGT)" );
#endif
      --cvtptrx;
      ffptr = fStkLodGT;
   }
   else if (ffptr == fStkGTE && ( prevfptr == fStkLod
         || prevfptr == fStkLodReal || prevfptr == fStkLodRealC ) ){
#ifdef TESTFP
      stopmsg(0, "Lod (*GTE) -> (*LodGTE)" );
#endif
      --cvtptrx;
      ffptr = fStkLodGTE;
   }
   else if (ffptr == fStkNE && ( prevfptr == fStkLod
         || prevfptr == fStkLodReal || prevfptr == fStkLodRealC ) ){
#ifdef TESTFP
      stopmsg(0, "Lod (*NE) -> (*LodNE)" );
#endif
      --cvtptrx;
      ffptr = fStkLodNE;
   }
   else if (ffptr == fStkEQ && ( prevfptr == fStkLod
         || prevfptr == fStkLodReal || prevfptr == fStkLodRealC ) ){
#ifdef TESTFP
      stopmsg(0, "Lod (*EQ) -> (*LodEQ)" );
#endif
      --cvtptrx;
      ffptr = fStkLodEQ;
   }

SkipOptimizer:  /* -----------  end of optimizer code  ------------ */

   fgf(cvtptrx++) = prevfptr = ffptr;
   prevstkcnt = stkcnt;

   if (Delta == 999 ){
      stkcnt = 0;
   }
   else {
      stkcnt += Delta;
   }
   return;
}

int CvtStk() {	/* convert the array of ptrs */
   extern int fform_per_pixel(void);	/* these fns are in parsera.asm */
   extern int fFormula(void);
   extern int BadFormula(void);
   extern char FormName[];
   void (far *ftst)(void);
   void (near *ntst)(void);

#ifdef TESTFP
   if (debugflag == 322) {
      stopmsg(0, "Skipping optimizer." );
   }
#endif

   for (OpPtr = LodPtr = lastsqrused = 0; OpPtr < LastOp; OpPtr++) {
      ftst = f[OpPtr];
      if (ftst == StkLod && Load[LodPtr++] == &LastSqr ){
         lastsqrused = 1; /* lastsqr is being used in the formula */
      }
      if (  ftst != StkLod  /* these are the supported parser fns */
            && ftst != StkClr
            && ftst != dStkAdd
            && ftst != dStkSub
            && ftst != dStkMul
            && ftst != dStkDiv
            && ftst != StkSto
            && ftst != dStkSqr
            && ftst != EndInit
            && ftst != dStkMod
            && ftst != dStkLTE
            && ftst != dStkSin
            && ftst != dStkCos
            && ftst != dStkSinh
            && ftst != dStkCosh
            && ftst != dStkCosXX
            && ftst != dStkTan
            && ftst != dStkTanh
            && ftst != dStkCoTan
            && ftst != dStkCoTanh
            && ftst != dStkLog
            && ftst != dStkExp
            && ftst != dStkPwr
            && ftst != dStkLT
            && ftst != dStkFlip
            && ftst != dStkReal
            && ftst != dStkImag
            && ftst != dStkConj
            && ftst != dStkNeg
            && ftst != dStkAbs
            && ftst != dStkRecip
            && ftst != StkIdent