usr/src/cmd/awk/parse.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22
  23 /*
  24  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
  25  * Use is subject to license terms.
  26  */
  27
  28 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  29 /*        All Rights Reserved   */
  30
  31 #pragma ident   "%Z%%M% %I%     %E% SMI"
  32
  33 #define DEBUG
  34 #include "awk.h"
  35 #include "y.tab.h"
  36
  37 Node *
  38 nodealloc(int n)
  39 {
  40         register Node *x;
  41
  42         x = (Node *)malloc(sizeof (Node) + (n - 1) * sizeof (Node *));
  43         if (x == NULL)
  44                 ERROR "out of space in nodealloc" FATAL;
  45         x->nnext = NULL;
  46         x->lineno = lineno;
  47         return (x);
  48 }
  49
  50 Node *
  51 exptostat(Node *a)
  52 {
  53         a->ntype = NSTAT;
  54         return (a);
  55 }
  56
  57 Node *
  58 node1(int a, Node *b)
  59 {
  60         register Node *x;
  61
  62         x = nodealloc(1);
  63         x->nobj = a;
  64         x->narg[0] = b;
  65         return (x);
  66 }
  67
  68 Node *
  69 node2(int a, Node *b, Node *c)
  70 {
  71         register Node *x;
  72
  73         x = nodealloc(2);
  74         x->nobj = a;
  75         x->narg[0] = b;
  76         x->narg[1] = c;
  77         return (x);
  78 }
  79
  80 Node *
  81 node3(int a, Node *b, Node *c, Node *d)
  82 {
  83         register Node *x;
  84
  85         x = nodealloc(3);
  86         x->nobj = a;
  87         x->narg[0] = b;
  88         x->narg[1] = c;
  89         x->narg[2] = d;
  90         return (x);
  91 }
  92
  93 Node *
  94 node4(int a, Node *b, Node *c, Node *d, Node *e)
  95 {
  96         register Node *x;
  97         x = nodealloc(4);
  98         x->nobj = a;
  99         x->narg[0] = b;
 100         x->narg[1] = c;
 101         x->narg[2] = d;
 102         x->narg[3] = e;
 103         return (x);
 104 }
 105
 106 Node *
 107 stat3(int a, Node *b, Node *c, Node *d)
 108 {
 109         register Node *x;
 110
 111         x = node3(a, b, c, d);
 112         x->ntype = NSTAT;
 113         return (x);
 114 }
 115
 116 Node *
 117 op2(int a, Node *b, Node *c)
 118 {
 119         register Node *x;
 120
 121         x = node2(a, b, c);
 122         x->ntype = NEXPR;
 123         return (x);
 124 }
 125
 126 Node *
 127 op1(int a, Node *b)
 128 {
 129         register Node *x;
 130
 131         x = node1(a, b);
 132         x->ntype = NEXPR;
 133         return (x);
 134 }
 135
 136 Node *
 137 stat1(int a, Node *b)
 138 {
 139         register Node *x;
 140
 141         x = node1(a, b);
 142         x->ntype = NSTAT;
 143         return (x);
 144 }
 145
 146 Node *
 147 op3(int a, Node *b, Node *c, Node *d)
 148 {
 149         register Node *x;
 150
 151         x = node3(a, b, c, d);
 152         x->ntype = NEXPR;
 153         return (x);
 154 }
 155
 156 Node *
 157 op4(int a, Node *b, Node *c, Node *d, Node *e)
 158 {
 159         register Node *x;
 160
 161         x = node4(a, b, c, d, e);
 162         x->ntype = NEXPR;
 163         return (x);
 164 }
 165
 166 Node *
 167 stat2(int a, Node *b, Node *c)
 168 {
 169         register Node *x;
 170
 171         x = node2(a, b, c);
 172         x->ntype = NSTAT;
 173         return (x);
 174 }
 175
 176 Node *
 177 stat4(int a, Node *b, Node *c, Node *d, Node *e)
 178 {
 179         register Node *x;
 180
 181         x = node4(a, b, c, d, e);
 182         x->ntype = NSTAT;
 183         return (x);
 184 }
 185
 186 Node *
 187 valtonode(Cell *a, int b)
 188 {
 189         register Node *x;
 190
 191         a->ctype = OCELL;
 192         a->csub = b;
 193         x = node1(0, (Node *)a);
 194         x->ntype = NVALUE;
 195         return (x);
 196 }
 197
 198 Node *
 199 rectonode(void)
 200 {
 201         /* return valtonode(lookup("$0", symtab), CFLD); */
 202         return (valtonode(recloc, CFLD));
 203 }
 204
 205 Node *
 206 makearr(Node *p)
 207 {
 208         Cell *cp;
 209
 210         if (isvalue(p)) {
 211                 cp = (Cell *)(p->narg[0]);
 212                 if (isfunc(cp))
 213                         ERROR "%s is a function, not an array", cp->nval SYNTAX;
 214                 else if (!isarr(cp)) {
 215                         xfree(cp->sval);
 216                         cp->sval = (uchar *)makesymtab(NSYMTAB);
 217                         cp->tval = ARR;
 218                 }
 219         }
 220         return (p);
 221 }
 222
 223 Node *
 224 pa2stat(Node *a, Node *b, Node *c)
 225 {
 226         register Node *x;
 227
 228         x = node4(PASTAT2, a, b, c, (Node *)paircnt);
 229         paircnt++;
 230         x->ntype = NSTAT;
 231         return (x);
 232 }
 233
 234 Node *
 235 linkum(Node *a, Node *b)
 236 {
 237         register Node *c;
 238
 239         if (errorflag)  /* don't link things that are wrong */
 240                 return (a);
 241         if (a == NULL)
 242                 return (b);
 243         else if (b == NULL)
 244                 return (a);
 245         for (c = a; c->nnext != NULL; c = c->nnext)
 246                 ;
 247         c->nnext = b;
 248         return (a);
 249 }
 250
 251 void
 252 defn(Cell *v, Node *vl, Node *st)       /* turn on FCN bit in definition */
 253 {
 254         Node *p;
 255         int n;
 256
 257         if (isarr(v)) {
 258                 ERROR "`%s' is an array name and a function name",
 259                     v->nval SYNTAX;
 260                 return;
 261         }
 262         v->tval = FCN;
 263         v->sval = (uchar *)st;
 264         n = 0;  /* count arguments */
 265         for (p = vl; p; p = p->nnext)
 266                 n++;
 267         v->fval = n;
 268         dprintf(("defining func %s (%d args)\n", v->nval, n));
 269 }
 270
 271 int
 272 isarg(uchar *s) /* is s in argument list for current function? */
 273 {
 274         extern Node *arglist;
 275         Node *p = arglist;
 276         int n;
 277
 278         for (n = 0; p != 0; p = p->nnext, n++) {
 279                 if (strcmp((char *)((Cell *)(p->narg[0]))->nval,
 280                     (char *)s) == 0) {
 281                         return (n);
 282                 }
 283         }
 284         return (-1);
 285 }