![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to awk4.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / awk|
Return to awk4.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / awk |
1.1 root 1: /*
2: * AWK - Common support routines.
3: * node allocation, etc.
4: */
5:
6: #include "awk.h"
7: #include "y.tab.h"
8:
9: static int eosflag; /* for pgetc/pungetc */
10:
11: /*
12: * Allocate n bytes of
13: * storage, checking for
14: * running out of space.
15: * This version doesn't call malloc, but
16: * rather uses sbrk and doles out storage
17: * itself. This sames much time for
18: * searching long alloc lists. However,
19: * i/o calls must all be buffered staticly.
20: * A call with 0 bytes returns the pointer to
21: * the end which can be saved for a call to xfree.
22: * The following are 2 pointers maintained by the allocator/xfree.
23: */
24: static int *xallrp; /* Running pointer for xalloc */
25: static int *xallep; /* End pointer for xfree */
26: CHAR *
27: xalloc(size)
28: register unsigned size;
29: {
30: register int *rp;
31:
32: if ((rp = (int *)malloc(size)) == NULL)
33: awkerr("Out of memory");
34: return ((CHAR *)rp);
35: }
36:
37: /*
38: * Create an expression tree node.
39: * The only required argument is the
40: * operation code. The other three
41: * are operands.
42: */
43: /* VARARGS 1 */
44: NODE *
45: node(op, o1, o2, o3, o4)
46: int op;
47: NODE *o1, *o2, *o3, *o4;
48: {
49: register NODE *np;
50:
51: np = (NODE *)xalloc(sizeof (NODE));
52: np->n_op = op;
53: np->n_flag = 0;
54: np->n_O1 = o1;
55: np->n_O2 = o2;
56: np->n_O3 = o3;
57: np->n_O4 = o4;
58: return (np);
59: }
60:
61: /*
62: * Produce a node with a character (int)
63: * int it (mostly for regular expressions).
64: */
65: NODE *
66: cnode(op, c)
67: int op, c;
68: {
69: register NODE *np;
70:
71: np = (NODE *)xalloc(sizeof (NODE));
72: np->n_op = op;
73: np->n_flag = 0;
74: np->n_o1.n_char = c;
75: np->n_O2 = np->n_O3 = np->n_O4 = NULL;
76: return (np);
77: }
78:
79: /*
80: * Produce a string node.
81: * While running, this node
82: * is considered temporary.
83: */
84: NODE *
85: snode(s, type)
86: register CHAR *s;
87: int type;
88: {
89: register NODE *np;
90:
91: np = (NODE *)xalloc(sizeof(TERM));
92: np->t_op = ATERM;
93: np->t_flag = type;
94: np->t_un.t_str = s;
95: if (runflag) {
96: np->t_next = tempnodes;
97: tempnodes = np;
98: }
99: return (np);
100: }
101:
102: /*
103: * Build a node for a (long)
104: * integer.
105: */
106: NODE *
107: inode(i)
108: INT i;
109: {
110: register NODE *np;
111:
112: np = (NODE *)xalloc(sizeof(NODE));
113: np->t_op = ATERM;
114: np->t_flag = T_NUM|T_INT;
115: np->t_un.t_int = i;
116: if (runflag) {
117: np->t_next = tempnodes;
118: tempnodes = np;
119: }
120: return (np);
121: }
122:
123: /*
124: * Build a node for a (double)
125: * floating point number.
126: */
127: NODE *
128: fnode(f)
129: FLOAT f;
130: {
131: register NODE *np;
132:
133: np = (NODE *)xalloc(sizeof(NODE));
134: np->t_op = ATERM;
135: np->t_flag = T_NUM;
136: np->t_un.t_float = f;
137: if (runflag) {
138: np->t_next = tempnodes;
139: tempnodes = np;
140: }
141: return (np);
142: }
143:
144: /*
145: * Free a terminal node. This
146: * looks at the flags to see if
147: * it is a string, and frees it if
148: * it is also an allocated string.
149: */
150: freenode(np)
151: register NODE *np;
152: {
153: if ((np->t_flag&(T_NUM|T_ALLOC)) == T_ALLOC)
154: free(np->t_STRING);
155: free(np);
156: }
157:
158: /*
159: * Checks to see if a node is numeric.
160: * Here it must be not in string form
161: * but in number form. This is
162: * used mostly for comparisons.
163: */
164: isnumeric(np)
165: register NODE *np;
166: {
167: if (np->t_flag & T_NUM)
168: return (1);
169: return (0);
170: }
171:
172: /*
173: * Return 1 if a number is of the floating
174: * type. This will check strings as well
175: * as numbers.
176: */
177: isfloat(np)
178: register NODE *np;
179: {
180: register CHAR *cp;
181: register int isfloat = 0, sawDigit = 0;
182:
183: if (np->t_flag & T_NUM)
184: return (!(np->t_flag & T_INT));
185:
186: for (cp = np->t_STRING;;cp++) {
187: switch (*cp) {
188: case 0:
189: return (isfloat);
190: case 'e':
191: case 'E':
192: if (!sawDigit)
193: return (0);
194: case '.':
195: sawDigit = isfloat = 1;
196: break;
197: case ' ':
198: case '\t':
199: if (sawDigit)
200: return (0);
201: break;
202: default:
203: if (isdigit(*cp) || '-' == *cp) {
204: sawDigit = 1;
205: break;
206: }
207: return (0);
208: }
209: }
210: }
211:
212: /*
213: * Fetch a character from
214: * the program, either on
215: * the command line or in a file.
216: */
217: pgetc()
218: {
219: register int c;
220:
221: if (parg != NULL) {
222: if (eosflag)
223: return (EOF);
224: else if ((c = *parg++) == '\0') {
225: eosflag = 1;
226: return ('\n');
227: }
228: } else {
229: while ((c = getc(pfp)) == '\\') {
230: if ((c = getc(pfp)) != '\n') {
231: ungetc(c, pfp);
232: return ('\\');
233: }
234: /* bypass \ newline */
235: if (lineno == 0)
236: lineno++;
237: lineno++;
238: }
239: }
240: if (c == '\n') {
241: if (lineno == 0)
242: lineno++;
243: lineno++;
244: }
245: return (c);
246: }
247:
248: /*
249: * Set up a new string for the
250: * lexical analyser to read.
251: */
252: pgetinit(s)
253: CHAR *s;
254: {
255: parg = s;
256: eosflag = 0;
257: lineno = 0;
258: }
259:
260: /*
261: * Return a character to the
262: * program input.
263: */
264: pungetc(c)
265: int c;
266: {
267: if (parg != NULL) {
268: if (eosflag)
269: c = '\0';
270: *--parg = c;
271: eosflag = 0;
272: } else
273: ungetc(c, pfp);
274: if (c == '\n')
275: --lineno;
276: }
277:
278: /*
279: * Error routines and usage
280: * messages.
281: */
282: usage()
283: {
284: fprintf(stderr,
285: "Usage: awk [-y] [-Fc] [-f prog] [parameters] [prog] [file ...]\n");
286: exit(1);
287: }
288:
289: /* VARARGS */
290: awkerr(x)
291: {
292: fprintf(stderr, "awk: ");
293: if (FILENAME[0] != '\0')
294: fprintf(stderr, "%s: ", FILENAME);
295: if (lineno != 0)
296: fprintf(stderr, "%d: ", lineno);
297: fprintf(stderr, "%r", &x);
298: putc('\n', stderr);
299: exit(1);
300: }
301:
302: /* VARARGS */
303: awkwarn(x)
304: {
305: fprintf(stderr, "awk: ");
306: if (FILENAME[0] != '\0')
307: fprintf(stderr, "%s: ", FILENAME);
308: if (lineno != 0)
309: fprintf(stderr, "%d: ", lineno);
310: fprintf(stderr, "Warning: %r", &x);
311: putc('\n', stderr);
312: }
313:
314: /* VARARGS */
315: yyerror(x)
316: {
317: awkerr(x);
318: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.