X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=editors%2Fawk.c;h=a820c7a179f946d39775a5a2b947a485161cb33a;hb=d21f596ddb294bdb65623ba1d0e49b17d0829229;hp=d00fcafb171003e51ff90cf1e596992d3a31707a;hpb=bb20462cb34245037ecf92a0e7fc42b54b9e2d7b;p=oweals%2Fbusybox.git diff --git a/editors/awk.c b/editors/awk.c index d00fcafb1..a820c7a17 100644 --- a/editors/awk.c +++ b/editors/awk.c @@ -4,64 +4,45 @@ * * Copyright (C) 2002 by Dmitry Zakharov * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * + * Licensed under the GPL v2 or later, see the file LICENSE in this tarball. */ -#include -#include -#include -#include -#include -#include +#include "libbb.h" +#include "xregex.h" #include -#include -#include +extern char **environ; -#include "xregex.h" -#include "busybox.h" +/* This is a NOEXEC applet. Be very careful! */ -#define MAXVARFMT 240 -#define MINNVBLOCK 64 +#define MAXVARFMT 240 +#define MINNVBLOCK 64 /* variable flags */ -#define VF_NUMBER 0x0001 /* 1 = primary type is number */ -#define VF_ARRAY 0x0002 /* 1 = it's an array */ +#define VF_NUMBER 0x0001 /* 1 = primary type is number */ +#define VF_ARRAY 0x0002 /* 1 = it's an array */ -#define VF_CACHED 0x0100 /* 1 = num/str value has cached str/num eq */ -#define VF_USER 0x0200 /* 1 = user input (may be numeric string) */ -#define VF_SPECIAL 0x0400 /* 1 = requires extra handling when changed */ -#define VF_WALK 0x0800 /* 1 = variable has alloc'd x.walker list */ -#define VF_FSTR 0x1000 /* 1 = string points to fstring buffer */ -#define VF_CHILD 0x2000 /* 1 = function arg; x.parent points to source */ -#define VF_DIRTY 0x4000 /* 1 = variable was set explicitly */ +#define VF_CACHED 0x0100 /* 1 = num/str value has cached str/num eq */ +#define VF_USER 0x0200 /* 1 = user input (may be numeric string) */ +#define VF_SPECIAL 0x0400 /* 1 = requires extra handling when changed */ +#define VF_WALK 0x0800 /* 1 = variable has alloc'd x.walker list */ +#define VF_FSTR 0x1000 /* 1 = var::string points to fstring buffer */ +#define VF_CHILD 0x2000 /* 1 = function arg; x.parent points to source */ +#define VF_DIRTY 0x4000 /* 1 = variable was set explicitly */ /* these flags are static, don't change them when value is changed */ -#define VF_DONTTOUCH (VF_ARRAY | VF_SPECIAL | VF_WALK | VF_CHILD | VF_DIRTY) +#define VF_DONTTOUCH (VF_ARRAY | VF_SPECIAL | VF_WALK | VF_CHILD | VF_DIRTY) /* Variable */ typedef struct var_s { - unsigned short type; /* flags */ + unsigned type; /* flags */ double number; char *string; union { - int aidx; /* func arg index (on compilation stage) */ - struct xhash_s *array; /* array ptr */ - struct var_s *parent; /* for func args, ptr to actual parameter */ - char **walker; /* list of array elements (for..in) */ + int aidx; /* func arg idx (for compilation stage) */ + struct xhash_s *array; /* array ptr */ + struct var_s *parent; /* for func args, ptr to actual parameter */ + char **walker; /* list of array elements (for..in) */ } x; } var; @@ -69,12 +50,12 @@ typedef struct var_s { typedef struct chain_s { struct node_s *first; struct node_s *last; - char *programname; + const char *programname; } chain; /* Function */ typedef struct func_s { - unsigned short nargs; + unsigned nargs; struct chain_s body; } func; @@ -85,31 +66,31 @@ typedef struct rstream_s { int adv; int size; int pos; - unsigned short is_pipe; + smallint is_pipe; } rstream; typedef struct hash_item_s { union { - struct var_s v; /* variable/array hash */ - struct rstream_s rs; /* redirect streams hash */ - struct func_s f; /* functions hash */ + struct var_s v; /* variable/array hash */ + struct rstream_s rs; /* redirect streams hash */ + struct func_s f; /* functions hash */ } data; - struct hash_item_s *next; /* next in chain */ - char name[1]; /* really it's longer */ + struct hash_item_s *next; /* next in chain */ + char name[1]; /* really it's longer */ } hash_item; typedef struct xhash_s { - unsigned int nel; /* num of elements */ - unsigned int csize; /* current hash size */ - unsigned int nprime; /* next hash size in PRIMES[] */ - unsigned int glen; /* summary length of item names */ + unsigned nel; /* num of elements */ + unsigned csize; /* current hash size */ + unsigned nprime; /* next hash size in PRIMES[] */ + unsigned glen; /* summary length of item names */ struct hash_item_s **items; } xhash; /* Tree node */ typedef struct node_s { uint32_t info; - unsigned short lineno; + unsigned lineno; union { struct node_s *n; var *v; @@ -175,42 +156,42 @@ typedef struct tsplitter_s { #define TC_STRING (1 << 28) #define TC_NUMBER (1 << 29) -#define TC_UOPPRE (TC_UOPPRE1 | TC_UOPPRE2) +#define TC_UOPPRE (TC_UOPPRE1 | TC_UOPPRE2) /* combined token classes */ -#define TC_BINOP (TC_BINOPX | TC_COMMA | TC_PIPE | TC_IN) -#define TC_UNARYOP (TC_UOPPRE | TC_UOPPOST) -#define TC_OPERAND (TC_VARIABLE | TC_ARRAY | TC_FUNCTION | \ - TC_BUILTIN | TC_GETLINE | TC_SEQSTART | TC_STRING | TC_NUMBER) +#define TC_BINOP (TC_BINOPX | TC_COMMA | TC_PIPE | TC_IN) +#define TC_UNARYOP (TC_UOPPRE | TC_UOPPOST) +#define TC_OPERAND (TC_VARIABLE | TC_ARRAY | TC_FUNCTION \ + | TC_BUILTIN | TC_GETLINE | TC_SEQSTART | TC_STRING | TC_NUMBER) -#define TC_STATEMNT (TC_STATX | TC_WHILE) -#define TC_OPTERM (TC_SEMICOL | TC_NEWLINE) +#define TC_STATEMNT (TC_STATX | TC_WHILE) +#define TC_OPTERM (TC_SEMICOL | TC_NEWLINE) /* word tokens, cannot mean something else if not expected */ -#define TC_WORD (TC_IN | TC_STATEMNT | TC_ELSE | TC_BUILTIN | \ - TC_GETLINE | TC_FUNCDECL | TC_BEGIN | TC_END) +#define TC_WORD (TC_IN | TC_STATEMNT | TC_ELSE | TC_BUILTIN \ + | TC_GETLINE | TC_FUNCDECL | TC_BEGIN | TC_END) /* discard newlines after these */ -#define TC_NOTERM (TC_COMMA | TC_GRPSTART | TC_GRPTERM | \ - TC_BINOP | TC_OPTERM) +#define TC_NOTERM (TC_COMMA | TC_GRPSTART | TC_GRPTERM \ + | TC_BINOP | TC_OPTERM) /* what can expression begin with */ -#define TC_OPSEQ (TC_OPERAND | TC_UOPPRE | TC_REGEXP) +#define TC_OPSEQ (TC_OPERAND | TC_UOPPRE | TC_REGEXP) /* what can group begin with */ -#define TC_GRPSEQ (TC_OPSEQ | TC_OPTERM | TC_STATEMNT | TC_GRPSTART) +#define TC_GRPSEQ (TC_OPSEQ | TC_OPTERM | TC_STATEMNT | TC_GRPSTART) /* if previous token class is CONCAT1 and next is CONCAT2, concatenation */ /* operator is inserted between them */ -#define TC_CONCAT1 (TC_VARIABLE | TC_ARRTERM | TC_SEQTERM | \ - TC_STRING | TC_NUMBER | TC_UOPPOST) -#define TC_CONCAT2 (TC_OPERAND | TC_UOPPRE) +#define TC_CONCAT1 (TC_VARIABLE | TC_ARRTERM | TC_SEQTERM \ + | TC_STRING | TC_NUMBER | TC_UOPPOST) +#define TC_CONCAT2 (TC_OPERAND | TC_UOPPRE) -#define OF_RES1 0x010000 -#define OF_RES2 0x020000 -#define OF_STR1 0x040000 -#define OF_STR2 0x080000 -#define OF_NUM1 0x100000 -#define OF_CHECKED 0x200000 +#define OF_RES1 0x010000 +#define OF_RES2 0x020000 +#define OF_STR1 0x040000 +#define OF_STR2 0x080000 +#define OF_NUM1 0x100000 +#define OF_CHECKED 0x200000 /* combined operator flags */ #define xx 0 @@ -224,16 +205,16 @@ typedef struct tsplitter_s { #define SV (OF_RES1 | OF_STR1 | OF_RES2) #define SS (OF_RES1 | OF_STR1 | OF_RES2 | OF_STR2) -#define OPCLSMASK 0xFF00 -#define OPNMASK 0x007F +#define OPCLSMASK 0xFF00 +#define OPNMASK 0x007F /* operator priority is a highest byte (even: r->l, odd: l->r grouping) * For builtins it has different meaning: n n s3 s2 s1 v3 v2 v1, * n - min. number of args, vN - resolve Nth arg to var, sN - resolve to string */ -#define P(x) (x << 24) -#define PRIMASK 0x7F000000 -#define PRIMASK2 0x7E000000 +#define P(x) (x << 24) +#define PRIMASK 0x7F000000 +#define PRIMASK2 0x7E000000 /* Operation classes */ @@ -241,129 +222,133 @@ typedef struct tsplitter_s { #define RECUR_FROM_THIS 0x1000 enum { - OC_DELETE=0x0100, OC_EXEC=0x0200, OC_NEWSOURCE=0x0300, - OC_PRINT=0x0400, OC_PRINTF=0x0500, OC_WALKINIT=0x0600, - - OC_BR=0x0700, OC_BREAK=0x0800, OC_CONTINUE=0x0900, - OC_EXIT=0x0a00, OC_NEXT=0x0b00, OC_NEXTFILE=0x0c00, - OC_TEST=0x0d00, OC_WALKNEXT=0x0e00, - - OC_BINARY=0x1000, OC_BUILTIN=0x1100, OC_COLON=0x1200, - OC_COMMA=0x1300, OC_COMPARE=0x1400, OC_CONCAT=0x1500, - OC_FBLTIN=0x1600, OC_FIELD=0x1700, OC_FNARG=0x1800, - OC_FUNC=0x1900, OC_GETLINE=0x1a00, OC_IN=0x1b00, - OC_LAND=0x1c00, OC_LOR=0x1d00, OC_MATCH=0x1e00, - OC_MOVE=0x1f00, OC_PGETLINE=0x2000, OC_REGEXP=0x2100, - OC_REPLACE=0x2200, OC_RETURN=0x2300, OC_SPRINTF=0x2400, - OC_TERNARY=0x2500, OC_UNARY=0x2600, OC_VAR=0x2700, - OC_DONE=0x2800, - - ST_IF=0x3000, ST_DO=0x3100, ST_FOR=0x3200, - ST_WHILE=0x3300 + OC_DELETE = 0x0100, OC_EXEC = 0x0200, OC_NEWSOURCE = 0x0300, + OC_PRINT = 0x0400, OC_PRINTF = 0x0500, OC_WALKINIT = 0x0600, + + OC_BR = 0x0700, OC_BREAK = 0x0800, OC_CONTINUE = 0x0900, + OC_EXIT = 0x0a00, OC_NEXT = 0x0b00, OC_NEXTFILE = 0x0c00, + OC_TEST = 0x0d00, OC_WALKNEXT = 0x0e00, + + OC_BINARY = 0x1000, OC_BUILTIN = 0x1100, OC_COLON = 0x1200, + OC_COMMA = 0x1300, OC_COMPARE = 0x1400, OC_CONCAT = 0x1500, + OC_FBLTIN = 0x1600, OC_FIELD = 0x1700, OC_FNARG = 0x1800, + OC_FUNC = 0x1900, OC_GETLINE = 0x1a00, OC_IN = 0x1b00, + OC_LAND = 0x1c00, OC_LOR = 0x1d00, OC_MATCH = 0x1e00, + OC_MOVE = 0x1f00, OC_PGETLINE = 0x2000, OC_REGEXP = 0x2100, + OC_REPLACE = 0x2200, OC_RETURN = 0x2300, OC_SPRINTF = 0x2400, + OC_TERNARY = 0x2500, OC_UNARY = 0x2600, OC_VAR = 0x2700, + OC_DONE = 0x2800, + + ST_IF = 0x3000, ST_DO = 0x3100, ST_FOR = 0x3200, + ST_WHILE = 0x3300 }; /* simple builtins */ enum { - F_in=0, F_rn, F_co, F_ex, F_lg, F_si, F_sq, F_sr, + F_in, F_rn, F_co, F_ex, F_lg, F_si, F_sq, F_sr, F_ti, F_le, F_sy, F_ff, F_cl }; /* builtins */ enum { - B_a2=0, B_ix, B_ma, B_sp, B_ss, B_ti, B_lo, B_up, - B_ge, B_gs, B_su + B_a2, B_ix, B_ma, B_sp, B_ss, B_ti, B_lo, B_up, + B_ge, B_gs, B_su, + B_an, B_co, B_ls, B_or, B_rs, B_xo, }; /* tokens and their corresponding info values */ -#define NTC "\377" /* switch to next token class (tc<<1) */ -#define NTCC '\377' +#define NTC "\377" /* switch to next token class (tc<<1) */ +#define NTCC '\377' #define OC_B OC_BUILTIN -static char * const tokenlist = - "\1(" NTC - "\1)" NTC - "\1/" NTC /* REGEXP */ - "\2>>" "\1>" "\1|" NTC /* OUTRDR */ - "\2++" "\2--" NTC /* UOPPOST */ - "\2++" "\2--" "\1$" NTC /* UOPPRE1 */ - "\2==" "\1=" "\2+=" "\2-=" /* BINOPX */ - "\2*=" "\2/=" "\2%=" "\2^=" - "\1+" "\1-" "\3**=" "\2**" - "\1/" "\1%" "\1^" "\1*" - "\2!=" "\2>=" "\2<=" "\1>" - "\1<" "\2!~" "\1~" "\2&&" - "\2||" "\1?" "\1:" NTC - "\2in" NTC - "\1," NTC - "\1|" NTC - "\1+" "\1-" "\1!" NTC /* UOPPRE2 */ - "\1]" NTC - "\1{" NTC - "\1}" NTC - "\1;" NTC - "\1\n" NTC - "\2if" "\2do" "\3for" "\5break" /* STATX */ - "\10continue" "\6delete" "\5print" - "\6printf" "\4next" "\10nextfile" - "\6return" "\4exit" NTC - "\5while" NTC - "\4else" NTC - - "\5close" "\6system" "\6fflush" "\5atan2" /* BUILTIN */ - "\3cos" "\3exp" "\3int" "\3log" - "\4rand" "\3sin" "\4sqrt" "\5srand" - "\6gensub" "\4gsub" "\5index" "\6length" - "\5match" "\5split" "\7sprintf" "\3sub" - "\6substr" "\7systime" "\10strftime" - "\7tolower" "\7toupper" NTC - "\7getline" NTC - "\4func" "\10function" NTC - "\5BEGIN" NTC - "\3END" "\0" +static const char tokenlist[] ALIGN1 = + "\1(" NTC + "\1)" NTC + "\1/" NTC /* REGEXP */ + "\2>>" "\1>" "\1|" NTC /* OUTRDR */ + "\2++" "\2--" NTC /* UOPPOST */ + "\2++" "\2--" "\1$" NTC /* UOPPRE1 */ + "\2==" "\1=" "\2+=" "\2-=" /* BINOPX */ + "\2*=" "\2/=" "\2%=" "\2^=" + "\1+" "\1-" "\3**=" "\2**" + "\1/" "\1%" "\1^" "\1*" + "\2!=" "\2>=" "\2<=" "\1>" + "\1<" "\2!~" "\1~" "\2&&" + "\2||" "\1?" "\1:" NTC + "\2in" NTC + "\1," NTC + "\1|" NTC + "\1+" "\1-" "\1!" NTC /* UOPPRE2 */ + "\1]" NTC + "\1{" NTC + "\1}" NTC + "\1;" NTC + "\1\n" NTC + "\2if" "\2do" "\3for" "\5break" /* STATX */ + "\10continue" "\6delete" "\5print" + "\6printf" "\4next" "\10nextfile" + "\6return" "\4exit" NTC + "\5while" NTC + "\4else" NTC + + "\3and" "\5compl" "\6lshift" "\2or" + "\6rshift" "\3xor" + "\5close" "\6system" "\6fflush" "\5atan2" /* BUILTIN */ + "\3cos" "\3exp" "\3int" "\3log" + "\4rand" "\3sin" "\4sqrt" "\5srand" + "\6gensub" "\4gsub" "\5index" "\6length" + "\5match" "\5split" "\7sprintf" "\3sub" + "\6substr" "\7systime" "\10strftime" + "\7tolower" "\7toupper" NTC + "\7getline" NTC + "\4func" "\10function" NTC + "\5BEGIN" NTC + "\3END" "\0" ; -static uint32_t tokeninfo[] = { - +static const uint32_t tokeninfo[] = { 0, 0, OC_REGEXP, - xS|'a', xS|'w', xS|'|', - OC_UNARY|xV|P(9)|'p', OC_UNARY|xV|P(9)|'m', - OC_UNARY|xV|P(9)|'P', OC_UNARY|xV|P(9)|'M', - OC_FIELD|xV|P(5), - OC_COMPARE|VV|P(39)|5, OC_MOVE|VV|P(74), - OC_REPLACE|NV|P(74)|'+', OC_REPLACE|NV|P(74)|'-', - OC_REPLACE|NV|P(74)|'*', OC_REPLACE|NV|P(74)|'/', - OC_REPLACE|NV|P(74)|'%', OC_REPLACE|NV|P(74)|'&', - OC_BINARY|NV|P(29)|'+', OC_BINARY|NV|P(29)|'-', - OC_REPLACE|NV|P(74)|'&', OC_BINARY|NV|P(15)|'&', - OC_BINARY|NV|P(25)|'/', OC_BINARY|NV|P(25)|'%', - OC_BINARY|NV|P(15)|'&', OC_BINARY|NV|P(25)|'*', - OC_COMPARE|VV|P(39)|4, OC_COMPARE|VV|P(39)|3, - OC_COMPARE|VV|P(39)|0, OC_COMPARE|VV|P(39)|1, - OC_COMPARE|VV|P(39)|2, OC_MATCH|Sx|P(45)|'!', - OC_MATCH|Sx|P(45)|'~', OC_LAND|Vx|P(55), - OC_LOR|Vx|P(59), OC_TERNARY|Vx|P(64)|'?', - OC_COLON|xx|P(67)|':', + xS|'a', xS|'w', xS|'|', + OC_UNARY|xV|P(9)|'p', OC_UNARY|xV|P(9)|'m', + OC_UNARY|xV|P(9)|'P', OC_UNARY|xV|P(9)|'M', + OC_FIELD|xV|P(5), + OC_COMPARE|VV|P(39)|5, OC_MOVE|VV|P(74), + OC_REPLACE|NV|P(74)|'+', OC_REPLACE|NV|P(74)|'-', + OC_REPLACE|NV|P(74)|'*', OC_REPLACE|NV|P(74)|'/', + OC_REPLACE|NV|P(74)|'%', OC_REPLACE|NV|P(74)|'&', + OC_BINARY|NV|P(29)|'+', OC_BINARY|NV|P(29)|'-', + OC_REPLACE|NV|P(74)|'&', OC_BINARY|NV|P(15)|'&', + OC_BINARY|NV|P(25)|'/', OC_BINARY|NV|P(25)|'%', + OC_BINARY|NV|P(15)|'&', OC_BINARY|NV|P(25)|'*', + OC_COMPARE|VV|P(39)|4, OC_COMPARE|VV|P(39)|3, + OC_COMPARE|VV|P(39)|0, OC_COMPARE|VV|P(39)|1, + OC_COMPARE|VV|P(39)|2, OC_MATCH|Sx|P(45)|'!', + OC_MATCH|Sx|P(45)|'~', OC_LAND|Vx|P(55), + OC_LOR|Vx|P(59), OC_TERNARY|Vx|P(64)|'?', + OC_COLON|xx|P(67)|':', OC_IN|SV|P(49), OC_COMMA|SS|P(80), OC_PGETLINE|SV|P(37), - OC_UNARY|xV|P(19)|'+', OC_UNARY|xV|P(19)|'-', - OC_UNARY|xV|P(19)|'!', + OC_UNARY|xV|P(19)|'+', OC_UNARY|xV|P(19)|'-', + OC_UNARY|xV|P(19)|'!', 0, 0, 0, 0, 0, - ST_IF, ST_DO, ST_FOR, OC_BREAK, - OC_CONTINUE, OC_DELETE|Vx, OC_PRINT, - OC_PRINTF, OC_NEXT, OC_NEXTFILE, - OC_RETURN|Vx, OC_EXIT|Nx, + ST_IF, ST_DO, ST_FOR, OC_BREAK, + OC_CONTINUE, OC_DELETE|Vx, OC_PRINT, + OC_PRINTF, OC_NEXT, OC_NEXTFILE, + OC_RETURN|Vx, OC_EXIT|Nx, ST_WHILE, 0, + OC_B|B_an|P(0x83), OC_B|B_co|P(0x41), OC_B|B_ls|P(0x83), OC_B|B_or|P(0x83), + OC_B|B_rs|P(0x83), OC_B|B_xo|P(0x83), OC_FBLTIN|Sx|F_cl, OC_FBLTIN|Sx|F_sy, OC_FBLTIN|Sx|F_ff, OC_B|B_a2|P(0x83), OC_FBLTIN|Nx|F_co, OC_FBLTIN|Nx|F_ex, OC_FBLTIN|Nx|F_in, OC_FBLTIN|Nx|F_lg, OC_FBLTIN|F_rn, OC_FBLTIN|Nx|F_si, OC_FBLTIN|Nx|F_sq, OC_FBLTIN|Nx|F_sr, @@ -380,63 +365,132 @@ static uint32_t tokeninfo[] = { /* internal variable names and their initial values */ /* asterisk marks SPECIAL vars; $ is just no-named Field0 */ enum { - CONVFMT=0, OFMT, FS, OFS, - ORS, RS, RT, FILENAME, - SUBSEP, ARGIND, ARGC, ARGV, - ERRNO, FNR, - NR, NF, IGNORECASE, - ENVIRON, F0, _intvarcount_ + CONVFMT, OFMT, FS, OFS, + ORS, RS, RT, FILENAME, + SUBSEP, ARGIND, ARGC, ARGV, + ERRNO, FNR, + NR, NF, IGNORECASE, + ENVIRON, F0, NUM_INTERNAL_VARS }; -static char * vNames = - "CONVFMT\0" "OFMT\0" "FS\0*" "OFS\0" - "ORS\0" "RS\0*" "RT\0" "FILENAME\0" - "SUBSEP\0" "ARGIND\0" "ARGC\0" "ARGV\0" - "ERRNO\0" "FNR\0" - "NR\0" "NF\0*" "IGNORECASE\0*" - "ENVIRON\0" "$\0*" "\0"; - -static char * vValues = - "%.6g\0" "%.6g\0" " \0" " \0" - "\n\0" "\n\0" "\0" "\0" +static const char vNames[] ALIGN1 = + "CONVFMT\0" "OFMT\0" "FS\0*" "OFS\0" + "ORS\0" "RS\0*" "RT\0" "FILENAME\0" + "SUBSEP\0" "ARGIND\0" "ARGC\0" "ARGV\0" + "ERRNO\0" "FNR\0" + "NR\0" "NF\0*" "IGNORECASE\0*" + "ENVIRON\0" "$\0*" "\0"; + +static const char vValues[] ALIGN1 = + "%.6g\0" "%.6g\0" " \0" " \0" + "\n\0" "\n\0" "\0" "\0" "\034\0" "\377"; /* hash size may grow to these values */ -#define FIRST_PRIME 61; -static const unsigned int PRIMES[] = { 251, 1021, 4093, 16381, 65521 }; -static const unsigned int NPRIMES = sizeof(PRIMES) / sizeof(unsigned int); +#define FIRST_PRIME 61 +static const uint16_t PRIMES[] ALIGN2 = { 251, 1021, 4093, 16381, 65521 }; + + +/* Globals. Split in two parts so that first one is addressed + * with (mostly short) negative offsets */ +struct globals { + chain beginseq, mainseq, endseq, *seq; + node *break_ptr, *continue_ptr; + rstream *iF; + xhash *vhash, *ahash, *fdhash, *fnhash; + const char *g_progname; + int g_lineno; + int nfields; + int maxfields; /* used in fsrealloc() only */ + var *Fields; + nvblock *g_cb; + char *g_pos; + char *g_buf; + smallint icase; + smallint exiting; + smallint nextrec; + smallint nextfile; + smallint is_f0_split; +}; +struct globals2 { + uint32_t t_info; /* often used */ + uint32_t t_tclass; + char *t_string; + int t_lineno; + int t_rollback; -/* globals */ + var *intvar[NUM_INTERNAL_VARS]; /* often used */ -extern char **environ; + /* former statics from various functions */ + char *split_f0__fstrings; + + uint32_t next_token__save_tclass; + uint32_t next_token__save_info; + uint32_t next_token__ltclass; + smallint next_token__concat_inserted; + + smallint next_input_file__files_happen; + rstream next_input_file__rsm; + + var *evaluate__fnargs; + unsigned evaluate__seed; + regex_t evaluate__sreg; + + var ptest__v; + + tsplitter exec_builtin__tspl; + + /* biggest and least used members go last */ + double t_double; + tsplitter fsplitter, rsplitter; +}; +#define G1 (ptr_to_globals[-1]) +#define G (*(struct globals2 *const)ptr_to_globals) +/* For debug. nm --size-sort awk.o | grep -vi ' [tr] ' */ +/* char G1size[sizeof(G1)]; - 0x6c */ +/* char Gsize[sizeof(G)]; - 0x1cc */ +/* Trying to keep most of members accessible with short offsets: */ +/* char Gofs_seed[offsetof(struct globals2, evaluate__seed)]; - 0x90 */ +#define beginseq (G1.beginseq ) +#define mainseq (G1.mainseq ) +#define endseq (G1.endseq ) +#define seq (G1.seq ) +#define break_ptr (G1.break_ptr ) +#define continue_ptr (G1.continue_ptr) +#define iF (G1.iF ) +#define vhash (G1.vhash ) +#define ahash (G1.ahash ) +#define fdhash (G1.fdhash ) +#define fnhash (G1.fnhash ) +#define g_progname (G1.g_progname ) +#define g_lineno (G1.g_lineno ) +#define nfields (G1.nfields ) +#define maxfields (G1.maxfields ) +#define Fields (G1.Fields ) +#define g_cb (G1.g_cb ) +#define g_pos (G1.g_pos ) +#define g_buf (G1.g_buf ) +#define icase (G1.icase ) +#define exiting (G1.exiting ) +#define nextrec (G1.nextrec ) +#define nextfile (G1.nextfile ) +#define is_f0_split (G1.is_f0_split ) +#define t_info (G.t_info ) +#define t_tclass (G.t_tclass ) +#define t_string (G.t_string ) +#define t_double (G.t_double ) +#define t_lineno (G.t_lineno ) +#define t_rollback (G.t_rollback ) +#define intvar (G.intvar ) +#define fsplitter (G.fsplitter ) +#define rsplitter (G.rsplitter ) +#define INIT_G() do { \ + PTR_TO_GLOBALS = xzalloc(sizeof(G1) + sizeof(G)) + sizeof(G1); \ + G.next_token__ltclass = TC_OPTERM; \ + G.evaluate__seed = 1; \ +} while (0) -static var * V[_intvarcount_]; -static chain beginseq, mainseq, endseq, *seq; -static int nextrec, nextfile; -static node *break_ptr, *continue_ptr; -static rstream *iF; -static xhash *vhash, *ahash, *fdhash, *fnhash; -static char *programname; -static short lineno; -static int is_f0_split; -static int nfields = 0; -static var *Fields = NULL; -static tsplitter fsplitter, rsplitter; -static nvblock *cb = NULL; -static char *pos; -static char *buf; -static int icase = FALSE; -static int exiting = FALSE; - -static struct { - uint32_t tclass; - uint32_t info; - char *string; - double number; - short lineno; - int rollback; -} t; /* function prototypes */ static void handle_special(var *); @@ -444,40 +498,42 @@ static node *parse_expr(uint32_t); static void chain_group(void); static var *evaluate(node *, var *); static rstream *next_input_file(void); -static int fmt_num(char *, int, char *, double, int); -static int awk_exit(int); +static int fmt_num(char *, int, const char *, double, int); +static int awk_exit(int) ATTRIBUTE_NORETURN; /* ---- error handling ---- */ -static const char EMSG_INTERNAL_ERROR[] = "Internal error"; -static const char EMSG_UNEXP_EOS[] = "Unexpected end of string"; -static const char EMSG_UNEXP_TOKEN[] = "Unexpected token"; -static const char EMSG_DIV_BY_ZERO[] = "Division by zero"; -static const char EMSG_INV_FMT[] = "Invalid format specifier"; -static const char EMSG_TOO_FEW_ARGS[] = "Too few arguments for builtin"; -static const char EMSG_NOT_ARRAY[] = "Not an array"; -static const char EMSG_POSSIBLE_ERROR[] = "Possible syntax error"; -static const char EMSG_UNDEF_FUNC[] = "Call to undefined function"; -#ifndef CONFIG_FEATURE_AWK_MATH -static const char EMSG_NO_MATH[] = "Math support is not compiled in"; +static const char EMSG_INTERNAL_ERROR[] ALIGN1 = "Internal error"; +static const char EMSG_UNEXP_EOS[] ALIGN1 = "Unexpected end of string"; +static const char EMSG_UNEXP_TOKEN[] ALIGN1 = "Unexpected token"; +static const char EMSG_DIV_BY_ZERO[] ALIGN1 = "Division by zero"; +static const char EMSG_INV_FMT[] ALIGN1 = "Invalid format specifier"; +static const char EMSG_TOO_FEW_ARGS[] ALIGN1 = "Too few arguments for builtin"; +static const char EMSG_NOT_ARRAY[] ALIGN1 = "Not an array"; +static const char EMSG_POSSIBLE_ERROR[] ALIGN1 = "Possible syntax error"; +static const char EMSG_UNDEF_FUNC[] ALIGN1 = "Call to undefined function"; +#if !ENABLE_FEATURE_AWK_MATH +static const char EMSG_NO_MATH[] ALIGN1 = "Math support is not compiled in"; #endif -static void syntax_error(const char * const message) +static void zero_out_var(var * vp) { - bb_error_msg("%s:%i: %s", programname, lineno, message); - exit(1); + memset(vp, 0, sizeof(*vp)); } -#define runtime_error(x) syntax_error(x) - +static void syntax_error(const char *const message) ATTRIBUTE_NORETURN; +static void syntax_error(const char *const message) +{ + bb_error_msg_and_die("%s:%i: %s", g_progname, g_lineno, message); +} /* ---- hash stuff ---- */ -static unsigned int hashidx(char *name) +static unsigned hashidx(const char *name) { - register unsigned int idx=0; + unsigned idx = 0; - while (*name) idx = *name++ + (idx << 6) - idx; + while (*name) idx = *name++ + (idx << 6) - idx; return idx; } @@ -486,15 +542,15 @@ static xhash *hash_init(void) { xhash *newhash; - newhash = (xhash *)xcalloc(1, sizeof(xhash)); + newhash = xzalloc(sizeof(xhash)); newhash->csize = FIRST_PRIME; - newhash->items = (hash_item **)xcalloc(newhash->csize, sizeof(hash_item *)); + newhash->items = xzalloc(newhash->csize * sizeof(hash_item *)); return newhash; } /* find item in hash, return ptr to data, NULL if not found */ -static void *hash_search(xhash *hash, char *name) +static void *hash_search(xhash *hash, const char *name) { hash_item *hi; @@ -510,16 +566,16 @@ static void *hash_search(xhash *hash, char *name) /* grow hash if it becomes too big */ static void hash_rebuild(xhash *hash) { - unsigned int newsize, i, idx; + unsigned newsize, i, idx; hash_item **newitems, *hi, *thi; - if (hash->nprime == NPRIMES) + if (hash->nprime == ARRAY_SIZE(PRIMES)) return; newsize = PRIMES[hash->nprime++]; - newitems = (hash_item **)xcalloc(newsize, sizeof(hash_item *)); + newitems = xzalloc(newsize * sizeof(hash_item *)); - for (i=0; icsize; i++) { + for (i = 0; i < hash->csize; i++) { hi = hash->items[i]; while (hi) { thi = hi; @@ -536,19 +592,19 @@ static void hash_rebuild(xhash *hash) } /* find item in hash, add it if necessary. Return ptr to data */ -static void *hash_find(xhash *hash, char *name) +static void *hash_find(xhash *hash, const char *name) { hash_item *hi; - unsigned int idx; + unsigned idx; int l; hi = hash_search(hash, name); - if (! hi) { + if (!hi) { if (++hash->nel / hash->csize > 10) hash_rebuild(hash); - l = bb_strlen(name) + 1; - hi = xcalloc(sizeof(hash_item) + l, 1); + l = strlen(name) + 1; + hi = xzalloc(sizeof(hash_item) + l); memcpy(hi->name, name, l); idx = hashidx(name) % hash->csize; @@ -559,20 +615,20 @@ static void *hash_find(xhash *hash, char *name) return &(hi->data); } -#define findvar(hash, name) (var *) hash_find ( (hash) , (name) ) -#define newvar(name) (var *) hash_find ( vhash , (name) ) -#define newfile(name) (rstream *) hash_find ( fdhash , (name) ) -#define newfunc(name) (func *) hash_find ( fnhash , (name) ) +#define findvar(hash, name) ((var*) hash_find((hash), (name))) +#define newvar(name) ((var*) hash_find(vhash, (name))) +#define newfile(name) ((rstream*)hash_find(fdhash, (name))) +#define newfunc(name) ((func*) hash_find(fnhash, (name))) -static void hash_remove(xhash *hash, char *name) +static void hash_remove(xhash *hash, const char *name) { hash_item *hi, **phi; - phi = &(hash->items[ hashidx(name) % hash->csize ]); + phi = &(hash->items[hashidx(name) % hash->csize]); while (*phi) { hi = *phi; if (strcmp(hi->name, name) == 0) { - hash->glen -= (bb_strlen(name) + 1); + hash->glen -= (strlen(name) + 1); hash->nel--; *phi = hi->next; free(hi); @@ -586,10 +642,15 @@ static void hash_remove(xhash *hash, char *name) static void skip_spaces(char **s) { - register char *p = *s; + char *p = *s; - while(*p == ' ' || *p == '\t' || - (*p == '\\' && *(p+1) == '\n' && (++p, ++t.lineno))) { + while (1) { + if (*p == '\\' && p[1] == '\n') { + p++; + t_lineno++; + } else if (*p != ' ' && *p != '\t') { + break; + } p++; } *s = p; @@ -597,16 +658,16 @@ static void skip_spaces(char **s) static char *nextword(char **s) { - register char *p = *s; + char *p = *s; - while (*(*s)++) ; + while (*(*s)++) /* */; return p; } static char nextchar(char **s) { - register char c, *pps; + char c, *pps; c = *((*s)++); pps = *s; @@ -615,14 +676,14 @@ static char nextchar(char **s) return c; } -static inline int isalnum_(int c) +static int ALWAYS_INLINE isalnum_(int c) { return (isalnum(c) || c == '_'); } static FILE *afopen(const char *path, const char *mode) { - return (*path == '-' && *(path+1) == '\0') ? stdin : bb_xfopen(path, mode); + return (*path == '-' && *(path+1) == '\0') ? stdin : xfopen(path, mode); } /* -------- working with variables (set/get/copy/etc) -------- */ @@ -634,7 +695,7 @@ static xhash *iamarray(var *v) while (a->type & VF_CHILD) a = a->x.parent; - if (! (a->type & VF_ARRAY)) { + if (!(a->type & VF_ARRAY)) { a->type |= VF_ARRAY; a->x.array = hash_init(); } @@ -643,10 +704,10 @@ static xhash *iamarray(var *v) static void clear_array(xhash *array) { - unsigned int i; + unsigned i; hash_item *hi, *thi; - for (i=0; icsize; i++) { + for (i = 0; i < array->csize; i++) { hi = array->items[i]; while (hi) { thi = hi; @@ -677,18 +738,17 @@ static var *setvar_p(var *v, char *value) clrvar(v); v->string = value; handle_special(v); - return v; } /* same as setvar_p but make a copy of string */ -static var *setvar_s(var *v, char *value) +static var *setvar_s(var *v, const char *value) { - return setvar_p(v, (value && *value) ? bb_xstrdup(value) : NULL); + return setvar_p(v, (value && *value) ? xstrdup(value) : NULL); } /* same as setvar_s but set USER flag */ -static var *setvar_u(var *v, char *value) +static var *setvar_u(var *v, const char *value) { setvar_s(v, value); v->type |= VF_USER; @@ -696,10 +756,10 @@ static var *setvar_u(var *v, char *value) } /* set array element to user string */ -static void setari_u(var *a, int idx, char *s) +static void setari_u(var *a, int idx, const char *s) { - register var *v; - static char sidx[12]; + char sidx[sizeof(int)*3 + 1]; + var *v; sprintf(sidx, "%d", idx); v = findvar(iamarray(a), sidx); @@ -716,12 +776,12 @@ static var *setvar_i(var *v, double value) return v; } -static char *getvar_s(var *v) +static const char *getvar_s(var *v) { /* if v is numeric and has no cached string, convert it to string */ if ((v->type & (VF_NUMBER | VF_CACHED)) == VF_NUMBER) { - fmt_num(buf, MAXVARFMT, getvar_s(V[CONVFMT]), v->number, TRUE); - v->string = bb_xstrdup(buf); + fmt_num(g_buf, MAXVARFMT, getvar_s(intvar[CONVFMT]), v->number, TRUE); + v->string = xstrdup(g_buf); v->type |= VF_CACHED; } return (v->string == NULL) ? "" : v->string; @@ -749,14 +809,14 @@ static double getvar_i(var *v) return v->number; } -static var *copyvar(var *dest, var *src) +static var *copyvar(var *dest, const var *src) { if (dest != src) { clrvar(dest); - dest->type |= (src->type & ~VF_DONTTOUCH); + dest->type |= (src->type & ~(VF_DONTTOUCH | VF_FSTR)); dest->number = src->number; if (src->string) - dest->string = bb_xstrdup(src->string); + dest->string = xstrdup(src->string); } handle_special(dest); return dest; @@ -764,7 +824,7 @@ static var *copyvar(var *dest, var *src) static var *incvar(var *v) { - return setvar_i(v, getvar_i(v)+1.); + return setvar_i(v, getvar_i(v) + 1.); } /* return true if v is number or numeric string */ @@ -779,8 +839,7 @@ static int istrue(var *v) { if (is_numeric(v)) return (v->number == 0) ? 0 : 1; - else - return (v->string && *(v->string)) ? 1 : 0; + return (v->string && *(v->string)) ? 1 : 0; } /* temporary variables allocator. Last allocated should be first freed */ @@ -790,26 +849,26 @@ static var *nvalloc(int n) var *v, *r; int size; - while (cb) { - pb = cb; - if ((cb->pos - cb->nv) + n <= cb->size) break; - cb = cb->next; + while (g_cb) { + pb = g_cb; + if ((g_cb->pos - g_cb->nv) + n <= g_cb->size) break; + g_cb = g_cb->next; } - if (! cb) { + if (!g_cb) { size = (n <= MINNVBLOCK) ? MINNVBLOCK : n; - cb = (nvblock *)xmalloc(sizeof(nvblock) + size * sizeof(var)); - cb->size = size; - cb->pos = cb->nv; - cb->prev = pb; - cb->next = NULL; - if (pb) pb->next = cb; + g_cb = xmalloc(sizeof(nvblock) + size * sizeof(var)); + g_cb->size = size; + g_cb->pos = g_cb->nv; + g_cb->prev = pb; + g_cb->next = NULL; + if (pb) pb->next = g_cb; } - v = r = cb->pos; - cb->pos += n; + v = r = g_cb->pos; + g_cb->pos += n; - while (v < cb->pos) { + while (v < g_cb->pos) { v->type = 0; v->string = NULL; v++; @@ -822,11 +881,11 @@ static void nvfree(var *v) { var *p; - if (v < cb->nv || v >= cb->pos) - runtime_error(EMSG_INTERNAL_ERROR); + if (v < g_cb->nv || v >= g_cb->pos) + syntax_error(EMSG_INTERNAL_ERROR); - for (p=v; ppos; p++) { - if ((p->type & (VF_ARRAY|VF_CHILD)) == VF_ARRAY) { + for (p = v; p < g_cb->pos; p++) { + if ((p->type & (VF_ARRAY | VF_CHILD)) == VF_ARRAY) { clear_array(iamarray(p)); free(p->x.array->items); free(p->x.array); @@ -837,56 +896,57 @@ static void nvfree(var *v) clrvar(p); } - cb->pos = v; - while (cb->prev && cb->pos == cb->nv) { - cb = cb->prev; + g_cb->pos = v; + while (g_cb->prev && g_cb->pos == g_cb->nv) { + g_cb = g_cb->prev; } } /* ------- awk program text parsing ------- */ -/* Parse next token pointed by global pos, place results into global t. +/* Parse next token pointed by global pos, place results into global ttt. * If token isn't expected, give away. Return token class */ static uint32_t next_token(uint32_t expected) { +#define concat_inserted (G.next_token__concat_inserted) +#define save_tclass (G.next_token__save_tclass) +#define save_info (G.next_token__save_info) +/* Initialized to TC_OPTERM: */ +#define ltclass (G.next_token__ltclass) + char *p, *pp, *s; - char *tl; - uint32_t tc, *ti; + const char *tl; + uint32_t tc; + const uint32_t *ti; int l; - static int concat_inserted = FALSE; - static uint32_t save_tclass, save_info; - static uint32_t ltclass = TC_OPTERM; - - if (t.rollback) { - t.rollback = FALSE; + if (t_rollback) { + t_rollback = FALSE; } else if (concat_inserted) { - concat_inserted = FALSE; - t.tclass = save_tclass; - t.info = save_info; + t_tclass = save_tclass; + t_info = save_info; } else { - - p = pos; - - readnext: + p = g_pos; + readnext: skip_spaces(&p); - lineno = t.lineno; + g_lineno = t_lineno; if (*p == '#') - while (*p != '\n' && *p != '\0') p++; + while (*p != '\n' && *p != '\0') + p++; if (*p == '\n') - t.lineno++; + t_lineno++; if (*p == '\0') { tc = TC_EOF; } else if (*p == '\"') { /* it's a string */ - t.string = s = ++p; + t_string = s = ++p; while (*p != '\"') { if (*p == '\0' || *p == '\n') syntax_error(EMSG_UNEXP_EOS); @@ -898,15 +958,18 @@ static uint32_t next_token(uint32_t expected) } else if ((expected & TC_REGEXP) && *p == '/') { /* it's regexp */ - t.string = s = ++p; + t_string = s = ++p; while (*p != '/') { if (*p == '\0' || *p == '\n') syntax_error(EMSG_UNEXP_EOS); - if ((*s++ = *p++) == '\\') { + *s = *p++; + if (*s++ == '\\') { pp = p; *(s-1) = bb_process_escape_sequence((const char **)&p); - if (*pp == '\\') *s++ = '\\'; - if (p == pp) *s++ = *p++; + if (*pp == '\\') + *s++ = '\\'; + if (p == pp) + *s++ = *p++; } } p++; @@ -915,7 +978,7 @@ static uint32_t next_token(uint32_t expected) } else if (*p == '.' || isdigit(*p)) { /* it's a number */ - t.number = strtod(p, &p); + t_double = strtod(p, &p); if (*p == '.') syntax_error(EMSG_UNEXP_TOKEN); tc = TC_NUMBER; @@ -935,10 +998,11 @@ static uint32_t next_token(uint32_t expected) * matches and it's not a longer word, * then this is what we are looking for */ - if ((tc & (expected | TC_WORD | TC_NEWLINE)) && - *tl == *p && strncmp(p, tl, l) == 0 && - !((tc & TC_WORD) && isalnum_(*(p + l)))) { - t.info = *ti; + if ((tc & (expected | TC_WORD | TC_NEWLINE)) + && *tl == *p && strncmp(p, tl, l) == 0 + && !((tc & TC_WORD) && isalnum_(p[l])) + ) { + t_info = *ti; p += l; break; } @@ -946,21 +1010,22 @@ static uint32_t next_token(uint32_t expected) tl += l; } - if (! *tl) { + if (!*tl) { /* it's a name (var/array/function), * otherwise it's something wrong */ - if (! isalnum_(*p)) + if (!isalnum_(*p)) syntax_error(EMSG_UNEXP_TOKEN); - t.string = --p; - while(isalnum_(*(++p))) { + t_string = --p; + while (isalnum_(*(++p))) { *(p-1) = *p; } *(p-1) = '\0'; tc = TC_VARIABLE; /* also consume whitespace between functionname and bracket */ - skip_spaces(&p); + if (!(expected & TC_VARIABLE)) + skip_spaces(&p); if (*p == '(') { tc = TC_FUNCTION; } else { @@ -971,52 +1036,59 @@ static uint32_t next_token(uint32_t expected) } } } - pos = p; + g_pos = p; /* skipping newlines in some cases */ if ((ltclass & TC_NOTERM) && (tc & TC_NEWLINE)) goto readnext; /* insert concatenation operator when needed */ - if ((ltclass&TC_CONCAT1) && (tc&TC_CONCAT2) && (expected&TC_BINOP)) { + if ((ltclass & TC_CONCAT1) && (tc & TC_CONCAT2) && (expected & TC_BINOP)) { concat_inserted = TRUE; save_tclass = tc; - save_info = t.info; + save_info = t_info; tc = TC_BINOP; - t.info = OC_CONCAT | SS | P(35); + t_info = OC_CONCAT | SS | P(35); } - t.tclass = tc; + t_tclass = tc; } - ltclass = t.tclass; + ltclass = t_tclass; /* Are we ready for this? */ - if (! (ltclass & expected)) + if (!(ltclass & expected)) syntax_error((ltclass & (TC_NEWLINE | TC_EOF)) ? - EMSG_UNEXP_EOS : EMSG_UNEXP_TOKEN); + EMSG_UNEXP_EOS : EMSG_UNEXP_TOKEN); return ltclass; +#undef concat_inserted +#undef save_tclass +#undef save_info +#undef ltclass } -static void rollback_token(void) { t.rollback = TRUE; } +static void rollback_token(void) +{ + t_rollback = TRUE; +} static node *new_node(uint32_t info) { - register node *n; + node *n; - n = (node *)xcalloc(sizeof(node), 1); + n = xzalloc(sizeof(node)); n->info = info; - n->lineno = lineno; + n->lineno = g_lineno; return n; } -static node *mk_re_node(char *s, node *n, regex_t *re) +static node *mk_re_node(const char *s, node *n, regex_t *re) { n->info = OC_REGEXP; n->l.re = re; n->r.ire = re + 1; xregcomp(re, s, REG_EXTENDED); - xregcomp(re+1, s, REG_EXTENDED | REG_ICASE); + xregcomp(re + 1, s, REG_EXTENDED | REG_ICASE); return n; } @@ -1041,10 +1113,10 @@ static node *parse_expr(uint32_t iexp) sn.r.n = glptr = NULL; xtc = TC_OPERAND | TC_UOPPRE | TC_REGEXP | iexp; - while (! ((tc = next_token(xtc)) & iexp)) { - if (glptr && (t.info == (OC_COMPARE|VV|P(39)|2))) { + while (!((tc = next_token(xtc)) & iexp)) { + if (glptr && (t_info == (OC_COMPARE | VV | P(39) | 2))) { /* input redirection (<) attached to glptr node */ - cn = glptr->l.n = new_node(OC_CONCAT|SS|P(37)); + cn = glptr->l.n = new_node(OC_CONCAT | SS | P(37)); cn->a.n = glptr; xtc = TC_OPERAND | TC_UOPPRE; glptr = NULL; @@ -1053,17 +1125,17 @@ static node *parse_expr(uint32_t iexp) /* for binary and postfix-unary operators, jump back over * previous operators with higher priority */ vn = cn; - while ( ((t.info & PRIMASK) > (vn->a.n->info & PRIMASK2)) || - ((t.info == vn->info) && ((t.info & OPCLSMASK) == OC_COLON)) ) + while ( ((t_info & PRIMASK) > (vn->a.n->info & PRIMASK2)) + || ((t_info == vn->info) && ((t_info & OPCLSMASK) == OC_COLON)) ) vn = vn->a.n; - if ((t.info & OPCLSMASK) == OC_TERNARY) - t.info += P(6); - cn = vn->a.n->r.n = new_node(t.info); + if ((t_info & OPCLSMASK) == OC_TERNARY) + t_info += P(6); + cn = vn->a.n->r.n = new_node(t_info); cn->a.n = vn->a.n; if (tc & TC_BINOP) { cn->l.n = vn; xtc = TC_OPERAND | TC_UOPPRE | TC_REGEXP; - if ((t.info & OPCLSMASK) == OC_PGETLINE) { + if ((t_info & OPCLSMASK) == OC_PGETLINE) { /* it's a pipe */ next_token(TC_GETLINE); /* give maximum priority to this pipe */ @@ -1080,7 +1152,7 @@ static node *parse_expr(uint32_t iexp) /* for operands and prefix-unary operators, attach them * to last node */ vn = cn; - cn = vn->r.n = new_node(t.info); + cn = vn->r.n = new_node(t_info); cn->a.n = vn; xtc = TC_OPERAND | TC_UOPPRE | TC_REGEXP; if (tc & (TC_OPERAND | TC_REGEXP)) { @@ -1088,14 +1160,15 @@ static node *parse_expr(uint32_t iexp) /* one should be very careful with switch on tclass - * only simple tclasses should be used! */ switch (tc) { - case TC_VARIABLE: - case TC_ARRAY: + case TC_VARIABLE: + case TC_ARRAY: cn->info = OC_VAR; - if ((v = hash_search(ahash, t.string)) != NULL) { + v = hash_search(ahash, t_string); + if (v != NULL) { cn->info = OC_FNARG; cn->l.i = v->x.aidx; } else { - cn->l.v = newvar(t.string); + cn->l.v = newvar(t_string); } if (tc & TC_ARRAY) { cn->info |= xS; @@ -1103,38 +1176,37 @@ static node *parse_expr(uint32_t iexp) } break; - case TC_NUMBER: - case TC_STRING: + case TC_NUMBER: + case TC_STRING: cn->info = OC_VAR; - v = cn->l.v = xcalloc(sizeof(var), 1); + v = cn->l.v = xzalloc(sizeof(var)); if (tc & TC_NUMBER) - setvar_i(v, t.number); + setvar_i(v, t_double); else - setvar_s(v, t.string); + setvar_s(v, t_string); break; - case TC_REGEXP: - mk_re_node(t.string, cn, - (regex_t *)xcalloc(sizeof(regex_t),2)); + case TC_REGEXP: + mk_re_node(t_string, cn, xzalloc(sizeof(regex_t)*2)); break; - case TC_FUNCTION: + case TC_FUNCTION: cn->info = OC_FUNC; - cn->r.f = newfunc(t.string); + cn->r.f = newfunc(t_string); cn->l.n = condition(); break; - case TC_SEQSTART: + case TC_SEQSTART: cn = vn->r.n = parse_expr(TC_SEQTERM); cn->a.n = vn; break; - case TC_GETLINE: + case TC_GETLINE: glptr = cn; xtc = TC_OPERAND | TC_UOPPRE | TC_BINOP | iexp; break; - case TC_BUILTIN: + case TC_BUILTIN: cn->l.n = condition(); break; } @@ -1147,15 +1219,15 @@ static node *parse_expr(uint32_t iexp) /* add node to chain. Return ptr to alloc'd node */ static node *chain_node(uint32_t info) { - register node *n; + node *n; - if (! seq->first) + if (!seq->first) seq->first = seq->last = new_node(0); - if (seq->programname != programname) { - seq->programname = programname; + if (seq->programname != g_progname) { + seq->programname = g_progname; n = chain_node(OC_NEWSOURCE); - n->l.s = bb_xstrdup(programname); + n->l.s = xstrdup(g_progname); } n = seq->last; @@ -1171,7 +1243,7 @@ static void chain_expr(uint32_t info) n = chain_node(info); n->l.n = parse_expr(TC_OPTERM | TC_GRPTERM); - if (t.tclass & TC_GRPTERM) + if (t_tclass & TC_GRPTERM) rollback_token(); } @@ -1209,8 +1281,8 @@ static void chain_group(void) } while (c & TC_NEWLINE); if (c & TC_GRPSTART) { - while(next_token(TC_GRPSEQ | TC_GRPTERM) != TC_GRPTERM) { - if (t.tclass & TC_NEWLINE) continue; + while (next_token(TC_GRPSEQ | TC_GRPTERM) != TC_GRPTERM) { + if (t_tclass & TC_NEWLINE) continue; rollback_token(); chain_group(); } @@ -1218,85 +1290,84 @@ static void chain_group(void) rollback_token(); chain_expr(OC_EXEC | Vx); } else { /* TC_STATEMNT */ - switch (t.info & OPCLSMASK) { - case ST_IF: - n = chain_node(OC_BR | Vx); - n->l.n = condition(); + switch (t_info & OPCLSMASK) { + case ST_IF: + n = chain_node(OC_BR | Vx); + n->l.n = condition(); + chain_group(); + n2 = chain_node(OC_EXEC); + n->r.n = seq->last; + if (next_token(TC_GRPSEQ | TC_GRPTERM | TC_ELSE) == TC_ELSE) { chain_group(); - n2 = chain_node(OC_EXEC); - n->r.n = seq->last; - if (next_token(TC_GRPSEQ | TC_GRPTERM | TC_ELSE)==TC_ELSE) { - chain_group(); - n2->a.n = seq->last; - } else { - rollback_token(); - } - break; - - case ST_WHILE: - n2 = condition(); - n = chain_loop(NULL); - n->l.n = n2; - break; + n2->a.n = seq->last; + } else { + rollback_token(); + } + break; - case ST_DO: - n2 = chain_node(OC_EXEC); - n = chain_loop(NULL); - n2->a.n = n->a.n; - next_token(TC_WHILE); - n->l.n = condition(); - break; + case ST_WHILE: + n2 = condition(); + n = chain_loop(NULL); + n->l.n = n2; + break; - case ST_FOR: - next_token(TC_SEQSTART); - n2 = parse_expr(TC_SEMICOL | TC_SEQTERM); - if (t.tclass & TC_SEQTERM) { /* for-in */ - if ((n2->info & OPCLSMASK) != OC_IN) - syntax_error(EMSG_UNEXP_TOKEN); - n = chain_node(OC_WALKINIT | VV); - n->l.n = n2->l.n; - n->r.n = n2->r.n; - n = chain_loop(NULL); - n->info = OC_WALKNEXT | Vx; - n->l.n = n2->l.n; - } else { /* for(;;) */ - n = chain_node(OC_EXEC | Vx); - n->l.n = n2; - n2 = parse_expr(TC_SEMICOL); - n3 = parse_expr(TC_SEQTERM); - n = chain_loop(n3); - n->l.n = n2; - if (! n2) - n->info = OC_EXEC; - } - break; + case ST_DO: + n2 = chain_node(OC_EXEC); + n = chain_loop(NULL); + n2->a.n = n->a.n; + next_token(TC_WHILE); + n->l.n = condition(); + break; - case OC_PRINT: - case OC_PRINTF: - n = chain_node(t.info); - n->l.n = parse_expr(TC_OPTERM | TC_OUTRDR | TC_GRPTERM); - if (t.tclass & TC_OUTRDR) { - n->info |= t.info; - n->r.n = parse_expr(TC_OPTERM | TC_GRPTERM); - } - if (t.tclass & TC_GRPTERM) - rollback_token(); - break; + case ST_FOR: + next_token(TC_SEQSTART); + n2 = parse_expr(TC_SEMICOL | TC_SEQTERM); + if (t_tclass & TC_SEQTERM) { /* for-in */ + if ((n2->info & OPCLSMASK) != OC_IN) + syntax_error(EMSG_UNEXP_TOKEN); + n = chain_node(OC_WALKINIT | VV); + n->l.n = n2->l.n; + n->r.n = n2->r.n; + n = chain_loop(NULL); + n->info = OC_WALKNEXT | Vx; + n->l.n = n2->l.n; + } else { /* for (;;) */ + n = chain_node(OC_EXEC | Vx); + n->l.n = n2; + n2 = parse_expr(TC_SEMICOL); + n3 = parse_expr(TC_SEQTERM); + n = chain_loop(n3); + n->l.n = n2; + if (!n2) + n->info = OC_EXEC; + } + break; - case OC_BREAK: - n = chain_node(OC_EXEC); - n->a.n = break_ptr; - break; + case OC_PRINT: + case OC_PRINTF: + n = chain_node(t_info); + n->l.n = parse_expr(TC_OPTERM | TC_OUTRDR | TC_GRPTERM); + if (t_tclass & TC_OUTRDR) { + n->info |= t_info; + n->r.n = parse_expr(TC_OPTERM | TC_GRPTERM); + } + if (t_tclass & TC_GRPTERM) + rollback_token(); + break; - case OC_CONTINUE: - n = chain_node(OC_EXEC); - n->a.n = continue_ptr; - break; + case OC_BREAK: + n = chain_node(OC_EXEC); + n->a.n = break_ptr; + break; - /* delete, next, nextfile, return, exit */ - default: - chain_expr(t.info); + case OC_CONTINUE: + n = chain_node(OC_EXEC); + n->a.n = continue_ptr; + break; + /* delete, next, nextfile, return, exit */ + default: + chain_expr(t_info); } } } @@ -1308,10 +1379,10 @@ static void parse_program(char *p) func *f; var *v; - pos = p; - t.lineno = 1; - while((tclass = next_token(TC_EOF | TC_OPSEQ | TC_GRPSTART | - TC_OPTERM | TC_BEGIN | TC_END | TC_FUNCDECL)) != TC_EOF) { + g_pos = p; + t_lineno = 1; + while ((tclass = next_token(TC_EOF | TC_OPSEQ | TC_GRPSTART | + TC_OPTERM | TC_BEGIN | TC_END | TC_FUNCDECL)) != TC_EOF) { if (tclass & TC_OPTERM) continue; @@ -1327,12 +1398,12 @@ static void parse_program(char *p) } else if (tclass & TC_FUNCDECL) { next_token(TC_FUNCTION); - pos++; - f = newfunc(t.string); + g_pos++; + f = newfunc(t_string); f->body.first = NULL; f->nargs = 0; - while(next_token(TC_VARIABLE | TC_SEQTERM) & TC_VARIABLE) { - v = findvar(ahash, t.string); + while (next_token(TC_VARIABLE | TC_SEQTERM) & TC_VARIABLE) { + v = findvar(ahash, t_string); v->x.aidx = (f->nargs)++; if (next_token(TC_COMMA | TC_SEQTERM) & TC_SEQTERM) @@ -1346,7 +1417,7 @@ static void parse_program(char *p) rollback_token(); cn = chain_node(OC_TEST); cn->l.n = parse_expr(TC_OPTERM | TC_EOF | TC_GRPSTART); - if (t.tclass & TC_GRPSTART) { + if (t_tclass & TC_GRPSTART) { rollback_token(); chain_group(); } else { @@ -1364,19 +1435,19 @@ static void parse_program(char *p) /* -------- program execution part -------- */ -static node *mk_splitter(char *s, tsplitter *spl) +static node *mk_splitter(const char *s, tsplitter *spl) { - register regex_t *re, *ire; + regex_t *re, *ire; node *n; re = &spl->re[0]; ire = &spl->re[1]; n = &spl->n; - if ((n->info && OPCLSMASK) == OC_REGEXP) { + if ((n->info & OPCLSMASK) == OC_REGEXP) { regfree(re); - regfree(ire); + regfree(ire); // TODO: nuke ire, use re+1? } - if (bb_strlen(s) > 1) { + if (strlen(s) > 1) { mk_re_node(s, n, re); } else { n->info = (uint32_t) *s; @@ -1392,114 +1463,127 @@ static node *mk_splitter(char *s, tsplitter *spl) static regex_t *as_regex(node *op, regex_t *preg) { var *v; - char *s; + const char *s; if ((op->info & OPCLSMASK) == OC_REGEXP) { return icase ? op->r.ire : op->l.re; - } else { - v = nvalloc(1); - s = getvar_s(evaluate(op, v)); - xregcomp(preg, s, icase ? REG_EXTENDED | REG_ICASE : REG_EXTENDED); - nvfree(v); - return preg; } + v = nvalloc(1); + s = getvar_s(evaluate(op, v)); + xregcomp(preg, s, icase ? REG_EXTENDED | REG_ICASE : REG_EXTENDED); + nvfree(v); + return preg; } /* gradually increasing buffer */ static void qrealloc(char **b, int n, int *size) { - if (! *b || n >= *size) + if (!*b || n >= *size) *b = xrealloc(*b, *size = n + (n>>1) + 80); } /* resize field storage space */ static void fsrealloc(int size) { - static int maxfields = 0; int i; if (size >= maxfields) { i = maxfields; maxfields = size + 16; - Fields = (var *)xrealloc(Fields, maxfields * sizeof(var)); - for (; iinfo; c[2] = c[3] = '\0'; - if (*getvar_s(V[RS]) == '\0') c[2] = '\n'; - - if ((spl->info & OPCLSMASK) == OC_REGEXP) { /* regex split */ - while (*s) { - l = strcspn(s, c+2); - if (regexec(icase ? spl->r.ire : spl->l.re, s, 1, pmatch, 0) == 0 && - pmatch[0].rm_so <= l) { + if (*getvar_s(intvar[RS]) == '\0') + c[2] = '\n'; + + if ((spl->info & OPCLSMASK) == OC_REGEXP) { /* regex split */ + if (!*s) + return n; /* "": zero fields */ + n++; /* at least one field will be there */ + do { + l = strcspn(s, c+2); /* len till next NUL or \n */ + if (regexec(icase ? spl->r.ire : spl->l.re, s, 1, pmatch, 0) == 0 + && pmatch[0].rm_so <= l + ) { l = pmatch[0].rm_so; - if (pmatch[0].rm_eo == 0) { l++; pmatch[0].rm_eo++; } + if (pmatch[0].rm_eo == 0) { + l++; + pmatch[0].rm_eo++; + } + n++; /* we saw yet another delimiter */ } else { pmatch[0].rm_eo = l; - if (*(s+l)) pmatch[0].rm_eo++; + if (s[l]) pmatch[0].rm_eo++; } - memcpy(s1, s, l); - *(s1+l) = '\0'; + s1[l] = '\0'; nextword(&s1); s += pmatch[0].rm_eo; + } while (*s); + return n; + } + if (c[0] == '\0') { /* null split */ + while (*s) { + *s1++ = *s++; + *s1++ = '\0'; n++; } - } else if (c[0] == '\0') { /* null split */ - while(*s) { - *(s1++) = *(s++); - *(s1++) = '\0'; - n++; - } - } else if (c[0] != ' ') { /* single-character split */ + return n; + } + if (c[0] != ' ') { /* single-character split */ if (icase) { c[0] = toupper(c[0]); c[1] = tolower(c[1]); } if (*s1) n++; while ((s1 = strpbrk(s1, c))) { - *(s1++) = '\0'; + *s1++ = '\0'; n++; } - } else { /* space split */ - while (*s) { - while (isspace(*s)) s++; - if (! *s) break; - n++; - while (*s && !isspace(*s)) - *(s1++) = *(s++); - *(s1++) = '\0'; - } + return n; + } + /* space split */ + while (*s) { + s = skip_whitespace(s); + if (!*s) break; + n++; + while (*s && !isspace(*s)) + *s1++ = *s++; + *s1++ = '\0'; } return n; } static void split_f0(void) { - static char *fstrings = NULL; +/* static char *fstrings; */ +#define fstrings (G.split_f0__fstrings) + int i, n; char *s; @@ -1509,42 +1593,44 @@ static void split_f0(void) is_f0_split = TRUE; free(fstrings); fsrealloc(0); - n = awk_split(getvar_s(V[F0]), &fsplitter.n, &fstrings); + n = awk_split(getvar_s(intvar[F0]), &fsplitter.n, &fstrings); fsrealloc(n); s = fstrings; - for (i=0; itype = VF_NUMBER | VF_SPECIAL; - V[NF]->number = nfields; + clrvar(intvar[NF]); + intvar[NF]->type = VF_NUMBER | VF_SPECIAL; + intvar[NF]->number = nfields; +#undef fstrings } /* perform additional actions when some internal variables changed */ static void handle_special(var *v) { int n; - char *b, *sep, *s; + char *b; + const char *sep, *s; int sl, l, len, i, bsize; - if (! (v->type & VF_SPECIAL)) + if (!(v->type & VF_SPECIAL)) return; - if (v == V[NF]) { + if (v == intvar[NF]) { n = (int)getvar_i(v); fsrealloc(n); /* recalculate $0 */ - sep = getvar_s(V[OFS]); - sl = bb_strlen(sep); + sep = getvar_s(intvar[OFS]); + sl = strlen(sep); b = NULL; len = 0; - for (i=0; i v-Fields ? n : v-Fields+1); + } else { /* $n */ + n = getvar_i(intvar[NF]); + setvar_i(intvar[NF], n > v-Fields ? n : v-Fields+1); /* right here v is invalid. Just to note... */ } } @@ -1601,11 +1688,11 @@ static void hashwalk_init(var *v, xhash *array) free(v->x.walker); v->type |= VF_WALK; - w = v->x.walker = (char **)xcalloc(2 + 2*sizeof(char *) + array->glen, 1); - *w = *(w+1) = (char *)(w + 2); - for (i=0; icsize; i++) { + w = v->x.walker = xzalloc(2 + 2*sizeof(char *) + array->glen); + w[0] = w[1] = (char *)(w + 2); + for (i = 0; i < array->csize; i++) { hi = array->items[i]; - while(hi) { + while (hi) { strcpy(*w, hi->name); nextword(w); hi = hi->next; @@ -1618,7 +1705,7 @@ static int hashwalk_next(var *v) char **w; w = v->x.walker; - if (*(w+1) == *w) + if (w[1] == w[0]) return FALSE; setvar_s(v, nextword(w+1)); @@ -1628,8 +1715,8 @@ static int hashwalk_next(var *v) /* evaluate node, return 1 when result is true, 0 otherwise */ static int ptest(node *pattern) { - static var v; - return istrue(evaluate(pattern, &v)); + /* ptest__v is "static": to save stack space? */ + return istrue(evaluate(pattern, &G.ptest__v)); } /* read next record from stream rsm into a variable v */ @@ -1652,7 +1739,7 @@ static int awk_getline(rstream *rsm, var *v) c = (char) rsplitter.n.info; rp = 0; - if (! m) qrealloc(&m, 256, &size); + if (!m) qrealloc(&m, 256, &size); do { b = m + a; so = eo = p; @@ -1660,7 +1747,7 @@ static int awk_getline(rstream *rsm, var *v) if (p > 0) { if ((rsplitter.n.info & OPCLSMASK) == OC_REGEXP) { if (regexec(icase ? rsplitter.n.r.ire : rsplitter.n.l.re, - b, 1, pmatch, 0) == 0) { + b, 1, pmatch, 0) == 0) { so = pmatch[0].rm_so; eo = pmatch[0].rm_eo; if (b[eo] != '\0') @@ -1668,6 +1755,7 @@ static int awk_getline(rstream *rsm, var *v) } } else if (c != '\0') { s = strchr(b+pp, c); + if (!s) s = memchr(b+pp, '\0', p - pp); if (s) { so = eo = s-b; eo++; @@ -1699,7 +1787,7 @@ static int awk_getline(rstream *rsm, var *v) if (p < pp) { p = 0; r = 0; - setvar_i(V[ERRNO], errno); + setvar_i(intvar[ERRNO], errno); } b[p] = '\0'; @@ -1713,7 +1801,7 @@ static int awk_getline(rstream *rsm, var *v) v->type |= VF_USER; b[so] = c; c = b[eo]; b[eo] = '\0'; - setvar_s(V[RT], b+so); + setvar_s(intvar[RT], b+so); b[eo] = c; } @@ -1725,21 +1813,22 @@ static int awk_getline(rstream *rsm, var *v) return r; } -static int fmt_num(char *b, int size, char *format, double n, int int_as_int) +static int fmt_num(char *b, int size, const char *format, double n, int int_as_int) { - int r=0; - char c, *s=format; + int r = 0; + char c; + const char *s = format; if (int_as_int && n == (int)n) { r = snprintf(b, size, "%d", (int)n); } else { - do { c = *s; } while (*s && *++s); + do { c = *s; } while (c && *++s); if (strchr("diouxX", c)) { r = snprintf(b, size, format, (int)n); } else if (strchr("eEfgG", c)) { r = snprintf(b, size, format, n); } else { - runtime_error(EMSG_INV_FMT); + syntax_error(EMSG_INV_FMT); } } return r; @@ -1750,38 +1839,42 @@ static int fmt_num(char *b, int size, char *format, double n, int int_as_int) static char *awk_printf(node *n) { char *b = NULL; - char *fmt, *s, *s1, *f; + char *fmt, *s, *f; + const char *s1; int i, j, incr, bsize; char c, c1; var *v, *arg; v = nvalloc(1); - fmt = f = bb_xstrdup(getvar_s(evaluate(nextarg(&n), v))); + fmt = f = xstrdup(getvar_s(evaluate(nextarg(&n), v))); i = 0; while (*f) { s = f; while (*f && (*f != '%' || *(++f) == '%')) f++; - while (*f && !isalpha(*f)) + while (*f && !isalpha(*f)) { + if (*f == '*') + syntax_error("%*x formats are not supported"); f++; + } incr = (f - s) + MAXVARFMT; - qrealloc(&b, incr+i, &bsize); - c = *f; if (c != '\0') f++; - c1 = *f ; *f = '\0'; + qrealloc(&b, incr + i, &bsize); + c = *f; + if (c != '\0') f++; + c1 = *f; + *f = '\0'; arg = evaluate(nextarg(&n), v); j = i; if (c == 'c' || !c) { - i += sprintf(b+i, s, - is_numeric(arg) ? (char)getvar_i(arg) : *getvar_s(arg)); - + i += sprintf(b+i, s, is_numeric(arg) ? + (char)getvar_i(arg) : *getvar_s(arg)); } else if (c == 's') { - s1 = getvar_s(arg); - qrealloc(&b, incr+i+bb_strlen(s1), &bsize); + s1 = getvar_s(arg); + qrealloc(&b, incr+i+strlen(s1), &bsize); i += sprintf(b+i, s, s1); - } else { i += fmt_num(b+i, incr, s, getvar_i(arg), FALSE); } @@ -1789,10 +1882,9 @@ static char *awk_printf(node *n) /* if there was an error while sprintf, return value is negative */ if (i < j) i = j; - } - b = xrealloc(b, i+1); + b = xrealloc(b, i + 1); free(fmt); nvfree(v); b[i] = '\0'; @@ -1805,22 +1897,23 @@ static char *awk_printf(node *n) * all matches. If src or dst is NULL, use $0. If ex=TRUE, enable * subexpression matching (\1-\9) */ -static int awk_sub(node *rn, char *repl, int nm, var *src, var *dest, int ex) +static int awk_sub(node *rn, const char *repl, int nm, var *src, var *dest, int ex) { char *ds = NULL; - char *sp, *s; + const char *s; + const char *sp; int c, i, j, di, rl, so, eo, nbs, n, dssize; regmatch_t pmatch[10]; regex_t sreg, *re; re = as_regex(rn, &sreg); - if (! src) src = V[F0]; - if (! dest) dest = V[F0]; + if (!src) src = intvar[F0]; + if (!dest) dest = intvar[F0]; i = di = 0; sp = getvar_s(src); - rl = bb_strlen(repl); - while (regexec(re, sp, 10, pmatch, sp==getvar_s(src) ? 0:REG_NOTBOL) == 0) { + rl = strlen(repl); + while (regexec(re, sp, 10, pmatch, sp==getvar_s(src) ? 0 : REG_NOTBOL) == 0) { so = pmatch[0].rm_so; eo = pmatch[0].rm_eo; @@ -1860,7 +1953,8 @@ static int awk_sub(node *rn, char *repl, int nm, var *src, var *dest, int ex) sp += eo; if (i == nm) break; if (eo == so) { - if (! (ds[di++] = *sp++)) break; + ds[di] = *sp++; + if (!ds[di++]) break; } } @@ -1873,14 +1967,15 @@ static int awk_sub(node *rn, char *repl, int nm, var *src, var *dest, int ex) static var *exec_builtin(node *op, var *res) { +#define tspl (G.exec_builtin__tspl) + int (*to_xxx)(int); var *tv; node *an[4]; - var *av[4]; - char *as[4]; + var *av[4]; + const char *as[4]; regmatch_t pmatch[2]; regex_t sreg, *re; - static tsplitter tspl; node *spl; uint32_t isr, info; int nargs; @@ -1893,7 +1988,7 @@ static var *exec_builtin(node *op, var *res) op = op->l.n; av[2] = av[3] = NULL; - for (i=0 ; i<4 && op ; i++) { + for (i = 0; i < 4 && op; i++) { an[i] = nextarg(&op); if (isr & 0x09000000) av[i] = evaluate(an[i], &tv[i]); if (isr & 0x08000000) as[i] = getvar_s(av[i]); @@ -1902,19 +1997,19 @@ static var *exec_builtin(node *op, var *res) nargs = i; if (nargs < (info >> 30)) - runtime_error(EMSG_TOO_FEW_ARGS); + syntax_error(EMSG_TOO_FEW_ARGS); switch (info & OPNMASK) { - case B_a2: -#ifdef CONFIG_FEATURE_AWK_MATH + case B_a2: +#if ENABLE_FEATURE_AWK_MATH setvar_i(res, atan2(getvar_i(av[i]), getvar_i(av[1]))); #else - runtime_error(EMSG_NO_MATH); + syntax_error(EMSG_NO_MATH); #endif break; - case B_sp: + case B_sp: if (nargs > 2) { spl = (an[2]->info & OPCLSMASK) == OC_REGEXP ? an[2] : mk_splitter(getvar_s(evaluate(an[2], &tv[2])), &tspl); @@ -1931,26 +2026,51 @@ static var *exec_builtin(node *op, var *res) setvar_i(res, n); break; - case B_ss: - l = bb_strlen(as[0]); + case B_ss: + l = strlen(as[0]); i = getvar_i(av[1]) - 1; - if (i>l) i=l; if (i<0) i=0; + if (i > l) i = l; + if (i < 0) i = 0; n = (nargs > 2) ? getvar_i(av[2]) : l-i; - if (n<0) n=0; + if (n < 0) n = 0; s = xmalloc(n+1); strncpy(s, as[0]+i, n); s[n] = '\0'; setvar_p(res, s); break; - case B_lo: + case B_an: + setvar_i(res, (long)getvar_i(av[0]) & (long)getvar_i(av[1])); + break; + + case B_co: + setvar_i(res, ~(long)getvar_i(av[0])); + break; + + case B_ls: + setvar_i(res, (long)getvar_i(av[0]) << (long)getvar_i(av[1])); + break; + + case B_or: + setvar_i(res, (long)getvar_i(av[0]) | (long)getvar_i(av[1])); + break; + + case B_rs: + setvar_i(res, (long)((unsigned long)getvar_i(av[0]) >> (unsigned long)getvar_i(av[1]))); + break; + + case B_xo: + setvar_i(res, (long)getvar_i(av[0]) ^ (long)getvar_i(av[1])); + break; + + case B_lo: to_xxx = tolower; goto lo_cont; - case B_up: + case B_up: to_xxx = toupper; -lo_cont: - s1 = s = bb_xstrdup(as[0]); + lo_cont: + s1 = s = xstrdup(as[0]); while (*s1) { *s1 = (*to_xxx)(*s1); s1++; @@ -1958,12 +2078,12 @@ lo_cont: setvar_p(res, s); break; - case B_ix: + case B_ix: n = 0; - ll = bb_strlen(as[1]); - l = bb_strlen(as[0]) - ll; + ll = strlen(as[1]); + l = strlen(as[0]) - ll; if (ll > 0 && l >= 0) { - if (! icase) { + if (!icase) { s = strstr(as[0], as[1]); if (s) n = (s - as[0]) + 1; } else { @@ -1981,18 +2101,20 @@ lo_cont: setvar_i(res, n); break; - case B_ti: + case B_ti: if (nargs > 1) tt = getvar_i(av[1]); else time(&tt); - s = (nargs > 0) ? as[0] : "%a %b %d %H:%M:%S %Z %Y"; - i = strftime(buf, MAXVARFMT, s, localtime(&tt)); - buf[i] = '\0'; - setvar_s(res, buf); + //s = (nargs > 0) ? as[0] : "%a %b %d %H:%M:%S %Z %Y"; + i = strftime(g_buf, MAXVARFMT, + ((nargs > 0) ? as[0] : "%a %b %d %H:%M:%S %Z %Y"), + localtime(&tt)); + g_buf[i] = '\0'; + setvar_s(res, g_buf); break; - case B_ma: + case B_ma: re = as_regex(an[1], &sreg); n = regexec(re, as[0], 1, pmatch, 0); if (n == 0) { @@ -2008,21 +2130,22 @@ lo_cont: if (re == &sreg) regfree(re); break; - case B_ge: + case B_ge: awk_sub(an[0], as[1], getvar_i(av[2]), av[3], res, TRUE); break; - case B_gs: + case B_gs: setvar_i(res, awk_sub(an[0], as[1], 0, av[2], av[2], FALSE)); break; - case B_su: + case B_su: setvar_i(res, awk_sub(an[0], as[1], 1, av[2], av[2], FALSE)); break; } nvfree(tv); return res; +#undef tspl } /* @@ -2033,20 +2156,22 @@ lo_cont: static var *evaluate(node *op, var *res) { - /* This procedure is recursive so we should count every byte */ - static var *fnargs = NULL; - static unsigned int seed = 1; - static regex_t sreg; +/* This procedure is recursive so we should count every byte */ +#define fnargs (G.evaluate__fnargs) +/* seed is initialized to 1 */ +#define seed (G.evaluate__seed) +#define sreg (G.evaluate__sreg) + node *op1; var *v1; union { var *v; - char *s; + const char *s; double d; int i; } L, R; uint32_t opinfo; - short opn; + int opn; union { char *s; rstream *rsm; @@ -2056,16 +2181,15 @@ static var *evaluate(node *op, var *res) uint32_t info; } X; - if (! op) + if (!op) return setvar_s(res, NULL); v1 = nvalloc(2); while (op) { - opinfo = op->info; - opn = (short)(opinfo & OPNMASK); - lineno = op->lineno; + opn = (opinfo & OPNMASK); + g_lineno = op->lineno; /* execute inevitable things */ op1 = op->l.n; @@ -2077,10 +2201,10 @@ static var *evaluate(node *op, var *res) switch (XC(opinfo & OPCLSMASK)) { - /* -- iterative node type -- */ + /* -- iterative node type -- */ - /* test pattern */ - case XC( OC_TEST ): + /* test pattern */ + case XC( OC_TEST ): if ((op1->info & OPCLSMASK) == OC_COMMA) { /* it's range pattern */ if ((opinfo & OF_CHECKED) || ptest(op1->l.n)) { @@ -2097,77 +2221,78 @@ static var *evaluate(node *op, var *res) } break; - /* just evaluate an expression, also used as unconditional jump */ - case XC( OC_EXEC ): + /* just evaluate an expression, also used as unconditional jump */ + case XC( OC_EXEC ): break; - /* branch, used in if-else and various loops */ - case XC( OC_BR ): + /* branch, used in if-else and various loops */ + case XC( OC_BR ): op = istrue(L.v) ? op->a.n : op->r.n; break; - /* initialize for-in loop */ - case XC( OC_WALKINIT ): + /* initialize for-in loop */ + case XC( OC_WALKINIT ): hashwalk_init(L.v, iamarray(R.v)); break; - /* get next array item */ - case XC( OC_WALKNEXT ): + /* get next array item */ + case XC( OC_WALKNEXT ): op = hashwalk_next(L.v) ? op->a.n : op->r.n; break; - case XC( OC_PRINT ): - case XC( OC_PRINTF ): + case XC( OC_PRINT ): + case XC( OC_PRINTF ): X.F = stdout; if (op->r.n) { X.rsm = newfile(R.s); - if (! X.rsm->F) { + if (!X.rsm->F) { if (opn == '|') { - if((X.rsm->F = popen(R.s, "w")) == NULL) + X.rsm->F = popen(R.s, "w"); + if (X.rsm->F == NULL) bb_perror_msg_and_die("popen"); X.rsm->is_pipe = 1; } else { - X.rsm->F = bb_xfopen(R.s, opn=='w' ? "w" : "a"); + X.rsm->F = xfopen(R.s, opn=='w' ? "w" : "a"); } } X.F = X.rsm->F; } if ((opinfo & OPCLSMASK) == OC_PRINT) { - if (! op1) { - fputs(getvar_s(V[F0]), X.F); + if (!op1) { + fputs(getvar_s(intvar[F0]), X.F); } else { while (op1) { L.v = evaluate(nextarg(&op1), v1); if (L.v->type & VF_NUMBER) { - fmt_num(buf, MAXVARFMT, getvar_s(V[OFMT]), - getvar_i(L.v), TRUE); - fputs(buf, X.F); + fmt_num(g_buf, MAXVARFMT, getvar_s(intvar[OFMT]), + getvar_i(L.v), TRUE); + fputs(g_buf, X.F); } else { fputs(getvar_s(L.v), X.F); } - if (op1) fputs(getvar_s(V[OFS]), X.F); + if (op1) fputs(getvar_s(intvar[OFS]), X.F); } } - fputs(getvar_s(V[ORS]), X.F); + fputs(getvar_s(intvar[ORS]), X.F); } else { /* OC_PRINTF */ L.s = awk_printf(op1); fputs(L.s, X.F); - free(L.s); + free((char*)L.s); } fflush(X.F); break; - case XC( OC_DELETE ): + case XC( OC_DELETE ): X.info = op1->info & OPCLSMASK; if (X.info == OC_VAR) { R.v = op1->l.v; } else if (X.info == OC_FNARG) { R.v = &fnargs[op1->l.i]; } else { - runtime_error(EMSG_NOT_ARRAY); + syntax_error(EMSG_NOT_ARRAY); } if (op1->r.n) { @@ -2179,59 +2304,58 @@ static var *evaluate(node *op, var *res) } break; - case XC( OC_NEWSOURCE ): - programname = op->l.s; + case XC( OC_NEWSOURCE ): + g_progname = op->l.s; break; - case XC( OC_RETURN ): + case XC( OC_RETURN ): copyvar(res, L.v); break; - case XC( OC_NEXTFILE ): + case XC( OC_NEXTFILE ): nextfile = TRUE; - case XC( OC_NEXT ): + case XC( OC_NEXT ): nextrec = TRUE; - case XC( OC_DONE ): + case XC( OC_DONE ): clrvar(res); break; - case XC( OC_EXIT ): + case XC( OC_EXIT ): awk_exit(L.d); - /* -- recursive node type -- */ + /* -- recursive node type -- */ - case XC( OC_VAR ): + case XC( OC_VAR ): L.v = op->l.v; - if (L.v == V[NF]) + if (L.v == intvar[NF]) split_f0(); goto v_cont; - case XC( OC_FNARG ): + case XC( OC_FNARG ): L.v = &fnargs[op->l.i]; - -v_cont: - res = (op->r.n) ? findvar(iamarray(L.v), R.s) : L.v; + v_cont: + res = op->r.n ? findvar(iamarray(L.v), R.s) : L.v; break; - case XC( OC_IN ): + case XC( OC_IN ): setvar_i(res, hash_search(iamarray(R.v), L.s) ? 1 : 0); break; - case XC( OC_REGEXP ): + case XC( OC_REGEXP ): op1 = op; - L.s = getvar_s(V[F0]); + L.s = getvar_s(intvar[F0]); goto re_cont; - case XC( OC_MATCH ): + case XC( OC_MATCH ): op1 = op->r.n; -re_cont: + re_cont: X.re = as_regex(op1, &sreg); R.i = regexec(X.re, L.s, 0, NULL, 0); if (X.re == &sreg) regfree(X.re); setvar_i(res, (R.i == 0 ? 1 : 0) ^ (opn == '!' ? 1 : 0)); break; - case XC( OC_MOVE ): + case XC( OC_MOVE ): /* if source is a temporary string, jusk relink it to dest */ if (R.v == v1+1 && R.v->string) { res = setvar_p(L.v, R.v->string); @@ -2241,15 +2365,15 @@ re_cont: } break; - case XC( OC_TERNARY ): + case XC( OC_TERNARY ): if ((op->r.n->info & OPCLSMASK) != OC_COLON) - runtime_error(EMSG_POSSIBLE_ERROR); + syntax_error(EMSG_POSSIBLE_ERROR); res = evaluate(istrue(L.v) ? op->r.n->l.n : op->r.n->r.n, res); break; - case XC( OC_FUNC ): - if (! op->r.f->body.first) - runtime_error(EMSG_UNDEF_FUNC); + case XC( OC_FUNC ): + if (!op->r.f->body.first) + syntax_error(EMSG_UNDEF_FUNC); X.v = R.v = nvalloc(op->r.f->nargs+1); while (op1) { @@ -2264,115 +2388,114 @@ re_cont: R.v = fnargs; fnargs = X.v; - L.s = programname; + L.s = g_progname; res = evaluate(op->r.f->body.first, res); - programname = L.s; + g_progname = L.s; nvfree(fnargs); fnargs = R.v; break; - case XC( OC_GETLINE ): - case XC( OC_PGETLINE ): + case XC( OC_GETLINE ): + case XC( OC_PGETLINE ): if (op1) { X.rsm = newfile(L.s); - if (! X.rsm->F) { + if (!X.rsm->F) { if ((opinfo & OPCLSMASK) == OC_PGETLINE) { X.rsm->F = popen(L.s, "r"); X.rsm->is_pipe = TRUE; } else { - X.rsm->F = fopen(L.s, "r"); /* not bb_xfopen! */ + X.rsm->F = fopen(L.s, "r"); /* not xfopen! */ } } } else { - if (! iF) iF = next_input_file(); + if (!iF) iF = next_input_file(); X.rsm = iF; } - if (! X.rsm->F) { - setvar_i(V[ERRNO], errno); + if (!X.rsm->F) { + setvar_i(intvar[ERRNO], errno); setvar_i(res, -1); break; } - if (! op->r.n) - R.v = V[F0]; + if (!op->r.n) + R.v = intvar[F0]; L.i = awk_getline(X.rsm, R.v); if (L.i > 0) { - if (! op1) { - incvar(V[FNR]); - incvar(V[NR]); + if (!op1) { + incvar(intvar[FNR]); + incvar(intvar[NR]); } } setvar_i(res, L.i); break; - /* simple builtins */ - case XC( OC_FBLTIN ): + /* simple builtins */ + case XC( OC_FBLTIN ): switch (opn) { - case F_in: + case F_in: R.d = (int)L.d; break; - case F_rn: - R.d = (double)rand() / (double)RAND_MAX; + case F_rn: + R.d = (double)rand() / (double)RAND_MAX; break; - -#ifdef CONFIG_FEATURE_AWK_MATH - case F_co: +#if ENABLE_FEATURE_AWK_MATH + case F_co: R.d = cos(L.d); break; - case F_ex: + case F_ex: R.d = exp(L.d); break; - case F_lg: + case F_lg: R.d = log(L.d); break; - case F_si: + case F_si: R.d = sin(L.d); break; - case F_sq: + case F_sq: R.d = sqrt(L.d); break; #else - case F_co: - case F_ex: - case F_lg: - case F_si: - case F_sq: - runtime_error(EMSG_NO_MATH); + case F_co: + case F_ex: + case F_lg: + case F_si: + case F_sq: + syntax_error(EMSG_NO_MATH); break; #endif - - case F_sr: + case F_sr: R.d = (double)seed; - seed = op1 ? (unsigned int)L.d : (unsigned int)time(NULL); + seed = op1 ? (unsigned)L.d : (unsigned)time(NULL); srand(seed); break; - case F_ti: + case F_ti: R.d = time(NULL); break; - case F_le: - if (! op1) - L.s = getvar_s(V[F0]); - R.d = bb_strlen(L.s); + case F_le: + if (!op1) + L.s = getvar_s(intvar[F0]); + R.d = strlen(L.s); break; - case F_sy: + case F_sy: fflush(NULL); - R.d = (L.s && *L.s) ? system(L.s) : 0; + R.d = (ENABLE_FEATURE_ALLOW_EXEC && L.s && *L.s) + ? (system(L.s) >> 8) : 0; break; - case F_ff: - if (! op1) + case F_ff: + if (!op1) fflush(stdout); else { if (L.s && *L.s) { @@ -2384,7 +2507,7 @@ re_cont: } break; - case F_cl: + case F_cl: X.rsm = (rstream *)hash_search(fdhash, L.s); if (X.rsm) { R.i = X.rsm->is_pipe ? pclose(X.rsm->F) : fclose(X.rsm->F); @@ -2392,118 +2515,117 @@ re_cont: hash_remove(fdhash, L.s); } if (R.i != 0) - setvar_i(V[ERRNO], errno); + setvar_i(intvar[ERRNO], errno); R.d = (double)R.i; break; } setvar_i(res, R.d); break; - case XC( OC_BUILTIN ): + case XC( OC_BUILTIN ): res = exec_builtin(op, res); break; - case XC( OC_SPRINTF ): + case XC( OC_SPRINTF ): setvar_p(res, awk_printf(op1)); break; - case XC( OC_UNARY ): + case XC( OC_UNARY ): X.v = R.v; L.d = R.d = getvar_i(R.v); switch (opn) { - case 'P': + case 'P': L.d = ++R.d; goto r_op_change; - case 'p': + case 'p': R.d++; goto r_op_change; - case 'M': + case 'M': L.d = --R.d; goto r_op_change; - case 'm': + case 'm': R.d--; goto r_op_change; - case '!': - L.d = istrue(X.v) ? 0 : 1; + case '!': + L.d = istrue(X.v) ? 0 : 1; break; - case '-': + case '-': L.d = -R.d; break; - r_op_change: + r_op_change: setvar_i(X.v, R.d); } setvar_i(res, L.d); break; - case XC( OC_FIELD ): + case XC( OC_FIELD ): R.i = (int)getvar_i(R.v); if (R.i == 0) { - res = V[F0]; + res = intvar[F0]; } else { split_f0(); if (R.i > nfields) fsrealloc(R.i); - - res = &Fields[R.i-1]; + res = &Fields[R.i - 1]; } break; - /* concatenation (" ") and index joining (",") */ - case XC( OC_CONCAT ): - case XC( OC_COMMA ): - opn = bb_strlen(L.s) + bb_strlen(R.s) + 2; - X.s = (char *)xmalloc(opn); + /* concatenation (" ") and index joining (",") */ + case XC( OC_CONCAT ): + case XC( OC_COMMA ): + opn = strlen(L.s) + strlen(R.s) + 2; + X.s = xmalloc(opn); strcpy(X.s, L.s); if ((opinfo & OPCLSMASK) == OC_COMMA) { - L.s = getvar_s(V[SUBSEP]); - X.s = (char *)xrealloc(X.s, opn + bb_strlen(L.s)); + L.s = getvar_s(intvar[SUBSEP]); + X.s = xrealloc(X.s, opn + strlen(L.s)); strcat(X.s, L.s); } strcat(X.s, R.s); setvar_p(res, X.s); break; - case XC( OC_LAND ): + case XC( OC_LAND ): setvar_i(res, istrue(L.v) ? ptest(op->r.n) : 0); break; - case XC( OC_LOR ): + case XC( OC_LOR ): setvar_i(res, istrue(L.v) ? 1 : ptest(op->r.n)); break; - case XC( OC_BINARY ): - case XC( OC_REPLACE ): + case XC( OC_BINARY ): + case XC( OC_REPLACE ): R.d = getvar_i(R.v); switch (opn) { - case '+': + case '+': L.d += R.d; break; - case '-': + case '-': L.d -= R.d; break; - case '*': + case '*': L.d *= R.d; break; - case '/': - if (R.d == 0) runtime_error(EMSG_DIV_BY_ZERO); + case '/': + if (R.d == 0) syntax_error(EMSG_DIV_BY_ZERO); L.d /= R.d; break; - case '&': -#ifdef CONFIG_FEATURE_AWK_MATH + case '&': +#if ENABLE_FEATURE_AWK_MATH L.d = pow(L.d, R.d); #else - runtime_error(EMSG_NO_MATH); + syntax_error(EMSG_NO_MATH); #endif break; - case '%': - if (R.d == 0) runtime_error(EMSG_DIV_BY_ZERO); + case '%': + if (R.d == 0) syntax_error(EMSG_DIV_BY_ZERO); L.d -= (int)(L.d / R.d) * R.d; break; } - res = setvar_i(((opinfo&OPCLSMASK) == OC_BINARY) ? res : X.v, L.d); + res = setvar_i(((opinfo & OPCLSMASK) == OC_BINARY) ? res : X.v, L.d); break; - case XC( OC_COMPARE ): + case XC( OC_COMPARE ): if (is_numeric(L.v) && is_numeric(R.v)) { L.d = getvar_i(L.v) - getvar_i(R.v); } else { @@ -2512,21 +2634,21 @@ re_cont: L.d = icase ? strcasecmp(L.s, R.s) : strcmp(L.s, R.s); } switch (opn & 0xfe) { - case 0: + case 0: R.i = (L.d > 0); break; - case 2: + case 2: R.i = (L.d >= 0); break; - case 4: + case 4: R.i = (L.d == 0); break; } setvar_i(res, (opn & 0x1 ? R.i : !R.i) ? 1 : 0); break; - default: - runtime_error(EMSG_POSSIBLE_ERROR); + default: + syntax_error(EMSG_POSSIBLE_ERROR); } if ((opinfo & OPCLSMASK) <= SHIFT_TIL_THIS) op = op->a.n; @@ -2537,6 +2659,9 @@ re_cont: } nvfree(v1); return res; +#undef fnargs +#undef seed +#undef sreg } @@ -2544,20 +2669,22 @@ re_cont: static int awk_exit(int r) { - unsigned int i; + var tv; + unsigned i; hash_item *hi; - static var tv; - if (! exiting) { + zero_out_var(&tv); + + if (!exiting) { exiting = TRUE; nextrec = FALSE; evaluate(endseq.first, &tv); } /* waiting for children */ - for (i=0; icsize; i++) { + for (i = 0; i < fdhash->csize; i++) { hi = fdhash->items[i]; - while(hi) { + while (hi) { if (hi->data.rs.F && hi->data.rs.is_pipe) pclose(hi->data.rs.F); hi = hi->next; @@ -2569,11 +2696,11 @@ static int awk_exit(int r) /* if expr looks like "var=value", perform assignment and return 1, * otherwise return 0 */ -static int is_assignment(char *expr) +static int is_assignment(const char *expr) { char *exprc, *s, *s0, *s1; - exprc = bb_xstrdup(expr); + exprc = xstrdup(expr); if (!isalnum_(*exprc) || (s = strchr(exprc, '=')) == NULL) { free(exprc); return FALSE; @@ -2593,49 +2720,62 @@ static int is_assignment(char *expr) /* switch to next input file */ static rstream *next_input_file(void) { - static rstream rsm; +#define rsm (G.next_input_file__rsm) +#define files_happen (G.next_input_file__files_happen) + FILE *F = NULL; - char *fname, *ind; - static int files_happen = FALSE; + const char *fname, *ind; if (rsm.F) fclose(rsm.F); rsm.F = NULL; rsm.pos = rsm.adv = 0; do { - if (getvar_i(V[ARGIND])+1 >= getvar_i(V[ARGC])) { + if (getvar_i(intvar[ARGIND])+1 >= getvar_i(intvar[ARGC])) { if (files_happen) return NULL; fname = "-"; F = stdin; } else { - ind = getvar_s(incvar(V[ARGIND])); - fname = getvar_s(findvar(iamarray(V[ARGV]), ind)); + ind = getvar_s(incvar(intvar[ARGIND])); + fname = getvar_s(findvar(iamarray(intvar[ARGV]), ind)); if (fname && *fname && !is_assignment(fname)) F = afopen(fname, "r"); } } while (!F); files_happen = TRUE; - setvar_s(V[FILENAME], fname); + setvar_s(intvar[FILENAME], fname); rsm.F = F; return &rsm; +#undef rsm +#undef files_happen } -extern int awk_main(int argc, char **argv) +int awk_main(int argc, char **argv); +int awk_main(int argc, char **argv) { - char *s, *s1; - int i, j, c; + unsigned opt; + char *opt_F, *opt_W; + llist_t *opt_v = NULL; + int i, j, flen; var *v; - static var tv; + var tv; char **envp; - static int from_file = FALSE; - rstream *rsm; - FILE *F, *stdfiles[3]; - static char * stdnames = "/dev/stdin\0/dev/stdout\0/dev/stderr"; + char *vnames = (char *)vNames; /* cheat */ + char *vvalues = (char *)vValues; + + INIT_G(); + + /* Undo busybox.c, or else strtod may eat ','! This breaks parsing: + * $1,$2 == '$1,' '$2', NOT '$1' ',' '$2' */ + if (ENABLE_LOCALE_SUPPORT) + setlocale(LC_NUMERIC, "C"); + + zero_out_var(&tv); /* allocate global buffer */ - buf = xmalloc(MAXVARFMT+1); + g_buf = xmalloc(MAXVARFMT + 1); vhash = hash_init(); ahash = hash_init(); @@ -2643,121 +2783,113 @@ extern int awk_main(int argc, char **argv) fnhash = hash_init(); /* initialize variables */ - for (i=0; *vNames; i++) { - V[i] = v = newvar(nextword(&vNames)); - if (*vValues != '\377') - setvar_s(v, nextword(&vValues)); + for (i = 0; *vnames; i++) { + intvar[i] = v = newvar(nextword(&vnames)); + if (*vvalues != '\377') + setvar_s(v, nextword(&vvalues)); else setvar_i(v, 0); - if (*vNames == '*') { + if (*vnames == '*') { v->type |= VF_SPECIAL; - vNames++; + vnames++; } } - handle_special(V[FS]); - handle_special(V[RS]); - - stdfiles[0] = stdin; - stdfiles[1] = stdout; - stdfiles[2] = stderr; - for (i=0; i<3; i++) { - rsm = newfile(nextword(&stdnames)); - rsm->F = stdfiles[i]; - } - - for (envp=environ; *envp; envp++) { - s = bb_xstrdup(*envp); - s1 = strchr(s, '='); - if (!s1) { - goto keep_going; + handle_special(intvar[FS]); + handle_special(intvar[RS]); + + newfile("/dev/stdin")->F = stdin; + newfile("/dev/stdout")->F = stdout; + newfile("/dev/stderr")->F = stderr; + + /* Huh, people report that sometimes environ is NULL. Oh well. */ + if (environ) for (envp = environ; *envp; envp++) { + /* environ is writable, thus we don't strdup it needlessly */ + char *s = *envp; + char *s1 = strchr(s, '='); + if (s1) { + *s1 = '\0'; + /* Both findvar and setvar_u take const char* + * as 2nd arg -> environment is not trashed */ + setvar_u(findvar(iamarray(intvar[ENVIRON]), s), s1 + 1); + *s1 = '='; } - *(s1++) = '\0'; - setvar_u(findvar(iamarray(V[ENVIRON]), s), s1); -keep_going: - free(s); } - - while((c = getopt(argc, argv, "F:v:f:W:")) != EOF) { - switch (c) { - case 'F': - setvar_s(V[FS], optarg); - break; - case 'v': - if (! is_assignment(optarg)) - bb_show_usage(); - break; - case 'f': - from_file = TRUE; - F = afopen(programname = optarg, "r"); - s = NULL; - /* one byte is reserved for some trick in next_token */ - for (i=j=1; j>0; i+=j) { - s = (char *)xrealloc(s, i+4096); - j = fread(s+i, 1, 4094, F); - } - s[i] = '\0'; - fclose(F); - parse_program(s+1); - free(s); - break; - case 'W': - bb_error_msg("Warning: unrecognized option '-W %s' ignored\n", optarg); - break; - - default: - bb_show_usage(); - } + opt_complementary = "v::"; + opt = getopt32(argv, "F:v:f:W:", &opt_F, &opt_v, &g_progname, &opt_W); + argv += optind; + argc -= optind; + if (opt & 0x1) + setvar_s(intvar[FS], opt_F); // -F + while (opt_v) { /* -v */ + if (!is_assignment(llist_pop(&opt_v))) + bb_show_usage(); } - - if (!from_file) { - if (argc == optind) + if (opt & 0x4) { // -f + char *s = s; /* die, gcc, die */ + FILE *from_file = afopen(g_progname, "r"); + /* one byte is reserved for some trick in next_token */ + if (fseek(from_file, 0, SEEK_END) == 0) { + flen = ftell(from_file); + s = xmalloc(flen + 4); + fseek(from_file, 0, SEEK_SET); + i = 1 + fread(s + 1, 1, flen, from_file); + } else { + for (i = j = 1; j > 0; i += j) { + s = xrealloc(s, i + 4096); + j = fread(s + i, 1, 4094, from_file); + } + } + s[i] = '\0'; + fclose(from_file); + parse_program(s + 1); + free(s); + } else { // no -f: take program from 1st parameter + if (!argc) bb_show_usage(); - programname="cmd. line"; - parse_program(argv[optind++]); - + g_progname = "cmd. line"; + parse_program(*argv++); + argc--; } + if (opt & 0x8) // -W + bb_error_msg("warning: unrecognized option '-W %s' ignored", opt_W); /* fill in ARGV array */ - setvar_i(V[ARGC], argc - optind + 1); - setari_u(V[ARGV], 0, "awk"); - for(i=optind; i < argc; i++) - setari_u(V[ARGV], i+1-optind, argv[i]); + setvar_i(intvar[ARGC], argc + 1); + setari_u(intvar[ARGV], 0, "awk"); + i = 0; + while (*argv) + setari_u(intvar[ARGV], ++i, *argv++); evaluate(beginseq.first, &tv); - if (! mainseq.first && ! endseq.first) + if (!mainseq.first && !endseq.first) awk_exit(EXIT_SUCCESS); /* input file could already be opened in BEGIN block */ - if (! iF) iF = next_input_file(); + if (!iF) iF = next_input_file(); /* passing through input files */ while (iF) { - nextfile = FALSE; - setvar_i(V[FNR], 0); - - while ((c = awk_getline(iF, V[F0])) > 0) { + setvar_i(intvar[FNR], 0); + while ((i = awk_getline(iF, intvar[F0])) > 0) { nextrec = FALSE; - incvar(V[NR]); - incvar(V[FNR]); + incvar(intvar[NR]); + incvar(intvar[FNR]); evaluate(mainseq.first, &tv); if (nextfile) break; } - if (c < 0) - runtime_error(strerror(errno)); + if (i < 0) + syntax_error(strerror(errno)); iF = next_input_file(); - } awk_exit(EXIT_SUCCESS); - - return 0; + /*return 0;*/ } -