editors/awk.c

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