tools/bioawk/parse.c

   1 /****************************************************************
   2 Copyright (C) Lucent Technologies 1997
   3 All Rights Reserved
   4
   5 Permission to use, copy, modify, and distribute this software and
   6 its documentation for any purpose and without fee is hereby
   7 granted, provided that the above copyright notice appear in all
   8 copies and that both that the copyright notice and this
   9 permission notice and warranty disclaimer appear in supporting
  10 documentation, and that the name Lucent Technologies or any of
  11 its entities not be used in advertising or publicity pertaining
  12 to distribution of the software without specific, written prior
  13 permission.
  14
  15 LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  16 INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
  17 IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY
  18 SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
  20 IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  21 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
  22 THIS SOFTWARE.
  23 ****************************************************************/
  24
  25 #define DEBUG
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <stdlib.h>
  29 #include "awk.h"
  30 #include "ytab.h"
  31
  32 Node *nodealloc(int n)
  33 {
  34         Node *x;
  35
  36         x = (Node *) malloc(sizeof(Node) + (n-1)*sizeof(Node *));
  37         if (x == NULL)
  38                 FATAL("out of space in nodealloc");
  39         x->nnext = NULL;
  40         x->lineno = lineno;
  41         return(x);
  42 }
  43
  44 Node *exptostat(Node *a)
  45 {
  46         a->ntype = NSTAT;
  47         return(a);
  48 }
  49
  50 Node *node1(int a, Node *b)
  51 {
  52         Node *x;
  53
  54         x = nodealloc(1);
  55         x->nobj = a;
  56         x->narg[0]=b;
  57         return(x);
  58 }
  59
  60 Node *node2(int a, Node *b, Node *c)
  61 {
  62         Node *x;
  63
  64         x = nodealloc(2);
  65         x->nobj = a;
  66         x->narg[0] = b;
  67         x->narg[1] = c;
  68         return(x);
  69 }
  70
  71 Node *node3(int a, Node *b, Node *c, Node *d)
  72 {
  73         Node *x;
  74
  75         x = nodealloc(3);
  76         x->nobj = a;
  77         x->narg[0] = b;
  78         x->narg[1] = c;
  79         x->narg[2] = d;
  80         return(x);
  81 }
  82
  83 Node *node4(int a, Node *b, Node *c, Node *d, Node *e)
  84 {
  85         Node *x;
  86
  87         x = nodealloc(4);
  88         x->nobj = a;
  89         x->narg[0] = b;
  90         x->narg[1] = c;
  91         x->narg[2] = d;
  92         x->narg[3] = e;
  93         return(x);
  94 }
  95
  96 Node *stat1(int a, Node *b)
  97 {
  98         Node *x;
  99
 100         x = node1(a,b);
 101         x->ntype = NSTAT;
 102         return(x);
 103 }
 104
 105 Node *stat2(int a, Node *b, Node *c)
 106 {
 107         Node *x;
 108
 109         x = node2(a,b,c);
 110         x->ntype = NSTAT;
 111         return(x);
 112 }
 113
 114 Node *stat3(int a, Node *b, Node *c, Node *d)
 115 {
 116         Node *x;
 117
 118         x = node3(a,b,c,d);
 119         x->ntype = NSTAT;
 120         return(x);
 121 }
 122
 123 Node *stat4(int a, Node *b, Node *c, Node *d, Node *e)
 124 {
 125         Node *x;
 126
 127         x = node4(a,b,c,d,e);
 128         x->ntype = NSTAT;
 129         return(x);
 130 }
 131
 132 Node *op1(int a, Node *b)
 133 {
 134         Node *x;
 135
 136         x = node1(a,b);
 137         x->ntype = NEXPR;
 138         return(x);
 139 }
 140
 141 Node *op2(int a, Node *b, Node *c)
 142 {
 143         Node *x;
 144
 145         x = node2(a,b,c);
 146         x->ntype = NEXPR;
 147         return(x);
 148 }
 149
 150 Node *op3(int a, Node *b, Node *c, Node *d)
 151 {
 152         Node *x;
 153
 154         x = node3(a,b,c,d);
 155         x->ntype = NEXPR;
 156         return(x);
 157 }
 158
 159 Node *op4(int a, Node *b, Node *c, Node *d, Node *e)
 160 {
 161         Node *x;
 162
 163         x = node4(a,b,c,d,e);
 164         x->ntype = NEXPR;
 165         return(x);
 166 }
 167
 168 Node *celltonode(Cell *a, int b)
 169 {
 170         Node *x;
 171
 172         a->ctype = OCELL;
 173         a->csub = b;
 174         x = node1(0, (Node *) a);
 175         x->ntype = NVALUE;
 176         return(x);
 177 }
 178
 179 Node *rectonode(void)   /* make $0 into a Node */
 180 {
 181         extern Cell *literal0;
 182         return op1(INDIRECT, celltonode(literal0, CUNK));
 183 }
 184
 185 Node *makearr(Node *p)
 186 {
 187         Cell *cp;
 188
 189         if (isvalue(p)) {
 190                 cp = (Cell *) (p->narg[0]);
 191                 if (isfcn(cp))
 192                         SYNTAX( "%s is a function, not an array", cp->nval );
 193                 else if (!isarr(cp)) {
 194                         xfree(cp->sval);
 195                         cp->sval = (char *) makesymtab(NSYMTAB);
 196                         cp->tval = ARR;
 197                 }
 198         }
 199         return p;
 200 }
 201
 202 #define PA2NUM  50      /* max number of pat,pat patterns allowed */
 203 int     paircnt;                /* number of them in use */
 204 int     pairstack[PA2NUM];      /* state of each pat,pat */
 205
 206 Node *pa2stat(Node *a, Node *b, Node *c)        /* pat, pat {...} */
 207 {
 208         Node *x;
 209
 210         x = node4(PASTAT2, a, b, c, itonp(paircnt));
 211         if (paircnt++ >= PA2NUM)
 212                 SYNTAX( "limited to %d pat,pat statements", PA2NUM );
 213         x->ntype = NSTAT;
 214         return(x);
 215 }
 216
 217 Node *linkum(Node *a, Node *b)
 218 {
 219         Node *c;
 220
 221         if (errorflag)  /* don't link things that are wrong */
 222                 return a;
 223         if (a == NULL)
 224                 return(b);
 225         else if (b == NULL)
 226                 return(a);
 227         for (c = a; c->nnext != NULL; c = c->nnext)
 228                 ;
 229         c->nnext = b;
 230         return(a);
 231 }
 232
 233 void defn(Cell *v, Node *vl, Node *st)  /* turn on FCN bit in definition, */
 234 {                                       /*   body of function, arglist */
 235         Node *p;
 236         int n;
 237
 238         if (isarr(v)) {
 239                 SYNTAX( "`%s' is an array name and a function name", v->nval );
 240                 return;
 241         }
 242         if (isarg(v->nval) != -1) {
 243                 SYNTAX( "`%s' is both function name and argument name", v->nval );
 244                 return;
 245         }
 246
 247         v->tval = FCN;
 248         v->sval = (char *) st;
 249         n = 0;  /* count arguments */
 250         for (p = vl; p; p = p->nnext)
 251                 n++;
 252         v->fval = n;
 253         dprintf( ("defining func %s (%d args)\n", v->nval, n) );
 254 }
 255
 256 int isarg(const char *s)                /* is s in argument list for current function? */
 257 {                       /* return -1 if not, otherwise arg # */
 258         extern Node *arglist;
 259         Node *p = arglist;
 260         int n;
 261
 262         for (n = 0; p != 0; p = p->nnext, n++)
 263                 if (strcmp(((Cell *)(p->narg[0]))->nval, s) == 0)
 264                         return n;
 265         return -1;
 266 }
 267
 268 int ptoi(void *p)       /* convert pointer to integer */
 269 {
 270         return (int) (long) p;  /* swearing that p fits, of course */
 271 }
 272
 273 Node *itonp(int i)      /* and vice versa */
 274 {
 275         return (Node *) (long) i;
 276 }