Annotation of rpl/rplawk/parse.c, revision 1.1
1.1 ! bertrand 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: }
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to parse.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / rplawk