home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1995 November / PCWK1195.iso / inne / dos / fraktale / frasr192.exe / LSYSF.C < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-12  |  16.9 KB  |  688 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <math.h>
  5. #ifdef __TURBOC__
  6. #include <alloc.h>
  7. #else
  8. #include <malloc.h>
  9. #endif
  10. #include "fractint.h"
  11. #include "prototyp.h"
  12. #include "lsys.h"
  13.  
  14. #ifdef max
  15. #undef max
  16. #endif
  17.  
  18. struct lsys_cmd {
  19.     void (*f)(struct lsys_turtlestatef *);
  20.     int ptype;
  21.     union {
  22.     long n;
  23.     LDBL nf;
  24.     } parm;
  25.     char ch;
  26. };
  27.  
  28. #define sins_f ((LDBL *)(boxy))
  29. #define coss_f (((LDBL *)(boxy)+50))
  30.  
  31. static struct lsys_cmd far * _fastcall findsize(struct lsys_cmd far *,struct lsys_turtlestatef *, struct lsys_cmd far **,int);
  32.  
  33. /* Define blanks for portability */
  34. #ifdef XFRACT
  35. void lsysf_prepfpu(struct lsys_turtlestatef *x) { }
  36. void lsysf_donefpu(struct lsys_turtlestatef *x) { }
  37. #endif
  38.  
  39.  
  40. #ifdef XFRACT
  41. static void lsysf_doplus(struct lsys_turtlestatef *cmd)
  42. {
  43.     if (cmd->reverse) {
  44.     if (++cmd->angle == cmd->maxangle)
  45.         cmd->angle = 0;
  46.     }
  47.     else {
  48.     if (cmd->angle)
  49.         cmd->angle--;
  50.     else
  51.         cmd->angle = cmd->dmaxangle;
  52.     }
  53. }
  54. #else
  55. extern void lsysf_doplus(struct lsys_turtlestatef *cmd);
  56. #endif
  57.  
  58. #ifdef XFRACT
  59. /* This is the same as lsys_doplus, except maxangle is a power of 2. */
  60. static void lsysf_doplus_pow2(struct lsys_turtlestatef *cmd)
  61. {
  62.     if (cmd->reverse) {
  63.     cmd->angle++;
  64.     cmd->angle &= cmd->dmaxangle;
  65.     }
  66.     else {
  67.     cmd->angle--;
  68.     cmd->angle &= cmd->dmaxangle;
  69.     }
  70. }
  71. #else
  72. extern void lsysf_doplus_pow2(struct lsys_turtlestatef *cmd);
  73. #endif
  74.  
  75. #ifdef XFRACT
  76. static void lsysf_dominus(struct lsys_turtlestatef *cmd)
  77. {
  78.     if (cmd->reverse) {
  79.     if (cmd->angle)
  80.         cmd->angle--;
  81.     else
  82.         cmd->angle = cmd->dmaxangle;
  83.     }
  84.     else {
  85.     if (++cmd->angle == cmd->maxangle)
  86.         cmd->angle = 0;
  87.     }
  88. }
  89. #else
  90. extern void lsysf_dominus(struct lsys_turtlestatef *cmd);
  91. #endif
  92.  
  93. #ifdef XFRACT
  94. static void lsysf_dominus_pow2(struct lsys_turtlestatef *cmd)
  95. {
  96.     if (cmd->reverse) {
  97.     cmd->angle--;
  98.     cmd->angle &= cmd->dmaxangle;
  99.     }
  100.     else {
  101.     cmd->angle++;
  102.     cmd->angle &= cmd->dmaxangle;
  103.     }
  104. }
  105. #else
  106. extern void lsysf_dominus_pow2(struct lsys_turtlestatef *cmd);
  107. #endif
  108.  
  109. #ifdef XFRACT
  110. static void lsysf_doslash(struct lsys_turtlestatef *cmd)
  111. {
  112.     if (cmd->reverse)
  113.     cmd->realangle -= cmd->parm.nf;
  114.     else
  115.     cmd->realangle += cmd->parm.nf;
  116. }
  117. #else
  118. extern void lsysf_doslash(struct lsys_turtlestatef *cmd);
  119. #endif
  120.  
  121. #ifdef XFRACT
  122. static void lsysf_dobslash(struct lsys_turtlestatef *cmd)
  123. {
  124.     if (cmd->reverse)
  125.     cmd->realangle += cmd->parm.nf;
  126.     else
  127.     cmd->realangle -= cmd->parm.nf;
  128. }
  129. #else
  130. extern void lsysf_dobslash(struct lsys_turtlestatef *cmd);
  131. #endif
  132.  
  133. #ifdef XFRACT
  134. static void lsysf_doat(struct lsys_turtlestatef *cmd)
  135. {
  136.     cmd->size *= cmd->parm.nf;
  137. }
  138. #else
  139. extern void lsysf_doat(struct lsys_turtlestatef *cmd, long n);
  140. #endif
  141.  
  142. static void 
  143. lsysf_dopipe(struct lsys_turtlestatef *cmd)
  144. {
  145.     cmd->angle = (char)(cmd->angle + cmd->maxangle / 2);
  146.     cmd->angle %= cmd->maxangle;
  147. }
  148.  
  149. #ifdef XFRACT
  150. static void lsysf_dopipe_pow2(struct lsys_turtlestatef *cmd)
  151. {
  152.     cmd->angle += cmd->maxangle >> 1;
  153.     cmd->angle &= cmd->dmaxangle;
  154. }
  155. #else
  156. extern void lsysf_dopipe_pow2(struct lsys_turtlestatef *cmd);
  157. #endif
  158.  
  159. #ifdef XFRACT
  160. static void lsysf_dobang(struct lsys_turtlestatef *cmd)
  161. {
  162.     cmd->reverse = ! cmd->reverse;
  163. }
  164. #else
  165. extern void lsysf_dobang(struct lsys_turtlestatef *cmd);
  166. #endif
  167.  
  168. #ifdef XFRACT
  169. static void lsysf_dosizedm(struct lsys_turtlestatef *cmd)
  170. {
  171.     double angle = (double) cmd->realangle;
  172.     double s, c;
  173.  
  174.     s = sin(angle);
  175.     c = cos(angle);
  176.  
  177.     cmd->xpos += cmd->size * cmd->aspect * c;
  178.     cmd->ypos += cmd->size * s;
  179.  
  180.     if (cmd->xpos>cmd->xmax) cmd->xmax=cmd->xpos;
  181.     if (cmd->ypos>cmd->ymax) cmd->ymax=cmd->ypos;
  182.     if (cmd->xpos<cmd->xmin) cmd->xmin=cmd->xpos;
  183.     if (cmd->ypos<cmd->ymin) cmd->ymin=cmd->ypos;
  184. }
  185. #else
  186. extern void lsysf_dosizedm(struct lsys_turtlestatef *cmd, long n);
  187. #endif
  188.  
  189. #ifdef XFRACT
  190. static void lsysf_dosizegf(struct lsys_turtlestatef *cmd)
  191. {
  192.     cmd->xpos += cmd->size * coss_f[cmd->angle];
  193.     cmd->ypos += cmd->size * sins_f[cmd->angle];
  194.  
  195.     if (cmd->xpos>cmd->xmax) cmd->xmax=cmd->xpos;
  196.     if (cmd->ypos>cmd->ymax) cmd->ymax=cmd->ypos;
  197.     if (cmd->xpos<cmd->xmin) cmd->xmin=cmd->xpos;
  198.     if (cmd->ypos<cmd->ymin) cmd->ymin=cmd->ypos;
  199. }
  200. #else
  201. extern void lsysf_dosizegf(struct lsys_turtlestatef *cmd);
  202. #endif
  203.  
  204. #ifdef XFRACT
  205. static void lsysf_dodrawd(struct lsys_turtlestatef *cmd)
  206. {
  207.     double angle = (double) cmd->realangle;
  208.     double s, c;
  209.     int lastx, lasty;
  210.     s = sin(angle);
  211.     c = cos(angle);
  212.  
  213.     lastx=(int) cmd->xpos;
  214.     lasty=(int) cmd->ypos;
  215.  
  216.     cmd->xpos += cmd->size * cmd->aspect * c;
  217.     cmd->ypos += cmd->size * s;
  218.  
  219.     draw_line(lastx, lasty, (int) cmd->xpos, (int) cmd->ypos, cmd->curcolor);
  220. }
  221. #else
  222. extern void lsysf_dodrawd(struct lsys_turtlestatef *cmd);
  223. #endif
  224.  
  225. #ifdef XFRACT
  226. static void lsysf_dodrawm(struct lsys_turtlestatef *cmd)
  227. {
  228.     double angle = (double) cmd->realangle;
  229.     double s, c;
  230.  
  231.     s = sin(angle);
  232.     c = cos(angle);
  233.  
  234.     cmd->xpos += cmd->size * cmd->aspect * c;
  235.     cmd->ypos += cmd->size * s;
  236. }
  237. #else
  238. extern void lsysf_dodrawm(struct lsys_turtlestatef *cmd);
  239. #endif
  240.  
  241. #ifdef XFRACT
  242. static void lsysf_dodrawg(struct lsys_turtlestatef *cmd)
  243. {
  244.     cmd->xpos += cmd->size * coss_f[cmd->angle];
  245.     cmd->ypos += cmd->size * sins_f[cmd->angle];
  246. }
  247. #else
  248. extern void lsysf_dodrawg(struct lsys_turtlestatef *cmd);
  249. #endif
  250.  
  251. #ifdef XFRACT
  252. static void lsysf_dodrawf(struct lsys_turtlestatef *cmd)
  253. {
  254.     int lastx = (int) cmd->xpos;
  255.     int lasty = (int) cmd->ypos;
  256.     cmd->xpos += cmd->size * coss_f[cmd->angle];
  257.     cmd->ypos += cmd->size * sins_f[cmd->angle];
  258.     draw_line(lastx,lasty,(int) cmd->xpos, (int) cmd->ypos, cmd->curcolor);
  259. }
  260. #else
  261. extern void lsysf_dodrawf(struct lsys_turtlestatef *cmd);
  262. #endif
  263.  
  264. static void lsysf_dodrawc(struct lsys_turtlestatef *cmd)
  265. {
  266.     cmd->curcolor = (char)(((int) cmd->parm.n) % colors);
  267. }
  268.  
  269. static void lsysf_dodrawgt(struct lsys_turtlestatef *cmd)
  270. {
  271.     cmd->curcolor = (char)(cmd->curcolor - cmd->parm.n);
  272.     if ((cmd->curcolor %= colors) == 0)
  273.     cmd->curcolor = (char)(colors-1);
  274. }
  275.  
  276. static void lsysf_dodrawlt(struct lsys_turtlestatef *cmd)
  277. {
  278.     cmd->curcolor = (char)(cmd->curcolor + cmd->parm.n);
  279.     if ((cmd->curcolor %= colors) == 0)
  280.     cmd->curcolor = 1;
  281. }
  282.  
  283. static struct lsys_cmd far * _fastcall
  284. findsize(struct lsys_cmd far *command, struct lsys_turtlestatef *ts, struct lsys_cmd far **rules, int depth)
  285. {
  286.    struct lsys_cmd far **rulind;
  287.    int tran;
  288.  
  289. if (overflow)     /* integer math routines overflowed */
  290.     return NULL;
  291.  
  292. #ifndef __TURBOC__
  293.    if (stackavail() < 400) { /* leave some margin for calling subrtns */
  294.       ts->stackoflow = 1;
  295.       return NULL;
  296.       }
  297. #endif
  298.  
  299.    while (command->ch && command->ch !=']') {
  300.       if (! (ts->counter++)) {
  301.      /* let user know we're not dead */
  302.      if (thinking(1,"L-System thinking (higher orders take longer)")) {
  303.         ts->counter--;
  304.         return NULL;
  305.      }
  306.       }
  307.       tran=0;
  308.       if (depth) {
  309.      for(rulind=rules;*rulind;rulind++)
  310.         if ((*rulind)->ch==command->ch) {
  311.            tran=1;
  312.            if (findsize((*rulind)+1,ts,rules,depth-1) == NULL)
  313.           return(NULL);
  314.         }
  315.       }
  316.       if (!depth || !tran) {
  317.     if (command->f) {
  318.         switch (command->ptype) {
  319.         case 4:
  320.             ts->parm.n = command->parm.n;
  321.             break;
  322.         case 10:
  323.             ts->parm.nf = command->parm.nf;
  324.             break;
  325.         default:
  326.             break;
  327.         }
  328.         (*command->f)(ts);
  329.     }
  330.     else if (command->ch == '[') {
  331.       char saveang,saverev;
  332.       LDBL savesize,savex,savey,saverang;
  333.  
  334.       lsys_donefpu(ts);
  335.       saveang=ts->angle;
  336.       saverev=ts->reverse;
  337.       savesize=ts->size;
  338.       saverang=ts->realangle;
  339.       savex=ts->xpos;
  340.       savey=ts->ypos;
  341.       lsys_prepfpu(ts);
  342.       if ((command=findsize(command+1,ts,rules,depth)) == NULL)
  343.          return(NULL);
  344.       lsys_donefpu(ts);
  345.       ts->angle=saveang;
  346.       ts->reverse=saverev;
  347.       ts->size=savesize;
  348.       ts->realangle=saverang;
  349.       ts->xpos=savex;
  350.       ts->ypos=savey;
  351.       lsys_prepfpu(ts);
  352.     }
  353.       }
  354.       command++;
  355.    }
  356.    return command;
  357. }
  358.  
  359. int _fastcall
  360. lsysf_findscale(struct lsys_cmd far *command, struct lsys_turtlestatef *ts, struct lsys_cmd far **rules, int depth)
  361. {
  362.    float horiz,vert;
  363.    LDBL xmin, xmax, ymin, ymax;
  364.    LDBL locsize;
  365.    LDBL locaspect;
  366.    struct lsys_cmd far *fsret;
  367.  
  368.    locaspect=screenaspect*xdots/ydots;
  369.    ts->aspect = locaspect;
  370.    ts->xpos =
  371.    ts->ypos =
  372.    ts->xmin =
  373.    ts->xmax =
  374.    ts->ymax =
  375.    ts->ymin = 0;
  376.    ts->angle =
  377.    ts->reverse =
  378.    ts->counter = 0;
  379.    ts->realangle = 0;
  380.    ts->size = 1;
  381.    lsys_prepfpu(ts);
  382.    fsret = findsize(command,ts,rules,depth);
  383.    lsys_donefpu(ts);
  384.    thinking(0, NULL); /* erase thinking message if any */
  385.    xmin = ts->xmin;
  386.    xmax = ts->xmax;
  387.    ymin = ts->ymin;
  388.    ymax = ts->ymax;
  389. /*   locsize = ts->size; */
  390.    if (fsret == NULL)
  391.       return 0;
  392.    if (xmax == xmin)
  393.       horiz = (float)1E37;
  394.    else
  395.       horiz = (float)((xdots-10)/(xmax-xmin));
  396.    if (ymax == ymin)
  397.       vert = (float)1E37;
  398.    else
  399.       vert = (float)((ydots-6) /(ymax-ymin));
  400.    locsize = (vert<horiz) ? vert : horiz;
  401.  
  402.    if (horiz == 1E37)
  403.       ts->xpos = xdots/2;
  404.    else
  405. /*    ts->xpos = -xmin*(locsize)+5+((xdots-10)-(locsize)*(xmax-xmin))/2; */
  406.       ts->xpos = (xdots-locsize*(xmax+xmin))/2;
  407.    if (vert == 1E37)
  408.       ts->ypos = ydots/2;
  409.    else
  410. /*    ts->ypos = -ymin*(locsize)+3+((ydots-6)-(locsize)*(ymax-ymin))/2; */
  411.       ts->ypos = (ydots-locsize*(ymax+ymin))/2;
  412.    ts->size = locsize;
  413.  
  414.    return 1;
  415. }
  416.  
  417. struct lsys_cmd far * _fastcall 
  418. drawLSysF(struct lsys_cmd far *command,struct lsys_turtlestatef *ts, struct lsys_cmd far **rules,int depth)
  419. {
  420.    struct lsys_cmd far **rulind;
  421.    int tran;
  422.  
  423. if (overflow)     /* integer math routines overflowed */
  424.     return NULL;
  425.  
  426. #ifndef __TURBOC__
  427.    if (stackavail() < 400) { /* leave some margin for calling subrtns */
  428.       ts->stackoflow = 1;
  429.       return NULL;
  430.       }
  431. #endif
  432.  
  433.    while (command->ch && command->ch !=']') {
  434.       if (!(ts->counter++)) {
  435.      if (keypressed()) {
  436.         ts->counter--;
  437.         return NULL;
  438.      }
  439.       }
  440.       tran=0;
  441.       if (depth) {
  442.      for(rulind=rules;*rulind;rulind++)
  443.         if ((*rulind)->ch == command->ch) {
  444.            tran=1;
  445.            if (drawLSysF((*rulind)+1,ts,rules,depth-1) == NULL)
  446.           return NULL;
  447.         }
  448.       }
  449.       if (!depth||!tran) {
  450.     if (command->f) {
  451.         switch (command->ptype) {
  452.         case 4:
  453.             ts->parm.n = command->parm.n;
  454.             break;
  455.         case 10:
  456.             ts->parm.nf = command->parm.nf;
  457.             break;
  458.         default:
  459.             break;
  460.         }
  461.         (*command->f)(ts);
  462.     }
  463.     else if (command->ch == '[') {
  464.       char saveang,saverev,savecolor;
  465.       LDBL savesize,savex,savey,saverang;
  466.  
  467.       lsys_donefpu(ts);
  468.       saveang=ts->angle;
  469.       saverev=ts->reverse;
  470.       savesize=ts->size;
  471.       saverang=ts->realangle;
  472.       savex=ts->xpos;
  473.       savey=ts->ypos;
  474.       savecolor=ts->curcolor;
  475.       lsys_prepfpu(ts);
  476.       if ((command=drawLSysF(command+1,ts,rules,depth)) == NULL)
  477.          return(NULL);
  478.       lsys_donefpu(ts);
  479.       ts->angle=saveang;
  480.       ts->reverse=saverev;
  481.       ts->size=savesize;
  482.       ts->realangle=saverang;
  483.       ts->xpos=savex;
  484.       ts->ypos=savey;
  485.       ts->curcolor=savecolor;
  486.       lsys_prepfpu(ts);
  487.     }
  488.       }
  489.       command++;
  490.    }
  491.    return command;
  492. }
  493.  
  494. struct lsys_cmd far *
  495. LSysFSizeTransform(char far *s, struct lsys_turtlestatef *ts)
  496. {
  497.   struct lsys_cmd far *ret;
  498.   struct lsys_cmd far *doub;
  499.   int max = 10;
  500.   int n = 0;
  501.   void (*f)();
  502.   long num;
  503.   int ptype;
  504.   double PI180 = PI / 180.0;
  505.  
  506.   void (*plus)() = (ispow2(ts->maxangle)) ? lsysf_doplus_pow2 : lsysf_doplus;
  507.   void (*minus)() = (ispow2(ts->maxangle)) ? lsysf_dominus_pow2 : lsysf_dominus;
  508.   void (*pipe)() = (ispow2(ts->maxangle)) ? lsysf_dopipe_pow2 : lsysf_dopipe;
  509.  
  510.   void (*slash)() =  lsysf_doslash;
  511.   void (*bslash)() = lsysf_dobslash;
  512.   void (*at)() =     lsysf_doat;
  513.   void (*dogf)() =   lsysf_dosizegf;
  514.  
  515.   ret = (struct lsys_cmd far *) farmemalloc((long) max * sizeof(struct lsys_cmd));
  516.   if (ret == NULL) {
  517.        ts->stackoflow = 1;
  518.        return NULL;
  519.        }
  520.   while (*s) {
  521.     f = NULL;
  522.     num = 0;
  523.     ptype = 4;
  524.     ret[n].ch = *s;
  525.     switch (*s) {
  526.       case '+': f = plus;            break;
  527.       case '-': f = minus;           break;
  528.       case '/': f = slash;           ptype = 10;  ret[n].parm.nf = getnumber(&s) * PI180;  break;
  529.       case '\\': f = bslash;         ptype = 10;  ret[n].parm.nf = getnumber(&s) * PI180;  break;
  530.       case '@': f = at;              ptype = 10;  ret[n].parm.nf = getnumber(&s);  break;
  531.       case '|': f = pipe;            break;
  532.       case '!': f = lsysf_dobang;     break;
  533.       case 'd':
  534.       case 'm': f = lsysf_dosizedm;   break;
  535.       case 'g':
  536.       case 'f': f = dogf;       break;
  537.       case '[': num = 1;        break;
  538.       case ']': num = 2;        break;
  539.       default:
  540.     num = 3;
  541.     break;
  542.     }
  543. #ifdef XFRACT
  544.     ret[n].f = (void (*)())f;
  545. #else
  546.     ret[n].f = (void (*)(struct lsys_turtlestatef *))f;
  547. #endif
  548.     if (ptype == 4)
  549.     ret[n].parm.n = num;
  550.     ret[n].ptype = ptype;
  551.     if (++n == max) {
  552.       doub = (struct lsys_cmd far *) farmemalloc((long) max*2*sizeof(struct lsys_cmd));
  553.       if (doub == NULL) {
  554.          farmemfree(ret);
  555.          ts->stackoflow = 1;
  556.          return NULL;
  557.          }
  558.       far_memcpy(doub, ret, max*sizeof(struct lsys_cmd));
  559.       farmemfree(ret);
  560.       ret = doub;
  561.       max <<= 1;
  562.     }
  563.     s++;
  564.   }
  565.   ret[n].ch = 0;
  566.   ret[n].f = NULL;
  567.   ret[n].parm.n = 0;
  568.   n++;
  569.  
  570.   doub = (struct lsys_cmd far *) farmemalloc((long) n*sizeof(struct lsys_cmd));
  571.   if (doub == NULL) {
  572.        farmemfree(ret);
  573.        ts->stackoflow = 1;
  574.        return NULL;
  575.        }
  576.   far_memcpy(doub, ret, n*sizeof(struct lsys_cmd));
  577.   farmemfree(ret);
  578.   return doub;
  579. }
  580.  
  581. struct lsys_cmd far *
  582. LSysFDrawTransform(char far *s, struct lsys_turtlestatef *ts)
  583. {
  584.   struct lsys_cmd far *ret;
  585.   struct lsys_cmd far *doub;
  586.   int max = 10;
  587.   int n = 0;
  588.   void (*f)();
  589.   LDBL num;
  590.   int ptype;
  591.   LDBL PI180 = PI / 180.0;
  592.  
  593.   void (*plus)() = (ispow2(ts->maxangle)) ? lsysf_doplus_pow2 : lsysf_doplus;
  594.   void (*minus)() = (ispow2(ts->maxangle)) ? lsysf_dominus_pow2 : lsysf_dominus;
  595.   void (*pipe)() = (ispow2(ts->maxangle)) ? lsysf_dopipe_pow2 : lsysf_dopipe;
  596.  
  597.   void (*slash)() =  lsysf_doslash;
  598.   void (*bslash)() = lsysf_dobslash;
  599.   void (*at)() =     lsysf_doat;
  600.   void (*drawg)() =  lsysf_dodrawg;
  601.  
  602.   ret = (struct lsys_cmd far *) farmemalloc((long) max * sizeof(struct lsys_cmd));
  603.   if (ret == NULL) {
  604.        ts->stackoflow = 1;
  605.        return NULL;
  606.        }
  607.   while (*s) {
  608.     f = NULL;
  609.     num = 0;
  610.     ptype = 4;
  611.     ret[n].ch = *s;
  612.     switch (*s) {
  613.       case '+': f = plus;            break;
  614.       case '-': f = minus;           break;
  615.       case '/': f = slash;           ptype = 10;  ret[n].parm.nf = getnumber(&s) * PI180;  break;
  616.       case '\\': f = bslash;         ptype = 10;  ret[n].parm.nf = getnumber(&s) * PI180;  break;
  617.       case '@': f = at;              ptype = 10;  ret[n].parm.nf = getnumber(&s);  break;
  618.       case '|': f = pipe;            break;
  619.       case '!': f = lsysf_dobang;    break;
  620.       case 'd': f = lsysf_dodrawd;   break;
  621.       case 'm': f = lsysf_dodrawm;   break;
  622.       case 'g': f = drawg;           break;
  623.       case 'f': f = lsysf_dodrawf;   break;
  624.       case 'c': f = lsysf_dodrawc;   num = getnumber(&s);    break;
  625.       case '<': f = lsysf_dodrawlt;  num = getnumber(&s);    break;
  626.       case '>': f = lsysf_dodrawgt;  num = getnumber(&s);    break;
  627.       case '[': num = 1;        break;
  628.       case ']': num = 2;        break;
  629.       default:
  630.     num = 3;
  631.     break;
  632.     }
  633. #ifdef XFRACT
  634.     ret[n].f = (void (*)())f;
  635. #else
  636.     ret[n].f = (void (*)(struct lsys_turtlestatef *))f;
  637. #endif
  638.     if (ptype == 4)
  639.     ret[n].parm.n = (long)num;
  640.     ret[n].ptype = ptype;
  641.     if (++n == max) {
  642.       doub = (struct lsys_cmd far *) farmemalloc((long) max*2*sizeof(struct lsys_cmd));
  643.       if (doub == NULL) {
  644.            farmemfree(ret);
  645.            ts->stackoflow = 1;
  646.            return NULL;
  647.            }
  648.       far_memcpy(doub, ret, max*sizeof(struct lsys_cmd));
  649.       farmemfree(ret);
  650.       ret = doub;
  651.       max <<= 1;
  652.     }
  653.     s++;
  654.   }
  655.   ret[n].ch = 0;
  656.   ret[n].f = NULL;
  657.   ret[n].parm.n = 0;
  658.   n++;
  659.  
  660.   doub = (struct lsys_cmd far *) farmemalloc((long) n*sizeof(struct lsys_cmd));
  661.   if (doub == NULL) {
  662.        farmemfree(ret);
  663.        ts->stackoflow = 1;
  664.        return NULL;
  665.        }
  666.   far_memcpy(doub, ret, n*sizeof(struct lsys_cmd));
  667.   farmemfree(ret);
  668.   return doub;
  669. }
  670.  
  671. void _fastcall lsysf_dosincos(void)
  672. {
  673.    LDBL locaspect;
  674.    LDBL TWOPI = 2.0 * PI;
  675.    LDBL twopimax;
  676.    LDBL twopimaxi;
  677.    int i;
  678.  
  679.    locaspect=screenaspect*xdots/ydots;
  680.    twopimax = TWOPI / maxangle;
  681.    for(i=0;i<maxangle;i++) {
  682.       twopimaxi = i * twopimax;
  683.       sins_f[i]= sinl(twopimaxi);
  684.       coss_f[i]= locaspect * cosl(twopimaxi);
  685.    }
  686.  
  687. }
  688.