/* fdevelop: convert script to intermediate language in two passes
       Input defined in script.def, output in int.def
       Pass 1 reads named file or stdin, writes intermediate file
       Pass 2 reads intermediate, writes output
       Intermediate file is like output, with these differences:
               Header lines (d v, d c, etc.) absent
               Erase commands: refer to line numbers in int file and
                       do not have geometric command following
               Geometry commands: numbers not yet scaled, slots not
                       assigned
  fdevelop is a filter, transforming stdin or one named file to stdout
       the shell script develop uses this program to develop foo.s
         into foo.i, if needed
*/

/* fdevelop.h: header file for fdevelop */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>

typedef struct Symbol { /* symbol table entry */
       struct Symbol   *next;
       char    *instr;
       int     innum;
       int     outnum;
} Symbol;

#define eq(s, t)        (strcmp(s,t) == 0)

extern char     *cmdname;
extern int      lineno;

extern char     *NULLSTR;
extern Symbol   *lookup(char*, int);
extern void     insert(char *, int, int);
extern void     delete(char *, int);
extern void     opensymtab(void);
extern void     closesymtab(void);
extern int      hash(char*, int);

#define FATAL   1
#define WARN    0
extern void     error(int, char*);
extern char     *emalloc(int);
extern void     efree(char *);

#define MAXSTR  40      /* view names, click names, etc. */
#define MAXBUF  500     /* text strings */
#define LINEMAX 50000   /* input lines */
#define SLOTMAX 10000   /* for erasures */

extern int      moreinput(FILE *);
extern void     lex(FILE*);
extern void     lexstr(FILE*);
extern void     lexrest(FILE*);
extern void     gobble(FILE*);
extern void     gobble2(FILE*);
extern          char buf[];
extern          lexsaweof;

/* end of header */




#define SCALE   9999

extern void     dox(int);
extern void     doy(int);

/* SLOTS */
int     slotmax = SLOTMAX;

/* STATUS OF EACH LINE IN INTERMEDIATE FILE*/
int     linemax = LINEMAX;
char    *linevec;       /* malloc'ed to [linemax] before pass 1 */

#define MAXVIEWS        10
                         /* if >10 views, change one-byte getc in pass2 */
#define ERASED          11
#define NOTGEOM         12

/* VIEWS */
extern void     recordx(int, float);
extern void     recordy(int, float);
extern int      scalex(int, float);
extern int      scaley(int, float);
int     viewcnt = 0;
struct  Viewelmt {
       char    name[MAXSTR];   /* character string name */
       float   maxx;           /* range of values, both coords */
       float   minx;
       float   maxy;
       float   miny;
       float   factorx;        /* factors used by scalex and scaley */
       float   factory;
       int     initx;          /* max and min set yet? */
       int     inity;
}       viewarr[MAXVIEWS];

/* CLICKS */
#define MAXCLICKS       30
int     clickcnt = 0;
char    clickname [MAXCLICKS] [MAXSTR];

/* OPTIONS FOR GEOMETRIC OBJECTS */
extern void     getoptions(int);
#define OPTMAX 10
char    optstring[OPTMAX];
#define TEXT    0
#define LINE    1
#define BOX     2
#define CIRCLE  3
char    *defaulttab[] = { /* match with above defines */
       "cm7",  /* TEXT:   center, medium, white        */
       "s-7",  /* LINE:   solid, -, white              */
       "n7",   /* BOX:    nofill, white                */
       "n7"    /* CIRCLE: nofill, white                */
};
struct  Geoelmt {
       int     cmd;
       int     pos;
       char    *name;
       char    val;
} geooptarr[] = {
       TEXT,   0,      "center",       'c',
       TEXT,   0,      "ljust",        'l',
       TEXT,   0,      "rjust",        'r',
       TEXT,   0,      "above",        'a',
       TEXT,   0,      "below",        'b',
       TEXT,   1,      "medium",       'm',
       TEXT,   1,      "small",        's',
       TEXT,   1,      "big",          'b',
       TEXT,   1,      "bigbig",       'B',
       TEXT,   2,      "c0",           '0',
       TEXT,   2,      "c1",           '1',
       TEXT,   2,      "c2",           '2',
       TEXT,   2,      "c3",           '3',
       TEXT,   2,      "c4",           '4',
       TEXT,   2,      "c5",           '5',
       TEXT,   2,      "c6",           '6',
       TEXT,   2,      "c7",           '7',
       TEXT,   2,      "black",        '0',
       TEXT,   2,      "red",          '1',
       TEXT,   2,      "green",        '2',
       TEXT,   2,      "yellow",       '3',
       TEXT,   2,      "blue",         '4',
       TEXT,   2,      "magenta",      '5',
       TEXT,   2,      "cyan",         '6',
       TEXT,   2,      "white",        '7',
       LINE,   0,      "solid",        's',
       LINE,   0,      "fat",          'f',
       LINE,   0,      "fatfat",       'F',
       LINE,   0,      "dotted",       'o',
       LINE,   0,      "dashed",       'a',
       LINE,   1,      "-",            '-',
       LINE,   1,      "->",           '>',
       LINE,   1,      "<-",           '<',
       LINE,   1,      "<->",          'x',
       LINE,   2,      "c0",           '0',
       LINE,   2,      "c1",           '1',
       LINE,   2,      "c2",           '2',
       LINE,   2,      "c3",           '3',
       LINE,   2,      "c4",           '4',
       LINE,   2,      "c5",           '5',
       LINE,   2,      "c6",           '6',
       LINE,   2,      "c7",           '7',
       LINE,   2,      "black",        '0',
       LINE,   2,      "red",          '1',
       LINE,   2,      "green",        '2',
       LINE,   2,      "yellow",       '3',
       LINE,   2,      "blue",         '4',
       LINE,   2,      "magenta",      '5',
       LINE,   2,      "cyan",         '6',
       LINE,   2,      "white",        '7',
       BOX,    0,      "nofill",       'n',
       BOX,    0,      "fill",         'f',
       BOX,    1,      "c0",           '0',
       BOX,    1,      "c1",           '1',
       BOX,    1,      "c2",           '2',
       BOX,    1,      "c3",           '3',
       BOX,    1,      "c4",           '4',
       BOX,    1,      "c5",           '5',
       BOX,    1,      "c6",           '6',
       BOX,    1,      "c7",           '7',
       BOX,    1,      "black",        '0',
       BOX,    1,      "red",          '1',
       BOX,    1,      "green",        '2',
       BOX,    1,      "yellow",       '3',
       BOX,    1,      "blue",         '4',
       BOX,    1,      "magenta",      '5',
       BOX,    1,      "cyan",         '6',
       BOX,    1,      "white",        '7',
       CIRCLE, 0,      "nofill",       'n',
       CIRCLE, 0,      "fill",         'f',
       CIRCLE, 1,      "c0",           '0',
       CIRCLE, 1,      "c1",           '1',
       CIRCLE, 1,      "c2",           '2',
       CIRCLE, 1,      "c3",           '3',
       CIRCLE, 1,      "c4",           '4',
       CIRCLE, 1,      "c5",           '5',
       CIRCLE, 1,      "c6",           '6',
       CIRCLE, 1,      "c7",           '7',
       CIRCLE, 1,      "black",        '0',
       CIRCLE, 1,      "red",          '1',
       CIRCLE, 1,      "green",        '2',
       CIRCLE, 1,      "yellow",       '3',
       CIRCLE, 1,      "blue",         '4',
       CIRCLE, 1,      "magenta",      '5',
       CIRCLE, 1,      "cyan",         '6',
       CIRCLE, 1,      "white",        '7'
};
int     geooptcnt = (sizeof(geooptarr) / sizeof(struct Geoelmt));

/* VARIABLES FOR LEXICAL ANALYSIS */
char    buf[MAXBUF];
int     lexsaweof = 0;

/* UTILITY VARIABLES */
char    *NULLSTR = "";
char    *cmdname;
int     lineno, outlineno;
char    *tempfname;
FILE    *infp, *tempfp;

extern void     pass1(void);
extern void     pass2(void);
extern int      strisnum(char*);

#define STOF(s) ((float) atof(s))

main(int argc, char *argv[])
{
       int     i;

       cmdname = argv[0];
       while (argc > 1 && argv[1][0] == '-') {
               switch (argv[1][1]) {
               case 'l':
                       linemax = atoi(&argv[1][2]);
                       break;
               case 's':
                       slotmax = atoi(&argv[1][2]);
                       break;
               }
               argc--;
               argv++;
       }
       if (argc == 1)
               infp = stdin;
       else {
               if ((infp = fopen(argv[1], "r")) == NULL)
                       error(FATAL, "can't open input file");
       }
       linevec = emalloc(linemax);
       for (i = 0; i < linemax; i++)
               linevec[i] = 0;

       tempfname = tmpnam(NULL);
       if ((tempfp = fopen(tempfname, "w")) == NULL)
               error(FATAL, "can't open temp file");
       pass1();
       fclose(tempfp);
       if ((tempfp = fopen(tempfname, "r")) == NULL)
               error(FATAL, "can't open temp file");
       pass2();
       remove(tempfname); /* DEBUG */
       exit(0);
}

void pass1(void)
{
       int     currentview;            /* view number */
       int     erased[MAXVIEWS];       /* last line erased */
       int     badlabel;               /* 1 if label, 0 if geom */
       char    savelabel[MAXSTR];      /* label */
       int     geomalready = 0;        /* seen any geometry yet? */
       struct Symbol   *sp;
       int     i;

#define DOGEOM          badlabel = 0;\
                       geomalready = 1;\
                       linevec[outlineno] = currentview;

#define DOERASE(L)      linevec[(L)] = ERASED;\
                       linevec[outlineno] = NOTGEOM;\
                       fprintf(tempfp, "e\t%d\n", (L));\
                       outlineno++;

       /* init */
       currentview = 0;
       for (i = 0; i < MAXVIEWS; i++)
               erased[i] = 0;
       opensymtab();

       /* read and process file */
       lineno = 0;
       outlineno = 1;
       while (moreinput(infp)) {
               if (++lineno > linemax)
                       error(FATAL, "too many input lines");
               /* fprintf(stderr, "STARTING TO PROCESS INPUT LINE %d\n",
                       lineno); */
               linevec[outlineno] = NOTGEOM;
               lex(infp);
               if (buf[0] == '#') {
                       gobble2(infp);
                       continue;
               }
               badlabel = 0;
               if (buf[strlen(buf)-1] == ':') {
                       buf[strlen(buf)-1] = '\0';
                       badlabel = 1;
                       strcpy(savelabel, buf);
                       sp = lookup(buf, currentview);
                       if (sp != NULL) {
                               if (linevec[sp->outnum] == currentview) {
                                       DOERASE(sp->outnum)
                               }
                               sp->outnum = outlineno;
                       } else {
                               insert(buf, currentview, outlineno);
                       }
                       lex(infp);
               }
               if (eq(buf, "text")) {
                       DOGEOM
                       getoptions(TEXT);
                       fprintf(tempfp, "g\t0\tt\t%d\t%s",
                               currentview, optstring);
                       dox(currentview);
                       lex(infp);
                       doy(currentview);
                       lexstr(infp);
                       fprintf(tempfp, "\t%s\n", buf);
                       outlineno++;
               } else if (eq(buf, "circle")) {
                       float savex, rad;
                       DOGEOM
                       getoptions(CIRCLE);
                       fprintf(tempfp, "g\t0\tc\t%d\t%s",
                               currentview, optstring);
                       dox(currentview);
                       savex = STOF(buf);
                       lex(infp);
                       doy(currentview);
                       lex(infp);
                       if (!strisnum(buf)) {
                               error(WARN, "radius not a number");
                               strcpy(buf, "0");
                       }
                       rad = STOF(buf);
                       if (rad < 0.0)
                               error(WARN, "radius is negative");
                       recordx(currentview, savex-rad);
                       recordx(currentview, savex+rad);
                       fprintf(tempfp, "\t%s\n", buf);
                       outlineno++;
                       gobble(infp);
               } else if (eq(buf, "line") || eq(buf, "box")) {
                       char cmdchar;
                       DOGEOM
                       if (eq(buf, "line")) {
                               getoptions(LINE);
                               cmdchar = 'l';
                       } else {
                               getoptions(BOX);
                               cmdchar = 'b';
                       }
                       fprintf(tempfp, "g\t0\t%c\t%d\t%s",
                               cmdchar, currentview, optstring);
                       dox(currentview);
                       lex(infp);
                       doy(currentview);
                       lex(infp);
                       dox(currentview);
                       lex(infp);
                       doy(currentview);
                       fprintf(tempfp, "\n");
                       outlineno++;
                       gobble(infp);
               } else if (eq(buf, "view")) {
                       lex(infp);
                       if (eq(buf,NULLSTR)) {
                               error(WARN, "no name in view statement");
                               strcpy(buf, "def.view");
                       }
                       if (viewcnt == 0 && geomalready)
                               error(WARN, "first view after geom");
                       for (i = 0; i < viewcnt; i++)
                               if (eq(buf, viewarr[i].name))
                                       break;
                       if (i >= viewcnt) {
                               viewcnt++;
                               if (i >= MAXVIEWS)
                                       error(FATAL, "too many views");
                               strcpy(viewarr[i].name, buf);
                               viewarr[i].initx = viewarr[i].inity = 0;
                       }
                       currentview = i;
                       gobble(infp);
               } else if (eq(buf, "click")) {
                       lex(infp);
                       if (eq(buf,NULLSTR))
                               strcpy(buf, "def.click");
                       for (i = 0; i < clickcnt; i++)
                               if (eq(buf, clickname[i]))
                                       break;
                       if (i >= clickcnt) {
                               clickcnt++;
                               if (i >= MAXCLICKS)
                                       error(FATAL, "too many click names");
                               strcpy(clickname[i], buf);
                       }
                       fprintf(tempfp, "c\t%d\n", i);
                       outlineno++;
                       gobble(infp);
               } else if (eq(buf, "erase")) {
                       lex(infp);
                       if (eq(buf,NULLSTR))
                               error(WARN, "no label in erase statement");
                       sp = lookup(buf, currentview);
                       if (sp != NULL) {
                               if (linevec[sp->outnum] == currentview) {
                                       DOERASE(sp->outnum)
                               }
                               delete(buf, currentview);
                       } else {
                               error(WARN, "undefined label");
                       }
                       gobble(infp);
               } else if (eq(buf, "clear")) {
                       int i, endline;
                       fprintf(tempfp, "b\ts\t%d\n", currentview);
                       endline = outlineno++;
                       for (i = erased[currentview]+1; i <= endline; i++) {
                               if (linevec[i] == currentview) {
                                       DOERASE(i)
                               }
                       }
                       erased[currentview] = outlineno;
                       fprintf(tempfp, "b\te\t%d\n", currentview);
                       linevec[outlineno] = NOTGEOM;
                       outlineno++;
                       gobble(infp);
               } else {
                       if (!eq(buf, NULLSTR))
                               error(WARN, "unrecognized command");
                       gobble(infp);
               }
               if (badlabel) {
                       error(WARN, "label on nongeometric object");
                       delete(savelabel, currentview);
               }
       }
       /* tidy up */
       lineno = 0;
       closesymtab();
       if (viewcnt == 0) {
               viewcnt = 1;
               strcpy(viewarr[0].name, "def.view");
       }
}


void pass2(void)
{
       typedef struct Slot {
               union {
                       int     i;
                       char    *p;
               } v;
       } Slot;
       char    cmd;            /* first char on a line */
       int     tlineno;        /* line number in temp file */
       int     slothead;       /* ptr to free list within slots */
       Slot    *slotarr;       /* init by malloc to slotmax elmts */
       int     i;
       int     c;
       int     v;
       struct Viewelmt *vp;

       /* Init */
       opensymtab();
       slotarr = (Slot *) emalloc(slotmax * sizeof(Slot));
       for (i = 1; i <= slotmax-2; i++)
               slotarr[i].v.i = i+1;
       slothead = 1;
       /* Write header for output file */
       for (i = 0; i < viewcnt; i++) {
               vp = &viewarr[i];
               printf("d\tv\t%d\t%s\t%g\t%g\t%g\t%g\n", i,
                       vp->name, vp->minx, vp->miny, vp->maxx, vp->maxy);
       }
       for (i = 0; i < clickcnt; i++)
               printf("d\tc\t%d\t%s\n", i, clickname[i]);
       printf("d\tp\te\n");
       /* Calculate view factors used to scale */
       for (v = 0; v < viewcnt; v++) {
               vp = &viewarr[v];
               if (vp->minx == vp->maxx) {
                       vp->minx = 0.0;
                       vp->maxx = 2*vp->maxx;
                       if (vp->maxx == 0.0) {
                               vp->minx = -1.0;
                               vp->maxx =  1.0;
                       }
               }
               vp->factorx = SCALE / (vp->maxx-vp->minx);
               if (vp->miny == vp->maxy) {
                       vp->miny = 0.0;
                       vp->maxy = 2*vp->maxy;
                       if (vp->maxy == 0.0) {
                               vp->miny = -1.0;
                               vp->maxy =  1.0;
                       }
               }
               vp->factory = SCALE / (vp->maxy-vp->miny);
       }
       /* Read and process intermediate file */
       tlineno = 0;
       while ((c = getc(tempfp)) != EOF) {
               tlineno++;
               cmd = c;
               getc(tempfp);   /* gobble tab */
               putchar(cmd);
               putchar('\t');
               if (cmd == 'g') {
                       int snum, vnum;
                       char gcmd;
                       char opts[OPTMAX];
                       float x1, y1, x2, y2;
                       int   i1, j1, i2, j2;
                       char bufa[MAXBUF+100];
                       /* fscanf(tempfp, "%d %c %d", &snum, &gcmd, &vnum); */
                         getc(tempfp); /* don't need snum -- always zero */
                         getc(tempfp); /* gobble tab */
                         gcmd = getc(tempfp);
                         getc(tempfp); /* gobble tab */
                         vnum = getc(tempfp) - '0';
                       fscanf(tempfp, "%s %f %f", opts, &x1, &y1);
                       if (linevec[tlineno] != ERASED)
                               snum = 0;
                       else {
                               snum = slothead;
                               slothead = slotarr[snum].v.i;
                               if (slothead == 0)
                                       error(FATAL, "ran out of slots");
                       }
                       insert(NULLSTR, tlineno, snum);
                       i1 = scalex(vnum, x1);
                       j1 = scaley(vnum, y1);
                       if (gcmd == 'b' || gcmd == 'l') {
                               fscanf(tempfp, "%f %f", &x2, &y2);
                               if (getc(tempfp) != '\n')
                                       error(FATAL, "develop bug: missing newline");
                               i2 = scalex(vnum, x2);
                               j2 = scaley(vnum, y2);
                               if (gcmd == 'b') {
                                       int t; /* normalize: min, max */
                                       if (i1 > i2) { t=i1; i1=i2; i2=t; }
                                       if (j1 > j2) { t=j1; j1=j2; j2=t; }
                               }
                               sprintf(bufa, "%d\t%c\t%d\t%s\t%d\t%d\t%d\t%d",
                                       snum, gcmd, vnum, opts, i1, j1, i2, j2);
                       } else if (gcmd == 'c') {
                               fscanf(tempfp, "%f", &x2);
                               if (getc(tempfp) != '\n')
                                       error(FATAL, "develop bug: missing newline");
                               i2 = scalex(vnum, x1+x2) - i1;
                               if (i2 < 0)
                                       i2 = -i2;
                               if (i2 == 0)
                                       i2 = 1;
                               sprintf(bufa, "%d\t%c\t%d\t%s\t%d\t%d\t%d",
                                       snum, gcmd, vnum, opts, i1, j1, i2);
                       } else if (gcmd == 't') {
                               getc(tempfp); /* gobble tab */
                               lexrest(tempfp);
                               sprintf(bufa, "%d\t%c\t%d\t%s\t%d\t%d\t%s",
                                       snum, gcmd, vnum, opts, i1, j1, buf);
                       } else error(FATAL, "develop bug: invalid g cmd");
                       slotarr[snum].v.p = emalloc(strlen(bufa)+1);
                       strcpy(slotarr[snum].v.p, bufa);
                       puts(bufa);
               } else if (cmd == 'e') {
                       int linenum, slotnum;
                       Symbol *sp;
                       fscanf(tempfp, "%d", &linenum);
                       if (getc(tempfp) != '\n')
                               error(FATAL, "develop bug: missing newline");
                       sp = lookup(NULLSTR, linenum);
                       if (sp == NULL)
                               error(FATAL, "develop bug: bad erase lookup");
                       slotnum = sp->outnum;
                       puts(slotarr[slotnum].v.p);
                       efree(slotarr[slotnum].v.p);
                       slotarr[slotnum].v.i = slothead;
                       slothead = slotnum;
                       delete(NULLSTR, linenum);
               } else {
                       lexrest(tempfp);
                       puts(buf);
               }
       }
       /* tidy up */
               /* closesymtab(); delete stuff in slots? */
}

void recordx(int vnum, float t)
{
       struct Viewelmt *vp;

       vp = &viewarr[vnum];
       if (vp->initx != 1) {
               vp->initx = 1;
               vp->minx = t;
               vp->maxx = t;
       } else {
               if (t < vp->minx)
                       vp->minx = t;
               if (t > vp->maxx)
                       vp->maxx = t;
       }
}

void recordy(int vnum, float t)
{
       struct Viewelmt *vp;

       vp = &viewarr[vnum];
       if (vp->inity != 1) {
               vp->inity = 1;
               vp->miny = t;
               vp->maxy = t;
       } else {
               if (t < vp->miny)
                       vp->miny = t;
               if (t > vp->maxy)
                       vp->maxy = t;
       }
}

int scalex(int vnum, float t)
{
       struct Viewelmt *vp;

       vp = &viewarr[vnum];
       return (int) ((t - vp->minx) * vp->factorx);
}

int scaley(int vnum, float t)
{
       struct Viewelmt *vp;

       vp = &viewarr[vnum];
       return (int) ((t - vp->miny) * vp->factory);
}

void getoptions(int cmdtype)    /* put options into optstring */
{
       int i;
       struct Geoelmt *gp;

       strcpy(optstring, defaulttab[cmdtype]);
       for (lex(infp); !eq(buf,NULLSTR) && !strisnum(buf); lex(infp)) {
               for (i = 0; i < geooptcnt; i++) {
                       gp = &geooptarr[i];
                       if (cmdtype == gp->cmd && eq(buf, gp->name))
                               break;
               }
               if (i < geooptcnt)
                       optstring[gp->pos] = gp -> val;
               else
                       error(WARN, "unrecognized option");
       }
}

void dox(int view)      /* handle x in input file */
{
       if (!strisnum(buf)) {
               error(WARN, "x value not a number");
               strcpy(buf, "0");
       }
       recordx(view, STOF(buf));
       fprintf(tempfp, "\t%s", buf);
}

void doy(int view)      /* handle y in input file */
{
       if (!strisnum(buf)) {
               error(WARN, "y value not a number");
               strcpy(buf, "0");
       }
       recordy(view, STOF(buf));
       fprintf(tempfp, "\t%s", buf);
}



/* symbol.c:
       General: functions for mapping {string} x {int} -> {int}
       In pass 1: {name} x {viewnum} -> {int file line num}
       In pass 2: {} x {int file line num} -> {slot num}
                  Therefore be careful with blank strings
*/

#define steq(s, n, p) (p->innum == n && ((p->instr == s) || eq(p->instr,s)))

#define SIZE    2053
Symbol  *head[SIZE];

int hash(char *s, int n)        /* form hash value */
{
       int hashval;

       for (hashval = 0; *s != '\0'; s++)
               hashval = (*s + 31 * hashval) % SIZE;
       hashval = (31 * hashval + 1259 * n) % SIZE;
       return hashval;
}

Symbol *lookup(char *s, int n)  /* return element with s, n */
{
       Symbol *p;
       for (p = head[hash(s, n)]; p != NULL; p = p->next)
               if (steq(s, n, p))
                       return p;
       return NULL;
}

void insert(char *s, int n, int v)      /* insert s, n with value v */
{
       Symbol *p;
       char *q;
       int i;

       /* fprintf(stderr, "Inserting: |%s|, %d with hash %d\n",
               s, n, hash(s,n)); */
       if (*s == '\0')
               q = NULLSTR;
       else {
               q = emalloc(strlen(s)+1);
               strcpy(q, s);
       }
       p = (Symbol *) emalloc(sizeof(Symbol));
       p->instr = q;
       p->innum = n;
       p->outnum = v;
       i = hash(s, n);
       p->next = head[i];
       head[i] = p;
}

void delete(char *s, int n)     /* remove s, n */
{
       Symbol *p, *pp;
       int i;

       /* fprintf(stderr, "Deleting:  |%s|, %d with hash %d\n",
               s, n, hash(s,n)); */
       i = hash(s, n);
       pp = NULL;
       for (p = head[i]; p != NULL; p = p->next) {
               if (steq(s, n, p))
                       break;
               pp = p;
       }
       if (p == NULL)
               error(FATAL, "symtab bug: bad delete");
       if (p->instr != NULLSTR)
               efree(p->instr);
       if (pp == NULL) {
               head[i] = p->next;
       } else {
               pp->next = p->next;
       }
       efree((char *) p);
}

void opensymtab(void)   /* init table */
{
       int i;

       for (i = 0; i < SIZE; i++)
               head[i] = NULL;
}

void closesymtab(void)  /* reclaim storage */
{
       int i;
       Symbol *p, *np;

       for (i = 0; i < SIZE; i++)
               for (p = head[i]; p != NULL; p = np) {
                       if (p->instr != NULLSTR)
                               efree(p->instr);
                       np = p->next;
                       efree((char *) p);
               }
}



/* util.c: utility routines */


void error(int f, char *s)
{
       fprintf(stderr, "%s: %s\n", cmdname, s);
       if (lineno)
               fprintf(stderr, " source line number %d\n", lineno);
       if (f)
               exit(1);
}

int strisnum(char *p)           /* 1 if string p represents a float */
{
       int digits = 0;
       int n;
                                               /* REG EXPR:    */
       if (*p == '-')                          /* -?           */
               p++;
       while (isdigit(*p)) {
               digits++;                       /* [0-9]*       */
               p++;
       }
       if (*p == '.') {                        /* (.[0-9]*)?   */
               p++;
               while (isdigit(*p)) {
                       digits++;
                       p++;
               }
       }
       if (digits == 0)                        /* >0 digits    */
               return 0;
       if (tolower(*p) == 'e') {               /* ([eE]        */
               *p++;
               if (*p == '+' || *p == '-')     /*  [+-]?       */
                       p++;
               digits = 1;
               if (!isdigit(*p))               /*  [0-9]       */
                       return 0;
               n = *p++ - '0';
               while (isdigit(*p)) {           /*  [0-9]+      */
                       digits++;
                       n = 10*n + *p++ - '0';
                       if (n > 30)
                               return 0;
               }
               if (digits == 0)
                       return 0;               /*        )?    */
       }
       return (*p == '\0');
}

int moreinput(FILE *fp)
{
       int c;

       if (lexsaweof)
               return 0;
       c = getc(fp);
       if (c == EOF)
               return 0;
       ungetc(c, fp);
       return 1;
}

#define CHECKEOF                if (c == EOF) {\
               lexsaweof = 1;\
               error(WARN, "file does not end with newline");\
               return;\
       }


void lex(FILE *fp)      /* put next string of non-white into buf */
{
       int c;
       char *p, *danger;

       danger = &buf[MAXSTR-1];
       while ((c = getc(fp)) == ' ' || c == '\t')
               ;
       CHECKEOF
       if (c == '\n') {
               ungetc(c, fp);
               buf[0] = '\0';
               return;
       }
       p = buf;
       *p++ = c;
       while ((c = getc(fp)) != EOF && c != ' ' && c != '\t' && c != '\n') {
               if (p < danger)
                       *p++ = c;
               else if (p == danger)
                       error(WARN, "string too long -- truncated");
       }
       *p = '\0';
       CHECKEOF
       if (c == '\n')
               ungetc(c, fp);
/* fprintf(stderr, "lex returning: %s\n", buf); */
}


void lexstr(FILE *fp)   /* like lex, but go til newline and handle quotes */
{
       int c;
       int quoted = 0;
       char *p, *danger;

       while ((c = getc(fp)) == ' ' || c == '\t')
               ;
       CHECKEOF
       if (c == '\"') {
               quoted = 1;
               c = getc(fp);
               CHECKEOF
       }
       if (c == '\n') {
               buf[0] = '\0';
               return;
       }
       p = buf;
       *p++ = c;
       danger = &buf[MAXBUF-1];
       while ((c = getc(fp)) != EOF && c != '\n') {
               if (p < danger)
                       *p++ = c;
               else if (p == danger)
                       error(WARN, "text string too long -- truncated");
       }
       CHECKEOF
       *p = '\0';
       if (quoted && *(--p) == '\"')
               *p = '\0';
}

void lexrest(FILE *fp)  /* get rest of line into buf */
                       /* no error checking; error free from Pass 1 */
{
       int c;
       char *p;

       p = buf;
       while ((c = getc(fp)) != EOF && c != '\n') {
               *p++ = c;
       }
       *p = '\0';
}

void gobble(FILE *fp)   /* chew space til EOF; complain if nonwhite */
{
       int c;

       while ((c = getc(fp)) == ' ' || c == '\t')
               ;
       CHECKEOF
       if (c != '\n') {
               error(WARN, "garbage at end of line");
               while ((c = getc(fp)) != EOF && c != '\n')
                       ;
               CHECKEOF
       }
}

void gobble2(FILE *fp)          /* chew space til EOF, no complaints */
{
       int c;

       while ((c = getc(fp)) != EOF && c != '\n')
               ;
       CHECKEOF
}

#define WANTPROF 0
#if WANTPROF
       int     hmallocinit;
       FILE    *hmallocfp;
#endif

char *emalloc(int n)    /* check return from malloc */
{
       char *p;

#if WANTPROF
       if (hmallocinit == 0) {
               hmallocinit = 1;
               if ((hmallocfp = fopen("/tmp/malloc.hist", "w")) == NULL)
                       error(FATAL, "malloc history bug: can't open file");
       }
#endif
       p = malloc((unsigned) n);
       if (p == NULL)
               error(FATAL, "out of memory");
#if WANTPROF
       fprintf(hmallocfp, "m\t%d\t%d\n", (int) p, n);
#endif
       return p;
}

void efree(char *p)             /* personal version of free to match emalloc */
{
#if WANTPROF
       if (hmallocinit == 0)
               error(FATAL, "malloc history bug: first free before malloc");
       fprintf(hmallocfp, "f\t%d\n", (int) p);
#endif
       free(p);
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.