?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
busybox: update to 1.23.2
[tomato.git] / release / src / router / busybox / editors / awk.c
blobf487163af731e3b26d0cb7fca3601ff94200bd93
1 /* vi: set sw=4 ts=4: */
2 /*
3 * awk implementation for busybox
4 *
5 * Copyright (C) 2002 by Dmitry Zakharov <dmit@crp.bank.gov.ua>
6 *
7 * Licensed under GPLv2 or later, see file LICENSE in this source tree.
8 */
9
10 //config:config AWK
11 //config: bool "awk"
12 //config: default y
13 //config: help
14 //config: Awk is used as a pattern scanning and processing language. This is
15 //config: the BusyBox implementation of that programming language.
16 //config:
17 //config:config FEATURE_AWK_LIBM
18 //config: bool "Enable math functions (requires libm)"
19 //config: default y
20 //config: depends on AWK
21 //config: help
22 //config: Enable math functions of the Awk programming language.
23 //config: NOTE: This will require libm to be present for linking.
24 //config:
25 //config:config FEATURE_AWK_GNU_EXTENSIONS
26 //config: bool "Enable a few GNU extensions"
27 //config: default y
28 //config: depends on AWK
29 //config: help
30 //config: Enable a few features from gawk:
31 //config: * command line option -e AWK_PROGRAM
32 //config: * simultaneous use of -f and -e on the command line.
33 //config: This enables the use of awk library files.
34 //config: Ex: awk -f mylib.awk -e '{print myfunction($1);}' ...
35
36 //applet:IF_AWK(APPLET_NOEXEC(awk, awk, BB_DIR_USR_BIN, BB_SUID_DROP, awk))
37
38 //kbuild:lib-$(CONFIG_AWK) += awk.o
39
40 //usage:#define awk_trivial_usage
41 //usage: "[OPTIONS] [AWK_PROGRAM] [FILE]..."
42 //usage:#define awk_full_usage "\n\n"
43 //usage: " -v VAR=VAL Set variable"
44 //usage: "\n -F SEP Use SEP as field separator"
45 //usage: "\n -f FILE Read program from FILE"
46 //usage: IF_FEATURE_AWK_GNU_EXTENSIONS(
47 //usage: "\n -e AWK_PROGRAM"
48 //usage: )
49
50 #include "libbb.h"
51 #include "xregex.h"
52 #include <math.h>
53
54 /* This is a NOEXEC applet. Be very careful! */
55
56
57 /* If you comment out one of these below, it will be #defined later
58 * to perform debug printfs to stderr: */
59 #define debug_printf_walker(...) do {} while (0)
60 #define debug_printf_eval(...) do {} while (0)
61 #define debug_printf_parse(...) do {} while (0)
62
63 #ifndef debug_printf_walker
64 # define debug_printf_walker(...) (fprintf(stderr, __VA_ARGS__))
65 #endif
66 #ifndef debug_printf_eval
67 # define debug_printf_eval(...) (fprintf(stderr, __VA_ARGS__))
68 #endif
69 #ifndef debug_printf_parse
70 # define debug_printf_parse(...) (fprintf(stderr, __VA_ARGS__))
71 #endif
72
73
74 #define OPTSTR_AWK \
75 "F:v:f:" \
76 IF_FEATURE_AWK_GNU_EXTENSIONS("e:") \
77 "W:"
78 #define OPTCOMPLSTR_AWK \
79 "v::f::" \
80 IF_FEATURE_AWK_GNU_EXTENSIONS("e::")
81 enum {
82 OPTBIT_F, /* define field separator */
83 OPTBIT_v, /* define variable */
84 OPTBIT_f, /* pull in awk program from file */
85 IF_FEATURE_AWK_GNU_EXTENSIONS(OPTBIT_e,) /* -e AWK_PROGRAM */
86 OPTBIT_W, /* -W ignored */
87 OPT_F = 1 << OPTBIT_F,
88 OPT_v = 1 << OPTBIT_v,
89 OPT_f = 1 << OPTBIT_f,
90 OPT_e = IF_FEATURE_AWK_GNU_EXTENSIONS((1 << OPTBIT_e)) + 0,
91 OPT_W = 1 << OPTBIT_W
92 };
93
94 #define MAXVARFMT 240
95 #define MINNVBLOCK 64
96
97 /* variable flags */
98 #define VF_NUMBER 0x0001 /* 1 = primary type is number */
99 #define VF_ARRAY 0x0002 /* 1 = it's an array */
100
101 #define VF_CACHED 0x0100 /* 1 = num/str value has cached str/num eq */
102 #define VF_USER 0x0200 /* 1 = user input (may be numeric string) */
103 #define VF_SPECIAL 0x0400 /* 1 = requires extra handling when changed */
104 #define VF_WALK 0x0800 /* 1 = variable has alloc'd x.walker list */
105 #define VF_FSTR 0x1000 /* 1 = var::string points to fstring buffer */
106 #define VF_CHILD 0x2000 /* 1 = function arg; x.parent points to source */
107 #define VF_DIRTY 0x4000 /* 1 = variable was set explicitly */
108
109 /* these flags are static, don't change them when value is changed */
110 #define VF_DONTTOUCH (VF_ARRAY | VF_SPECIAL | VF_WALK | VF_CHILD | VF_DIRTY)
111
112 typedef struct walker_list {
113 char *end;
114 char *cur;
115 struct walker_list *prev;
116 char wbuf[1];
117 } walker_list;
118
119 /* Variable */
120 typedef struct var_s {
121 unsigned type; /* flags */
122 double number;
123 char *string;
124 union {
125 int aidx; /* func arg idx (for compilation stage) */
126 struct xhash_s *array; /* array ptr */
127 struct var_s *parent; /* for func args, ptr to actual parameter */
128 walker_list *walker; /* list of array elements (for..in) */
129 } x;
130 } var;
131
132 /* Node chain (pattern-action chain, BEGIN, END, function bodies) */
133 typedef struct chain_s {
134 struct node_s *first;
135 struct node_s *last;
136 const char *programname;
137 } chain;
138
139 /* Function */
140 typedef struct func_s {
141 unsigned nargs;
142 struct chain_s body;
143 } func;
144
145 /* I/O stream */
146 typedef struct rstream_s {
147 FILE *F;
148 char *buffer;
149 int adv;
150 int size;
151 int pos;
152 smallint is_pipe;
153 } rstream;
154
155 typedef struct hash_item_s {
156 union {
157 struct var_s v; /* variable/array hash */
158 struct rstream_s rs; /* redirect streams hash */
159 struct func_s f; /* functions hash */
160 } data;
161 struct hash_item_s *next; /* next in chain */
162 char name[1]; /* really it's longer */
163 } hash_item;
164
165 typedef struct xhash_s {
166 unsigned nel; /* num of elements */
167 unsigned csize; /* current hash size */
168 unsigned nprime; /* next hash size in PRIMES[] */
169 unsigned glen; /* summary length of item names */
170 struct hash_item_s **items;
171 } xhash;
172
173 /* Tree node */
174 typedef struct node_s {
175 uint32_t info;
176 unsigned lineno;
177 union {
178 struct node_s *n;
179 var *v;
180 int aidx;
181 char *new_progname;
182 regex_t *re;
183 } l;
184 union {
185 struct node_s *n;
186 regex_t *ire;
187 func *f;
188 } r;
189 union {
190 struct node_s *n;
191 } a;
192 } node;
193
194 /* Block of temporary variables */
195 typedef struct nvblock_s {
196 int size;
197 var *pos;
198 struct nvblock_s *prev;
199 struct nvblock_s *next;
200 var nv[];
201 } nvblock;
202
203 typedef struct tsplitter_s {
204 node n;
205 regex_t re[2];
206 } tsplitter;
207
208 /* simple token classes */
209 /* Order and hex values are very important!!! See next_token() */
210 #define TC_SEQSTART 1 /* ( */
211 #define TC_SEQTERM (1 << 1) /* ) */
212 #define TC_REGEXP (1 << 2) /* /.../ */
213 #define TC_OUTRDR (1 << 3) /* | > >> */
214 #define TC_UOPPOST (1 << 4) /* unary postfix operator */
215 #define TC_UOPPRE1 (1 << 5) /* unary prefix operator */
216 #define TC_BINOPX (1 << 6) /* two-opnd operator */
217 #define TC_IN (1 << 7)
218 #define TC_COMMA (1 << 8)
219 #define TC_PIPE (1 << 9) /* input redirection pipe */
220 #define TC_UOPPRE2 (1 << 10) /* unary prefix operator */
221 #define TC_ARRTERM (1 << 11) /* ] */
222 #define TC_GRPSTART (1 << 12) /* { */
223 #define TC_GRPTERM (1 << 13) /* } */
224 #define TC_SEMICOL (1 << 14)
225 #define TC_NEWLINE (1 << 15)
226 #define TC_STATX (1 << 16) /* ctl statement (for, next...) */
227 #define TC_WHILE (1 << 17)
228 #define TC_ELSE (1 << 18)
229 #define TC_BUILTIN (1 << 19)
230 #define TC_GETLINE (1 << 20)
231 #define TC_FUNCDECL (1 << 21) /* `function' `func' */
232 #define TC_BEGIN (1 << 22)
233 #define TC_END (1 << 23)
234 #define TC_EOF (1 << 24)
235 #define TC_VARIABLE (1 << 25)
236 #define TC_ARRAY (1 << 26)
237 #define TC_FUNCTION (1 << 27)
238 #define TC_STRING (1 << 28)
239 #define TC_NUMBER (1 << 29)
240
241 #define TC_UOPPRE (TC_UOPPRE1 | TC_UOPPRE2)
242
243 /* combined token classes */
244 #define TC_BINOP (TC_BINOPX | TC_COMMA | TC_PIPE | TC_IN)
245 //#define TC_UNARYOP (TC_UOPPRE | TC_UOPPOST)
246 #define TC_OPERAND (TC_VARIABLE | TC_ARRAY | TC_FUNCTION \
247 | TC_BUILTIN | TC_GETLINE | TC_SEQSTART | TC_STRING | TC_NUMBER)
248
249 #define TC_STATEMNT (TC_STATX | TC_WHILE)
250 #define TC_OPTERM (TC_SEMICOL | TC_NEWLINE)
251
252 /* word tokens, cannot mean something else if not expected */
253 #define TC_WORD (TC_IN | TC_STATEMNT | TC_ELSE | TC_BUILTIN \
254 | TC_GETLINE | TC_FUNCDECL | TC_BEGIN | TC_END)
255
256 /* discard newlines after these */
257 #define TC_NOTERM (TC_COMMA | TC_GRPSTART | TC_GRPTERM \
258 | TC_BINOP | TC_OPTERM)
259
260 /* what can expression begin with */
261 #define TC_OPSEQ (TC_OPERAND | TC_UOPPRE | TC_REGEXP)
262 /* what can group begin with */
263 #define TC_GRPSEQ (TC_OPSEQ | TC_OPTERM | TC_STATEMNT | TC_GRPSTART)
264
265 /* if previous token class is CONCAT1 and next is CONCAT2, concatenation */
266 /* operator is inserted between them */
267 #define TC_CONCAT1 (TC_VARIABLE | TC_ARRTERM | TC_SEQTERM \
268 | TC_STRING | TC_NUMBER | TC_UOPPOST)
269 #define TC_CONCAT2 (TC_OPERAND | TC_UOPPRE)
270
271 #define OF_RES1 0x010000
272 #define OF_RES2 0x020000
273 #define OF_STR1 0x040000
274 #define OF_STR2 0x080000
275 #define OF_NUM1 0x100000
276 #define OF_CHECKED 0x200000
277
278 /* combined operator flags */
279 #define xx 0
280 #define xV OF_RES2
281 #define xS (OF_RES2 | OF_STR2)
282 #define Vx OF_RES1
283 #define VV (OF_RES1 | OF_RES2)
284 #define Nx (OF_RES1 | OF_NUM1)
285 #define NV (OF_RES1 | OF_NUM1 | OF_RES2)
286 #define Sx (OF_RES1 | OF_STR1)
287 #define SV (OF_RES1 | OF_STR1 | OF_RES2)
288 #define SS (OF_RES1 | OF_STR1 | OF_RES2 | OF_STR2)
289
290 #define OPCLSMASK 0xFF00
291 #define OPNMASK 0x007F
292
293 /* operator priority is a highest byte (even: r->l, odd: l->r grouping)
294 * For builtins it has different meaning: n n s3 s2 s1 v3 v2 v1,
295 * n - min. number of args, vN - resolve Nth arg to var, sN - resolve to string
296 */
297 #undef P
298 #undef PRIMASK
299 #undef PRIMASK2
300 #define P(x) (x << 24)
301 #define PRIMASK 0x7F000000
302 #define PRIMASK2 0x7E000000
303
304 /* Operation classes */
305
306 #define SHIFT_TIL_THIS 0x0600
307 #define RECUR_FROM_THIS 0x1000
308
309 enum {
310 OC_DELETE = 0x0100, OC_EXEC = 0x0200, OC_NEWSOURCE = 0x0300,
311 OC_PRINT = 0x0400, OC_PRINTF = 0x0500, OC_WALKINIT = 0x0600,
312
313 OC_BR = 0x0700, OC_BREAK = 0x0800, OC_CONTINUE = 0x0900,
314 OC_EXIT = 0x0a00, OC_NEXT = 0x0b00, OC_NEXTFILE = 0x0c00,
315 OC_TEST = 0x0d00, OC_WALKNEXT = 0x0e00,
316
317 OC_BINARY = 0x1000, OC_BUILTIN = 0x1100, OC_COLON = 0x1200,
318 OC_COMMA = 0x1300, OC_COMPARE = 0x1400, OC_CONCAT = 0x1500,
319 OC_FBLTIN = 0x1600, OC_FIELD = 0x1700, OC_FNARG = 0x1800,
320 OC_FUNC = 0x1900, OC_GETLINE = 0x1a00, OC_IN = 0x1b00,
321 OC_LAND = 0x1c00, OC_LOR = 0x1d00, OC_MATCH = 0x1e00,
322 OC_MOVE = 0x1f00, OC_PGETLINE = 0x2000, OC_REGEXP = 0x2100,
323 OC_REPLACE = 0x2200, OC_RETURN = 0x2300, OC_SPRINTF = 0x2400,
324 OC_TERNARY = 0x2500, OC_UNARY = 0x2600, OC_VAR = 0x2700,
325 OC_DONE = 0x2800,
326
327 ST_IF = 0x3000, ST_DO = 0x3100, ST_FOR = 0x3200,
328 ST_WHILE = 0x3300
329 };
330
331 /* simple builtins */
332 enum {
333 F_in, F_rn, F_co, F_ex, F_lg, F_si, F_sq, F_sr,
334 F_ti, F_le, F_sy, F_ff, F_cl
335 };
336
337 /* builtins */
338 enum {
339 B_a2, B_ix, B_ma, B_sp, B_ss, B_ti, B_mt, B_lo, B_up,
340 B_ge, B_gs, B_su,
341 B_an, B_co, B_ls, B_or, B_rs, B_xo,
342 };
343
344 /* tokens and their corresponding info values */
345
346 #define NTC "\377" /* switch to next token class (tc<<1) */
347 #define NTCC '\377'
348
349 #define OC_B OC_BUILTIN
350
351 static const char tokenlist[] ALIGN1 =
352 "\1(" NTC
353 "\1)" NTC
354 "\1/" NTC /* REGEXP */
355 "\2>>" "\1>" "\1|" NTC /* OUTRDR */
356 "\2++" "\2--" NTC /* UOPPOST */
357 "\2++" "\2--" "\1$" NTC /* UOPPRE1 */
358 "\2==" "\1=" "\2+=" "\2-=" /* BINOPX */
359 "\2*=" "\2/=" "\2%=" "\2^="
360 "\1+" "\1-" "\3**=" "\2**"
361 "\1/" "\1%" "\1^" "\1*"
362 "\2!=" "\2>=" "\2<=" "\1>"
363 "\1<" "\2!~" "\1~" "\2&&"
364 "\2||" "\1?" "\1:" NTC
365 "\2in" NTC
366 "\1," NTC
367 "\1|" NTC
368 "\1+" "\1-" "\1!" NTC /* UOPPRE2 */
369 "\1]" NTC
370 "\1{" NTC
371 "\1}" NTC
372 "\1;" NTC
373 "\1\n" NTC
374 "\2if" "\2do" "\3for" "\5break" /* STATX */
375 "\10continue" "\6delete" "\5print"
376 "\6printf" "\4next" "\10nextfile"
377 "\6return" "\4exit" NTC
378 "\5while" NTC
379 "\4else" NTC
380
381 "\3and" "\5compl" "\6lshift" "\2or"
382 "\6rshift" "\3xor"
383 "\5close" "\6system" "\6fflush" "\5atan2" /* BUILTIN */
384 "\3cos" "\3exp" "\3int" "\3log"
385 "\4rand" "\3sin" "\4sqrt" "\5srand"
386 "\6gensub" "\4gsub" "\5index" "\6length"
387 "\5match" "\5split" "\7sprintf" "\3sub"
388 "\6substr" "\7systime" "\10strftime" "\6mktime"
389 "\7tolower" "\7toupper" NTC
390 "\7getline" NTC
391 "\4func" "\10function" NTC
392 "\5BEGIN" NTC
393 "\3END"
394 /* compiler adds trailing "\0" */
395 ;
396
397 static const uint32_t tokeninfo[] = {
398 0,
399 0,
400 OC_REGEXP,
401 xS|'a', xS|'w', xS|'|',
402 OC_UNARY|xV|P(9)|'p', OC_UNARY|xV|P(9)|'m',
403 OC_UNARY|xV|P(9)|'P', OC_UNARY|xV|P(9)|'M', OC_FIELD|xV|P(5),
404 OC_COMPARE|VV|P(39)|5, OC_MOVE|VV|P(74), OC_REPLACE|NV|P(74)|'+', OC_REPLACE|NV|P(74)|'-',
405 OC_REPLACE|NV|P(74)|'*', OC_REPLACE|NV|P(74)|'/', OC_REPLACE|NV|P(74)|'%', OC_REPLACE|NV|P(74)|'&',
406 OC_BINARY|NV|P(29)|'+', OC_BINARY|NV|P(29)|'-', OC_REPLACE|NV|P(74)|'&', OC_BINARY|NV|P(15)|'&',
407 OC_BINARY|NV|P(25)|'/', OC_BINARY|NV|P(25)|'%', OC_BINARY|NV|P(15)|'&', OC_BINARY|NV|P(25)|'*',
408 OC_COMPARE|VV|P(39)|4, OC_COMPARE|VV|P(39)|3, OC_COMPARE|VV|P(39)|0, OC_COMPARE|VV|P(39)|1,
409 OC_COMPARE|VV|P(39)|2, OC_MATCH|Sx|P(45)|'!', OC_MATCH|Sx|P(45)|'~', OC_LAND|Vx|P(55),
410 OC_LOR|Vx|P(59), OC_TERNARY|Vx|P(64)|'?', OC_COLON|xx|P(67)|':',
411 OC_IN|SV|P(49), /* in */
412 OC_COMMA|SS|P(80),
413 OC_PGETLINE|SV|P(37),
414 OC_UNARY|xV|P(19)|'+', OC_UNARY|xV|P(19)|'-', OC_UNARY|xV|P(19)|'!',
415 0, /* ] */
416 0,
417 0,
418 0,
419 0, /* \n */
420 ST_IF, ST_DO, ST_FOR, OC_BREAK,
421 OC_CONTINUE, OC_DELETE|Vx, OC_PRINT,
422 OC_PRINTF, OC_NEXT, OC_NEXTFILE,
423 OC_RETURN|Vx, OC_EXIT|Nx,
424 ST_WHILE,
425 0, /* else */
426
427 OC_B|B_an|P(0x83), OC_B|B_co|P(0x41), OC_B|B_ls|P(0x83), OC_B|B_or|P(0x83),
428 OC_B|B_rs|P(0x83), OC_B|B_xo|P(0x83),
429 OC_FBLTIN|Sx|F_cl, OC_FBLTIN|Sx|F_sy, OC_FBLTIN|Sx|F_ff, OC_B|B_a2|P(0x83),
430 OC_FBLTIN|Nx|F_co, OC_FBLTIN|Nx|F_ex, OC_FBLTIN|Nx|F_in, OC_FBLTIN|Nx|F_lg,
431 OC_FBLTIN|F_rn, OC_FBLTIN|Nx|F_si, OC_FBLTIN|Nx|F_sq, OC_FBLTIN|Nx|F_sr,
432 OC_B|B_ge|P(0xd6), OC_B|B_gs|P(0xb6), OC_B|B_ix|P(0x9b), OC_FBLTIN|Sx|F_le,
433 OC_B|B_ma|P(0x89), OC_B|B_sp|P(0x8b), OC_SPRINTF, OC_B|B_su|P(0xb6),
434 OC_B|B_ss|P(0x8f), OC_FBLTIN|F_ti, OC_B|B_ti|P(0x0b), OC_B|B_mt|P(0x0b),
435 OC_B|B_lo|P(0x49), OC_B|B_up|P(0x49),
436 OC_GETLINE|SV|P(0),
437 0, 0,
438 0,
439 0 /* END */
440 };
441
442 /* internal variable names and their initial values */
443 /* asterisk marks SPECIAL vars; $ is just no-named Field0 */
444 enum {
445 CONVFMT, OFMT, FS, OFS,
446 ORS, RS, RT, FILENAME,
447 SUBSEP, F0, ARGIND, ARGC,
448 ARGV, ERRNO, FNR, NR,
449 NF, IGNORECASE, ENVIRON, NUM_INTERNAL_VARS
450 };
451
452 static const char vNames[] ALIGN1 =
453 "CONVFMT\0" "OFMT\0" "FS\0*" "OFS\0"
454 "ORS\0" "RS\0*" "RT\0" "FILENAME\0"
455 "SUBSEP\0" "$\0*" "ARGIND\0" "ARGC\0"
456 "ARGV\0" "ERRNO\0" "FNR\0" "NR\0"
457 "NF\0*" "IGNORECASE\0*" "ENVIRON\0" "\0";
458
459 static const char vValues[] ALIGN1 =
460 "%.6g\0" "%.6g\0" " \0" " \0"
461 "\n\0" "\n\0" "\0" "\0"
462 "\034\0" "\0" "\377";
463
464 /* hash size may grow to these values */
465 #define FIRST_PRIME 61
466 static const uint16_t PRIMES[] ALIGN2 = { 251, 1021, 4093, 16381, 65521 };
467
468
469 /* Globals. Split in two parts so that first one is addressed
470 * with (mostly short) negative offsets.
471 * NB: it's unsafe to put members of type "double"
472 * into globals2 (gcc may fail to align them).
473 */
474 struct globals {
475 double t_double;
476 chain beginseq, mainseq, endseq;
477 chain *seq;
478 node *break_ptr, *continue_ptr;
479 rstream *iF;
480 xhash *vhash, *ahash, *fdhash, *fnhash;
481 const char *g_progname;
482 int g_lineno;
483 int nfields;
484 int maxfields; /* used in fsrealloc() only */
485 var *Fields;
486 nvblock *g_cb;
487 char *g_pos;
488 char *g_buf;
489 smallint icase;
490 smallint exiting;
491 smallint nextrec;
492 smallint nextfile;
493 smallint is_f0_split;
494 smallint t_rollback;
495 };
496 struct globals2 {
497 uint32_t t_info; /* often used */
498 uint32_t t_tclass;
499 char *t_string;
500 int t_lineno;
501
502 var *intvar[NUM_INTERNAL_VARS]; /* often used */
503
504 /* former statics from various functions */
505 char *split_f0__fstrings;
506
507 uint32_t next_token__save_tclass;
508 uint32_t next_token__save_info;
509 uint32_t next_token__ltclass;
510 smallint next_token__concat_inserted;
511
512 smallint next_input_file__files_happen;
513 rstream next_input_file__rsm;
514
515 var *evaluate__fnargs;
516 unsigned evaluate__seed;
517 regex_t evaluate__sreg;
518
519 var ptest__v;
520
521 tsplitter exec_builtin__tspl;
522
523 /* biggest and least used members go last */
524 tsplitter fsplitter, rsplitter;
525 };
526 #define G1 (ptr_to_globals[-1])
527 #define G (*(struct globals2 *)ptr_to_globals)
528 /* For debug. nm --size-sort awk.o | grep -vi ' [tr] ' */
529 /*char G1size[sizeof(G1)]; - 0x74 */
530 /*char Gsize[sizeof(G)]; - 0x1c4 */
531 /* Trying to keep most of members accessible with short offsets: */
532 /*char Gofs_seed[offsetof(struct globals2, evaluate__seed)]; - 0x90 */
533 #define t_double (G1.t_double )
534 #define beginseq (G1.beginseq )
535 #define mainseq (G1.mainseq )
536 #define endseq (G1.endseq )
537 #define seq (G1.seq )
538 #define break_ptr (G1.break_ptr )
539 #define continue_ptr (G1.continue_ptr)
540 #define iF (G1.iF )
541 #define vhash (G1.vhash )
542 #define ahash (G1.ahash )
543 #define fdhash (G1.fdhash )
544 #define fnhash (G1.fnhash )
545 #define g_progname (G1.g_progname )
546 #define g_lineno (G1.g_lineno )
547 #define nfields (G1.nfields )
548 #define maxfields (G1.maxfields )
549 #define Fields (G1.Fields )
550 #define g_cb (G1.g_cb )
551 #define g_pos (G1.g_pos )
552 #define g_buf (G1.g_buf )
553 #define icase (G1.icase )
554 #define exiting (G1.exiting )
555 #define nextrec (G1.nextrec )
556 #define nextfile (G1.nextfile )
557 #define is_f0_split (G1.is_f0_split )
558 #define t_rollback (G1.t_rollback )
559 #define t_info (G.t_info )
560 #define t_tclass (G.t_tclass )
561 #define t_string (G.t_string )
562 #define t_lineno (G.t_lineno )
563 #define intvar (G.intvar )
564 #define fsplitter (G.fsplitter )
565 #define rsplitter (G.rsplitter )
566 #define INIT_G() do { \
567 SET_PTR_TO_GLOBALS((char*)xzalloc(sizeof(G1)+sizeof(G)) + sizeof(G1)); \
568 G.next_token__ltclass = TC_OPTERM; \
569 G.evaluate__seed = 1; \
570 } while (0)
571
572
573 /* function prototypes */
574 static void handle_special(var *);
575 static node *parse_expr(uint32_t);
576 static void chain_group(void);
577 static var *evaluate(node *, var *);
578 static rstream *next_input_file(void);
579 static int fmt_num(char *, int, const char *, double, int);
580 static int awk_exit(int) NORETURN;
581
582 /* ---- error handling ---- */
583
584 static const char EMSG_INTERNAL_ERROR[] ALIGN1 = "Internal error";
585 static const char EMSG_UNEXP_EOS[] ALIGN1 = "Unexpected end of string";
586 static const char EMSG_UNEXP_TOKEN[] ALIGN1 = "Unexpected token";
587 static const char EMSG_DIV_BY_ZERO[] ALIGN1 = "Division by zero";
588 static const char EMSG_INV_FMT[] ALIGN1 = "Invalid format specifier";
589 static const char EMSG_TOO_FEW_ARGS[] ALIGN1 = "Too few arguments for builtin";
590 static const char EMSG_NOT_ARRAY[] ALIGN1 = "Not an array";
591 static const char EMSG_POSSIBLE_ERROR[] ALIGN1 = "Possible syntax error";
592 static const char EMSG_UNDEF_FUNC[] ALIGN1 = "Call to undefined function";
593 static const char EMSG_NO_MATH[] ALIGN1 = "Math support is not compiled in";
594
595 static void zero_out_var(var *vp)
596 {
597 memset(vp, 0, sizeof(*vp));
598 }
599
600 static void syntax_error(const char *message) NORETURN;
601 static void syntax_error(const char *message)
602 {
603 bb_error_msg_and_die("%s:%i: %s", g_progname, g_lineno, message);
604 }
605
606 /* ---- hash stuff ---- */
607
608 static unsigned hashidx(const char *name)
609 {
610 unsigned idx = 0;
611
612 while (*name)
613 idx = *name++ + (idx << 6) - idx;
614 return idx;
615 }
616
617 /* create new hash */
618 static xhash *hash_init(void)
619 {
620 xhash *newhash;
621
622 newhash = xzalloc(sizeof(*newhash));
623 newhash->csize = FIRST_PRIME;
624 newhash->items = xzalloc(FIRST_PRIME * sizeof(newhash->items[0]));
625
626 return newhash;
627 }
628
629 /* find item in hash, return ptr to data, NULL if not found */
630 static void *hash_search(xhash *hash, const char *name)
631 {
632 hash_item *hi;
633
634 hi = hash->items[hashidx(name) % hash->csize];
635 while (hi) {
636 if (strcmp(hi->name, name) == 0)
637 return &hi->data;
638 hi = hi->next;
639 }
640 return NULL;
641 }
642
643 /* grow hash if it becomes too big */
644 static void hash_rebuild(xhash *hash)
645 {
646 unsigned newsize, i, idx;
647 hash_item **newitems, *hi, *thi;
648
649 if (hash->nprime == ARRAY_SIZE(PRIMES))
650 return;
651
652 newsize = PRIMES[hash->nprime++];
653 newitems = xzalloc(newsize * sizeof(newitems[0]));
654
655 for (i = 0; i < hash->csize; i++) {
656 hi = hash->items[i];
657 while (hi) {
658 thi = hi;
659 hi = thi->next;
660 idx = hashidx(thi->name) % newsize;
661 thi->next = newitems[idx];
662 newitems[idx] = thi;
663 }
664 }
665
666 free(hash->items);
667 hash->csize = newsize;
668 hash->items = newitems;
669 }
670
671 /* find item in hash, add it if necessary. Return ptr to data */
672 static void *hash_find(xhash *hash, const char *name)
673 {
674 hash_item *hi;
675 unsigned idx;
676 int l;
677
678 hi = hash_search(hash, name);
679 if (!hi) {
680 if (++hash->nel / hash->csize > 10)
681 hash_rebuild(hash);
682
683 l = strlen(name) + 1;
684 hi = xzalloc(sizeof(*hi) + l);
685 strcpy(hi->name, name);
686
687 idx = hashidx(name) % hash->csize;
688 hi->next = hash->items[idx];
689 hash->items[idx] = hi;
690 hash->glen += l;
691 }
692 return &hi->data;
693 }
694
695 #define findvar(hash, name) ((var*) hash_find((hash), (name)))
696 #define newvar(name) ((var*) hash_find(vhash, (name)))
697 #define newfile(name) ((rstream*)hash_find(fdhash, (name)))
698 #define newfunc(name) ((func*) hash_find(fnhash, (name)))
699
700 static void hash_remove(xhash *hash, const char *name)
701 {
702 hash_item *hi, **phi;
703
704 phi = &hash->items[hashidx(name) % hash->csize];
705 while (*phi) {
706 hi = *phi;
707 if (strcmp(hi->name, name) == 0) {
708 hash->glen -= (strlen(name) + 1);
709 hash->nel--;
710 *phi = hi->next;
711 free(hi);
712 break;
713 }
714 phi = &hi->next;
715 }
716 }
717
718 /* ------ some useful functions ------ */
719
720 static char *skip_spaces(char *p)
721 {
722 while (1) {
723 if (*p == '\\' && p[1] == '\n') {
724 p++;
725 t_lineno++;
726 } else if (*p != ' ' && *p != '\t') {
727 break;
728 }
729 p++;
730 }
731 return p;
732 }
733
734 /* returns old *s, advances *s past word and terminating NUL */
735 static char *nextword(char **s)
736 {
737 char *p = *s;
738 while (*(*s)++ != '\0')
739 continue;
740 return p;
741 }
742
743 static char nextchar(char **s)
744 {
745 char c, *pps;
746
747 c = *(*s)++;
748 pps = *s;
749 if (c == '\\')
750 c = bb_process_escape_sequence((const char**)s);
751 /* Example awk statement:
752 * s = "abc\"def"
753 * we must treat \" as "
754 */
755 if (c == '\\' && *s == pps) { /* unrecognized \z? */
756 c = *(*s); /* yes, fetch z */
757 if (c)
758 (*s)++; /* advance unless z = NUL */
759 }
760 return c;
761 }
762
763 /* TODO: merge with strcpy_and_process_escape_sequences()?
764 */
765 static void unescape_string_in_place(char *s1)
766 {
767 char *s = s1;
768 while ((*s1 = nextchar(&s)) != '\0')
769 s1++;
770 }
771
772 static ALWAYS_INLINE int isalnum_(int c)
773 {
774 return (isalnum(c) || c == '_');
775 }
776
777 static double my_strtod(char **pp)
778 {
779 char *cp = *pp;
780 if (ENABLE_DESKTOP && cp[0] == '0') {
781 /* Might be hex or octal integer: 0x123abc or 07777 */
782 char c = (cp[1] | 0x20);
783 if (c == 'x' || isdigit(cp[1])) {
784 unsigned long long ull = strtoull(cp, pp, 0);
785 if (c == 'x')
786 return ull;
787 c = **pp;
788 if (!isdigit(c) && c != '.')
789 return ull;
790 /* else: it may be a floating number. Examples:
791 * 009.123 (*pp points to '9')
792 * 000.123 (*pp points to '.')
793 * fall through to strtod.
794 */
795 }
796 }
797 return strtod(cp, pp);
798 }
799
800 /* -------- working with variables (set/get/copy/etc) -------- */
801
802 static xhash *iamarray(var *v)
803 {
804 var *a = v;
805
806 while (a->type & VF_CHILD)
807 a = a->x.parent;
808
809 if (!(a->type & VF_ARRAY)) {
810 a->type |= VF_ARRAY;
811 a->x.array = hash_init();
812 }
813 return a->x.array;
814 }
815
816 static void clear_array(xhash *array)
817 {
818 unsigned i;
819 hash_item *hi, *thi;
820
821 for (i = 0; i < array->csize; i++) {
822 hi = array->items[i];
823 while (hi) {
824 thi = hi;
825 hi = hi->next;
826 free(thi->data.v.string);
827 free(thi);
828 }
829 array->items[i] = NULL;
830 }
831 array->glen = array->nel = 0;
832 }
833
834 /* clear a variable */
835 static var *clrvar(var *v)
836 {
837 if (!(v->type & VF_FSTR))
838 free(v->string);
839
840 v->type &= VF_DONTTOUCH;
841 v->type |= VF_DIRTY;
842 v->string = NULL;
843 return v;
844 }
845
846 /* assign string value to variable */
847 static var *setvar_p(var *v, char *value)
848 {
849 clrvar(v);
850 v->string = value;
851 handle_special(v);
852 return v;
853 }
854
855 /* same as setvar_p but make a copy of string */
856 static var *setvar_s(var *v, const char *value)
857 {
858 return setvar_p(v, (value && *value) ? xstrdup(value) : NULL);
859 }
860
861 /* same as setvar_s but sets USER flag */
862 static var *setvar_u(var *v, const char *value)
863 {
864 v = setvar_s(v, value);
865 v->type |= VF_USER;
866 return v;
867 }
868
869 /* set array element to user string */
870 static void setari_u(var *a, int idx, const char *s)
871 {
872 var *v;
873
874 v = findvar(iamarray(a), itoa(idx));
875 setvar_u(v, s);
876 }
877
878 /* assign numeric value to variable */
879 static var *setvar_i(var *v, double value)
880 {
881 clrvar(v);
882 v->type |= VF_NUMBER;
883 v->number = value;
884 handle_special(v);
885 return v;
886 }
887
888 static const char *getvar_s(var *v)
889 {
890 /* if v is numeric and has no cached string, convert it to string */
891 if ((v->type & (VF_NUMBER | VF_CACHED)) == VF_NUMBER) {
892 fmt_num(g_buf, MAXVARFMT, getvar_s(intvar[CONVFMT]), v->number, TRUE);
893 v->string = xstrdup(g_buf);
894 v->type |= VF_CACHED;
895 }
896 return (v->string == NULL) ? "" : v->string;
897 }
898
899 static double getvar_i(var *v)
900 {
901 char *s;
902
903 if ((v->type & (VF_NUMBER | VF_CACHED)) == 0) {
904 v->number = 0;
905 s = v->string;
906 if (s && *s) {
907 debug_printf_eval("getvar_i: '%s'->", s);
908 v->number = my_strtod(&s);
909 debug_printf_eval("%f (s:'%s')\n", v->number, s);
910 if (v->type & VF_USER) {
911 s = skip_spaces(s);
912 if (*s != '\0')
913 v->type &= ~VF_USER;
914 }
915 } else {
916 debug_printf_eval("getvar_i: '%s'->zero\n", s);
917 v->type &= ~VF_USER;
918 }
919 v->type |= VF_CACHED;
920 }
921 debug_printf_eval("getvar_i: %f\n", v->number);
922 return v->number;
923 }
924
925 /* Used for operands of bitwise ops */
926 static unsigned long getvar_i_int(var *v)
927 {
928 double d = getvar_i(v);
929
930 /* Casting doubles to longs is undefined for values outside
931 * of target type range. Try to widen it as much as possible */
932 if (d >= 0)
933 return (unsigned long)d;
934 /* Why? Think about d == -4294967295.0 (assuming 32bit longs) */
935 return - (long) (unsigned long) (-d);
936 }
937
938 static var *copyvar(var *dest, const var *src)
939 {
940 if (dest != src) {
941 clrvar(dest);
942 dest->type |= (src->type & ~(VF_DONTTOUCH | VF_FSTR));
943 debug_printf_eval("copyvar: number:%f string:'%s'\n", src->number, src->string);
944 dest->number = src->number;
945 if (src->string)
946 dest->string = xstrdup(src->string);
947 }
948 handle_special(dest);
949 return dest;
950 }
951
952 static var *incvar(var *v)
953 {
954 return setvar_i(v, getvar_i(v) + 1.0);
955 }
956
957 /* return true if v is number or numeric string */
958 static int is_numeric(var *v)
959 {
960 getvar_i(v);
961 return ((v->type ^ VF_DIRTY) & (VF_NUMBER | VF_USER | VF_DIRTY));
962 }
963
964 /* return 1 when value of v corresponds to true, 0 otherwise */
965 static int istrue(var *v)
966 {
967 if (is_numeric(v))
968 return (v->number != 0);
969 return (v->string && v->string[0]);
970 }
971
972 /* temporary variables allocator. Last allocated should be first freed */
973 static var *nvalloc(int n)
974 {
975 nvblock *pb = NULL;
976 var *v, *r;
977 int size;
978
979 while (g_cb) {
980 pb = g_cb;
981 if ((g_cb->pos - g_cb->nv) + n <= g_cb->size)
982 break;
983 g_cb = g_cb->next;
984 }
985
986 if (!g_cb) {
987 size = (n <= MINNVBLOCK) ? MINNVBLOCK : n;
988 g_cb = xzalloc(sizeof(nvblock) + size * sizeof(var));
989 g_cb->size = size;
990 g_cb->pos = g_cb->nv;
991 g_cb->prev = pb;
992 /*g_cb->next = NULL; - xzalloc did it */
993 if (pb)
994 pb->next = g_cb;
995 }
996
997 v = r = g_cb->pos;
998 g_cb->pos += n;
999
1000 while (v < g_cb->pos) {
1001 v->type = 0;
1002 v->string = NULL;
1003 v++;
1004 }
1005
1006 return r;
1007 }
1008
1009 static void nvfree(var *v)
1010 {
1011 var *p;
1012
1013 if (v < g_cb->nv || v >= g_cb->pos)
1014 syntax_error(EMSG_INTERNAL_ERROR);
1015
1016 for (p = v; p < g_cb->pos; p++) {
1017 if ((p->type & (VF_ARRAY | VF_CHILD)) == VF_ARRAY) {
1018 clear_array(iamarray(p));
1019 free(p->x.array->items);
1020 free(p->x.array);
1021 }
1022 if (p->type & VF_WALK) {
1023 walker_list *n;
1024 walker_list *w = p->x.walker;
1025 debug_printf_walker("nvfree: freeing walker @%p\n", &p->x.walker);
1026 p->x.walker = NULL;
1027 while (w) {
1028 n = w->prev;
1029 debug_printf_walker(" free(%p)\n", w);
1030 free(w);
1031 w = n;
1032 }
1033 }
1034 clrvar(p);
1035 }
1036
1037 g_cb->pos = v;
1038 while (g_cb->prev && g_cb->pos == g_cb->nv) {
1039 g_cb = g_cb->prev;
1040 }
1041 }
1042
1043 /* ------- awk program text parsing ------- */
1044
1045 /* Parse next token pointed by global pos, place results into global ttt.
1046 * If token isn't expected, give away. Return token class
1047 */
1048 static uint32_t next_token(uint32_t expected)
1049 {
1050 #define concat_inserted (G.next_token__concat_inserted)
1051 #define save_tclass (G.next_token__save_tclass)
1052 #define save_info (G.next_token__save_info)
1053 /* Initialized to TC_OPTERM: */
1054 #define ltclass (G.next_token__ltclass)
1055
1056 char *p, *s;
1057 const char *tl;
1058 uint32_t tc;
1059 const uint32_t *ti;
1060
1061 if (t_rollback) {
1062 t_rollback = FALSE;
1063
1064 } else if (concat_inserted) {
1065 concat_inserted = FALSE;
1066 t_tclass = save_tclass;
1067 t_info = save_info;
1068
1069 } else {
1070 p = g_pos;
1071 readnext:
1072 p = skip_spaces(p);
1073 g_lineno = t_lineno;
1074 if (*p == '#')
1075 while (*p != '\n' && *p != '\0')
1076 p++;
1077
1078 if (*p == '\n')
1079 t_lineno++;
1080
1081 if (*p == '\0') {
1082 tc = TC_EOF;
1083 debug_printf_parse("%s: token found: TC_EOF\n", __func__);
1084
1085 } else if (*p == '\"') {
1086 /* it's a string */
1087 t_string = s = ++p;
1088 while (*p != '\"') {
1089 char *pp;
1090 if (*p == '\0' || *p == '\n')
1091 syntax_error(EMSG_UNEXP_EOS);
1092 pp = p;
1093 *s++ = nextchar(&pp);
1094 p = pp;
1095 }
1096 p++;
1097 *s = '\0';
1098 tc = TC_STRING;
1099 debug_printf_parse("%s: token found:'%s' TC_STRING\n", __func__, t_string);
1100
1101 } else if ((expected & TC_REGEXP) && *p == '/') {
1102 /* it's regexp */
1103 t_string = s = ++p;
1104 while (*p != '/') {
1105 if (*p == '\0' || *p == '\n')
1106 syntax_error(EMSG_UNEXP_EOS);
1107 *s = *p++;
1108 if (*s++ == '\\') {
1109 char *pp = p;
1110 s[-1] = bb_process_escape_sequence((const char **)&pp);
1111 if (*p == '\\')
1112 *s++ = '\\';
1113 if (pp == p)
1114 *s++ = *p++;
1115 else
1116 p = pp;
1117 }
1118 }
1119 p++;
1120 *s = '\0';
1121 tc = TC_REGEXP;
1122 debug_printf_parse("%s: token found:'%s' TC_REGEXP\n", __func__, t_string);
1123
1124 } else if (*p == '.' || isdigit(*p)) {
1125 /* it's a number */
1126 char *pp = p;
1127 t_double = my_strtod(&pp);
1128 p = pp;
1129 if (*p == '.')
1130 syntax_error(EMSG_UNEXP_TOKEN);
1131 tc = TC_NUMBER;
1132 debug_printf_parse("%s: token found:%f TC_NUMBER\n", __func__, t_double);
1133
1134 } else {
1135 /* search for something known */
1136 tl = tokenlist;
1137 tc = 0x00000001;
1138 ti = tokeninfo;
1139 while (*tl) {
1140 int l = (unsigned char) *tl++;
1141 if (l == (unsigned char) NTCC) {
1142 tc <<= 1;
1143 continue;
1144 }
1145 /* if token class is expected,
1146 * token matches,
1147 * and it's not a longer word,
1148 */
1149 if ((tc & (expected | TC_WORD | TC_NEWLINE))
1150 && strncmp(p, tl, l) == 0
1151 && !((tc & TC_WORD) && isalnum_(p[l]))
1152 ) {
1153 /* then this is what we are looking for */
1154 t_info = *ti;
1155 debug_printf_parse("%s: token found:'%.*s' t_info:%x\n", __func__, l, p, t_info);
1156 p += l;
1157 goto token_found;
1158 }
1159 ti++;
1160 tl += l;
1161 }
1162 /* not a known token */
1163
1164 /* is it a name? (var/array/function) */
1165 if (!isalnum_(*p))
1166 syntax_error(EMSG_UNEXP_TOKEN); /* no */
1167 /* yes */
1168 t_string = --p;
1169 while (isalnum_(*++p)) {
1170 p[-1] = *p;
1171 }
1172 p[-1] = '\0';
1173 tc = TC_VARIABLE;
1174 /* also consume whitespace between functionname and bracket */
1175 if (!(expected & TC_VARIABLE) || (expected & TC_ARRAY))
1176 p = skip_spaces(p);
1177 if (*p == '(') {
1178 tc = TC_FUNCTION;
1179 debug_printf_parse("%s: token found:'%s' TC_FUNCTION\n", __func__, t_string);
1180 } else {
1181 if (*p == '[') {
1182 p++;
1183 tc = TC_ARRAY;
1184 debug_printf_parse("%s: token found:'%s' TC_ARRAY\n", __func__, t_string);
1185 } else
1186 debug_printf_parse("%s: token found:'%s' TC_VARIABLE\n", __func__, t_string);
1187 }
1188 }
1189 token_found:
1190 g_pos = p;
1191
1192 /* skipping newlines in some cases */
1193 if ((ltclass & TC_NOTERM) && (tc & TC_NEWLINE))
1194 goto readnext;
1195
1196 /* insert concatenation operator when needed */
1197 if ((ltclass & TC_CONCAT1) && (tc & TC_CONCAT2) && (expected & TC_BINOP)) {
1198 concat_inserted = TRUE;
1199 save_tclass = tc;
1200 save_info = t_info;
1201 tc = TC_BINOP;
1202 t_info = OC_CONCAT | SS | P(35);
1203 }
1204
1205 t_tclass = tc;
1206 }
1207 ltclass = t_tclass;
1208
1209 /* Are we ready for this? */
1210 if (!(ltclass & expected))
1211 syntax_error((ltclass & (TC_NEWLINE | TC_EOF)) ?
1212 EMSG_UNEXP_EOS : EMSG_UNEXP_TOKEN);
1213
1214 return ltclass;
1215 #undef concat_inserted
1216 #undef save_tclass
1217 #undef save_info
1218 #undef ltclass
1219 }
1220
1221 static void rollback_token(void)
1222 {
1223 t_rollback = TRUE;
1224 }
1225
1226 static node *new_node(uint32_t info)
1227 {
1228 node *n;
1229
1230 n = xzalloc(sizeof(node));
1231 n->info = info;
1232 n->lineno = g_lineno;
1233 return n;
1234 }
1235
1236 static void mk_re_node(const char *s, node *n, regex_t *re)
1237 {
1238 n->info = OC_REGEXP;
1239 n->l.re = re;
1240 n->r.ire = re + 1;
1241 xregcomp(re, s, REG_EXTENDED);
1242 xregcomp(re + 1, s, REG_EXTENDED | REG_ICASE);
1243 }
1244
1245 static node *condition(void)
1246 {
1247 next_token(TC_SEQSTART);
1248 return parse_expr(TC_SEQTERM);
1249 }
1250
1251 /* parse expression terminated by given argument, return ptr
1252 * to built subtree. Terminator is eaten by parse_expr */
1253 static node *parse_expr(uint32_t iexp)
1254 {
1255 node sn;
1256 node *cn = &sn;
1257 node *vn, *glptr;
1258 uint32_t tc, xtc;
1259 var *v;
1260
1261 debug_printf_parse("%s(%x)\n", __func__, iexp);
1262
1263 sn.info = PRIMASK;
1264 sn.r.n = glptr = NULL;
1265 xtc = TC_OPERAND | TC_UOPPRE | TC_REGEXP | iexp;
1266
1267 while (!((tc = next_token(xtc)) & iexp)) {
1268
1269 if (glptr && (t_info == (OC_COMPARE | VV | P(39) | 2))) {
1270 /* input redirection (<) attached to glptr node */
1271 debug_printf_parse("%s: input redir\n", __func__);
1272 cn = glptr->l.n = new_node(OC_CONCAT | SS | P(37));
1273 cn->a.n = glptr;
1274 xtc = TC_OPERAND | TC_UOPPRE;
1275 glptr = NULL;
1276
1277 } else if (tc & (TC_BINOP | TC_UOPPOST)) {
1278 debug_printf_parse("%s: TC_BINOP | TC_UOPPOST\n", __func__);
1279 /* for binary and postfix-unary operators, jump back over
1280 * previous operators with higher priority */
1281 vn = cn;
1282 while (((t_info & PRIMASK) > (vn->a.n->info & PRIMASK2))
1283 || ((t_info == vn->info) && ((t_info & OPCLSMASK) == OC_COLON))
1284 ) {
1285 vn = vn->a.n;
1286 }
1287 if ((t_info & OPCLSMASK) == OC_TERNARY)
1288 t_info += P(6);
1289 cn = vn->a.n->r.n = new_node(t_info);
1290 cn->a.n = vn->a.n;
1291 if (tc & TC_BINOP) {
1292 cn->l.n = vn;
1293 xtc = TC_OPERAND | TC_UOPPRE | TC_REGEXP;
1294 if ((t_info & OPCLSMASK) == OC_PGETLINE) {
1295 /* it's a pipe */
1296 next_token(TC_GETLINE);
1297 /* give maximum priority to this pipe */
1298 cn->info &= ~PRIMASK;
1299 xtc = TC_OPERAND | TC_UOPPRE | TC_BINOP | iexp;
1300 }
1301 } else {
1302 cn->r.n = vn;
1303 xtc = TC_OPERAND | TC_UOPPRE | TC_BINOP | iexp;
1304 }
1305 vn->a.n = cn;
1306
1307 } else {
1308 debug_printf_parse("%s: other\n", __func__);
1309 /* for operands and prefix-unary operators, attach them
1310 * to last node */
1311 vn = cn;
1312 cn = vn->r.n = new_node(t_info);
1313 cn->a.n = vn;
1314 xtc = TC_OPERAND | TC_UOPPRE | TC_REGEXP;
1315 if (tc & (TC_OPERAND | TC_REGEXP)) {
1316 debug_printf_parse("%s: TC_OPERAND | TC_REGEXP\n", __func__);
1317 xtc = TC_UOPPRE | TC_UOPPOST | TC_BINOP | TC_OPERAND | iexp;
1318 /* one should be very careful with switch on tclass -
1319 * only simple tclasses should be used! */
1320 switch (tc) {
1321 case TC_VARIABLE:
1322 case TC_ARRAY:
1323 debug_printf_parse("%s: TC_VARIABLE | TC_ARRAY\n", __func__);
1324 cn->info = OC_VAR;
1325 v = hash_search(ahash, t_string);
1326 if (v != NULL) {
1327 cn->info = OC_FNARG;
1328 cn->l.aidx = v->x.aidx;
1329 } else {
1330 cn->l.v = newvar(t_string);
1331 }
1332 if (tc & TC_ARRAY) {
1333 cn->info |= xS;
1334 cn->r.n = parse_expr(TC_ARRTERM);
1335 }
1336 break;
1337
1338 case TC_NUMBER:
1339 case TC_STRING:
1340 debug_printf_parse("%s: TC_NUMBER | TC_STRING\n", __func__);
1341 cn->info = OC_VAR;
1342 v = cn->l.v = xzalloc(sizeof(var));
1343 if (tc & TC_NUMBER)
1344 setvar_i(v, t_double);
1345 else
1346 setvar_s(v, t_string);
1347 break;
1348
1349 case TC_REGEXP:
1350 debug_printf_parse("%s: TC_REGEXP\n", __func__);
1351 mk_re_node(t_string, cn, xzalloc(sizeof(regex_t)*2));
1352 break;
1353
1354 case TC_FUNCTION:
1355 debug_printf_parse("%s: TC_FUNCTION\n", __func__);
1356 cn->info = OC_FUNC;
1357 cn->r.f = newfunc(t_string);
1358 cn->l.n = condition();
1359 break;
1360
1361 case TC_SEQSTART:
1362 debug_printf_parse("%s: TC_SEQSTART\n", __func__);
1363 cn = vn->r.n = parse_expr(TC_SEQTERM);
1364 if (!cn)
1365 syntax_error("Empty sequence");
1366 cn->a.n = vn;
1367 break;
1368
1369 case TC_GETLINE:
1370 debug_printf_parse("%s: TC_GETLINE\n", __func__);
1371 glptr = cn;
1372 xtc = TC_OPERAND | TC_UOPPRE | TC_BINOP | iexp;
1373 break;
1374
1375 case TC_BUILTIN:
1376 debug_printf_parse("%s: TC_BUILTIN\n", __func__);
1377 cn->l.n = condition();
1378 break;
1379 }
1380 }
1381 }
1382 }
1383
1384 debug_printf_parse("%s() returns %p\n", __func__, sn.r.n);
1385 return sn.r.n;
1386 }
1387
1388 /* add node to chain. Return ptr to alloc'd node */
1389 static node *chain_node(uint32_t info)
1390 {
1391 node *n;
1392
1393 if (!seq->first)
1394 seq->first = seq->last = new_node(0);
1395
1396 if (seq->programname != g_progname) {
1397 seq->programname = g_progname;
1398 n = chain_node(OC_NEWSOURCE);
1399 n->l.new_progname = xstrdup(g_progname);
1400 }
1401
1402 n = seq->last;
1403 n->info = info;
1404 seq->last = n->a.n = new_node(OC_DONE);
1405
1406 return n;
1407 }
1408
1409 static void chain_expr(uint32_t info)
1410 {
1411 node *n;
1412
1413 n = chain_node(info);
1414 n->l.n = parse_expr(TC_OPTERM | TC_GRPTERM);
1415 if (t_tclass & TC_GRPTERM)
1416 rollback_token();
1417 }
1418
1419 static node *chain_loop(node *nn)
1420 {
1421 node *n, *n2, *save_brk, *save_cont;
1422
1423 save_brk = break_ptr;
1424 save_cont = continue_ptr;
1425
1426 n = chain_node(OC_BR | Vx);
1427 continue_ptr = new_node(OC_EXEC);
1428 break_ptr = new_node(OC_EXEC);
1429 chain_group();
1430 n2 = chain_node(OC_EXEC | Vx);
1431 n2->l.n = nn;
1432 n2->a.n = n;
1433 continue_ptr->a.n = n2;
1434 break_ptr->a.n = n->r.n = seq->last;
1435
1436 continue_ptr = save_cont;
1437 break_ptr = save_brk;
1438
1439 return n;
1440 }
1441
1442 /* parse group and attach it to chain */
1443 static void chain_group(void)
1444 {
1445 uint32_t c;
1446 node *n, *n2, *n3;
1447
1448 do {
1449 c = next_token(TC_GRPSEQ);
1450 } while (c & TC_NEWLINE);
1451
1452 if (c & TC_GRPSTART) {
1453 debug_printf_parse("%s: TC_GRPSTART\n", __func__);
1454 while (next_token(TC_GRPSEQ | TC_GRPTERM) != TC_GRPTERM) {
1455 debug_printf_parse("%s: !TC_GRPTERM\n", __func__);
1456 if (t_tclass & TC_NEWLINE)
1457 continue;
1458 rollback_token();
1459 chain_group();
1460 }
1461 debug_printf_parse("%s: TC_GRPTERM\n", __func__);
1462 } else if (c & (TC_OPSEQ | TC_OPTERM)) {
1463 debug_printf_parse("%s: TC_OPSEQ | TC_OPTERM\n", __func__);
1464 rollback_token();
1465 chain_expr(OC_EXEC | Vx);
1466 } else {
1467 /* TC_STATEMNT */
1468 debug_printf_parse("%s: TC_STATEMNT(?)\n", __func__);
1469 switch (t_info & OPCLSMASK) {
1470 case ST_IF:
1471 debug_printf_parse("%s: ST_IF\n", __func__);
1472 n = chain_node(OC_BR | Vx);
1473 n->l.n = condition();
1474 chain_group();
1475 n2 = chain_node(OC_EXEC);
1476 n->r.n = seq->last;
1477 if (next_token(TC_GRPSEQ | TC_GRPTERM | TC_ELSE) == TC_ELSE) {
1478 chain_group();
1479 n2->a.n = seq->last;
1480 } else {
1481 rollback_token();
1482 }
1483 break;
1484
1485 case ST_WHILE:
1486 debug_printf_parse("%s: ST_WHILE\n", __func__);
1487 n2 = condition();
1488 n = chain_loop(NULL);
1489 n->l.n = n2;
1490 break;
1491
1492 case ST_DO:
1493 debug_printf_parse("%s: ST_DO\n", __func__);
1494 n2 = chain_node(OC_EXEC);
1495 n = chain_loop(NULL);
1496 n2->a.n = n->a.n;
1497 next_token(TC_WHILE);
1498 n->l.n = condition();
1499 break;
1500
1501 case ST_FOR:
1502 debug_printf_parse("%s: ST_FOR\n", __func__);
1503 next_token(TC_SEQSTART);
1504 n2 = parse_expr(TC_SEMICOL | TC_SEQTERM);
1505 if (t_tclass & TC_SEQTERM) { /* for-in */
1506 if ((n2->info & OPCLSMASK) != OC_IN)
1507 syntax_error(EMSG_UNEXP_TOKEN);
1508 n = chain_node(OC_WALKINIT | VV);
1509 n->l.n = n2->l.n;
1510 n->r.n = n2->r.n;
1511 n = chain_loop(NULL);
1512 n->info = OC_WALKNEXT | Vx;
1513 n->l.n = n2->l.n;
1514 } else { /* for (;;) */
1515 n = chain_node(OC_EXEC | Vx);
1516 n->l.n = n2;
1517 n2 = parse_expr(TC_SEMICOL);
1518 n3 = parse_expr(TC_SEQTERM);
1519 n = chain_loop(n3);
1520 n->l.n = n2;
1521 if (!n2)
1522 n->info = OC_EXEC;
1523 }
1524 break;
1525
1526 case OC_PRINT:
1527 case OC_PRINTF:
1528 debug_printf_parse("%s: OC_PRINT[F]\n", __func__);
1529 n = chain_node(t_info);
1530 n->l.n = parse_expr(TC_OPTERM | TC_OUTRDR | TC_GRPTERM);
1531 if (t_tclass & TC_OUTRDR) {
1532 n->info |= t_info;
1533 n->r.n = parse_expr(TC_OPTERM | TC_GRPTERM);
1534 }
1535 if (t_tclass & TC_GRPTERM)
1536 rollback_token();
1537 break;
1538
1539 case OC_BREAK:
1540 debug_printf_parse("%s: OC_BREAK\n", __func__);
1541 n = chain_node(OC_EXEC);
1542 n->a.n = break_ptr;
1543 chain_expr(t_info);
1544 break;
1545
1546 case OC_CONTINUE:
1547 debug_printf_parse("%s: OC_CONTINUE\n", __func__);
1548 n = chain_node(OC_EXEC);
1549 n->a.n = continue_ptr;
1550 chain_expr(t_info);
1551 break;
1552
1553 /* delete, next, nextfile, return, exit */
1554 default:
1555 debug_printf_parse("%s: default\n", __func__);
1556 chain_expr(t_info);
1557 }
1558 }
1559 }
1560
1561 static void parse_program(char *p)
1562 {
1563 uint32_t tclass;
1564 node *cn;
1565 func *f;
1566 var *v;
1567
1568 g_pos = p;
1569 t_lineno = 1;
1570 while ((tclass = next_token(TC_EOF | TC_OPSEQ | TC_GRPSTART |
1571 TC_OPTERM | TC_BEGIN | TC_END | TC_FUNCDECL)) != TC_EOF) {
1572
1573 if (tclass & TC_OPTERM) {
1574 debug_printf_parse("%s: TC_OPTERM\n", __func__);
1575 continue;
1576 }
1577
1578 seq = &mainseq;
1579 if (tclass & TC_BEGIN) {
1580 debug_printf_parse("%s: TC_BEGIN\n", __func__);
1581 seq = &beginseq;
1582 chain_group();
1583
1584 } else if (tclass & TC_END) {
1585 debug_printf_parse("%s: TC_END\n", __func__);
1586 seq = &endseq;
1587 chain_group();
1588
1589 } else if (tclass & TC_FUNCDECL) {
1590 debug_printf_parse("%s: TC_FUNCDECL\n", __func__);
1591 next_token(TC_FUNCTION);
1592 g_pos++;
1593 f = newfunc(t_string);
1594 f->body.first = NULL;
1595 f->nargs = 0;
1596 while (next_token(TC_VARIABLE | TC_SEQTERM) & TC_VARIABLE) {
1597 v = findvar(ahash, t_string);
1598 v->x.aidx = f->nargs++;
1599
1600 if (next_token(TC_COMMA | TC_SEQTERM) & TC_SEQTERM)
1601 break;
1602 }
1603 seq = &f->body;
1604 chain_group();
1605 clear_array(ahash);
1606
1607 } else if (tclass & TC_OPSEQ) {
1608 debug_printf_parse("%s: TC_OPSEQ\n", __func__);
1609 rollback_token();
1610 cn = chain_node(OC_TEST);
1611 cn->l.n = parse_expr(TC_OPTERM | TC_EOF | TC_GRPSTART);
1612 if (t_tclass & TC_GRPSTART) {
1613 debug_printf_parse("%s: TC_GRPSTART\n", __func__);
1614 rollback_token();
1615 chain_group();
1616 } else {
1617 debug_printf_parse("%s: !TC_GRPSTART\n", __func__);
1618 chain_node(OC_PRINT);
1619 }
1620 cn->r.n = mainseq.last;
1621
1622 } else /* if (tclass & TC_GRPSTART) */ {
1623 debug_printf_parse("%s: TC_GRPSTART(?)\n", __func__);
1624 rollback_token();
1625 chain_group();
1626 }
1627 }
1628 debug_printf_parse("%s: TC_EOF\n", __func__);
1629 }
1630
1631
1632 /* -------- program execution part -------- */
1633
1634 static node *mk_splitter(const char *s, tsplitter *spl)
1635 {
1636 regex_t *re, *ire;
1637 node *n;
1638
1639 re = &spl->re[0];
1640 ire = &spl->re[1];
1641 n = &spl->n;
1642 if ((n->info & OPCLSMASK) == OC_REGEXP) {
1643 regfree(re);
1644 regfree(ire); // TODO: nuke ire, use re+1?
1645 }
1646 if (s[0] && s[1]) { /* strlen(s) > 1 */
1647 mk_re_node(s, n, re);
1648 } else {
1649 n->info = (uint32_t) s[0];
1650 }
1651
1652 return n;
1653 }
1654
1655 /* use node as a regular expression. Supplied with node ptr and regex_t
1656 * storage space. Return ptr to regex (if result points to preg, it should
1657 * be later regfree'd manually
1658 */
1659 static regex_t *as_regex(node *op, regex_t *preg)
1660 {
1661 int cflags;
1662 var *v;
1663 const char *s;
1664
1665 if ((op->info & OPCLSMASK) == OC_REGEXP) {
1666 return icase ? op->r.ire : op->l.re;
1667 }
1668 v = nvalloc(1);
1669 s = getvar_s(evaluate(op, v));
1670
1671 cflags = icase ? REG_EXTENDED | REG_ICASE : REG_EXTENDED;
1672 /* Testcase where REG_EXTENDED fails (unpaired '{'):
1673 * echo Hi | awk 'gsub("@(samp|code|file)\{","");'
1674 * gawk 3.1.5 eats this. We revert to ~REG_EXTENDED
1675 * (maybe gsub is not supposed to use REG_EXTENDED?).
1676 */
1677 if (regcomp(preg, s, cflags)) {
1678 cflags &= ~REG_EXTENDED;
1679 xregcomp(preg, s, cflags);
1680 }
1681 nvfree(v);
1682 return preg;
1683 }
1684
1685 /* gradually increasing buffer.
1686 * note that we reallocate even if n == old_size,
1687 * and thus there is at least one extra allocated byte.
1688 */
1689 static char* qrealloc(char *b, int n, int *size)
1690 {
1691 if (!b || n >= *size) {
1692 *size = n + (n>>1) + 80;
1693 b = xrealloc(b, *size);
1694 }
1695 return b;
1696 }
1697
1698 /* resize field storage space */
1699 static void fsrealloc(int size)
1700 {
1701 int i;
1702
1703 if (size >= maxfields) {
1704 i = maxfields;
1705 maxfields = size + 16;
1706 Fields = xrealloc(Fields, maxfields * sizeof(Fields[0]));
1707 for (; i < maxfields; i++) {
1708 Fields[i].type = VF_SPECIAL;
1709 Fields[i].string = NULL;
1710 }
1711 }
1712 /* if size < nfields, clear extra field variables */
1713 for (i = size; i < nfields; i++) {
1714 clrvar(Fields + i);
1715 }
1716 nfields = size;
1717 }
1718
1719 static int awk_split(const char *s, node *spl, char **slist)
1720 {
1721 int l, n;
1722 char c[4];
1723 char *s1;
1724 regmatch_t pmatch[2]; // TODO: why [2]? [1] is enough...
1725
1726 /* in worst case, each char would be a separate field */
1727 *slist = s1 = xzalloc(strlen(s) * 2 + 3);
1728 strcpy(s1, s);
1729
1730 c[0] = c[1] = (char)spl->info;
1731 c[2] = c[3] = '\0';
1732 if (*getvar_s(intvar[RS]) == '\0')
1733 c[2] = '\n';
1734
1735 n = 0;
1736 if ((spl->info & OPCLSMASK) == OC_REGEXP) { /* regex split */
1737 if (!*s)
1738 return n; /* "": zero fields */
1739 n++; /* at least one field will be there */
1740 do {
1741 l = strcspn(s, c+2); /* len till next NUL or \n */
1742 if (regexec(icase ? spl->r.ire : spl->l.re, s, 1, pmatch, 0) == 0
1743 && pmatch[0].rm_so <= l
1744 ) {
1745 l = pmatch[0].rm_so;
1746 if (pmatch[0].rm_eo == 0) {
1747 l++;
1748 pmatch[0].rm_eo++;
1749 }
1750 n++; /* we saw yet another delimiter */
1751 } else {
1752 pmatch[0].rm_eo = l;
1753 if (s[l])
1754 pmatch[0].rm_eo++;
1755 }
1756 memcpy(s1, s, l);
1757 /* make sure we remove *all* of the separator chars */
1758 do {
1759 s1[l] = '\0';
1760 } while (++l < pmatch[0].rm_eo);
1761 nextword(&s1);
1762 s += pmatch[0].rm_eo;
1763 } while (*s);
1764 return n;
1765 }
1766 if (c[0] == '\0') { /* null split */
1767 while (*s) {
1768 *s1++ = *s++;
1769 *s1++ = '\0';
1770 n++;
1771 }
1772 return n;
1773 }
1774 if (c[0] != ' ') { /* single-character split */
1775 if (icase) {
1776 c[0] = toupper(c[0]);
1777 c[1] = tolower(c[1]);
1778 }
1779 if (*s1)
1780 n++;
1781 while ((s1 = strpbrk(s1, c)) != NULL) {
1782 *s1++ = '\0';
1783 n++;
1784 }
1785 return n;
1786 }
1787 /* space split */
1788 while (*s) {
1789 s = skip_whitespace(s);
1790 if (!*s)
1791 break;
1792 n++;
1793 while (*s && !isspace(*s))
1794 *s1++ = *s++;
1795 *s1++ = '\0';
1796 }
1797 return n;
1798 }
1799
1800 static void split_f0(void)
1801 {
1802 /* static char *fstrings; */
1803 #define fstrings (G.split_f0__fstrings)
1804
1805 int i, n;
1806 char *s;
1807
1808 if (is_f0_split)
1809 return;
1810
1811 is_f0_split = TRUE;
1812 free(fstrings);
1813 fsrealloc(0);
1814 n = awk_split(getvar_s(intvar[F0]), &fsplitter.n, &fstrings);
1815 fsrealloc(n);
1816 s = fstrings;
1817 for (i = 0; i < n; i++) {
1818 Fields[i].string = nextword(&s);
1819 Fields[i].type |= (VF_FSTR | VF_USER | VF_DIRTY);
1820 }
1821
1822 /* set NF manually to avoid side effects */
1823 clrvar(intvar[NF]);
1824 intvar[NF]->type = VF_NUMBER | VF_SPECIAL;
1825 intvar[NF]->number = nfields;
1826 #undef fstrings
1827 }
1828
1829 /* perform additional actions when some internal variables changed */
1830 static void handle_special(var *v)
1831 {
1832 int n;
1833 char *b;
1834 const char *sep, *s;
1835 int sl, l, len, i, bsize;
1836
1837 if (!(v->type & VF_SPECIAL))
1838 return;
1839
1840 if (v == intvar[NF]) {
1841 n = (int)getvar_i(v);
1842 fsrealloc(n);
1843
1844 /* recalculate $0 */
1845 sep = getvar_s(intvar[OFS]);
1846 sl = strlen(sep);
1847 b = NULL;
1848 len = 0;
1849 for (i = 0; i < n; i++) {
1850 s = getvar_s(&Fields[i]);
1851 l = strlen(s);
1852 if (b) {
1853 memcpy(b+len, sep, sl);
1854 len += sl;
1855 }
1856 b = qrealloc(b, len+l+sl, &bsize);
1857 memcpy(b+len, s, l);
1858 len += l;
1859 }
1860 if (b)
1861 b[len] = '\0';
1862 setvar_p(intvar[F0], b);
1863 is_f0_split = TRUE;
1864
1865 } else if (v == intvar[F0]) {
1866 is_f0_split = FALSE;
1867
1868 } else if (v == intvar[FS]) {
1869 /*
1870 * The POSIX-2008 standard says that changing FS should have no effect on the
1871 * current input line, but only on the next one. The language is:
1872 *
1873 * > Before the first reference to a field in the record is evaluated, the record
1874 * > shall be split into fields, according to the rules in Regular Expressions,
1875 * > using the value of FS that was current at the time the record was read.
1876 *
1877 * So, split up current line before assignment to FS:
1878 */
1879 split_f0();
1880
1881 mk_splitter(getvar_s(v), &fsplitter);
1882
1883 } else if (v == intvar[RS]) {
1884 mk_splitter(getvar_s(v), &rsplitter);
1885
1886 } else if (v == intvar[IGNORECASE]) {
1887 icase = istrue(v);
1888
1889 } else { /* $n */
1890 n = getvar_i(intvar[NF]);
1891 setvar_i(intvar[NF], n > v-Fields ? n : v-Fields+1);
1892 /* right here v is invalid. Just to note... */
1893 }
1894 }
1895
1896 /* step through func/builtin/etc arguments */
1897 static node *nextarg(node **pn)
1898 {
1899 node *n;
1900
1901 n = *pn;
1902 if (n && (n->info & OPCLSMASK) == OC_COMMA) {
1903 *pn = n->r.n;
1904 n = n->l.n;
1905 } else {
1906 *pn = NULL;
1907 }
1908 return n;
1909 }
1910
1911 static void hashwalk_init(var *v, xhash *array)
1912 {
1913 hash_item *hi;
1914 unsigned i;
1915 walker_list *w;
1916 walker_list *prev_walker;
1917
1918 if (v->type & VF_WALK) {
1919 prev_walker = v->x.walker;
1920 } else {
1921 v->type |= VF_WALK;
1922 prev_walker = NULL;
1923 }
1924 debug_printf_walker("hashwalk_init: prev_walker:%p\n", prev_walker);
1925
1926 w = v->x.walker = xzalloc(sizeof(*w) + array->glen + 1); /* why + 1? */
1927 debug_printf_walker(" walker@%p=%p\n", &v->x.walker, w);
1928 w->cur = w->end = w->wbuf;
1929 w->prev = prev_walker;
1930 for (i = 0; i < array->csize; i++) {
1931 hi = array->items[i];
1932 while (hi) {
1933 strcpy(w->end, hi->name);
1934 nextword(&w->end);
1935 hi = hi->next;
1936 }
1937 }
1938 }
1939
1940 static int hashwalk_next(var *v)
1941 {
1942 walker_list *w = v->x.walker;
1943
1944 if (w->cur >= w->end) {
1945 walker_list *prev_walker = w->prev;
1946
1947 debug_printf_walker("end of iteration, free(walker@%p:%p), prev_walker:%p\n", &v->x.walker, w, prev_walker);
1948 free(w);
1949 v->x.walker = prev_walker;
1950 return FALSE;
1951 }
1952
1953 setvar_s(v, nextword(&w->cur));
1954 return TRUE;
1955 }
1956
1957 /* evaluate node, return 1 when result is true, 0 otherwise */
1958 static int ptest(node *pattern)
1959 {
1960 /* ptest__v is "static": to save stack space? */
1961 return istrue(evaluate(pattern, &G.ptest__v));
1962 }
1963
1964 /* read next record from stream rsm into a variable v */
1965 static int awk_getline(rstream *rsm, var *v)
1966 {
1967 char *b;
1968 regmatch_t pmatch[2];
1969 int size, a, p, pp = 0;
1970 int fd, so, eo, r, rp;
1971 char c, *m, *s;
1972
1973 debug_printf_eval("entered %s()\n", __func__);
1974
1975 /* we're using our own buffer since we need access to accumulating
1976 * characters
1977 */
1978 fd = fileno(rsm->F);
1979 m = rsm->buffer;
1980 a = rsm->adv;
1981 p = rsm->pos;
1982 size = rsm->size;
1983 c = (char) rsplitter.n.info;
1984 rp = 0;
1985
1986 if (!m)
1987 m = qrealloc(m, 256, &size);
1988
1989 do {
1990 b = m + a;
1991 so = eo = p;
1992 r = 1;
1993 if (p > 0) {
1994 if ((rsplitter.n.info & OPCLSMASK) == OC_REGEXP) {
1995 if (regexec(icase ? rsplitter.n.r.ire : rsplitter.n.l.re,
1996 b, 1, pmatch, 0) == 0) {
1997 so = pmatch[0].rm_so;
1998 eo = pmatch[0].rm_eo;
1999 if (b[eo] != '\0')
2000 break;
2001 }
2002 } else if (c != '\0') {
2003 s = strchr(b+pp, c);
2004 if (!s)
2005 s = memchr(b+pp, '\0', p - pp);
2006 if (s) {
2007 so = eo = s-b;
2008 eo++;
2009 break;
2010 }
2011 } else {
2012 while (b[rp] == '\n')
2013 rp++;
2014 s = strstr(b+rp, "\n\n");
2015 if (s) {
2016 so = eo = s-b;
2017 while (b[eo] == '\n')
2018 eo++;
2019 if (b[eo] != '\0')
2020 break;
2021 }
2022 }
2023 }
2024
2025 if (a > 0) {
2026 memmove(m, m+a, p+1);
2027 b = m;
2028 a = 0;
2029 }
2030
2031 m = qrealloc(m, a+p+128, &size);
2032 b = m + a;
2033 pp = p;
2034 p += safe_read(fd, b+p, size-p-1);
2035 if (p < pp) {
2036 p = 0;
2037 r = 0;
2038 setvar_i(intvar[ERRNO], errno);
2039 }
2040 b[p] = '\0';
2041
2042 } while (p > pp);
2043
2044 if (p == 0) {
2045 r--;
2046 } else {
2047 c = b[so]; b[so] = '\0';
2048 setvar_s(v, b+rp);
2049 v->type |= VF_USER;
2050 b[so] = c;
2051 c = b[eo]; b[eo] = '\0';
2052 setvar_s(intvar[RT], b+so);
2053 b[eo] = c;
2054 }
2055
2056 rsm->buffer = m;
2057 rsm->adv = a + eo;
2058 rsm->pos = p - eo;
2059 rsm->size = size;
2060
2061 debug_printf_eval("returning from %s(): %d\n", __func__, r);
2062
2063 return r;
2064 }
2065
2066 static int fmt_num(char *b, int size, const char *format, double n, int int_as_int)
2067 {
2068 int r = 0;
2069 char c;
2070 const char *s = format;
2071
2072 if (int_as_int && n == (long long)n) {
2073 r = snprintf(b, size, "%lld", (long long)n);
2074 } else {
2075 do { c = *s; } while (c && *++s);
2076 if (strchr("diouxX", c)) {
2077 r = snprintf(b, size, format, (int)n);
2078 } else if (strchr("eEfgG", c)) {
2079 r = snprintf(b, size, format, n);
2080 } else {
2081 syntax_error(EMSG_INV_FMT);
2082 }
2083 }
2084 return r;
2085 }
2086
2087 /* formatted output into an allocated buffer, return ptr to buffer */
2088 static char *awk_printf(node *n)
2089 {
2090 char *b = NULL;
2091 char *fmt, *s, *f;
2092 const char *s1;
2093 int i, j, incr, bsize;
2094 char c, c1;
2095 var *v, *arg;
2096
2097 v = nvalloc(1);
2098 fmt = f = xstrdup(getvar_s(evaluate(nextarg(&n), v)));
2099
2100 i = 0;
2101 while (*f) {
2102 s = f;
2103 while (*f && (*f != '%' || *++f == '%'))
2104 f++;
2105 while (*f && !isalpha(*f)) {
2106 if (*f == '*')
2107 syntax_error("%*x formats are not supported");
2108 f++;
2109 }
2110
2111 incr = (f - s) + MAXVARFMT;
2112 b = qrealloc(b, incr + i, &bsize);
2113 c = *f;
2114 if (c != '\0')
2115 f++;
2116 c1 = *f;
2117 *f = '\0';
2118 arg = evaluate(nextarg(&n), v);
2119
2120 j = i;
2121 if (c == 'c' || !c) {
2122 i += sprintf(b+i, s, is_numeric(arg) ?
2123 (char)getvar_i(arg) : *getvar_s(arg));
2124 } else if (c == 's') {
2125 s1 = getvar_s(arg);
2126 b = qrealloc(b, incr+i+strlen(s1), &bsize);
2127 i += sprintf(b+i, s, s1);
2128 } else {
2129 i += fmt_num(b+i, incr, s, getvar_i(arg), FALSE);
2130 }
2131 *f = c1;
2132
2133 /* if there was an error while sprintf, return value is negative */
2134 if (i < j)
2135 i = j;
2136 }
2137
2138 free(fmt);
2139 nvfree(v);
2140 b = xrealloc(b, i + 1);
2141 b[i] = '\0';
2142 return b;
2143 }
2144
2145 /* Common substitution routine.
2146 * Replace (nm)'th substring of (src) that matches (rn) with (repl),
2147 * store result into (dest), return number of substitutions.
2148 * If nm = 0, replace all matches.
2149 * If src or dst is NULL, use $0.
2150 * If subexp != 0, enable subexpression matching (\1-\9).
2151 */
2152 static int awk_sub(node *rn, const char *repl, int nm, var *src, var *dest, int subexp)
2153 {
2154 char *resbuf;
2155 const char *sp;
2156 int match_no, residx, replen, resbufsize;
2157 int regexec_flags;
2158 regmatch_t pmatch[10];
2159 regex_t sreg, *regex;
2160
2161 resbuf = NULL;
2162 residx = 0;
2163 match_no = 0;
2164 regexec_flags = 0;
2165 regex = as_regex(rn, &sreg);
2166 sp = getvar_s(src ? src : intvar[F0]);
2167 replen = strlen(repl);
2168 while (regexec(regex, sp, 10, pmatch, regexec_flags) == 0) {
2169 int so = pmatch[0].rm_so;
2170 int eo = pmatch[0].rm_eo;
2171
2172 //bb_error_msg("match %u: [%u,%u] '%s'%p", match_no+1, so, eo, sp,sp);
2173 resbuf = qrealloc(resbuf, residx + eo + replen, &resbufsize);
2174 memcpy(resbuf + residx, sp, eo);
2175 residx += eo;
2176 if (++match_no >= nm) {
2177 const char *s;
2178 int nbs;
2179
2180 /* replace */
2181 residx -= (eo - so);
2182 nbs = 0;
2183 for (s = repl; *s; s++) {
2184 char c = resbuf[residx++] = *s;
2185 if (c == '\\') {
2186 nbs++;
2187 continue;
2188 }
2189 if (c == '&' || (subexp && c >= '0' && c <= '9')) {
2190 int j;
2191 residx -= ((nbs + 3) >> 1);
2192 j = 0;
2193 if (c != '&') {
2194 j = c - '0';
2195 nbs++;
2196 }
2197 if (nbs % 2) {
2198 resbuf[residx++] = c;
2199 } else {
2200 int n = pmatch[j].rm_eo - pmatch[j].rm_so;
2201 resbuf = qrealloc(resbuf, residx + replen + n, &resbufsize);
2202 memcpy(resbuf + residx, sp + pmatch[j].rm_so, n);
2203 residx += n;
2204 }
2205 }
2206 nbs = 0;
2207 }
2208 }
2209
2210 regexec_flags = REG_NOTBOL;
2211 sp += eo;
2212 if (match_no == nm)
2213 break;
2214 if (eo == so) {
2215 /* Empty match (e.g. "b*" will match anywhere).
2216 * Advance by one char. */
2217 //BUG (bug 1333):
2218 //gsub(/\<b*/,"") on "abc" will reach this point, advance to "bc"
2219 //... and will erroneously match "b" even though it is NOT at the word start.
2220 //we need REG_NOTBOW but it does not exist...
2221 //TODO: if EXTRA_COMPAT=y, use GNU matching and re_search,
2222 //it should be able to do it correctly.
2223 /* Subtle: this is safe only because
2224 * qrealloc allocated at least one extra byte */
2225 resbuf[residx] = *sp;
2226 if (*sp == '\0')
2227 goto ret;
2228 sp++;
2229 residx++;
2230 }
2231 }
2232
2233 resbuf = qrealloc(resbuf, residx + strlen(sp), &resbufsize);
2234 strcpy(resbuf + residx, sp);
2235 ret:
2236 //bb_error_msg("end sp:'%s'%p", sp,sp);
2237 setvar_p(dest ? dest : intvar[F0], resbuf);
2238 if (regex == &sreg)
2239 regfree(regex);
2240 return match_no;
2241 }
2242
2243 static NOINLINE int do_mktime(const char *ds)
2244 {
2245 struct tm then;
2246 int count;
2247
2248 /*memset(&then, 0, sizeof(then)); - not needed */
2249 then.tm_isdst = -1; /* default is unknown */
2250
2251 /* manpage of mktime says these fields are ints,
2252 * so we can sscanf stuff directly into them */
2253 count = sscanf(ds, "%u %u %u %u %u %u %d",
2254 &then.tm_year, &then.tm_mon, &then.tm_mday,
2255 &then.tm_hour, &then.tm_min, &then.tm_sec,
2256 &then.tm_isdst);
2257
2258 if (count < 6
2259 || (unsigned)then.tm_mon < 1
2260 || (unsigned)then.tm_year < 1900
2261 ) {
2262 return -1;
2263 }
2264
2265 then.tm_mon -= 1;
2266 then.tm_year -= 1900;
2267
2268 return mktime(&then);
2269 }
2270
2271 static NOINLINE var *exec_builtin(node *op, var *res)
2272 {
2273 #define tspl (G.exec_builtin__tspl)
2274
2275 var *tv;
2276 node *an[4];
2277 var *av[4];
2278 const char *as[4];
2279 regmatch_t pmatch[2];
2280 regex_t sreg, *re;
2281 node *spl;
2282 uint32_t isr, info;
2283 int nargs;
2284 time_t tt;
2285 int i, l, ll, n;
2286
2287 tv = nvalloc(4);
2288 isr = info = op->info;
2289 op = op->l.n;
2290
2291 av[2] = av[3] = NULL;
2292 for (i = 0; i < 4 && op; i++) {
2293 an[i] = nextarg(&op);
2294 if (isr & 0x09000000)
2295 av[i] = evaluate(an[i], &tv[i]);
2296 if (isr & 0x08000000)
2297 as[i] = getvar_s(av[i]);
2298 isr >>= 1;
2299 }
2300
2301 nargs = i;
2302 if ((uint32_t)nargs < (info >> 30))
2303 syntax_error(EMSG_TOO_FEW_ARGS);
2304
2305 info &= OPNMASK;
2306 switch (info) {
2307
2308 case B_a2:
2309 if (ENABLE_FEATURE_AWK_LIBM)
2310 setvar_i(res, atan2(getvar_i(av[0]), getvar_i(av[1])));
2311 else
2312 syntax_error(EMSG_NO_MATH);
2313 break;
2314
2315 case B_sp: {
2316 char *s, *s1;
2317
2318 if (nargs > 2) {
2319 spl = (an[2]->info & OPCLSMASK) == OC_REGEXP ?
2320 an[2] : mk_splitter(getvar_s(evaluate(an[2], &tv[2])), &tspl);
2321 } else {
2322 spl = &fsplitter.n;
2323 }
2324
2325 n = awk_split(as[0], spl, &s);
2326 s1 = s;
2327 clear_array(iamarray(av[1]));
2328 for (i = 1; i <= n; i++)
2329 setari_u(av[1], i, nextword(&s));
2330 free(s1);
2331 setvar_i(res, n);
2332 break;
2333 }
2334
2335 case B_ss: {
2336 char *s;
2337
2338 l = strlen(as[0]);
2339 i = getvar_i(av[1]) - 1;
2340 if (i > l)
2341 i = l;
2342 if (i < 0)
2343 i = 0;
2344 n = (nargs > 2) ? getvar_i(av[2]) : l-i;
2345 if (n < 0)
2346 n = 0;
2347 s = xstrndup(as[0]+i, n);
2348 setvar_p(res, s);
2349 break;
2350 }
2351
2352 /* Bitwise ops must assume that operands are unsigned. GNU Awk 3.1.5:
2353 * awk '{ print or(-1,1) }' gives "4.29497e+09", not "-2.xxxe+09" */
2354 case B_an:
2355 setvar_i(res, getvar_i_int(av[0]) & getvar_i_int(av[1]));
2356 break;
2357
2358 case B_co:
2359 setvar_i(res, ~getvar_i_int(av[0]));
2360 break;
2361
2362 case B_ls:
2363 setvar_i(res, getvar_i_int(av[0]) << getvar_i_int(av[1]));
2364 break;
2365
2366 case B_or:
2367 setvar_i(res, getvar_i_int(av[0]) | getvar_i_int(av[1]));
2368 break;
2369
2370 case B_rs:
2371 setvar_i(res, getvar_i_int(av[0]) >> getvar_i_int(av[1]));
2372 break;
2373
2374 case B_xo:
2375 setvar_i(res, getvar_i_int(av[0]) ^ getvar_i_int(av[1]));
2376 break;
2377
2378 case B_lo:
2379 case B_up: {
2380 char *s, *s1;
2381 s1 = s = xstrdup(as[0]);
2382 while (*s1) {
2383 //*s1 = (info == B_up) ? toupper(*s1) : tolower(*s1);
2384 if ((unsigned char)((*s1 | 0x20) - 'a') <= ('z' - 'a'))
2385 *s1 = (info == B_up) ? (*s1 & 0xdf) : (*s1 | 0x20);
2386 s1++;
2387 }
2388 setvar_p(res, s);
2389 break;
2390 }
2391
2392 case B_ix:
2393 n = 0;
2394 ll = strlen(as[1]);
2395 l = strlen(as[0]) - ll;
2396 if (ll > 0 && l >= 0) {
2397 if (!icase) {
2398 char *s = strstr(as[0], as[1]);
2399 if (s)
2400 n = (s - as[0]) + 1;
2401 } else {
2402 /* this piece of code is terribly slow and
2403 * really should be rewritten
2404 */
2405 for (i = 0; i <= l; i++) {
2406 if (strncasecmp(as[0]+i, as[1], ll) == 0) {
2407 n = i+1;
2408 break;
2409 }
2410 }
2411 }
2412 }
2413 setvar_i(res, n);
2414 break;
2415
2416 case B_ti:
2417 if (nargs > 1)
2418 tt = getvar_i(av[1]);
2419 else
2420 time(&tt);
2421 //s = (nargs > 0) ? as[0] : "%a %b %d %H:%M:%S %Z %Y";
2422 i = strftime(g_buf, MAXVARFMT,
2423 ((nargs > 0) ? as[0] : "%a %b %d %H:%M:%S %Z %Y"),
2424 localtime(&tt));
2425 g_buf[i] = '\0';
2426 setvar_s(res, g_buf);
2427 break;
2428
2429 case B_mt:
2430 setvar_i(res, do_mktime(as[0]));
2431 break;
2432
2433 case B_ma:
2434 re = as_regex(an[1], &sreg);
2435 n = regexec(re, as[0], 1, pmatch, 0);
2436 if (n == 0) {
2437 pmatch[0].rm_so++;
2438 pmatch[0].rm_eo++;
2439 } else {
2440 pmatch[0].rm_so = 0;
2441 pmatch[0].rm_eo = -1;
2442 }
2443 setvar_i(newvar("RSTART"), pmatch[0].rm_so);
2444 setvar_i(newvar("RLENGTH"), pmatch[0].rm_eo - pmatch[0].rm_so);
2445 setvar_i(res, pmatch[0].rm_so);
2446 if (re == &sreg)
2447 regfree(re);
2448 break;
2449
2450 case B_ge:
2451 awk_sub(an[0], as[1], getvar_i(av[2]), av[3], res, TRUE);
2452 break;
2453
2454 case B_gs:
2455 setvar_i(res, awk_sub(an[0], as[1], 0, av[2], av[2], FALSE));
2456 break;
2457
2458 case B_su:
2459 setvar_i(res, awk_sub(an[0], as[1], 1, av[2], av[2], FALSE));
2460 break;
2461 }
2462
2463 nvfree(tv);
2464 return res;
2465 #undef tspl
2466 }
2467
2468 /*
2469 * Evaluate node - the heart of the program. Supplied with subtree
2470 * and place where to store result. returns ptr to result.
2471 */
2472 #define XC(n) ((n) >> 8)
2473
2474 static var *evaluate(node *op, var *res)
2475 {
2476 /* This procedure is recursive so we should count every byte */
2477 #define fnargs (G.evaluate__fnargs)
2478 /* seed is initialized to 1 */
2479 #define seed (G.evaluate__seed)
2480 #define sreg (G.evaluate__sreg)
2481
2482 var *v1;
2483
2484 if (!op)
2485 return setvar_s(res, NULL);
2486
2487 debug_printf_eval("entered %s()\n", __func__);
2488
2489 v1 = nvalloc(2);
2490
2491 while (op) {
2492 struct {
2493 var *v;
2494 const char *s;
2495 } L = L; /* for compiler */
2496 struct {
2497 var *v;
2498 const char *s;
2499 } R = R;
2500 double L_d = L_d;
2501 uint32_t opinfo;
2502 int opn;
2503 node *op1;
2504
2505 opinfo = op->info;
2506 opn = (opinfo & OPNMASK);
2507 g_lineno = op->lineno;
2508 op1 = op->l.n;
2509 debug_printf_eval("opinfo:%08x opn:%08x\n", opinfo, opn);
2510
2511 /* execute inevitable things */
2512 if (opinfo & OF_RES1)
2513 L.v = evaluate(op1, v1);
2514 if (opinfo & OF_RES2)
2515 R.v = evaluate(op->r.n, v1+1);
2516 if (opinfo & OF_STR1) {
2517 L.s = getvar_s(L.v);
2518 debug_printf_eval("L.s:'%s'\n", L.s);
2519 }
2520 if (opinfo & OF_STR2) {
2521 R.s = getvar_s(R.v);
2522 debug_printf_eval("R.s:'%s'\n", R.s);
2523 }
2524 if (opinfo & OF_NUM1) {
2525 L_d = getvar_i(L.v);
2526 debug_printf_eval("L_d:%f\n", L_d);
2527 }
2528
2529 debug_printf_eval("switch(0x%x)\n", XC(opinfo & OPCLSMASK));
2530 switch (XC(opinfo & OPCLSMASK)) {
2531
2532 /* -- iterative node type -- */
2533
2534 /* test pattern */
2535 case XC( OC_TEST ):
2536 if ((op1->info & OPCLSMASK) == OC_COMMA) {
2537 /* it's range pattern */
2538 if ((opinfo & OF_CHECKED) || ptest(op1->l.n)) {
2539 op->info |= OF_CHECKED;
2540 if (ptest(op1->r.n))
2541 op->info &= ~OF_CHECKED;
2542 op = op->a.n;
2543 } else {
2544 op = op->r.n;
2545 }
2546 } else {
2547 op = ptest(op1) ? op->a.n : op->r.n;
2548 }
2549 break;
2550
2551 /* just evaluate an expression, also used as unconditional jump */
2552 case XC( OC_EXEC ):
2553 break;
2554
2555 /* branch, used in if-else and various loops */
2556 case XC( OC_BR ):
2557 op = istrue(L.v) ? op->a.n : op->r.n;
2558 break;
2559
2560 /* initialize for-in loop */
2561 case XC( OC_WALKINIT ):
2562 hashwalk_init(L.v, iamarray(R.v));
2563 break;
2564
2565 /* get next array item */
2566 case XC( OC_WALKNEXT ):
2567 op = hashwalk_next(L.v) ? op->a.n : op->r.n;
2568 break;
2569
2570 case XC( OC_PRINT ):
2571 case XC( OC_PRINTF ): {
2572 FILE *F = stdout;
2573
2574 if (op->r.n) {
2575 rstream *rsm = newfile(R.s);
2576 if (!rsm->F) {
2577 if (opn == '|') {
2578 rsm->F = popen(R.s, "w");
2579 if (rsm->F == NULL)
2580 bb_perror_msg_and_die("popen");
2581 rsm->is_pipe = 1;
2582 } else {
2583 rsm->F = xfopen(R.s, opn=='w' ? "w" : "a");
2584 }
2585 }
2586 F = rsm->F;
2587 }
2588
2589 if ((opinfo & OPCLSMASK) == OC_PRINT) {
2590 if (!op1) {
2591 fputs(getvar_s(intvar[F0]), F);
2592 } else {
2593 while (op1) {
2594 var *v = evaluate(nextarg(&op1), v1);
2595 if (v->type & VF_NUMBER) {
2596 fmt_num(g_buf, MAXVARFMT, getvar_s(intvar[OFMT]),
2597 getvar_i(v), TRUE);
2598 fputs(g_buf, F);
2599 } else {
2600 fputs(getvar_s(v), F);
2601 }
2602
2603 if (op1)
2604 fputs(getvar_s(intvar[OFS]), F);
2605 }
2606 }
2607 fputs(getvar_s(intvar[ORS]), F);
2608
2609 } else { /* OC_PRINTF */
2610 char *s = awk_printf(op1);
2611 fputs(s, F);
2612 free(s);
2613 }
2614 fflush(F);
2615 break;
2616 }
2617
2618 case XC( OC_DELETE ): {
2619 uint32_t info = op1->info & OPCLSMASK;
2620 var *v;
2621
2622 if (info == OC_VAR) {
2623 v = op1->l.v;
2624 } else if (info == OC_FNARG) {
2625 v = &fnargs[op1->l.aidx];
2626 } else {
2627 syntax_error(EMSG_NOT_ARRAY);
2628 }
2629
2630 if (op1->r.n) {
2631 const char *s;
2632 clrvar(L.v);
2633 s = getvar_s(evaluate(op1->r.n, v1));
2634 hash_remove(iamarray(v), s);
2635 } else {
2636 clear_array(iamarray(v));
2637 }
2638 break;
2639 }
2640
2641 case XC( OC_NEWSOURCE ):
2642 g_progname = op->l.new_progname;
2643 break;
2644
2645 case XC( OC_RETURN ):
2646 copyvar(res, L.v);
2647 break;
2648
2649 case XC( OC_NEXTFILE ):
2650 nextfile = TRUE;
2651 case XC( OC_NEXT ):
2652 nextrec = TRUE;
2653 case XC( OC_DONE ):
2654 clrvar(res);
2655 break;
2656
2657 case XC( OC_EXIT ):
2658 awk_exit(L_d);
2659
2660 /* -- recursive node type -- */
2661
2662 case XC( OC_VAR ):
2663 L.v = op->l.v;
2664 if (L.v == intvar[NF])
2665 split_f0();
2666 goto v_cont;
2667
2668 case XC( OC_FNARG ):
2669 L.v = &fnargs[op->l.aidx];
2670 v_cont:
2671 res = op->r.n ? findvar(iamarray(L.v), R.s) : L.v;
2672 break;
2673
2674 case XC( OC_IN ):
2675 setvar_i(res, hash_search(iamarray(R.v), L.s) ? 1 : 0);
2676 break;
2677
2678 case XC( OC_REGEXP ):
2679 op1 = op;
2680 L.s = getvar_s(intvar[F0]);
2681 goto re_cont;
2682
2683 case XC( OC_MATCH ):
2684 op1 = op->r.n;
2685 re_cont:
2686 {
2687 regex_t *re = as_regex(op1, &sreg);
2688 int i = regexec(re, L.s, 0, NULL, 0);
2689 if (re == &sreg)
2690 regfree(re);
2691 setvar_i(res, (i == 0) ^ (opn == '!'));
2692 }
2693 break;
2694
2695 case XC( OC_MOVE ):
2696 debug_printf_eval("MOVE\n");
2697 /* if source is a temporary string, jusk relink it to dest */
2698 //Disabled: if R.v is numeric but happens to have cached R.v->string,
2699 //then L.v ends up being a string, which is wrong
2700 // if (R.v == v1+1 && R.v->string) {
2701 // res = setvar_p(L.v, R.v->string);
2702 // R.v->string = NULL;
2703 // } else {
2704 res = copyvar(L.v, R.v);
2705 // }
2706 break;
2707
2708 case XC( OC_TERNARY ):
2709 if ((op->r.n->info & OPCLSMASK) != OC_COLON)
2710 syntax_error(EMSG_POSSIBLE_ERROR);
2711 res = evaluate(istrue(L.v) ? op->r.n->l.n : op->r.n->r.n, res);
2712 break;
2713
2714 case XC( OC_FUNC ): {
2715 var *vbeg, *v;
2716 const char *sv_progname;
2717
2718 /* The body might be empty, still has to eval the args */
2719 if (!op->r.n->info && !op->r.f->body.first)
2720 syntax_error(EMSG_UNDEF_FUNC);
2721
2722 vbeg = v = nvalloc(op->r.f->nargs + 1);
2723 while (op1) {
2724 var *arg = evaluate(nextarg(&op1), v1);
2725 copyvar(v, arg);
2726 v->type |= VF_CHILD;
2727 v->x.parent = arg;
2728 if (++v - vbeg >= op->r.f->nargs)
2729 break;
2730 }
2731
2732 v = fnargs;
2733 fnargs = vbeg;
2734 sv_progname = g_progname;
2735
2736 res = evaluate(op->r.f->body.first, res);
2737
2738 g_progname = sv_progname;
2739 nvfree(fnargs);
2740 fnargs = v;
2741
2742 break;
2743 }
2744
2745 case XC( OC_GETLINE ):
2746 case XC( OC_PGETLINE ): {
2747 rstream *rsm;
2748 int i;
2749
2750 if (op1) {
2751 rsm = newfile(L.s);
2752 if (!rsm->F) {
2753 if ((opinfo & OPCLSMASK) == OC_PGETLINE) {
2754 rsm->F = popen(L.s, "r");
2755 rsm->is_pipe = TRUE;
2756 } else {
2757 rsm->F = fopen_for_read(L.s); /* not xfopen! */
2758 }
2759 }
2760 } else {
2761 if (!iF)
2762 iF = next_input_file();
2763 rsm = iF;
2764 }
2765
2766 if (!rsm || !rsm->F) {
2767 setvar_i(intvar[ERRNO], errno);
2768 setvar_i(res, -1);
2769 break;
2770 }
2771
2772 if (!op->r.n)
2773 R.v = intvar[F0];
2774
2775 i = awk_getline(rsm, R.v);
2776 if (i > 0 && !op1) {
2777 incvar(intvar[FNR]);
2778 incvar(intvar[NR]);
2779 }
2780 setvar_i(res, i);
2781 break;
2782 }
2783
2784 /* simple builtins */
2785 case XC( OC_FBLTIN ): {
2786 double R_d = R_d; /* for compiler */
2787
2788 switch (opn) {
2789 case F_in:
2790 R_d = (long long)L_d;
2791 break;
2792
2793 case F_rn:
2794 R_d = (double)rand() / (double)RAND_MAX;
2795 break;
2796
2797 case F_co:
2798 if (ENABLE_FEATURE_AWK_LIBM) {
2799 R_d = cos(L_d);
2800 break;
2801 }
2802
2803 case F_ex:
2804 if (ENABLE_FEATURE_AWK_LIBM) {
2805 R_d = exp(L_d);
2806 break;
2807 }
2808
2809 case F_lg:
2810 if (ENABLE_FEATURE_AWK_LIBM) {
2811 R_d = log(L_d);
2812 break;
2813 }
2814
2815 case F_si:
2816 if (ENABLE_FEATURE_AWK_LIBM) {
2817 R_d = sin(L_d);
2818 break;
2819 }
2820
2821 case F_sq:
2822 if (ENABLE_FEATURE_AWK_LIBM) {
2823 R_d = sqrt(L_d);
2824 break;
2825 }
2826
2827 syntax_error(EMSG_NO_MATH);
2828 break;
2829
2830 case F_sr:
2831 R_d = (double)seed;
2832 seed = op1 ? (unsigned)L_d : (unsigned)time(NULL);
2833 srand(seed);
2834 break;
2835
2836 case F_ti:
2837 R_d = time(NULL);
2838 break;
2839
2840 case F_le:
2841 debug_printf_eval("length: L.s:'%s'\n", L.s);
2842 if (!op1) {
2843 L.s = getvar_s(intvar[F0]);
2844 debug_printf_eval("length: L.s='%s'\n", L.s);
2845 }
2846 else if (L.v->type & VF_ARRAY) {
2847 R_d = L.v->x.array->nel;
2848 debug_printf_eval("length: array_len:%d\n", L.v->x.array->nel);
2849 break;
2850 }
2851 R_d = strlen(L.s);
2852 break;
2853
2854 case F_sy:
2855 fflush_all();
2856 R_d = (ENABLE_FEATURE_ALLOW_EXEC && L.s && *L.s)
2857 ? (system(L.s) >> 8) : 0;
2858 break;
2859
2860 case F_ff:
2861 if (!op1) {
2862 fflush(stdout);
2863 } else if (L.s && *L.s) {
2864 rstream *rsm = newfile(L.s);
2865 fflush(rsm->F);
2866 } else {
2867 fflush_all();
2868 }
2869 break;
2870
2871 case F_cl: {
2872 rstream *rsm;
2873 int err = 0;
2874 rsm = (rstream *)hash_search(fdhash, L.s);
2875 debug_printf_eval("OC_FBLTIN F_cl rsm:%p\n", rsm);
2876 if (rsm) {
2877 debug_printf_eval("OC_FBLTIN F_cl "
2878 "rsm->is_pipe:%d, ->F:%p\n",
2879 rsm->is_pipe, rsm->F);
2880 /* Can be NULL if open failed. Example:
2881 * getline line <"doesnt_exist";
2882 * close("doesnt_exist"); <--- here rsm->F is NULL
2883 */
2884 if (rsm->F)
2885 err = rsm->is_pipe ? pclose(rsm->F) : fclose(rsm->F);
2886 free(rsm->buffer);
2887 hash_remove(fdhash, L.s);
2888 }
2889 if (err)
2890 setvar_i(intvar[ERRNO], errno);
2891 R_d = (double)err;
2892 break;
2893 }
2894 } /* switch */
2895 setvar_i(res, R_d);
2896 break;
2897 }
2898
2899 case XC( OC_BUILTIN ):
2900 res = exec_builtin(op, res);
2901 break;
2902
2903 case XC( OC_SPRINTF ):
2904 setvar_p(res, awk_printf(op1));
2905 break;
2906
2907 case XC( OC_UNARY ): {
2908 double Ld, R_d;
2909
2910 Ld = R_d = getvar_i(R.v);
2911 switch (opn) {
2912 case 'P':
2913 Ld = ++R_d;
2914 goto r_op_change;
2915 case 'p':
2916 R_d++;
2917 goto r_op_change;
2918 case 'M':
2919 Ld = --R_d;
2920 goto r_op_change;
2921 case 'm':
2922 R_d--;
2923 r_op_change:
2924 setvar_i(R.v, R_d);
2925 break;
2926 case '!':
2927 Ld = !istrue(R.v);
2928 break;
2929 case '-':
2930 Ld = -R_d;
2931 break;
2932 }
2933 setvar_i(res, Ld);
2934 break;
2935 }
2936
2937 case XC( OC_FIELD ): {
2938 int i = (int)getvar_i(R.v);
2939 if (i == 0) {
2940 res = intvar[F0];
2941 } else {
2942 split_f0();
2943 if (i > nfields)
2944 fsrealloc(i);
2945 res = &Fields[i - 1];
2946 }
2947 break;
2948 }
2949
2950 /* concatenation (" ") and index joining (",") */
2951 case XC( OC_CONCAT ):
2952 case XC( OC_COMMA ): {
2953 const char *sep = "";
2954 if ((opinfo & OPCLSMASK) == OC_COMMA)
2955 sep = getvar_s(intvar[SUBSEP]);
2956 setvar_p(res, xasprintf("%s%s%s", L.s, sep, R.s));
2957 break;
2958 }
2959
2960 case XC( OC_LAND ):
2961 setvar_i(res, istrue(L.v) ? ptest(op->r.n) : 0);
2962 break;
2963
2964 case XC( OC_LOR ):
2965 setvar_i(res, istrue(L.v) ? 1 : ptest(op->r.n));
2966 break;
2967
2968 case XC( OC_BINARY ):
2969 case XC( OC_REPLACE ): {
2970 double R_d = getvar_i(R.v);
2971 debug_printf_eval("BINARY/REPLACE: R_d:%f opn:%c\n", R_d, opn);
2972 switch (opn) {
2973 case '+':
2974 L_d += R_d;
2975 break;
2976 case '-':
2977 L_d -= R_d;
2978 break;
2979 case '*':
2980 L_d *= R_d;
2981 break;
2982 case '/':
2983 if (R_d == 0)
2984 syntax_error(EMSG_DIV_BY_ZERO);
2985 L_d /= R_d;
2986 break;
2987 case '&':
2988 if (ENABLE_FEATURE_AWK_LIBM)
2989 L_d = pow(L_d, R_d);
2990 else
2991 syntax_error(EMSG_NO_MATH);
2992 break;
2993 case '%':
2994 if (R_d == 0)
2995 syntax_error(EMSG_DIV_BY_ZERO);
2996 L_d -= (long long)(L_d / R_d) * R_d;
2997 break;
2998 }
2999 debug_printf_eval("BINARY/REPLACE result:%f\n", L_d);
3000 res = setvar_i(((opinfo & OPCLSMASK) == OC_BINARY) ? res : L.v, L_d);
3001 break;
3002 }
3003
3004 case XC( OC_COMPARE ): {
3005 int i = i; /* for compiler */
3006 double Ld;
3007
3008 if (is_numeric(L.v) && is_numeric(R.v)) {
3009 Ld = getvar_i(L.v) - getvar_i(R.v);
3010 } else {
3011 const char *l = getvar_s(L.v);
3012 const char *r = getvar_s(R.v);
3013 Ld = icase ? strcasecmp(l, r) : strcmp(l, r);
3014 }
3015 switch (opn & 0xfe) {
3016 case 0:
3017 i = (Ld > 0);
3018 break;
3019 case 2:
3020 i = (Ld >= 0);
3021 break;
3022 case 4:
3023 i = (Ld == 0);
3024 break;
3025 }
3026 setvar_i(res, (i == 0) ^ (opn & 1));
3027 break;
3028 }
3029
3030 default:
3031 syntax_error(EMSG_POSSIBLE_ERROR);
3032 }
3033 if ((opinfo & OPCLSMASK) <= SHIFT_TIL_THIS)
3034 op = op->a.n;
3035 if ((opinfo & OPCLSMASK) >= RECUR_FROM_THIS)
3036 break;
3037 if (nextrec)
3038 break;
3039 } /* while (op) */
3040
3041 nvfree(v1);
3042 debug_printf_eval("returning from %s(): %p\n", __func__, res);
3043 return res;
3044 #undef fnargs
3045 #undef seed
3046 #undef sreg
3047 }
3048
3049
3050 /* -------- main & co. -------- */
3051
3052 static int awk_exit(int r)
3053 {
3054 var tv;
3055 unsigned i;
3056 hash_item *hi;
3057
3058 zero_out_var(&tv);
3059
3060 if (!exiting) {
3061 exiting = TRUE;
3062 nextrec = FALSE;
3063 evaluate(endseq.first, &tv);
3064 }
3065
3066 /* waiting for children */
3067 for (i = 0; i < fdhash->csize; i++) {
3068 hi = fdhash->items[i];
3069 while (hi) {
3070 if (hi->data.rs.F && hi->data.rs.is_pipe)
3071 pclose(hi->data.rs.F);
3072 hi = hi->next;
3073 }
3074 }
3075
3076 exit(r);
3077 }
3078
3079 /* if expr looks like "var=value", perform assignment and return 1,
3080 * otherwise return 0 */
3081 static int is_assignment(const char *expr)
3082 {
3083 char *exprc, *val;
3084
3085 if (!isalnum_(*expr) || (val = strchr(expr, '=')) == NULL) {
3086 return FALSE;
3087 }
3088
3089 exprc = xstrdup(expr);
3090 val = exprc + (val - expr);
3091 *val++ = '\0';
3092
3093 unescape_string_in_place(val);
3094 setvar_u(newvar(exprc), val);
3095 free(exprc);
3096 return TRUE;
3097 }
3098
3099 /* switch to next input file */
3100 static rstream *next_input_file(void)
3101 {
3102 #define rsm (G.next_input_file__rsm)
3103 #define files_happen (G.next_input_file__files_happen)
3104
3105 FILE *F;
3106 const char *fname, *ind;
3107
3108 if (rsm.F)
3109 fclose(rsm.F);
3110 rsm.F = NULL;
3111 rsm.pos = rsm.adv = 0;
3112
3113 for (;;) {
3114 if (getvar_i(intvar[ARGIND])+1 >= getvar_i(intvar[ARGC])) {
3115 if (files_happen)
3116 return NULL;
3117 fname = "-";
3118 F = stdin;
3119 break;
3120 }
3121 ind = getvar_s(incvar(intvar[ARGIND]));
3122 fname = getvar_s(findvar(iamarray(intvar[ARGV]), ind));
3123 if (fname && *fname && !is_assignment(fname)) {
3124 F = xfopen_stdin(fname);
3125 break;
3126 }
3127 }
3128
3129 files_happen = TRUE;
3130 setvar_s(intvar[FILENAME], fname);
3131 rsm.F = F;
3132 return &rsm;
3133 #undef rsm
3134 #undef files_happen
3135 }
3136
3137 int awk_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
3138 int awk_main(int argc, char **argv)
3139 {
3140 unsigned opt;
3141 char *opt_F;
3142 llist_t *list_v = NULL;
3143 llist_t *list_f = NULL;
3144 #if ENABLE_FEATURE_AWK_GNU_EXTENSIONS
3145 llist_t *list_e = NULL;
3146 #endif
3147 int i, j;
3148 var *v;
3149 var tv;
3150 char **envp;
3151 char *vnames = (char *)vNames; /* cheat */
3152 char *vvalues = (char *)vValues;
3153
3154 INIT_G();
3155
3156 /* Undo busybox.c, or else strtod may eat ','! This breaks parsing:
3157 * $1,$2 == '$1,' '$2', NOT '$1' ',' '$2' */
3158 if (ENABLE_LOCALE_SUPPORT)
3159 setlocale(LC_NUMERIC, "C");
3160
3161 zero_out_var(&tv);
3162
3163 /* allocate global buffer */
3164 g_buf = xmalloc(MAXVARFMT + 1);
3165
3166 vhash = hash_init();
3167 ahash = hash_init();
3168 fdhash = hash_init();
3169 fnhash = hash_init();
3170
3171 /* initialize variables */
3172 for (i = 0; *vnames; i++) {
3173 intvar[i] = v = newvar(nextword(&vnames));
3174 if (*vvalues != '\377')
3175 setvar_s(v, nextword(&vvalues));
3176 else
3177 setvar_i(v, 0);
3178
3179 if (*vnames == '*') {
3180 v->type |= VF_SPECIAL;
3181 vnames++;
3182 }
3183 }
3184
3185 handle_special(intvar[FS]);
3186 handle_special(intvar[RS]);
3187
3188 newfile("/dev/stdin")->F = stdin;
3189 newfile("/dev/stdout")->F = stdout;
3190 newfile("/dev/stderr")->F = stderr;
3191
3192 /* Huh, people report that sometimes environ is NULL. Oh well. */
3193 if (environ) for (envp = environ; *envp; envp++) {
3194 /* environ is writable, thus we don't strdup it needlessly */
3195 char *s = *envp;
3196 char *s1 = strchr(s, '=');
3197 if (s1) {
3198 *s1 = '\0';
3199 /* Both findvar and setvar_u take const char*
3200 * as 2nd arg -> environment is not trashed */
3201 setvar_u(findvar(iamarray(intvar[ENVIRON]), s), s1 + 1);
3202 *s1 = '=';
3203 }
3204 }
3205 opt_complementary = OPTCOMPLSTR_AWK;
3206 opt = getopt32(argv, OPTSTR_AWK, &opt_F, &list_v, &list_f, IF_FEATURE_AWK_GNU_EXTENSIONS(&list_e,) NULL);
3207 argv += optind;
3208 argc -= optind;
3209 if (opt & OPT_W)
3210 bb_error_msg("warning: option -W is ignored");
3211 if (opt & OPT_F) {
3212 unescape_string_in_place(opt_F);
3213 setvar_s(intvar[FS], opt_F);
3214 }
3215 while (list_v) {
3216 if (!is_assignment(llist_pop(&list_v)))
3217 bb_show_usage();
3218 }
3219 while (list_f) {
3220 char *s = NULL;
3221 FILE *from_file;
3222
3223 g_progname = llist_pop(&list_f);
3224 from_file = xfopen_stdin(g_progname);
3225 /* one byte is reserved for some trick in next_token */
3226 for (i = j = 1; j > 0; i += j) {
3227 s = xrealloc(s, i + 4096);
3228 j = fread(s + i, 1, 4094, from_file);
3229 }
3230 s[i] = '\0';
3231 fclose(from_file);
3232 parse_program(s + 1);
3233 free(s);
3234 }
3235 g_progname = "cmd. line";
3236 #if ENABLE_FEATURE_AWK_GNU_EXTENSIONS
3237 while (list_e) {
3238 parse_program(llist_pop(&list_e));
3239 }
3240 #endif
3241 if (!(opt & (OPT_f | OPT_e))) {
3242 if (!*argv)
3243 bb_show_usage();
3244 parse_program(*argv++);
3245 argc--;
3246 }
3247
3248 /* fill in ARGV array */
3249 setvar_i(intvar[ARGC], argc + 1);
3250 setari_u(intvar[ARGV], 0, "awk");
3251 i = 0;
3252 while (*argv)
3253 setari_u(intvar[ARGV], ++i, *argv++);
3254
3255 evaluate(beginseq.first, &tv);
3256 if (!mainseq.first && !endseq.first)
3257 awk_exit(EXIT_SUCCESS);
3258
3259 /* input file could already be opened in BEGIN block */
3260 if (!iF)
3261 iF = next_input_file();
3262
3263 /* passing through input files */
3264 while (iF) {
3265 nextfile = FALSE;
3266 setvar_i(intvar[FNR], 0);
3267
3268 while ((i = awk_getline(iF, intvar[F0])) > 0) {
3269 nextrec = FALSE;
3270 incvar(intvar[NR]);
3271 incvar(intvar[FNR]);
3272 evaluate(mainseq.first, &tv);
3273
3274 if (nextfile)
3275 break;
3276 }
3277
3278 if (i < 0)
3279 syntax_error(strerror(errno));
3280
3281 iF = next_input_file();
3282 }
3283
3284 awk_exit(EXIT_SUCCESS);
3285 /*return 0;*/
3286 }
Tomato firmware and modifications.