4.4BSD/usr/src/old/dbx/scanner.c
/*
* Copyright (c) 1983 The Regents of the University of California.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#ifndef lint
static char sccsid[] = "@(#)scanner.c 5.3 (Berkeley) 6/1/90";
#endif /* not lint */
/*
* Debugger scanner.
*/
#include "defs.h"
#include "scanner.h"
#include "main.h"
#include "keywords.h"
#include "tree.h"
#include "symbols.h"
#include "names.h"
#include "y.tab.h"
#ifndef public
typedef int Token;
#define MAXLINESIZE 10240
#endif
public String initfile = ".dbxinit";
typedef enum { WHITE, ALPHA, NUM, OTHER } Charclass;
private Charclass class[256 + 1];
private Charclass *lexclass = class + 1;
#define isdigit(c) (lexclass[c] == NUM)
#define isalnum(c) (lexclass[c] == ALPHA or lexclass[c] == NUM)
#define ishexdigit(c) ( \
isdigit(c) or (c >= 'a' and c <= 'f') or (c >= 'A' and c <= 'F') \
)
public boolean chkalias;
public char scanner_linebuf[MAXLINESIZE];
private File in;
private char *curchar, *prevchar;
#define MAXINCLDEPTH 10
private struct {
File savefile;
Filename savefn;
int savelineno;
} inclinfo[MAXINCLDEPTH];
private unsigned int curinclindex;
private Token getident();
private Token getnum();
private Token getstring();
private Boolean eofinput();
private char charcon();
private enterlexclass(class, s)
Charclass class;
String s;
{
register char *p;
for (p = s; *p != '\0'; p++) {
lexclass[*p] = class;
}
}
public scanner_init()
{
register Integer i;
for (i = 0; i < 257; i++) {
class[i] = OTHER;
}
enterlexclass(WHITE, " \t");
enterlexclass(ALPHA, "abcdefghijklmnopqrstuvwxyz");
enterlexclass(ALPHA, "ABCDEFGHIJKLMNOPQRSTUVWXYZ_$");
enterlexclass(NUM, "0123456789");
in = stdin;
errfilename = nil;
errlineno = 0;
curchar = scanner_linebuf;
scanner_linebuf[0] = '\0';
chkalias = true;
}
/*
* Read a single token.
*
* The input is line buffered. Tokens cannot cross line boundaries.
*
* There are two "modes" of operation: one as in a compiler,
* and one for reading shell-like syntax. In the first mode
* there is the additional choice of doing alias processing.
*/
private Boolean shellmode;
public Token yylex()
{
register int c;
register char *p;
register Token t;
String line;
integer n;
p = curchar;
if (*p == '\0') {
do {
if (isterm(in)) {
printf("(%s) ", cmdname);
}
fflush(stdout);
line = fgets(scanner_linebuf, MAXLINESIZE, in);
} while (line == nil and not eofinput());
if (line == nil) {
c = EOF;
} else {
p = scanner_linebuf;
while (lexclass[*p] == WHITE) {
p++;
}
shellmode = false;
}
chkalias = true;
} else {
while (lexclass[*p] == WHITE) {
p++;
}
}
curchar = p;
prevchar = curchar;
c = *p;
if (lexclass[c] == ALPHA) {
t = getident(chkalias);
} else if (lexclass[c] == NUM) {
if (shellmode) {
t = getident(chkalias);
} else {
t = getnum();
}
} else {
++curchar;
switch (c) {
case '\n':
t = '\n';
if (errlineno != 0) {
errlineno++;
}
break;
case '"':
case '\'':
t = getstring(c);
break;
case '.':
if (shellmode) {
--curchar;
t = getident(chkalias);
} else if (isdigit(*curchar)) {
--curchar;
t = getnum();
} else {
t = '.';
}
break;
case '-':
if (shellmode) {
--curchar;
t = getident(chkalias);
} else if (*curchar == '>') {
++curchar;
t = ARROW;
} else {
t = '-';
}
break;
case '#':
if (not isterm(in)) {
*p = '\0';
curchar = p;
t = '\n';
++errlineno;
} else {
t = '#';
}
break;
case '\\':
if (*(p+1) == '\n') {
n = MAXLINESIZE - (p - &scanner_linebuf[0]);
if (n > 1) {
if (fgets(p, n, in) == nil) {
t = 0;
} else {
curchar = p;
t = yylex();
}
} else {
t = '\\';
}
} else {
t = '\\';
}
break;
case EOF:
t = 0;
break;
default:
if (shellmode and index("!&*<>()[]", c) == nil) {
--curchar;
t = getident(chkalias);
} else {
t = c;
}
break;
}
}
chkalias = false;
# ifdef LEXDEBUG
if (lexdebug) {
fprintf(stderr, "yylex returns ");
print_token(stderr, t);
fprintf(stderr, "\n");
}
# endif
return t;
}
/*
* Put the given string before the current character
* in the current line, thus inserting it into the input stream.
*/
public insertinput (s)
String s;
{
register char *p, *q;
int need, avail, shift;
q = s;
need = strlen(q);
avail = curchar - &scanner_linebuf[0];
if (need <= avail) {
curchar = &scanner_linebuf[avail - need];
p = curchar;
while (*q != '\0') {
*p++ = *q++;
}
} else {
p = curchar;
while (*p != '\0') {
++p;
}
shift = need - avail;
if (p + shift >= &scanner_linebuf[MAXLINESIZE]) {
error("alias expansion too large");
}
for (;;) {
*(p + shift) = *p;
if (p == curchar) {
break;
}
--p;
}
p = &scanner_linebuf[0];
while (*q != '\0') {
*p++ = *q++;
}
curchar = &scanner_linebuf[0];
}
}
/*
* Get the actuals for a macro call.
*/
private String movetochar (str, c)
String str;
char c;
{
register char *p;
while (*p != c) {
if (*p == '\0') {
error("missing ')' in macro call");
} else if (*p == ')') {
error("not enough parameters in macro call");
} else if (*p == ',') {
error("too many parameters in macro call");
}
++p;
}
return p;
}
private String *getactuals (n)
integer n;
{
String *a;
register char *p;
int i;
a = newarr(String, n);
p = curchar;
while (*p != '(') {
if (lexclass[*p] != WHITE) {
error("missing actuals for macro");
}
++p;
}
++p;
for (i = 0; i < n - 1; i++) {
a[i] = p;
p = movetochar(p, ',');
*p = '\0';
++p;
}
a[n-1] = p;
p = movetochar(p, ')');
*p = '\0';
curchar = p + 1;
return a;
}
/*
* Do command macro expansion, assuming curchar points to the beginning
* of the actuals, and we are not in shell mode.
*/
private expand (pl, str)
List pl;
String str;
{
char buf[4096], namebuf[100];
register char *p, *q, *r;
String *actual;
Name n;
integer i;
boolean match;
if (pl == nil) {
insertinput(str);
} else {
actual = getactuals(list_size(pl));
p = buf;
q = str;
while (*q != '\0') {
if (p >= &buf[4096]) {
error("alias expansion too large");
}
if (lexclass[*q] == ALPHA) {
r = namebuf;
do {
*r++ = *q++;
} while (isalnum(*q));
*r = '\0';
i = 0;
match = false;
foreach(Name, n, pl)
if (streq(ident(n), namebuf)) {
match = true;
break;
}
++i;
endfor
if (match) {
r = actual[i];
} else {
r = namebuf;
}
while (*r != '\0') {
*p++ = *r++;
}
} else {
*p++ = *q++;
}
}
*p = '\0';
insertinput(buf);
}
}
/*
* Parser error handling.
*/
public yyerror(s)
String s;
{
register char *p;
register integer start;
if (streq(s, "syntax error")) {
beginerrmsg();
p = prevchar;
start = p - &scanner_linebuf[0];
if (p > &scanner_linebuf[0]) {
while (lexclass[*p] == WHITE and p > &scanner_linebuf[0]) {
--p;
}
}
fprintf(stderr, "%s", scanner_linebuf);
if (start != 0) {
fprintf(stderr, "%*c", start, ' ');
}
if (p == &scanner_linebuf[0]) {
fprintf(stderr, "^ unrecognized command");
} else {
fprintf(stderr, "^ syntax error");
}
enderrmsg();
} else {
error(s);
}
}
/*
* Eat the current line.
*/
public gobble ()
{
curchar = scanner_linebuf;
scanner_linebuf[0] = '\0';
}
/*
* Scan an identifier.
*
* If chkalias is true, check first to see if it's an alias.
* Otherwise, check to see if it's a keyword.
*/
private Token getident (chkalias)
boolean chkalias;
{
char buf[1024];
register char *p, *q;
register Token t;
List pl;
String str;
p = curchar;
q = buf;
if (shellmode) {
do {
*q++ = *p++;
} while (index(" \t\n!&<>*[]()'\"", *p) == nil);
} else {
do {
*q++ = *p++;
} while (isalnum(*p));
}
curchar = p;
*q = '\0';
yylval.y_name = identname(buf, false);
if (chkalias) {
if (findalias(yylval.y_name, &pl, &str)) {
expand(pl, str);
while (lexclass[*curchar] == WHITE) {
++curchar;
}
if (pl == nil) {
t = getident(false);
} else {
t = getident(true);
}
} else if (shellmode) {
t = NAME;
} else {
t = findkeyword(yylval.y_name, NAME);
}
} else if (shellmode) {
t = NAME;
} else {
t = findkeyword(yylval.y_name, NAME);
}
return t;
}
/*
* Scan a number.
*/
private Token getnum()
{
char buf[1024];
register Char *p, *q;
register Token t;
Integer base;
p = curchar;
q = buf;
if (*p == '0') {
if (*(p+1) == 'x') {
p += 2;
base = 16;
} else if (*(p+1) == 't') {
base = 10;
} else if (varIsSet("$hexin")) {
base = 16;
} else {
base = 8;
}
} else if (varIsSet("$hexin")) {
base = 16;
} else if (varIsSet("$octin")) {
base = 8;
} else {
base = 10;
}
if (base == 16) {
do {
*q++ = *p++;
} while (ishexdigit(*p));
} else {
do {
*q++ = *p++;
} while (isdigit(*p));
}
if (*p == '.') {
do {
*q++ = *p++;
} while (isdigit(*p));
if (*p == 'e' or *p == 'E') {
p++;
if (*p == '+' or *p == '-' or isdigit(*p)) {
*q++ = 'e';
do {
*q++ = *p++;
} while (isdigit(*p));
}
}
*q = '\0';
yylval.y_real = atof(buf);
t = REAL;
} else {
*q = '\0';
switch (base) {
case 10:
yylval.y_int = atol(buf);
break;
case 8:
yylval.y_int = octal(buf);
break;
case 16:
yylval.y_int = hex(buf);
break;
default:
badcaseval(base);
}
t = INT;
}
curchar = p;
return t;
}
/*
* Convert a string of octal digits to an integer.
*/
private int octal(s)
String s;
{
register Char *p;
register Integer n;
n = 0;
for (p = s; *p != '\0'; p++) {
n = 8*n + (*p - '0');
}
return n;
}
/*
* Convert a string of hexadecimal digits to an integer.
*/
private int hex(s)
String s;
{
register Char *p;
register Integer n;
n = 0;
for (p = s; *p != '\0'; p++) {
n *= 16;
if (*p >= 'a' and *p <= 'f') {
n += (*p - 'a' + 10);
} else if (*p >= 'A' and *p <= 'F') {
n += (*p - 'A' + 10);
} else {
n += (*p - '0');
}
}
return n;
}
/*
* Scan a string.
*/
private Token getstring (quote)
char quote;
{
register char *p, *q;
char buf[MAXLINESIZE];
boolean endofstring;
Token t;
p = curchar;
q = buf;
endofstring = false;
while (not endofstring) {
if (*p == '\\' and *(p+1) == '\n') {
if (fgets(scanner_linebuf, MAXLINESIZE, in) == nil) {
error("non-terminated string");
}
p = &scanner_linebuf[0] - 1;
} else if (*p == '\n' or *p == '\0') {
error("non-terminated string");
endofstring = true;
} else if (*p == quote) {
endofstring = true;
} else {
curchar = p;
*q++ = charcon(p);
p = curchar;
}
p++;
}
curchar = p;
*q = '\0';
if (quote == '\'' and buf[1] == '\0') {
yylval.y_char = buf[0];
t = CHAR;
} else {
yylval.y_string = strdup(buf);
t = STRING;
}
return t;
}
/*
* Process a character constant.
* Watch out for backslashes.
*/
private char charcon (s)
String s;
{
register char *p, *q;
char c, buf[10];
p = s;
if (*p == '\\') {
++p;
switch (*p) {
case '\\':
c = '\\';
break;
case 'n':
c = '\n';
break;
case 'r':
c = '\r';
break;
case 't':
c = '\t';
break;
case '\'':
case '"':
c = *p;
break;
default:
if (isdigit(*p)) {
q = buf;
do {
*q++ = *p++;
} while (isdigit(*p));
*q = '\0';
c = (char) octal(buf);
}
--p;
break;
}
curchar = p;
} else {
c = *p;
}
return c;
}
/*
* Input file management routines.
*/
public setinput(filename)
Filename filename;
{
File f;
f = fopen(filename, "r");
if (f == nil) {
error("can't open %s", filename);
} else {
if (curinclindex >= MAXINCLDEPTH) {
error("unreasonable input nesting on \"%s\"", filename);
}
inclinfo[curinclindex].savefile = in;
inclinfo[curinclindex].savefn = errfilename;
inclinfo[curinclindex].savelineno = errlineno;
curinclindex++;
in = f;
errfilename = filename;
errlineno = 1;
}
}
private Boolean eofinput()
{
register Boolean b;
if (curinclindex == 0) {
if (isterm(in)) {
putchar('\n');
clearerr(in);
b = false;
} else {
b = true;
}
} else {
fclose(in);
--curinclindex;
in = inclinfo[curinclindex].savefile;
errfilename = inclinfo[curinclindex].savefn;
errlineno = inclinfo[curinclindex].savelineno;
b = false;
}
return b;
}
/*
* Pop the current input. Return whether successful.
*/
public Boolean popinput()
{
Boolean b;
if (curinclindex == 0) {
b = false;
} else {
b = (Boolean) (not eofinput());
}
return b;
}
/*
* Return whether we are currently reading from standard input.
*/
public Boolean isstdin()
{
return (Boolean) (in == stdin);
}
/*
* Send the current line to the shell.
*/
public shellline()
{
register char *p;
p = curchar;
while (*p != '\0' and (*p == '\n' or lexclass[*p] == WHITE)) {
++p;
}
shell(p);
if (*p == '\0' and isterm(in)) {
putchar('\n');
}
erecover();
}
/*
* Read the rest of the current line in "shell mode".
*/
public beginshellmode()
{
shellmode = true;
}
/*
* Print out a token for debugging.
*/
public print_token(f, t)
File f;
Token t;
{
if (t == '\n') {
fprintf(f, "char '\\n'");
} else if (t == EOF) {
fprintf(f, "EOF");
} else if (t < 256) {
fprintf(f, "char '%c'", t);
} else {
fprintf(f, "\"%s\"", keywdstring(t));
}
}