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 37Node * 38nodealloc(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 50Node * 51exptostat(Node *a) 52{ 53 a->ntype = NSTAT; 54 return (a); 55} 56 57Node * 58node1(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 68Node * 69node2(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 80Node * 81node3(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 93Node * 94node4(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 106Node * 107stat3(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 116Node * 117op2(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 126Node * 127op1(int a, Node *b) 128{ 129 register Node *x; 130 131 x = node1(a, b); 132 x->ntype = NEXPR; 133 return (x); 134} 135 136Node * 137stat1(int a, Node *b) 138{ 139 register Node *x; 140 141 x = node1(a, b); 142 x->ntype = NSTAT; 143 return (x); 144} 145 146Node * 147op3(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 156Node * 157op4(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 166Node * 167stat2(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 176Node * 177stat4(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 186Node * 187valtonode(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 198Node * 199rectonode(void) 200{ 201 /* return valtonode(lookup("$0", symtab), CFLD); */ 202 return (valtonode(recloc, CFLD)); 203} 204 205Node * 206makearr(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 223Node * 224pa2stat(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 234Node * 235linkum(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 251void 252defn(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 271int 272isarg(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} 286