home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / mac / developm / source / glview.sit / glview.src / parser.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-10-13  |  5.8 KB  |  334 lines
  1. /*
  2.  * parser.c - grasp language file parser.
  3.  *
  4.  * Copyright (c) 1991 by Patrick J. Naughton
  5.  */
  6.  
  7. #pragma segment Parser
  8.  
  9. #include "grasp.h"
  10.  
  11. char       *tokens[] = {
  12.     "notoken",
  13.     "box",
  14.     "break",
  15.     "call",
  16.     "cfade",
  17.     "cfree",
  18.     "cgetbuf",
  19.     "chgcolor",
  20.     "circle",
  21.     "clearscr",
  22.     "cload",
  23.     "closegl",
  24.     "color",
  25.     "cycle",
  26.     "data",
  27.     "databegin",
  28.     "dataend",
  29.     "dataskip",
  30.     "dfree",
  31.     "dload",
  32.     "edge",
  33.     "else",
  34.     "endlfloat",
  35.     "endif",
  36.     "exec",
  37.     "exit",
  38.     "ffree",
  39.     "fgaps",
  40.     "fload",
  41.     "float",
  42.     "fly",
  43.     "font",
  44.     "fstyle",
  45.     "getcolor",
  46.     "getkey",
  47.     "gosub",
  48.     "goto",
  49.     "if",
  50.     "ifkey",
  51.     "ifmem",
  52.     "ifmouse",
  53.     "ifvideo",
  54.     "int",
  55.     "line",
  56.     "link",
  57.     "local",
  58.     "loop",
  59.     "mark",
  60.     "merge",
  61.     "mode",
  62.     "mouse",
  63.     "move",
  64.     "noise",
  65.     "note",
  66.     "offset",
  67.     "opengl",
  68.     "out",
  69.     "palette",
  70.     "pan",
  71.     "pfade",
  72.     "pfree",
  73.     "pgetbuf",
  74.     "pload",
  75.     "pnewbuf",
  76.     "point",
  77.     "poke",
  78.     "pokel",
  79.     "pokew",
  80.     "pop",
  81.     "position",
  82.     "psave",
  83.     "psetbuf",
  84.     "putoff",
  85.     "putup",
  86.     "rect",
  87.     "resetgl",
  88.     "resetscr",
  89.     "return",
  90.     "revpage",
  91.     "send",
  92.     "set",
  93.     "setcolor",
  94.     "setpage",
  95.     "setrgb",
  96.     "setupscr",
  97.     "split",
  98.     "spread",
  99.     "text",
  100.     "tile",
  101.     "timer",
  102.     "tran",
  103.     "video",
  104.     "waitkey",
  105.     "when",
  106.     "window",
  107.     "fade",
  108.     "wait",
  109. };
  110.  
  111. static char *
  112. sows(ptr)
  113.     char       *ptr;
  114. {
  115.     int         incomment = 0;
  116.  
  117.     while (incomment || *ptr == ' ' || *ptr == '\t' || *ptr == '\r' ||
  118.         *ptr == ',' || *ptr == ';') {
  119.     if (*ptr == ';')
  120.         incomment = 1;
  121.     else if (*ptr == '\n')
  122.         break;
  123.     ptr++;
  124.     }
  125.     return ptr;
  126. }
  127.  
  128. static char *
  129. sowsanl(ptr)
  130.     char       *ptr;
  131. {
  132.     int         incomment = 0;
  133.  
  134.     while (incomment || *ptr == ' ' || *ptr == '\t' || *ptr == '\r' ||
  135.         *ptr == ',' || *ptr == ';' || *ptr == '\n') {
  136.     if (*ptr == ';')
  137.         incomment = 1;
  138.     else if (*ptr == '\n')
  139.         incomment = 0;
  140.     ptr++;
  141.     }
  142.     return ptr;
  143. }
  144.  
  145. static char *
  146. copytoken(src, dst)
  147.     char       *src;
  148.     char       *dst;
  149. {
  150.     src = sowsanl(src);
  151.     if (*src == '"') {
  152.     src++;
  153.     while (*src != '"' && *src != '\n' && *src != '\r')
  154.         *dst++ = *src++;
  155.     if (*src != '\n')
  156.         src++;
  157.     } else
  158.     while (*src != ' ' && *src != '\t' && *src != '\r' &&
  159.         *src != ',' && *src != '\n' && *src != 26) {
  160.         if (*src >= 'A' && *src <= 'Z')
  161.         *dst++ = *src++ + 'a' - 'A';    /* tolower */
  162.         else
  163.         *dst++ = *src++;
  164.     }
  165.     *dst = 0;
  166.     src = sows(src);
  167.     return src;
  168. }
  169.  
  170. static int
  171. lookuptoken(ptr)
  172.     char       *ptr;
  173. {
  174.     int         i;
  175.  
  176.     if (ptr[strlen(ptr) - 1] != ':')
  177.     for (i = 1; i < NTOKENS; i++)
  178.         if (!strcmp(ptr, tokens[i]))
  179.         return i;
  180.  
  181.     return NOTOKEN;
  182. }
  183.  
  184. static int
  185. tokentoint(s, ret)
  186.     char       *s;
  187.     int        *ret;
  188. {
  189.     int         i;
  190.     for (i = 0; i < strlen(s); i++)
  191.     if (!isdigit(s[i]) && s[i] != '-')
  192.         return 0;
  193.     sscanf(s, "%d", ret);
  194.     return 1;
  195. }
  196.  
  197. static void
  198. addlabel(ex, s)
  199.     ExecStruct *ex;
  200.     char       *s;
  201. {
  202.     ex->label[ex->numlabels].string = strdup(s);
  203.     ex->label[ex->numlabels].ipaddr = ex->numcodes;
  204.     if (++(ex->numlabels) >= MAXLABELS)
  205.     error("%s: too many labels!");
  206. }
  207.  
  208. static void
  209. addargcount(ex, tokenaddr)
  210.     ExecStruct *ex;
  211.     int         tokenaddr;
  212. {
  213.     ex->Code[tokenaddr].val.i = ex->numcodes - tokenaddr - 1;
  214. }
  215.  
  216. static void
  217. addtoken(ex, t)
  218.     ExecStruct *ex;
  219.     int         t;
  220. {
  221.     ex->Code[ex->numcodes].token = t;
  222.     if (++(ex->numcodes) >= MAXCODES)
  223.     error("%s: text file too large. can only have %d tokens\n", MAXCODES);
  224. }
  225.  
  226. static void
  227. addstring(ex, string)
  228.     ExecStruct *ex;
  229.     char       *string;
  230. {
  231.     ex->Code[ex->numcodes].val.s = strdup(string);
  232.     addtoken(ex, STRING);
  233. }
  234.  
  235. static void
  236. addint(token, arg, ex, string, integer)
  237.     int         token;
  238.     int         arg;
  239.     ExecStruct *ex;
  240.     char       *string;
  241.     int         integer;
  242. {
  243.     /*
  244.      * make sure we don't convert a string that happens to parse as a number
  245.      * such as a filename, or keyname, or video mode, into an integer
  246.      */
  247.     if (((token == CLOAD || token == PLOAD || token == FLOAD)
  248.      && (arg == 1))
  249.         || (token == TEXT && arg == 3)
  250.         || (token == VIDEO || token == IFKEY))
  251.     addstring(ex, string);
  252.     else {
  253.     ex->Code[ex->numcodes].val.i = integer;
  254.     addtoken(ex, INTEGER);
  255.     }
  256. }
  257.  
  258. void
  259. parsefile(ex, ptr)
  260.     ExecStruct *ex;
  261.     char       *ptr;
  262. {
  263.     char        buffer[100];
  264.     int         tokenaddr;
  265.  
  266.     ex->numcodes = 0;
  267.     ex->numlabels = 0;
  268.     do {
  269.     int         i;
  270.     int         token;
  271.  
  272.     ptr = copytoken(ptr, buffer);
  273.     if (buffer[0] == 0)
  274.         break;
  275.     if (buffer[strlen(buffer) - 1] == ':') {
  276.         buffer[strlen(buffer) - 1] = 0;
  277.         addlabel(ex, buffer);
  278.         while (*ptr != '\n' && *ptr != 26)
  279.         ptr++;
  280.     } else {
  281.         int         range;
  282.         int         start;
  283.  
  284.         token = lookuptoken(buffer);
  285.         if (token == NOTOKEN) {
  286.         if (tokentoint(buffer, &i))
  287.             addint(token, 0, ex, buffer, i);
  288.         else
  289.             addstring(ex, buffer);
  290.         tokenaddr = -1;
  291.         } else {
  292.         tokenaddr = ex->numcodes;
  293.         addtoken(ex, token);
  294.         }
  295.  
  296.         range = 0;
  297.         while (*ptr != '\n' && *ptr != 26) {
  298.         int         arg = ex->numcodes - tokenaddr;
  299.         ptr = copytoken(ptr, buffer);
  300.         if (range) {
  301.             if (tokentoint(buffer, &i)) {
  302.             int         val;
  303.             if (i >= start)
  304.                 for (val = start; val <= i; val++)
  305.                 addint(token, arg, ex, buffer, val);
  306.             else
  307.                 for (val = start; val >= i; val--)
  308.                 addint(token, arg, ex, buffer, val);
  309.             range = 0;
  310.             } else
  311.             error("%s: parse error on int range\n");
  312.  
  313.         } else {
  314.             if (buffer[0] == '-' && buffer[1] == 0) {
  315.             range = 1;
  316.             } else {
  317.             if (tokentoint(buffer, &i)) {
  318.                 addint(token, arg, ex, buffer, i);
  319.                 start = i;
  320.             } else
  321.                 addstring(ex, buffer);
  322.             }
  323.         }
  324.         }
  325.         if (tokenaddr != -1)
  326.         addargcount(ex, tokenaddr);
  327.     }
  328.  
  329.     if (*ptr == 26)
  330.         break;
  331.     ptr++;
  332.     } while (*ptr != 26);
  333. }
  334.