Print this page
3731 Update nawk to version 20121220
*** 23,49 ****
/*
* Copyright 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
! /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
! /* All Rights Reserved */
!
! #pragma ident "%Z%%M% %I% %E% SMI"
#define DEBUG
#include "awk.h"
#include "y.tab.h"
Node *
nodealloc(int n)
{
! register Node *x;
x = (Node *)malloc(sizeof (Node) + (n - 1) * sizeof (Node *));
if (x == NULL)
! ERROR "out of space in nodealloc" FATAL;
x->nnext = NULL;
x->lineno = lineno;
return (x);
}
--- 23,68 ----
/*
* Copyright 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
! /*
! * Copyright (C) Lucent Technologies 1997
! * All Rights Reserved
! *
! * Permission to use, copy, modify, and distribute this software and
! * its documentation for any purpose and without fee is hereby
! * granted, provided that the above copyright notice appear in all
! * copies and that both that the copyright notice and this
! * permission notice and warranty disclaimer appear in supporting
! * documentation, and that the name Lucent Technologies or any of
! * its entities not be used in advertising or publicity pertaining
! * to distribution of the software without specific, written prior
! * permission.
! *
! * LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
! * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
! * IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY
! * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
! * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
! * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
! * THIS SOFTWARE.
! */
#define DEBUG
#include "awk.h"
#include "y.tab.h"
Node *
nodealloc(int n)
{
! Node *x;
x = (Node *)malloc(sizeof (Node) + (n - 1) * sizeof (Node *));
if (x == NULL)
! FATAL("out of space in nodealloc");
x->nnext = NULL;
x->lineno = lineno;
return (x);
}
*** 55,76 ****
}
Node *
node1(int a, Node *b)
{
! register Node *x;
x = nodealloc(1);
x->nobj = a;
x->narg[0] = b;
return (x);
}
Node *
node2(int a, Node *b, Node *c)
{
! register Node *x;
x = nodealloc(2);
x->nobj = a;
x->narg[0] = b;
x->narg[1] = c;
--- 74,95 ----
}
Node *
node1(int a, Node *b)
{
! Node *x;
x = nodealloc(1);
x->nobj = a;
x->narg[0] = b;
return (x);
}
Node *
node2(int a, Node *b, Node *c)
{
! Node *x;
x = nodealloc(2);
x->nobj = a;
x->narg[0] = b;
x->narg[1] = c;
*** 78,88 ****
}
Node *
node3(int a, Node *b, Node *c, Node *d)
{
! register Node *x;
x = nodealloc(3);
x->nobj = a;
x->narg[0] = b;
x->narg[1] = c;
--- 97,107 ----
}
Node *
node3(int a, Node *b, Node *c, Node *d)
{
! Node *x;
x = nodealloc(3);
x->nobj = a;
x->narg[0] = b;
x->narg[1] = c;
*** 91,242 ****
}
Node *
node4(int a, Node *b, Node *c, Node *d, Node *e)
{
! register Node *x;
x = nodealloc(4);
x->nobj = a;
x->narg[0] = b;
x->narg[1] = c;
x->narg[2] = d;
x->narg[3] = e;
return (x);
}
Node *
! stat3(int a, Node *b, Node *c, Node *d)
{
! register Node *x;
! x = node3(a, b, c, d);
x->ntype = NSTAT;
return (x);
}
Node *
! op2(int a, Node *b, Node *c)
{
! register Node *x;
x = node2(a, b, c);
! x->ntype = NEXPR;
return (x);
}
Node *
! op1(int a, Node *b)
{
! register Node *x;
! x = node1(a, b);
! x->ntype = NEXPR;
return (x);
}
Node *
! stat1(int a, Node *b)
{
! register Node *x;
! x = node1(a, b);
x->ntype = NSTAT;
return (x);
}
Node *
! op3(int a, Node *b, Node *c, Node *d)
{
! register Node *x;
! x = node3(a, b, c, d);
x->ntype = NEXPR;
return (x);
}
Node *
! op4(int a, Node *b, Node *c, Node *d, Node *e)
{
! register Node *x;
! x = node4(a, b, c, d, e);
x->ntype = NEXPR;
return (x);
}
Node *
! stat2(int a, Node *b, Node *c)
{
! register Node *x;
! x = node2(a, b, c);
! x->ntype = NSTAT;
return (x);
}
Node *
! stat4(int a, Node *b, Node *c, Node *d, Node *e)
{
! register Node *x;
x = node4(a, b, c, d, e);
! x->ntype = NSTAT;
return (x);
}
! Node *
! valtonode(Cell *a, int b)
{
! register Node *x;
a->ctype = OCELL;
a->csub = b;
x = node1(0, (Node *)a);
x->ntype = NVALUE;
return (x);
}
! Node *
! rectonode(void)
{
! /* return valtonode(lookup("$0", symtab), CFLD); */
! return (valtonode(recloc, CFLD));
}
Node *
makearr(Node *p)
{
Cell *cp;
if (isvalue(p)) {
cp = (Cell *)(p->narg[0]);
! if (isfunc(cp))
! ERROR "%s is a function, not an array", cp->nval SYNTAX;
else if (!isarr(cp)) {
xfree(cp->sval);
cp->sval = (uchar *)makesymtab(NSYMTAB);
cp->tval = ARR;
}
}
return (p);
}
Node *
! pa2stat(Node *a, Node *b, Node *c)
{
! register Node *x;
! x = node4(PASTAT2, a, b, c, (Node *)paircnt);
! paircnt++;
x->ntype = NSTAT;
return (x);
}
Node *
linkum(Node *a, Node *b)
{
! register Node *c;
if (errorflag) /* don't link things that are wrong */
return (a);
if (a == NULL)
return (b);
--- 110,269 ----
}
Node *
node4(int a, Node *b, Node *c, Node *d, Node *e)
{
! Node *x;
x = nodealloc(4);
x->nobj = a;
x->narg[0] = b;
x->narg[1] = c;
x->narg[2] = d;
x->narg[3] = e;
return (x);
}
Node *
! stat1(int a, Node *b)
{
! Node *x;
! x = node1(a, b);
x->ntype = NSTAT;
return (x);
}
Node *
! stat2(int a, Node *b, Node *c)
{
! Node *x;
x = node2(a, b, c);
! x->ntype = NSTAT;
return (x);
}
Node *
! stat3(int a, Node *b, Node *c, Node *d)
{
! Node *x;
! x = node3(a, b, c, d);
! x->ntype = NSTAT;
return (x);
}
Node *
! stat4(int a, Node *b, Node *c, Node *d, Node *e)
{
! Node *x;
! x = node4(a, b, c, d, e);
x->ntype = NSTAT;
return (x);
}
Node *
! op1(int a, Node *b)
{
! Node *x;
! x = node1(a, b);
x->ntype = NEXPR;
return (x);
}
Node *
! op2(int a, Node *b, Node *c)
{
! Node *x;
! x = node2(a, b, c);
x->ntype = NEXPR;
return (x);
}
Node *
! op3(int a, Node *b, Node *c, Node *d)
{
! Node *x;
! x = node3(a, b, c, d);
! x->ntype = NEXPR;
return (x);
}
Node *
! op4(int a, Node *b, Node *c, Node *d, Node *e)
{
! Node *x;
x = node4(a, b, c, d, e);
! x->ntype = NEXPR;
return (x);
}
! Node
! *celltonode(Cell *a, int b)
{
! Node *x;
a->ctype = OCELL;
a->csub = b;
x = node1(0, (Node *)a);
x->ntype = NVALUE;
return (x);
}
! Node
! *rectonode(void) /* make $0 into a Node */
{
! extern Cell *literal0;
! return (op1(INDIRECT, celltonode(literal0, CUNK)));
}
Node *
makearr(Node *p)
{
Cell *cp;
if (isvalue(p)) {
cp = (Cell *)(p->narg[0]);
! if (isfcn(cp))
! SYNTAX("%s is a function, not an array", cp->nval);
else if (!isarr(cp)) {
xfree(cp->sval);
cp->sval = (uchar *)makesymtab(NSYMTAB);
cp->tval = ARR;
}
}
return (p);
}
+ /*
+ * The One True Awk sets PA2NUM to 50, which is not enough for webrev(1).
+ */
+ #define PA2NUM 250 /* max number of pat,pat patterns allowed */
+ int paircnt; /* number of them in use */
+ int pairstack[PA2NUM]; /* state of each pat,pat */
+
Node *
! pa2stat(Node *a, Node *b, Node *c) /* pat, pat {...} */
{
! Node *x;
! x = node4(PASTAT2, a, b, c, itonp(paircnt));
! if (paircnt++ >= PA2NUM)
! SYNTAX("limited to %d pat,pat statements", PA2NUM);
x->ntype = NSTAT;
return (x);
}
Node *
linkum(Node *a, Node *b)
{
! Node *c;
if (errorflag) /* don't link things that are wrong */
return (a);
if (a == NULL)
return (b);
*** 248,278 ****
return (a);
}
void
defn(Cell *v, Node *vl, Node *st) /* turn on FCN bit in definition */
! {
Node *p;
int n;
if (isarr(v)) {
! ERROR "`%s' is an array name and a function name",
! v->nval SYNTAX;
return;
}
v->tval = FCN;
v->sval = (uchar *)st;
n = 0; /* count arguments */
for (p = vl; p; p = p->nnext)
n++;
v->fval = n;
dprintf(("defining func %s (%d args)\n", v->nval, n));
}
int
! isarg(uchar *s) /* is s in argument list for current function? */
! {
extern Node *arglist;
Node *p = arglist;
int n;
for (n = 0; p != 0; p = p->nnext, n++) {
--- 275,311 ----
return (a);
}
void
defn(Cell *v, Node *vl, Node *st) /* turn on FCN bit in definition */
! { /* body of function, arglist */
Node *p;
int n;
if (isarr(v)) {
! SYNTAX("`%s' is an array name and a function name",
! v->nval);
return;
}
+ if (isarg(v->nval) != -1) {
+ SYNTAX("`%s' is both function name and argument name",
+ v->nval);
+ return;
+ }
+
v->tval = FCN;
v->sval = (uchar *)st;
n = 0; /* count arguments */
for (p = vl; p; p = p->nnext)
n++;
v->fval = n;
dprintf(("defining func %s (%d args)\n", v->nval, n));
}
int
! isarg(const uchar *s) /* is s in argument list for current function? */
! { /* return -1 if not, otherwise arg # */
extern Node *arglist;
Node *p = arglist;
int n;
for (n = 0; p != 0; p = p->nnext, n++) {
*** 281,285 ****
--- 314,330 ----
return (n);
}
}
return (-1);
}
+
+ int
+ ptoi(void *p) /* convert pointer to integer */
+ {
+ return ((int)(long)p); /* swearing that p fits, of course */
+ }
+
+ Node
+ *itonp(int i) /* and vice versa */
+ {
+ return ((Node *)(long)i);
+ }