home *** CD-ROM | disk | FTP | other *** search
/ Shareware Overload / ShartewareOverload.cdr / windows / winsrc.zip / PARSER.C < prev    next >
Text File  |  1990-11-03  |  33KB  |  1,301 lines
  1. /* Parser.c (C) 1990, Mark C. Peterson, CompuServe [70441,3353]
  2.      All rights reserved.
  3.  
  4.    Code may be used in any program provided the author is credited
  5.      either during program execution or in the documentation.  Source
  6.      code may be distributed only in combination with public domain or
  7.      shareware source code.  Source code may be modified provided the
  8.      copyright notice and this message is left unchanged and all
  9.      modifications are clearly documented.
  10.  
  11.      I would appreciate a copy of any work which incorporates this code,
  12.      however this is optional.
  13.  
  14.      Mark C. Peterson
  15.      253 West St., H
  16.      Plantsville, CT 06479
  17.      (203) 276-9474
  18. */
  19.  
  20. #include <string.h>
  21. #include <ctype.h>
  22. #include <stdio.h>
  23. #include "mpmath.h"
  24.  
  25. void findpath(char *filename, char *fullpathname);
  26. void far *farmemalloc(long bytestoalloc);
  27. void farmemfree(void far *farptr);
  28. int  stopmsg(int,unsigned char far *);
  29.  
  30. MATH_TYPE MathType = D_MATH;
  31. /* moved struct lcomplex and union ARg to mpmath.h -6-20-90 TIW */
  32.  
  33. struct ConstArg {
  34.    char *s;
  35.    int len;
  36.    union Arg a;
  37. };
  38.  
  39. struct PEND_OP {
  40.    void (far *f)(void);
  41.    int p;
  42. };
  43.  
  44. /* PB 901103 made some of the following static for safety */
  45. static struct PEND_OP far *o;
  46.  
  47. union Arg *Arg1, *Arg2;
  48. static union Arg s[20], far *a, far * far *Store, far * far *Load;
  49. static int StoPtr, LodPtr, OpPtr;
  50.  
  51. static void (far * far *f)(void) = (void(far * far *)(void))0;
  52.  
  53. static unsigned n, ErrPtr, posp, vsp, NextOp, LastOp, InitN;
  54. static int paren, SyntaxErr, ExpectingArg;
  55. static struct ConstArg far *v = (struct ConstArg far *)0;
  56. static int InitLodPtr, InitStoPtr, InitOpPtr, LastInitOp, NumVar;
  57. static int Delta16;
  58. static double fgLimit;
  59. static double fg;
  60. static int ShiftBack;     /* TIW 06-18-90 */
  61.  
  62. extern int bitshift;
  63. extern int bitshiftless1;
  64. extern long multiply(long x, long y, int bitshift);
  65. extern long divide(long x, long y, int bitshift);
  66. extern int symmetry;          /* symmetry flag for calcmand()  */
  67. extern double param[];
  68.  
  69. extern int debugflag;         /* BDT for debugging */
  70. extern int row, col, overflow, cpu, fpu;
  71. extern struct complex old, new;
  72. extern double far *dx0, far *dy0;
  73. extern long far *lx0, far *ly0;     /* BDT moved these to FAR */
  74.  
  75. #ifndef TESTING_MATH
  76.    extern double far *dx1, far *dy1;
  77.    extern long far *lx1, far *ly1;
  78.    #define dShiftx dx1[row]
  79.    #define dShifty dy1[col]
  80.    #define lShiftx lx1[row]
  81.    #define lShifty ly1[col]
  82. #else
  83.    #define dShiftx 0.0
  84.    #define dShifty 0.0
  85.    #define lShiftx 0L
  86.    #define lShifty 0L
  87. #endif
  88.  
  89. extern struct lcomplex lold, lnew;
  90. extern char FormName[];
  91.  
  92. #define LastSqr v[4].a
  93.  
  94. static char * ErrStrings[] = {
  95.    "Should be an Argument",
  96.    "Should be an Operator",
  97.    "')' needs a matching '('",
  98.    "Need more ')'",
  99.    "Undefined Operator",
  100.    "Undefined Function",
  101.    "More than one ','",
  102.    "Table overflow"
  103. };
  104.  
  105. void dStkAbs(void) {
  106.    Arg1->d.x = fabs(Arg1->d.x);
  107.    Arg1->d.y = fabs(Arg1->d.y);
  108. }
  109.  
  110. void mStkAbs(void) {
  111.    if(Arg1->m.x.Exp < 0)
  112.       Arg1->m.x.Exp = -Arg1->m.x.Exp;
  113.    if(Arg1->m.y.Exp < 0)
  114.       Arg1->m.y.Exp = -Arg1->m.y.Exp;
  115. }
  116.  
  117. void lStkAbs(void) {
  118.    Arg1->l.x = labs(Arg1->l.x);
  119.    Arg1->l.y = labs(Arg1->l.y);
  120. }
  121.  
  122. void (*StkAbs)(void) = dStkAbs;
  123.  
  124. void dStkSqr(void) {
  125.    LastSqr.d.x = Arg1->d.x * Arg1->d.x;
  126.    LastSqr.d.y = Arg1->d.y * Arg1->d.y;
  127.    Arg1->d.y = Arg1->d.x * Arg1->d.y * 2.0;
  128.    Arg1->d.x = LastSqr.d.x - LastSqr.d.y;
  129.    LastSqr.d.x += LastSqr.d.y;
  130. }
  131.  
  132. void mStkSqr(void) {
  133.    LastSqr.m.x = MPmul(Arg1->m.x, Arg1->m.x);
  134.    LastSqr.m.y = MPmul(Arg1->m.y, Arg1->m.y);
  135.    Arg1->m.y = MPmul(Arg1->m.x, Arg1->m.y);
  136.    Arg1->m.y.Exp++;
  137.    Arg1->m.x = MPsub(LastSqr.m.x, LastSqr.m.y);
  138.    LastSqr.m.x = MPadd(LastSqr.m.x, LastSqr.m.y);
  139. }
  140.  
  141. void lStkSqr(void) {
  142.    LastSqr.l.x = multiply(Arg1->l.x, Arg1->l.x, bitshift);
  143.    LastSqr.l.y = multiply(Arg1->l.y, Arg1->l.y, bitshift);
  144.    Arg1->l.y = multiply(Arg1->l.x, Arg1->l.y, bitshift) << 1;
  145.    Arg1->l.x = LastSqr.l.x - LastSqr.l.y;
  146.    LastSqr.l.x += LastSqr.l.y;
  147. }
  148.  
  149. void (*StkSqr)(void) = dStkSqr;
  150.  
  151. void dStkAdd(void) {
  152.    Arg2->d.x += Arg1->d.x;
  153.    Arg2->d.y += Arg1->d.y;
  154.    Arg1--;
  155.    Arg2--;
  156. }
  157.  
  158. void mStkAdd(void) {
  159.    Arg2->m = MPCadd(Arg2->m, Arg1->m);
  160.    Arg1--;
  161.    Arg2--;
  162. }
  163.  
  164. void lStkAdd(void) {
  165.    Arg2->l.x += Arg1->l.x;
  166.    Arg2->l.y += Arg1->l.y;
  167.    Arg1--;
  168.    Arg2--;
  169. }
  170.  
  171. void (*StkAdd)(void) = dStkAdd;
  172.  
  173. void dStkSub(void) {
  174.    Arg2->d.x -= Arg1->d.x;
  175.    Arg2->d.y -= Arg1->d.y;
  176.    Arg1--;
  177.    Arg2--;
  178. }
  179.  
  180. void mStkSub(void) {
  181.    Arg2->m = MPCsub(Arg2->m, Arg1->m);
  182.    Arg1--;
  183.    Arg2--;
  184. }
  185.  
  186. void lStkSub(void) {
  187.    Arg2->l.x -= Arg1->l.x;
  188.    Arg2->l.y -= Arg1->l.y;
  189.    Arg1--;
  190.    Arg2--;
  191. }
  192.  
  193. void (*StkSub)(void) = dStkSub;
  194.  
  195. void dStkConj(void) {
  196.    Arg1->d.y = -Arg1->d.y;
  197. }
  198.  
  199. void mStkConj(void) {
  200.    Arg1->m.y.Exp ^= 0x8000;
  201. }
  202.  
  203. void lStkConj(void) {
  204.    Arg1->l.y = -Arg1->l.y;
  205. }
  206.  
  207. void (*StkConj)(void) = dStkConj;
  208.  
  209. void dStkReal(void) {
  210.    Arg1->d.y = 0.0;
  211. }
  212.  
  213. void mStkReal(void) {
  214.    Arg1->m.y.Mant = (long)(Arg1->m.y.Exp = 0);
  215. }
  216.  
  217. void lStkReal(void) {
  218.    Arg1->l.y = 0l;
  219. }
  220.  
  221. void (*StkReal)(void) = dStkReal;
  222.  
  223. void dStkImag(void) {
  224.    Arg1->d.x = 0.0;
  225. }
  226.  
  227. void mStkImag(void) {
  228.    Arg1->m.x.Mant = (long)(Arg1->m.x.Exp = 0);
  229. }
  230.  
  231. void lStkImag(void) {
  232.    Arg1->l.x = 0l;
  233. }
  234.  
  235. void (*StkImag)(void) = dStkImag;
  236.  
  237. void dStkNeg(void) {
  238.    Arg1->d.x = -Arg1->d.x;
  239.    Arg1->d.y = -Arg1->d.y;
  240. }
  241.  
  242. void mStkNeg(void) {
  243.    Arg1->m.x.Exp ^= 0x8000;
  244.    Arg1->m.y.Exp ^= 0x8000;
  245. }
  246.  
  247. void lStkNeg(void) {
  248.    Arg1->l.x = -Arg1->l.x;
  249.    Arg1->l.y = -Arg1->l.y;
  250. }
  251.  
  252. void (*StkNeg)(void) = dStkNeg;
  253.  
  254. void dStkMul(void) {
  255.    FPUcplxmul(&Arg2->d, &Arg1->d, &Arg2->d);
  256.    Arg1--;
  257.    Arg2--;
  258. }
  259.  
  260. void mStkMul(void) {
  261.    Arg2->m = MPCmul(Arg2->m, Arg1->m);
  262.    Arg1--;
  263.    Arg2--;
  264. }
  265.  
  266. void lStkMul(void) {
  267.    long x, y;
  268.  
  269.    x = multiply(Arg2->l.x, Arg1->l.x, bitshift) -
  270.        multiply(Arg2->l.y, Arg1->l.y, bitshift);
  271.    y = multiply(Arg2->l.y, Arg1->l.x, bitshift) +
  272.        multiply(Arg2->l.x, Arg1->l.y, bitshift);
  273.    Arg2->l.x = x;
  274.    Arg2->l.y = y;
  275.    Arg1--;
  276.    Arg2--;
  277. }
  278.  
  279. void (*StkMul)(void) = dStkMul;
  280.  
  281. void dStkDiv(void) {
  282.    FPUcplxdiv(&Arg2->d, &Arg1->d, &Arg2->d);
  283.    Arg1--;
  284.    Arg2--;
  285. }
  286.  
  287. void mStkDiv(void) {
  288.    Arg2->m = MPCdiv(Arg2->m, Arg1->m);
  289.    Arg1--;
  290.    Arg2--;
  291. }
  292.  
  293. void lStkDiv(void) {
  294.    long x, y, mod, x2, y2;
  295.  
  296.    mod = multiply(Arg1->l.x, Arg1->l.x, bitshift) +
  297.          multiply(Arg1->l.y, Arg1->l.y, bitshift);
  298.    x = divide(Arg1->l.x, mod, bitshift);
  299.    y = -divide(Arg1->l.y, mod, bitshift);
  300.    /* pb 900617 changed next 4 lines to use x2,y2 instead of x,y */
  301.    x2 = multiply(Arg2->l.x, x, bitshift) - multiply(Arg2->l.y, y, bitshift);
  302.    y2 = multiply(Arg2->l.y, x, bitshift) + multiply(Arg2->l.x, y, bitshift);
  303.    Arg2->l.x = x2;
  304.    Arg2->l.y = y2;
  305.    Arg1--;
  306.    Arg2--;
  307. }
  308.  
  309. void (*StkDiv)(void) = dStkDiv;
  310.  
  311. void StkSto(void) {
  312.    *Store[StoPtr++] = *Arg1;
  313. }
  314.  
  315. void StkLod(void) {
  316.    Arg1++;
  317.    Arg2++;
  318.    *Arg1 = *Load[LodPtr++];
  319. }
  320.  
  321. void dStkMod(void) {
  322.    Arg1->d.x = (Arg1->d.x * Arg1->d.x) + (Arg1->d.y * Arg1->d.y);
  323.    Arg1->d.y = 0.0;
  324. }
  325.  
  326. void mStkMod(void) {
  327.    Arg1->m.x = MPCmod(Arg1->m);
  328.    Arg1->m.y.Mant = (long)(Arg1->m.y.Exp = 0);
  329. }
  330.  
  331. void lStkMod(void) {
  332.    Arg1->l.x = multiply(Arg2->l.x, Arg1->l.x, bitshift) +
  333.                  multiply(Arg2->l.y, Arg1->l.y, bitshift);
  334.    if(Arg1->l.x < 0)
  335.       overflow = 1;
  336.    Arg1->l.y = 0L;
  337. }
  338.  
  339. void (*StkMod)(void) = dStkMod;
  340.  
  341. void StkClr(void) {
  342.    s[0] = *Arg1;
  343.    Arg1 = &s[0];
  344.    Arg2 = Arg1;
  345.    Arg2--;
  346. }
  347.  
  348. void dStkSin(void) {
  349.    double sinx, cosx, sinhy, coshy;
  350.  
  351.    FPUsincos(&Arg1->d.x, &sinx, &cosx);
  352.    FPUsinhcosh(&Arg1->d.y, &sinhy, &coshy);
  353.    Arg1->d.x = sinx*coshy;
  354.    Arg1->d.y = cosx*sinhy;
  355. }
  356.  
  357. void mStkSin(void) {
  358.    Arg1->d = MPC2cmplx(Arg1->m);
  359.    dStkSin();
  360.    Arg1->m = cmplx2MPC(Arg1->d);
  361. }
  362.  
  363. void lStkSin(void) {
  364.    int f;
  365.    long x, y, sinx, cosx, sinhy, coshy;
  366.  
  367.    x = Arg1->l.x >> Delta16;
  368.    y = Arg1->l.y >> Delta16;
  369.    SinCos086(x, &sinx, &cosx);
  370.    SinhCosh086(y, &sinhy, &coshy);
  371.    Arg1->l.x = multiply(sinx, coshy, ShiftBack); /* TIW 06-18-90 */
  372.    Arg1->l.y = multiply(cosx, sinhy, ShiftBack); /* TIW 06-18-90 */
  373. }
  374.  
  375. void (*StkSin)(void) = dStkSin;
  376.  
  377. void dStkSinh(void) {
  378.    double siny, cosy, sinhx, coshx;
  379.  
  380.    FPUsincos(&Arg1->d.y, &siny, &cosy);
  381.    FPUsinhcosh(&Arg1->d.x, &sinhx, &coshx);
  382.    Arg1->d.x = sinhx*cosy;
  383.    Arg1->d.y = coshx*siny;
  384. }
  385.  
  386. void mStkSinh(void) {
  387.    Arg1->d = MPC2cmplx(Arg1->m);
  388.    dStkSinh();
  389.    Arg1->m = cmplx2MPC(Arg1->d);
  390. }
  391.  
  392. void lStkSinh(void) {
  393.    int f;
  394.    long x, y, sinhx, coshx, siny, cosy;
  395.  
  396.    x = Arg1->l.x >> Delta16;
  397.    y = Arg1->l.y >> Delta16;
  398.    SinCos086(y, &siny, &cosy);
  399.    SinhCosh086(x, &sinhx, &coshx);
  400.    Arg1->l.x = multiply(cosy, sinhx, ShiftBack); /* TIW 06-18-90 */
  401.    Arg1->l.y = multiply(siny, coshx, ShiftBack); /* TIW 06-18-90 */
  402. }
  403.  
  404. void (*StkSinh)(void) = dStkSinh;
  405.  
  406. void dStkCos(void) {
  407.    double sinx, cosx, sinhy, coshy;
  408.  
  409.    FPUsincos(&Arg1->d.x, &sinx, &cosx);
  410.    FPUsinhcosh(&Arg1->d.y, &sinhy, &coshy);
  411.    Arg1->d.x = cosx*coshy;
  412.    Arg1->d.y = sinx*sinhy;
  413. }
  414.  
  415. void mStkCos(void) {
  416.    Arg1->d = MPC2cmplx(Arg1->m);
  417.    dStkCos();
  418.    Arg1->m = cmplx2MPC(Arg1->d);
  419. }
  420.  
  421. void lStkCos(void) {
  422.    int f;
  423.    long x, y, sinx, cosx, sinhy, coshy;
  424.  
  425.    x = Arg1->l.x >> Delta16;
  426.    y = Arg1->l.y >> Delta16;
  427.    SinCos086(x, &sinx, &cosx);
  428.    SinhCosh086(y, &sinhy, &coshy);
  429.    Arg1->l.x = multiply(cosx, coshy, ShiftBack); /* TIW 06-18-90 */
  430.    Arg1->l.y = multiply(sinx, sinhy, ShiftBack); /* TIW 06-18-90 */
  431. }
  432.  
  433. void (*StkCos)(void) = dStkCos;
  434.  
  435. void dStkCosh(void) {
  436.    double siny, cosy, sinhx, coshx;
  437.  
  438.    FPUsincos(&Arg1->d.y, &siny, &cosy);
  439.    FPUsinhcosh(&Arg1->d.x, &sinhx, &coshx);
  440.    Arg1->d.x = coshx*cosy;
  441.    Arg1->d.y = sinhx*siny;
  442. }
  443.  
  444. void mStkCosh(void) {
  445.    Arg1->d = MPC2cmplx(Arg1->m);
  446.    dStkCosh();
  447.    Arg1->m = cmplx2MPC(Arg1->d);
  448. }
  449.  
  450. void lStkCosh(void) {
  451.    int f;
  452.    long x, y, sinhx, coshx, siny, cosy;
  453.  
  454.    x = Arg1->l.x >> Delta16;
  455.    y = Arg1->l.y >> Delta16;
  456.    SinCos086(y, &siny, &cosy);
  457.    SinhCosh086(x, &sinhx, &coshx);
  458.    Arg1->l.x = multiply(cosy, coshx, ShiftBack); /* TIW 06-18-90 */
  459.    Arg1->l.y = multiply(siny, sinhx, ShiftBack); /* TIW 06-18-90 */
  460. }
  461.  
  462. void (*StkCosh)(void) = dStkCosh;
  463.  
  464. void dStkLT(void) {
  465.    Arg2->d.x = (double)(Arg2->d.x < Arg1->d.x);
  466.    Arg2->d.y = 0.0;
  467.    Arg1--;
  468.    Arg2--;
  469. }
  470.  
  471. void mStkLT(void) {
  472.    Arg2->m.x = fg2MP((long)(MPcmp(Arg2->m.x, Arg1->m.x) == -1), 0);
  473.    Arg2->m.y.Mant = (long)(Arg2->m.y.Exp = 0);
  474.    Arg1--;
  475.    Arg2--;
  476. }
  477.  
  478. void lStkLT(void) {
  479.    Arg2->l.x = Arg2->l.x < Arg1->l.x;
  480.    Arg2->l.y = 0l;
  481.    Arg1--;
  482.    Arg2--;
  483. }
  484.  
  485. void (*StkLT)(void) = dStkLT;
  486.  
  487. void dStkLTE(void) {
  488.    Arg2->d.x = (double)(Arg2->d.x <= Arg1->d.x);
  489.    Arg2->d.y = 0.0;
  490.    Arg1--;
  491.    Arg2--;
  492. }
  493.  
  494. void mStkLTE(void) {
  495.    int comp;
  496.  
  497.    comp = MPcmp(Arg2->m.x, Arg1->m.x);
  498.    Arg2->m.x = fg2MP((long)(comp == -1 || comp == 0), 0);
  499.    Arg2->m.y.Mant = (long)(Arg2->m.y.Exp = 0);
  500.    Arg1--;
  501.    Arg2--;
  502. }
  503.  
  504. void lStkLTE(void) {
  505.    Arg2->l.x = Arg2->l.x <= Arg1->l.x;
  506.    Arg2->l.y = 0l;
  507.    Arg1--;
  508.    Arg2--;
  509. }
  510.  
  511. void (*StkLTE)(void) = dStkLTE;
  512.  
  513. void dStkLog(void) {
  514.    FPUcplxlog(&Arg1->d, &Arg1->d);
  515. }
  516.  
  517. void mStkLog(void) {
  518.    Arg1->d = MPC2cmplx(Arg1->m);
  519.    dStkLog();
  520.    Arg1->m = cmplx2MPC(Arg1->d);
  521. }
  522.  
  523. void lStkLog(void) {
  524.    struct complex x;
  525.  
  526.    x.x = (double)Arg1->l.x / fg;
  527.    x.y = (double)Arg1->l.y / fg;
  528.    FPUcplxlog(&x, &x);
  529.    if(fabs(x.x) < fgLimit && fabs(x.y) < fgLimit) {
  530.       Arg1->l.x = (long)(x.x * fg);
  531.       Arg1->l.y = (long)(x.y * fg);
  532.    }
  533.    else
  534.       overflow = 1;
  535. }
  536.  
  537. void (*StkLog)(void) = dStkLog;
  538.  
  539. void FPUcplxexp(struct complex *x, struct complex *z) {
  540.    double e2x, siny, cosy;
  541.  
  542.    if(fpu == 387)
  543.       FPUcplxexp387(x, z);
  544.    else {
  545.       e2x = exp(x->x);
  546.       FPUsincos(&x->y, &siny, &cosy);
  547.       z->x = e2x * cosy;
  548.       z->y = e2x * siny;
  549.    }
  550. }
  551.  
  552. void dStkExp(void) {
  553.    FPUcplxexp(&Arg1->d, &Arg1->d);
  554. }
  555.  
  556. void mStkExp(void) {
  557.    Arg1->d = MPC2cmplx(Arg1->m);
  558.    FPUcplxexp(&Arg1->d, &Arg1->d);
  559.    Arg1->m = cmplx2MPC(Arg1->d);
  560. }
  561.  
  562. void lStkExp(void) {
  563.    struct complex x;
  564.  
  565.    x.x = (double)Arg1->l.x / fg;
  566.    x.y = (double)Arg1->l.y / fg;
  567.    FPUcplxexp(&x, &x);
  568.    if(fabs(x.x) < fgLimit && fabs(x.y) < fgLimit) {
  569.       Arg1->l.x = (long)(x.x * fg);
  570.       Arg1->l.y = (long)(x.y * fg);
  571.    }
  572.    else
  573.       overflow = 1;
  574. }
  575.  
  576. void (*StkExp)(void) = dStkExp;
  577.  
  578. void dStkPwr(void) {
  579.    Arg2->d = ComplexPower(Arg2->d, Arg1->d);
  580.    Arg1--;
  581.    Arg2--;
  582. }
  583.  
  584. void mStkPwr(void) {
  585.    struct complex x, y;
  586.  
  587.    x = MPC2cmplx(Arg2->m);
  588.    y = MPC2cmplx(Arg1->m);
  589.    x = ComplexPower(x, y);
  590.    Arg2->m = cmplx2MPC(x);
  591.    Arg1--;
  592.    Arg2--;
  593. }
  594.  
  595. void lStkPwr(void) {
  596.    struct complex x, y;
  597.  
  598.    x.x = (double)Arg2->l.x / fg;
  599.    x.y = (double)Arg2->l.y / fg;
  600.    y.x = (double)Arg1->l.x / fg;
  601.    y.y = (double)Arg1->l.y / fg;
  602.    x = ComplexPower(x, y);
  603.    if(fabs(x.x) < fgLimit && fabs(x.y) < fgLimit) {
  604.       Arg2->l.x = (long)(x.x * fg);
  605.       Arg2->l.y = (long)(x.y * fg);
  606.    }
  607.    else
  608.       overflow = 1;
  609.    Arg1--;
  610.    Arg2--;
  611. }
  612.  
  613. void (*StkPwr)(void) = dStkPwr;
  614.  
  615. void EndInit(void) {
  616.    LastInitOp = OpPtr;
  617. }
  618.  
  619. struct ConstArg far *isconst(char *Str, int Len) {
  620.    struct complex z;
  621.    unsigned n, j;
  622.  
  623.    for(n = 0; n < vsp; n++) {
  624.       if(v[n].len == Len) {
  625.          if(!strnicmp(v[n].s, Str, Len))
  626.             return(&v[n]);
  627.       }
  628.    }
  629.    v[vsp].s = Str;
  630.    v[vsp].len = Len;
  631.    v[vsp].a.d.x = v[vsp].a.d.y = 0.0;
  632.    if(isdigit(Str[0]) || Str[0] == '.') {
  633.       if(o[posp-1].f == StkNeg) {
  634.          posp--;
  635.          Str = Str - 1;
  636.          InitN--;
  637.       }
  638.       for(n = 1; isdigit(Str[n]) || Str[n] == '.'; n++);
  639.       if(Str[n] == ',') {
  640.          j = n + strspn(&Str[n+1], " \t\r\n") + 1;
  641.          if(isdigit(Str[j]) || (Str[j] == '-' && isdigit(Str[j+1]))) {
  642.             z.y = atof(&Str[j]);
  643.             for(; isdigit(Str[j]) || Str[j] == '.' || Str[j] == '-'; j++);
  644.             v[vsp].len = j;
  645.          }
  646.       }
  647.       else
  648.          z.y = 0.0;
  649.       z.x = atof(Str);
  650.       switch(MathType) {
  651.          case D_MATH:
  652.             v[vsp].a.d = z;
  653.             break;
  654.          case M_MATH:
  655.             v[vsp].a.m = cmplx2MPC(z);
  656.             break;
  657.          case L_MATH:
  658.             v[vsp].a.l.x = (long)(z.x * fg);
  659.             v[vsp].a.l.y = (long)(z.y * fg);
  660.             break;
  661.       }
  662.       v[vsp].s = Str;
  663.    }
  664.    return(&v[vsp++]);
  665. }
  666.  
  667. struct FNCT_LIST {
  668.    char *s;
  669.    void (* *ptr)(void);
  670. };
  671.  
  672. struct FNCT_LIST FnctList[] = {
  673.    "sin", &StkSin,
  674.    "sinh", &StkSinh,
  675.    "cos", &StkCos,
  676.    "cosh", &StkCosh,
  677.    "sqr", &StkSqr,
  678.    "log", &StkLog,
  679.    "exp", &StkExp,
  680.    "abs", &StkAbs,
  681.    "conj", &StkConj,
  682.    "real", &StkReal,
  683.    "imag", &StkImag,
  684. };
  685.  
  686. void NotAFnct(void) { }
  687. void FnctNotFound(void) { }
  688.  
  689. void (far *isfunct(char *Str, int Len))(void) {
  690.    unsigned n;
  691.  
  692.    n = strspn(&Str[Len], " \t\r\n");
  693.    if(Str[Len+n] == '(') {
  694.       for(n = 0; n < sizeof(FnctList) / sizeof(struct FNCT_LIST); n++) {
  695.          if(strlen(FnctList[n].s) == Len) {
  696.             if(!strnicmp(FnctList[n].s, Str, Len))
  697.                return(*FnctList[n].ptr);
  698.          }
  699.       }
  700.       return(FnctNotFound);
  701.    }
  702.    return(NotAFnct);
  703. }
  704.  
  705. void RecSortPrec(void) {
  706.    int ThisOp = NextOp++;
  707.  
  708.    while(o[ThisOp].p > o[NextOp].p && NextOp < posp)
  709.       RecSortPrec();
  710.    f[OpPtr++] = o[ThisOp].f;
  711. }
  712.  
  713. static char *Constants[] = {
  714.    "pixel",
  715.    "p1",
  716.    "p2",
  717.    "z",
  718.    "LastSqr",
  719. };
  720.  
  721. struct SYMETRY {
  722.    char *s;
  723.    int n;
  724. } SymStr[] = {
  725.    "NOSYM",         0,
  726.    "XAXIS_NOPARM", -1,
  727.    "XAXIS",         1,
  728.    "YAXIS_NOPARM", -2,
  729.    "YAXIS",         2,
  730.    "XYAXIS_NOPARM",-3,
  731.    "XYAXIS",        3,
  732.    "ORIGIN_NOPARM",-4,
  733.    "ORIGIN",        4,
  734.    "PI_SYM_NOPARM",-5,
  735.    "PI_SYM",        5,
  736.    "NOPLOT",       99,
  737.    "", 0
  738. };
  739.  
  740. int ParseStr(char *Str) {
  741.    char memstr[80];
  742.    struct ConstArg far *c;
  743.    int CondFlag = 0, ModFlag = 999, Len, Equals = 0, Mod[20], mdstk = 0;
  744.    struct ERROR { int n, s; } far *e;
  745.    strcpy(memstr,"Insufficient memory to run fractal type 'formula'");
  746.  
  747.    e = (struct ERROR far *)farmemalloc(sizeof(struct ERROR) * 100L);
  748.    if(!e || !o || !a || !Store || !Load || !v) {
  749.       stopmsg(0,memstr); /* PB printf replaced by stopmsg */
  750.       return(1);
  751.    }
  752.    switch(MathType) {
  753.       case D_MATH:
  754.          StkAdd = dStkAdd;
  755.          StkSub = dStkSub;
  756.          StkNeg = dStkNeg;
  757.          StkMul = dStkMul;
  758.          StkSin = dStkSin;
  759.          StkSinh = dStkSinh;
  760.          StkLT = dStkLT;
  761.          StkLTE = dStkLTE;
  762.          StkMod = dStkMod;
  763.          StkSqr = dStkSqr;
  764.          StkCos = dStkCos;
  765.          StkCosh = dStkCosh;
  766.          StkLog = dStkLog;
  767.          StkExp = dStkExp;
  768.          StkPwr = dStkPwr;
  769.          StkDiv = dStkDiv;
  770.          StkAbs = dStkAbs;
  771.          StkReal = dStkReal;
  772.          StkImag = dStkImag;
  773.          StkConj = dStkConj;
  774.          break;
  775.       case M_MATH:
  776.          StkAdd = mStkAdd;
  777.          StkSub = mStkSub;
  778.          StkNeg = mStkNeg;
  779.          StkMul = mStkMul;
  780.          StkSin = mStkSin;
  781.          StkSinh = mStkSinh;
  782.          StkLT = mStkLT;
  783.          StkLTE = mStkLTE;
  784.          StkMod = mStkMod;
  785.          StkSqr = mStkSqr;
  786.          StkCos = mStkCos;
  787.          StkCosh = mStkCosh;
  788.          StkLog = mStkLog;
  789.          StkExp = mStkExp;
  790.          StkPwr = mStkPwr;
  791.          StkDiv = mStkDiv;
  792.          StkAbs = mStkAbs;
  793.          StkReal = mStkReal;
  794.          StkImag = mStkImag;
  795.          StkConj = mStkConj;
  796.          break;
  797.       case L_MATH:
  798.          Delta16 = bitshift - 16;
  799.          ShiftBack = 32 - bitshift; /* TW 06-18-90 */
  800.          StkAdd = lStkAdd;
  801.          StkSub = lStkSub;
  802.          StkNeg = lStkNeg;
  803.          StkMul = lStkMul;
  804.          StkSin = lStkSin;
  805.          StkSinh = lStkSinh;
  806.          StkLT = lStkLT;
  807.          StkLTE = lStkLTE;
  808.          StkMod = lStkMod;
  809.          StkSqr = lStkSqr;
  810.          StkCos = lStkCos;
  811.          StkCosh = lStkCosh;
  812.          StkLog = lStkLog;
  813.          StkExp = lStkExp;
  814.          StkPwr = lStkPwr;
  815.          StkDiv = lStkDiv;
  816.          StkAbs = lStkAbs;
  817.          StkReal = lStkReal;
  818.          StkImag = lStkImag;
  819.          StkConj = lStkConj;
  820.          break;
  821.    }
  822.    for(vsp = 0; vsp < sizeof(Constants) / sizeof(char*); vsp++) {
  823.       v[vsp].s = Constants[vsp];
  824.       v[vsp].len = strlen(Constants[vsp]);
  825.    }
  826.    switch(MathType) {
  827.       case D_MATH:
  828.          v[1].a.d.x = param[0];
  829.          v[1].a.d.y = param[1];
  830.          v[2].a.d.x = param[2];
  831.          v[2].a.d.y = param[3];
  832.          break;
  833.       case M_MATH:
  834.          v[1].a.m.x = d2MP(param[0]);
  835.          v[1].a.m.y = d2MP(param[1]);
  836.          v[2].a.m.x = d2MP(param[2]);
  837.          v[2].a.m.y = d2MP(param[3]);
  838.          break;
  839.       case L_MATH:
  840.          v[1].a.l.x = (long)(param[0] * fg);
  841.          v[1].a.l.y = (long)(param[1] * fg);
  842.          v[2].a.l.x = (long)(param[2] * fg);
  843.          v[2].a.l.y = (long)(param[3] * fg);
  844.          break;
  845.    }
  846.  
  847.    LastInitOp = ErrPtr = paren = OpPtr = LodPtr = StoPtr = posp = 0;
  848.    SyntaxErr = -1;
  849.    ExpectingArg = 1;
  850.    for(n = 0; Str[n]; n++) {
  851.       n += strspn(&Str[n], " \t\r\n");
  852.       if(!Str[n])
  853.          break;
  854.       InitN = n;
  855.       switch(Str[n]) {
  856.          case '(':
  857.             paren++;
  858.             if(!ExpectingArg)
  859.                SyntaxErr = 1;
  860.             break;
  861.          case ')':
  862.             if(paren)
  863.                paren--;
  864.             else
  865.                SyntaxErr = 2;
  866.             if(ExpectingArg) {
  867.                e[ErrPtr].n = InitN;
  868.                e[ErrPtr++].s = 0;
  869.             }
  870.             break;
  871.          case '|':
  872.             if(ModFlag == paren-1) {
  873.                if(ExpectingArg)
  874.                   SyntaxErr = 0;
  875.                paren--;
  876.                ModFlag = Mod[--mdstk];
  877.             }
  878.             else {
  879.                if(!ExpectingArg)
  880.                   SyntaxErr = 1;
  881.                Mod[mdstk++] = ModFlag;
  882.                o[posp].f = StkMod;
  883.                o[posp++].p = 2 - (paren + Equals)*15;
  884.                ModFlag = paren++;
  885.             }
  886.             break;
  887.          case ',':
  888.          case ';':
  889.             if(paren) {
  890.                e[ErrPtr].n = InitN;
  891.                e[ErrPtr++].s = 3;
  892.             }
  893.             if(ExpectingArg)
  894.                SyntaxErr = 0;
  895.             else
  896.                ExpectingArg = 1;
  897.             o[posp].f = (void(far*)(void))0;
  898.             o[posp++].p = 15;
  899.             o[posp].f = StkClr;
  900.             o[posp++].p = -30000;
  901.             Equals = paren = 0;
  902.             break;
  903.          case ':':
  904.             if(paren) {
  905.                e[ErrPtr].n = InitN;
  906.                e[ErrPtr++].s = 3;
  907.             }
  908.             if(ExpectingArg)
  909.                SyntaxErr = 0;
  910.             else
  911.                ExpectingArg = 1;
  912.             o[posp].f = (void(far*)(void))0;
  913.             o[posp++].p = 15;
  914.             o[posp].f = EndInit;
  915.             o[posp++].p = -30000;
  916.             Equals = paren = 0;
  917.             LastInitOp = 10000;
  918.             break;
  919.          case '+':
  920.             if(ExpectingArg)
  921.                SyntaxErr = 0;
  922.             ExpectingArg = 1;
  923.             o[posp].f = StkAdd;
  924.             o[posp++].p = 4 - (paren + Equals)*15;
  925.             break;
  926.          case '-':
  927.             if(ExpectingArg) {
  928.                o[posp].f = StkNeg;
  929.                o[posp++].p = 2 - (paren + Equals)*15;
  930.             }
  931.             else {
  932.                o[posp].f = StkSub;
  933.                o[posp++].p = 4 - (paren + Equals)*15;
  934.                ExpectingArg = 1;
  935.             }
  936.             break;
  937.          case '<':
  938.             if(ExpectingArg)
  939.                SyntaxErr = 0;
  940.             ExpectingArg = 1;
  941.             if(Str[n+1] == '=') {
  942.                n++;
  943.                o[posp].f = StkLTE;
  944.             }
  945.             else
  946.                o[posp].f = StkLT;
  947.             o[posp++].p = 6 - (paren + Equals)*15;
  948.             break;
  949.          case '*':
  950.             if(ExpectingArg)
  951.                SyntaxErr = 0;
  952.             ExpectingArg = 1;
  953.             o[posp].f = StkMul;
  954.             o[posp++].p = 3 - (paren + Equals)*15;
  955.             break;
  956.          case '/':
  957.             if(ExpectingArg)
  958.                SyntaxErr = 0;
  959.             ExpectingArg = 1;
  960.             o[posp].f = StkDiv;
  961.             o[posp++].p = 3 - (paren + Equals)*15;
  962.             break;
  963.          case '^':
  964.             if(ExpectingArg)
  965.                SyntaxErr = 0;
  966.             ExpectingArg = 1;
  967.             o[posp].f = StkPwr;
  968.             o[posp++].p = 2 - (paren + Equals)*15;
  969.             break;
  970.          case '=':
  971.             if(ExpectingArg)
  972.                SyntaxErr = 0;
  973.             ExpectingArg = 1;
  974.             o[posp-1].f = StkSto;
  975.             o[posp-1].p = 5 - (paren + Equals)*15;
  976.             Store[StoPtr++] = Load[--LodPtr];
  977.             Equals++;
  978.             break;
  979.          default:
  980.             if(isalnum(Str[n]) || Str[n] == '.') {
  981.                while(isalnum(Str[n+1]) || Str[n+1] == '.')
  982.                   n++;
  983.                if(!ExpectingArg) {
  984.                   SyntaxErr = 1;
  985.                }
  986.                ExpectingArg = 0;
  987.                Len = (n+1)-InitN;
  988.                o[posp].f = isfunct(&Str[InitN], Len);
  989.                if(o[posp].f != NotAFnct) {
  990.                   if(o[posp].f == FnctNotFound) {
  991.                      e[ErrPtr].n = InitN;
  992.                      e[ErrPtr++].s = 5;
  993.                   }
  994.                   else
  995.                      o[posp++].p = 1 - (paren + Equals)*15;
  996.                   ExpectingArg = 1;
  997.                }
  998.                else {
  999.                   c = isconst(&Str[InitN], Len);
  1000.                   Load[LodPtr++] = &(c->a);
  1001.                   o[posp].f = StkLod;
  1002.                   o[posp++].p = 1 - (paren + Equals)*15;
  1003.                   n = InitN + c->len - 1;
  1004.                }
  1005.             }
  1006.             else {
  1007.                if(ExpectingArg)
  1008.                   SyntaxErr = 0;
  1009.                ExpectingArg = 1;
  1010.                e[ErrPtr].n = InitN;
  1011.                e[ErrPtr++].s = 4;
  1012.             }
  1013.             break;
  1014.       }
  1015.       if(SyntaxErr >= 0) {
  1016.          e[ErrPtr].n = InitN;
  1017.          e[ErrPtr++].s = SyntaxErr;
  1018.          SyntaxErr = -1;
  1019.       }
  1020.       if(posp>=100-1) { /* PB 901103 added safety test here */
  1021.          e[ErrPtr].n = InitN;
  1022.          e[ErrPtr++].s = 7;
  1023.          break;
  1024.       }
  1025.    }
  1026.  
  1027.    o[posp].f = (void(far*)(void))0;
  1028.    o[posp++].p = 16;
  1029.    if(paren > 0) {
  1030.       e[ErrPtr].n = n;
  1031.       e[ErrPtr++].s = 3;
  1032.    }
  1033.    if (ErrPtr) {
  1034.       int i, j, k, m;
  1035.       char msgbuf[700];  /* PB replaced printf loop by build msgbuf & stopmsg */
  1036.       /* stopmsg defined to have max 9 lines, show at most first 3 errors */
  1037.       msgbuf[0] = 0;
  1038.       for(n = 0; n < ErrPtr && n < 3; n++) {
  1039.          if (n)
  1040.             strcat(msgbuf,"\n");
  1041.          sprintf(&msgbuf[strlen(msgbuf)], "Error(%d):  %s\n  ", e[n].s,
  1042.                ErrStrings[e[n].s]);
  1043.          j = 24;
  1044.          if ((i = e[n].n - j) < 0) {
  1045.             j = e[n].n;
  1046.             i = 0;
  1047.          }
  1048.          else {
  1049.             strcat(msgbuf,"...");
  1050.             j += 3;
  1051.          }
  1052.          k = strlen(msgbuf);
  1053.          m = i + 66;
  1054.          while (i < m && Str[i]) {
  1055.             if ((msgbuf[k] = Str[i]) == '\n' || msgbuf[k] == '\t')
  1056.                msgbuf[k] = ' ';
  1057.             ++i;
  1058.             ++k;
  1059.          }
  1060.          if (Str[i]) {
  1061.             msgbuf[k++] = '.';
  1062.             msgbuf[k++] = '.';
  1063.             msgbuf[k++] = '.';
  1064.          }
  1065.          msgbuf[k++] = '\n';
  1066.          while (--j >= -2)
  1067.             msgbuf[k++] = ' ';
  1068.          msgbuf[k++] = '^';
  1069.          msgbuf[k] = 0;
  1070.       }
  1071.       stopmsg(8,msgbuf);
  1072.    }
  1073.    if(!ErrPtr) {
  1074.       NextOp = 0;
  1075.       LastOp = posp;
  1076.       NumVar = vsp;
  1077.       if(f)
  1078.          farmemfree(f);
  1079.       f = (void(far * far *)(void))farmemalloc(sizeof(void(far * far *)(void))
  1080.             * (long)posp);
  1081.       if(!f) {
  1082.          stopmsg(0,memstr); /* PB printf replaced by stopmsg */
  1083.          return(1);
  1084.       }
  1085.       while(NextOp < posp) {
  1086.          if(o[NextOp].f)
  1087.             RecSortPrec();
  1088.          else {
  1089.             NextOp++;
  1090.             LastOp--;
  1091.          }
  1092.       }
  1093.    }
  1094.    else
  1095.       posp = 0;
  1096.    farmemfree(e);
  1097. /*
  1098.    farmemfree(o);
  1099.    farmemfree(a);
  1100.    farmemfree(Store);
  1101.    farmemfree(Load);
  1102.    farmemfree(v);
  1103. */
  1104.    return(ErrPtr);
  1105. }
  1106.  
  1107. int Formula(void) {
  1108.    if(FormName[0] == 0 || overflow) return(1);
  1109.  
  1110.    LodPtr = InitLodPtr;
  1111.    StoPtr = InitStoPtr;
  1112.    OpPtr = InitOpPtr;
  1113.  
  1114.    Arg1 = &s[0];
  1115.    Arg2 = Arg1;
  1116.    Arg2--;
  1117.    while(OpPtr < LastOp)
  1118.       f[OpPtr++]();
  1119.  
  1120.    switch(MathType) {
  1121.       case D_MATH:
  1122.          old = new = v[3].a.d;
  1123.          return(Arg1->d.x == 0.0);
  1124.       case M_MATH:
  1125.          old = new = MPC2cmplx(v[3].a.m);
  1126.          return(Arg1->m.x.Exp == 0 && Arg1->m.x.Mant == 0);
  1127.       case L_MATH:
  1128.          lold = lnew = v[3].a.l;
  1129.          if(overflow)
  1130.             return(1);
  1131.          return(Arg1->l.x == 0L);
  1132.    }
  1133.    return(1);
  1134. }
  1135.  
  1136. int form_per_pixel(void) {
  1137.    double x, y;
  1138.  
  1139.    if (FormName[0] == 0) return(1);
  1140.    overflow = LodPtr = StoPtr = OpPtr = 0;
  1141.    Arg1 = &s[0];
  1142.    Arg2 = Arg1;
  1143.    Arg2--;
  1144.    switch(MathType) {
  1145.       case D_MATH:
  1146.          old.x = new.x = v[0].a.d.x = dx0[col]+dShiftx;
  1147.          old.y = new.y = v[0].a.d.y = dy0[row]+dShifty;
  1148.          break;
  1149.       case M_MATH:
  1150.          v[0].a.m.x = d2MP(old.x = new.x = dx0[col]+dShiftx);
  1151.          v[0].a.m.y = d2MP(old.y = new.y = dy0[row]+dShifty);
  1152.          break;
  1153.       case L_MATH:
  1154.          lold.x = lnew.x = v[0].a.l.x = lx0[col]+lShiftx;
  1155.          lold.y = lnew.y = v[0].a.l.y = ly0[row]+lShifty;
  1156.          break;
  1157.    }
  1158.  
  1159.    if(LastInitOp)
  1160.       LastInitOp = LastOp;
  1161.    while(OpPtr < LastInitOp)
  1162.       f[OpPtr++]();
  1163.  
  1164.    InitLodPtr = LodPtr;
  1165.    InitStoPtr = StoPtr;
  1166.    InitOpPtr = OpPtr;
  1167.  
  1168.    if(overflow)
  1169.       return(0);
  1170.    else
  1171.       return(1);
  1172. }
  1173.  
  1174. char *FormStr;
  1175.  
  1176. extern char FormFileName[];   /* BDT file to find the formulas in */
  1177. extern char FormName[];    /* BDT Name of the Formula (if not null) */
  1178.  
  1179. char *FindFormula(char *Str) {
  1180.    static char StrBuff[201];  /* PB, to match a safety fix in parser */
  1181.    char fullfilename[100]; /* BDT Full file name */
  1182.    int c, j, k, l;
  1183.    FILE *File;
  1184.  
  1185.    findpath(FormFileName, fullfilename);  /* BDT get full path name */
  1186.  
  1187.    symmetry = 0;
  1188.    if(File = fopen(fullfilename, "rt")) { /* BDT use variable files */
  1189.       while(fscanf(File, "%200[^ \n\t({]", StrBuff) != EOF) {
  1190.          if(!stricmp(StrBuff, Str) || !Str[0]) {
  1191.             while((c = getc(File)) != EOF) {
  1192.                if(c == '(') {
  1193.                   fscanf(File, "%200[^)]", StrBuff);
  1194.                   for(n = 0; SymStr[n].s[0]; n++) {
  1195.                      if(!stricmp(SymStr[n].s, StrBuff)) {
  1196.                         symmetry = SymStr[n].n;
  1197.                         break;
  1198.                      }
  1199.                   }
  1200.                   if(!SymStr[n].s[0]) {
  1201.                      sprintf(fullfilename,"Undefined symmetry:\n  %.76s",
  1202.                            StrBuff);
  1203.                      stopmsg(0,fullfilename); /* PB printf -> stopmsg */
  1204.                      fclose(File);
  1205.                      return((char*)0);
  1206.                   }
  1207.                }
  1208.                else if(c == '{')
  1209.                   break;
  1210.             }
  1211.             if(fscanf(File, "%200[^}]", StrBuff) != EOF) {
  1212.                Str = &StrBuff[strspn(StrBuff, " \n\t\r")];
  1213.                l = strlen(Str);
  1214.                for(j = 1; isspace(Str[l-j]); j++);
  1215.                Str[l-j+1] = 0;
  1216.                for(n = 0; n < l-j; n++)
  1217.                   if(isspace(Str[n]))
  1218.                      Str[n] = ' ';
  1219.                fclose(File);        /* BDT close the file */
  1220.                return(StrBuff);
  1221.             }
  1222.             else
  1223.                break;               /* PB moved close & msg to end of while */
  1224.          }
  1225.          fscanf(File, "%200[ \n\t({]", StrBuff);
  1226.          if(StrBuff[strcspn(StrBuff, "({")]) {
  1227. skipcomments:
  1228.             fscanf(File, "%200[^}]", StrBuff);
  1229.             if (getc(File)!= '}') goto skipcomments;
  1230.          }
  1231.       }
  1232.       fclose(File);                 /* BDT close the file */
  1233.       sprintf(fullfilename, "Formula \"%s\" not found", Str);
  1234.       stopmsg(0,fullfilename);      /* PB printf -> stopmsg */
  1235.    }
  1236.    else {
  1237.       sprintf(fullfilename, "Unable to open %s", FormFileName);
  1238.       stopmsg(0,fullfilename);      /* PB printf -> stopmsg */
  1239.    }
  1240.    return((char*)0);
  1241. }
  1242.  
  1243. int RunForm(char *Name) {
  1244.    if (FormName[0] == 0) return(1);
  1245.    parser_allocate();
  1246.    if(FormStr = FindFormula(Name))
  1247.       return(ParseStr(FormStr));
  1248.    else
  1249.       return(1);                    /* PB, msg moved to FindFormula */
  1250. }
  1251.  
  1252. int fpFormulaSetup(void) {
  1253.    if (fpu > 0) {
  1254.       MathType = D_MATH;
  1255.       return(!RunForm(FormName));
  1256.     }
  1257.     else {
  1258.        MathType = M_MATH;
  1259.        return(!RunForm(FormName));
  1260.     }
  1261.  }
  1262.  
  1263. int intFormulaSetup(void) {
  1264.    MathType = L_MATH;
  1265.    fg = (double)(1L << bitshift);
  1266.    fgLimit = (double)0x7fffffffL / fg;
  1267.    ShiftBack = 32 - bitshift;
  1268.    return(!RunForm(FormName));
  1269. }
  1270.  
  1271.  
  1272. /* TIW added 06-20-90 so functions can be called from fractals.c */
  1273. void init_misc()
  1274. {
  1275.    static struct ConstArg far vv[5];
  1276.    static union Arg argfirst,argsecond;
  1277.    if(!v) /* PB 901103 added this test to avoid clobbering the real thing */
  1278.       v = vv;  /* this is needed by lStkSqr and dStkSqr */
  1279.    Arg1 = &argfirst; Arg2 = &argsecond; /* needed by all the ?Stk* functions */
  1280.    fg = (double)(1L << bitshift);
  1281.    fgLimit = (double)0x7fffffffL / fg;
  1282.    ShiftBack = 32 - bitshift;
  1283.    Delta16 = bitshift - 16;
  1284.    bitshiftless1 = bitshift-1;
  1285. }
  1286.  
  1287. static int parser_allocated = 0;
  1288.  
  1289. parser_allocate()
  1290. {
  1291.    if (parser_allocated) return(0);
  1292.    parser_allocated = 1;
  1293.  
  1294.    o = (struct PEND_OP far *)farmemalloc(sizeof(struct PEND_OP) * 100L);
  1295.    a = (union Arg far *)farmemalloc(sizeof(union Arg) * 100L);
  1296.    Store = (union Arg far * far *)farmemalloc(sizeof(union Arg far *) * 100L);
  1297.    Load = (union Arg far * far *)farmemalloc(sizeof(union Arg far *) * 100L);
  1298.    v = (struct ConstArg far *)farmemalloc(sizeof(struct ConstArg) * 100L);
  1299.  
  1300. }
  1301.