void
eat_nl(void) /* eat all space including newlines */
{
while (1) {
switch (scan_code[(UChar) next()]) {
case SC_COMMENT:
eat_comment();
break;
case SC_NL:
lineno++;
/* FALLTHRU */
case SC_SPACE:
break;
case SC_ESCAPE:
/* bug fix - surprised anyone did this,
a csh user with backslash dyslexia.(Not a joke)
*/
{
int c;
while (scan_code[NextUChar(c)] == SC_SPACE) {
; /* empty */
}
if (c == '\n')
token_lineno = ++lineno;
else if (c == 0) {
un_next();
return;
} else { /* error */
un_next();
/* can't un_next() twice so deal with it */
yylval.ival = '\\';
unexpected_char();
if (++compile_error_count == MAX_COMPILE_ERRORS)
mawk_exit(2);
return;
}
}
break;
default:
un_next();
return;
}
}
}
void
scan_init(const char *cmdline_program)
{
if (cmdline_program) {
program_fd = -1; /* command line program */
program_string = new_STRING0(strlen(cmdline_program) + 1);
strcpy(program_string->str, cmdline_program);
/* simulate file termination */
program_string->str[program_string->len - 1] = '\n';
buffp = (UChar *) program_string->str;
eof_flag = 1;
} else { /* program from file[s] */
scan_open();
buffp = buffer = (UChar *) zmalloc((size_t) (BUFFSZ + 1));
scan_fillbuff();
}
#ifdef OS2 /* OS/2 "extproc" is similar to #! */
if (strnicmp(buffp, "extproc ", 8) == 0)
eat_comment();
#endif
eat_nl(); /* scan to first token */
if (next() == 0) {
/* no program */
mawk_exit(0);
}
un_next();
}
static void
eat_comment(void)
{
register int c;
while (scan_code[NextUChar(c)] && (c != '\n')) {
; /* empty */
}
un_next();
}
static void
eat_semi_colon(void)
/* eat one semi-colon on the current line */
{
register int c;
while (scan_code[NextUChar(c)] == SC_SPACE) {
; /* empty */
}
if (c != ';')
un_next();
}
static int
collect_string(void)
{
register char *p = string_buff;
int c;
int e_flag = 0; /* on if have an escape char */
size_t len_buff;
while (1) {
CheckStringSize(p);
switch (scan_code[NextUChar(*p++)]) {
case SC_DQUOTE: /* done */
*--p = 0;
goto out;
case SC_NL:
p[-1] = 0;
/* FALLTHRU */
case 0: /* unterminated string */
compile_error(
"runaway string constant \"%.10s ...",
string_buff);
mawk_exit(2);
case SC_ESCAPE:
if ((c = next()) == '\n') {
p--;
lineno++;
} else if (c == 0)
un_next();
else {
*p++ = (char) c;
e_flag = 1;
}
break;
default:
break;
}
}
out:
if (e_flag)
rm_escape(string_buff, &len_buff);
else
len_buff = (unsigned) ((char *) p - string_buff);
yylval.ptr = (PTR) new_STRING1(string_buff, len_buff);
return STRING_;
}
int change_current(T const & new_val) // be very careful with this -- check the return value which is non-zero on success
{
Ordered_Heap_Member<T> * old_m = m;
next();
Ordered_Heap_Member<T> * lower_m = m;
m = old_m;
un_next();
Ordered_Heap_Member<T> * higher_m = m;
m = old_m;
if (lower_m) if (new_val < lower_m->data) { return 0; }
if (higher_m) if (higher_m->data < new_val) { return 0; }
m->data = new_val;
return 1;
}
static double
collect_decimal(int c, int *flag)
{
register char *p = string_buff + 1;
char *endp;
char *temp;
char *last_decimal = 0;
double d;
*flag = 0;
string_buff[0] = (char) c;
if (c == '.') {
last_decimal = p - 1;
CheckStringSize(p);
if (scan_code[NextUChar(*p++)] != SC_DIGIT) {
*flag = UNEXPECTED;
yylval.ival = '.';
return 0.0;
}
} else {
while (1) {
CheckStringSize(p);
if (scan_code[NextUChar(*p++)] != SC_DIGIT) {
break;
}
};
if (p[-1] == '.') {
last_decimal = p - 1;
} else {
un_next();
p--;
}
}
/* get rest of digits after decimal point */
while (1) {
CheckStringSize(p);
if (scan_code[NextUChar(*p++)] != SC_DIGIT) {
break;
}
}
/* check for exponent */
if (p[-1] != 'e' && p[-1] != 'E') {
un_next();
*--p = 0;
} else { /* get the exponent */
if (scan_code[NextUChar(*p)] != SC_DIGIT &&
*p != '-' && *p != '+') {
/* if we can, undo and try again */
if (buffp - buffer >= 2) {
un_next(); /* undo the last character */
un_next(); /* undo the 'e' */
*--p = 0;
} else {
*++p = 0;
*flag = BAD_DECIMAL;
return 0.0;
}
} else { /* get the rest of the exponent */
p++;
while (1) {
CheckStringSize(p);
if (scan_code[NextUChar(*p++)] != SC_DIGIT) {
break;
}
}
un_next();
*--p = 0;
}
}
#ifdef LOCALE
if (last_decimal && decimal_dot) {
*last_decimal = decimal_dot;
}
#endif
errno = 0; /* check for overflow/underflow */
d = strtod(string_buff, &temp);
endp = temp;
#ifndef STRTOD_UNDERFLOW_ON_ZERO_BUG
if (errno)
compile_error("%s : decimal %sflow", string_buff,
d == 0.0 ? "under" : "over");
#else /* ! sun4 bug */
if (errno && d != 0.0)
compile_error("%s : decimal overflow", string_buff);
#endif
if (endp < p) {
/* if we can, undo and try again */
if ((p - endp) < (buffp - buffer)) {
while (endp < p) {
un_next();
++endp;
}
} else {
*flag = BAD_DECIMAL;
return 0.0;
}
}
return d;
}
int
yylex(void)
{
register int c;
token_lineno = lineno;
#ifdef NO_LEAKS
memset(&yylval, 0, sizeof(yylval));
#endif
reswitch:
switch (scan_code[NextUChar(c)]) {
case 0:
ct_ret(EOF);
case SC_SPACE:
goto reswitch;
case SC_COMMENT:
eat_comment();
goto reswitch;
case SC_NL:
lineno++;
eat_nl();
ct_ret(NL);
case SC_ESCAPE:
while (scan_code[NextUChar(c)] == SC_SPACE) {
; /* empty */
};
if (c == '\n') {
token_lineno = ++lineno;
goto reswitch;
}
if (c == 0)
ct_ret(EOF);
un_next();
yylval.ival = '\\';
ct_ret(UNEXPECTED);
case SC_SEMI_COLON:
eat_nl();
ct_ret(SEMI_COLON);
case SC_LBRACE:
eat_nl();
brace_cnt++;
ct_ret(LBRACE);
case SC_PLUS:
switch (next()) {
case '+':
yylval.ival = '+';
string_buff[0] =
string_buff[1] = '+';
string_buff[2] = 0;
ct_ret(INC_or_DEC);
case '=':
ct_ret(ADD_ASG);
default:
un_next();
ct_ret(PLUS);
}
case SC_MINUS:
switch (next()) {
case '-':
yylval.ival = '-';
string_buff[0] =
string_buff[1] = '-';
string_buff[2] = 0;
ct_ret(INC_or_DEC);
case '=':
ct_ret(SUB_ASG);
default:
un_next();
ct_ret(MINUS);
}
case SC_COMMA:
eat_nl();
ct_ret(COMMA);
case SC_MUL:
test1_ret('=', MUL_ASG, MUL);
case SC_DIV:
{
static const int can_precede_div[] =
{DOUBLE, STRING_, RPAREN, ID, D_ID, RE, RBOX, FIELD,
GETLINE, INC_or_DEC, -1};
const int *p = can_precede_div;
do {
if (*p == current_token) {
if (*p != INC_or_DEC) {
test1_ret('=', DIV_ASG, DIV);
}
if (next() == '=') {
un_next();
ct_ret(collect_RE());
}
}
}
while (*++p != -1);
ct_ret(collect_RE());
}
case SC_MOD:
test1_ret('=', MOD_ASG, MOD);
case SC_POW:
test1_ret('=', POW_ASG, POW);
case SC_LPAREN:
paren_cnt++;
ct_ret(LPAREN);
case SC_RPAREN:
if (--paren_cnt < 0) {
compile_error("extra ')'");
paren_cnt = 0;
goto reswitch;
}
ct_ret(RPAREN);
case SC_LBOX:
ct_ret(LBOX);
case SC_RBOX:
ct_ret(RBOX);
case SC_MATCH:
string_buff[1] = '~';
string_buff[0] = 0;
yylval.ival = 1;
ct_ret(MATCH);
case SC_EQUAL:
test1_ret('=', EQ, ASSIGN);
case SC_NOT: /* ! */
if ((c = next()) == '~') {
string_buff[0] = '!';
string_buff[1] = '~';
string_buff[2] = 0;
yylval.ival = 0;
ct_ret(MATCH);
} else if (c == '=')
ct_ret(NEQ);
un_next();
ct_ret(NOT);
case SC_LT: /* '<' */
if (next() == '=')
ct_ret(LTE);
else
un_next();
if (getline_flag) {
getline_flag = 0;
ct_ret(IO_IN);
} else
ct_ret(LT);
case SC_GT: /* '>' */
if (print_flag && paren_cnt == 0) {
print_flag = 0;
/* there are 3 types of IO_OUT
-- build the error string in string_buff */
string_buff[0] = '>';
if (next() == '>') {
yylval.ival = F_APPEND;
string_buff[1] = '>';
string_buff[2] = 0;
} else {
un_next();
yylval.ival = F_TRUNC;
string_buff[1] = 0;
}
return current_token = IO_OUT;
}
test1_ret('=', GTE, GT);
case SC_OR:
if (next() == '|') {
eat_nl();
ct_ret(OR);
} else {
un_next();
if (print_flag && paren_cnt == 0) {
print_flag = 0;
yylval.ival = PIPE_OUT;
string_buff[0] = '|';
string_buff[1] = 0;
ct_ret(IO_OUT);
} else
ct_ret(PIPE);
}
case SC_AND:
if (next() == '&') {
eat_nl();
ct_ret(AND);
} else {
un_next();
yylval.ival = '&';
ct_ret(UNEXPECTED);
}
case SC_QMARK:
ct_ret(QMARK);
case SC_COLON:
ct_ret(COLON);
case SC_RBRACE:
if (--brace_cnt < 0) {
compile_error("extra '}'");
eat_semi_colon();
brace_cnt = 0;
goto reswitch;
}
if ((c = current_token) == NL || c == SEMI_COLON
|| c == SC_FAKE_SEMI_COLON || c == RBRACE) {
/* if the brace_cnt is zero , we've completed
a pattern action block. If the user insists
on adding a semi-colon on the same line
we will eat it. Note what we do below:
physical law -- conservation of semi-colons */
if (brace_cnt == 0)
eat_semi_colon();
eat_nl();
ct_ret(RBRACE);
}
/* supply missing semi-colon to statement that
precedes a '}' */
brace_cnt++;
un_next();
current_token = SC_FAKE_SEMI_COLON;
return SEMI_COLON;
case SC_DIGIT:
case SC_DOT:
{
double d;
int flag;
if ((d = collect_decimal(c, &flag)) == 0.0) {
if (flag)
ct_ret(flag);
else
yylval.ptr = (PTR) & double_zero;
} else if (d == 1.0) {
yylval.ptr = (PTR) & double_one;
} else {
yylval.ptr = (PTR) ZMALLOC(double);
*(double *) yylval.ptr = d;
}
ct_ret(DOUBLE);
}
case SC_DOLLAR: /* '$' */
{
double d;
int flag;
while (scan_code[NextUChar(c)] == SC_SPACE) {
; /* empty */
};
if (scan_code[c] != SC_DIGIT &&
scan_code[c] != SC_DOT) {
un_next();
ct_ret(DOLLAR);
}
/* compute field address at compile time */
if ((d = collect_decimal(c, &flag)) <= 0.0) {
if (flag)
ct_ret(flag); /* an error */
else
yylval.cp = &field[0];
} else {
int ival = d_to_I(d);
double dval = (double) ival;
if (dval != d) {
compile_error("$%g is invalid field index", d);
}
yylval.cp = field_ptr(ival);
}
ct_ret(FIELD);
}
case SC_DQUOTE:
return current_token = collect_string();
case SC_IDCHAR: /* collect an identifier */
{
char *p = string_buff + 1;
SYMTAB *stp;
string_buff[0] = (char) c;
while (1) {
CheckStringSize(p);
c = scan_code[NextUChar(*p++)];
if (c != SC_IDCHAR && c != SC_DIGIT)
break;
}
un_next();
*--p = 0;
switch ((stp = find(string_buff))->type) {
case ST_NONE:
/* check for function call before defined */
if (next() == '(') {
stp->type = ST_FUNCT;
stp->stval.fbp = (FBLOCK *)
zmalloc(sizeof(FBLOCK));
stp->stval.fbp->name = stp->name;
stp->stval.fbp->code = (INST *) 0;
stp->stval.fbp->size = 0;
yylval.fbp = stp->stval.fbp;
current_token = FUNCT_ID;
} else {
yylval.stp = stp;
current_token =
current_token == DOLLAR ? D_ID : ID;
}
un_next();
break;
case ST_NR:
NR_flag = 1;
stp->type = ST_VAR;
/* FALLTHRU */
case ST_VAR:
case ST_ARRAY:
case ST_LOCAL_NONE:
case ST_LOCAL_VAR:
case ST_LOCAL_ARRAY:
yylval.stp = stp;
current_token =
current_token == DOLLAR ? D_ID : ID;
break;
case ST_ENV:
stp->type = ST_ARRAY;
stp->stval.array = new_ARRAY();
load_environ(stp->stval.array);
yylval.stp = stp;
current_token =
current_token == DOLLAR ? D_ID : ID;
break;
case ST_FUNCT:
yylval.fbp = stp->stval.fbp;
current_token = FUNCT_ID;
break;
case ST_KEYWORD:
current_token = stp->stval.kw;
break;
case ST_BUILTIN:
yylval.bip = stp->stval.bip;
current_token = BUILTIN;
break;
case ST_LENGTH:
yylval.bip = stp->stval.bip;
/* check for length alone, this is an ugly
hack */
while (scan_code[NextUChar(c)] == SC_SPACE) {
; /* empty */
};
un_next();
current_token = c == '(' ? BUILTIN : LENGTH;
break;
case ST_FIELD:
yylval.cp = stp->stval.cp;
current_token = FIELD;
break;
default:
bozo("find returned bad st type");
}
return current_token;
}
case SC_UNEXPECTED:
yylval.ival = c & 0xff;
ct_ret(UNEXPECTED);
}
return 0; /* never get here make lint happy */
}
static int
collect_RE(void)
{
char *p = string_buff;
const char *first = NULL;
int limit = sizeof(string_buff) - 2;
int c;
int boxed = 0;
STRING *sval;
while (1) {
if (p >= (string_buff + limit)) {
compile_error(
"regular expression /%.10s ..."
" exceeds implementation size limit (%d)",
string_buff,
limit);
mawk_exit(2);
}
CheckStringSize(p);
switch (scan_code[NextUChar(c = *p++)]) {
case SC_POW:
/* Handle [^]] and [^^] correctly. */
if ((p - 1) == first && first != 0 && first[-1] == '[') {
first = p;
}
break;
case SC_LBOX:
/*
* If we're starting a bracket expression, remember where that
* started, so we can make comparisons to handle things like
* "[]xxxx]" and "[^]xxxx]".
*/
if (!boxed) {
first = p;
++boxed;
} else {
/* XXX. Does not handle collating symbols or equivalence
* class expressions. */
/* XXX. Does not match logic used in rexp0.c to check for
* a character class expression, though probably the
* latter should be adjusted.
* POSIX and common sense give us license to complain about
* expressions such as '[[:not a special character class]]'.
*/
if (next() == ':') {
++boxed;
}
un_next();
}
break;
case SC_RBOX:
/*
* A right square-bracket loses its special meaning if it occurs
* first in the list (after an optional "^").
*/
if (boxed && p - 1 != first) {
--boxed;
}
break;
case SC_DIV: /* done */
if (!boxed) {
*--p = 0;
goto out;
}
break;
case SC_NL:
p[-1] = 0;
/* FALLTHRU */
case 0: /* unterminated re */
compile_error(
"runaway regular expression /%.10s ...",
string_buff);
mawk_exit(2);
case SC_ESCAPE:
switch (c = next()) {
case '/':
p[-1] = '/';
break;
case '\n':
p--;
break;
case 0:
un_next();
break;
default:
*p++ = (char) c;
break;
}
break;
}
}
out:
/* now we've got the RE, so compile it */
sval = new_STRING(string_buff);
yylval.ptr = re_compile(sval);
free_STRING(sval);
return RE;
}
