563 lines
8.8 KiB
C
563 lines
8.8 KiB
C
/* $Header$ */
|
|
/*
|
|
* (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
|
* See the copyright notice in the ACK home directory, in the file "Copyright".
|
|
*/
|
|
/* @(#)comm5.c 1.1 */
|
|
|
|
#include "comm0.h"
|
|
#include "comm1.h"
|
|
#include "y.tab.h"
|
|
|
|
extern YYSTYPE yylval;
|
|
|
|
yylex()
|
|
{
|
|
register c;
|
|
|
|
if (pass == PASS_1) {
|
|
/* scan the input file */
|
|
do
|
|
c = nextchar();
|
|
while (isspace(c) && c != '\n');
|
|
if (ISALPHA(c))
|
|
c = inident(c);
|
|
else if (isdigit(c))
|
|
c = innumber(c);
|
|
else switch (c) {
|
|
case '=':
|
|
case '<':
|
|
case '>':
|
|
case '|':
|
|
case '&':
|
|
c = induo(c); break;
|
|
case ASC_SQUO:
|
|
case ASC_DQUO:
|
|
c = instring(c); break;
|
|
case ASC_COMM:
|
|
do
|
|
c = nextchar();
|
|
while (c != '\n' && c != '\0');
|
|
break;
|
|
case CTRL('A'):
|
|
c = CODE1; readcode(1); break;
|
|
case CTRL('B'):
|
|
c = CODE2; readcode(2); break;
|
|
case CTRL('C'):
|
|
c = CODE4; readcode(4); break;
|
|
}
|
|
|
|
/* produce the intermediate token file */
|
|
if (c <= 0)
|
|
return(0);
|
|
if (c <= 127)
|
|
putc(c, tempfile);
|
|
else
|
|
putval(c);
|
|
} else {
|
|
/* read from intermediate token file */
|
|
c = getc(tempfile);
|
|
if (c == EOF)
|
|
return(0);
|
|
if (c > 127) {
|
|
c += 128;
|
|
c = getval(c);
|
|
}
|
|
}
|
|
curr_token = c;
|
|
return(c);
|
|
}
|
|
|
|
putval(c)
|
|
{
|
|
register valu_t v;
|
|
register n = 0;
|
|
register char *p = 0;
|
|
|
|
assert(c >= 256 && c < 256+128);
|
|
switch (c) {
|
|
case CODE1:
|
|
n = 1; goto putnum;
|
|
case CODE2:
|
|
n = 2; goto putnum;
|
|
case CODE4:
|
|
n = 4; goto putnum;
|
|
case NUMBER:
|
|
v = yylval.y_valu;
|
|
for (n = 0; n < sizeof(v); n++) {
|
|
if (v == 0)
|
|
break;
|
|
v >>= 8;
|
|
}
|
|
c = NUMBER0 + n;
|
|
putnum:
|
|
putc(c-128, tempfile);
|
|
v = yylval.y_valu;
|
|
while (--n >= 0)
|
|
putc((int) (v >> (n*8)), tempfile);
|
|
return;
|
|
case IDENT:
|
|
case FBSYM:
|
|
n = sizeof(item_t *);
|
|
p = (char *) &yylval.y_item; break;
|
|
#ifdef ASLD
|
|
case MODULE:
|
|
n = sizeof(char *);
|
|
p = (char *) &yylval.y_strp; break;
|
|
#endif
|
|
case STRING:
|
|
v = stringlen;
|
|
putc(c-128, tempfile);
|
|
for (n = 0; n < sizeof(v); n++) {
|
|
if (v == 0)
|
|
break;
|
|
v >>= 8;
|
|
}
|
|
c = NUMBER0 + n;
|
|
putc(c-128, tempfile);
|
|
v = stringlen;
|
|
while (--n >= 0)
|
|
putc((int) (v >> (n*8)), tempfile);
|
|
p = stringbuf;
|
|
n = stringlen;
|
|
while (--n >= 0)
|
|
putc(*p++, tempfile);
|
|
return;
|
|
case OP_EQ:
|
|
case OP_NE:
|
|
case OP_LE:
|
|
case OP_GE:
|
|
case OP_LL:
|
|
case OP_RR:
|
|
case OP_OO:
|
|
case OP_AA:
|
|
break;
|
|
default:
|
|
n = sizeof(word_t);
|
|
p = (char *) &yylval.y_word; break;
|
|
}
|
|
putc(c-128, tempfile);
|
|
while (--n >= 0)
|
|
putc(*p++, tempfile);
|
|
}
|
|
|
|
getval(c)
|
|
{
|
|
register n = 0;
|
|
register valu_t v;
|
|
register char *p = 0;
|
|
|
|
switch (c) {
|
|
case CODE1:
|
|
n = 1; goto getnum;
|
|
case CODE2:
|
|
n = 2; goto getnum;
|
|
case CODE4:
|
|
n = 4; goto getnum;
|
|
case NUMBER0:
|
|
c = NUMBER; goto getnum;
|
|
case NUMBER1:
|
|
n = 1; c = NUMBER; goto getnum;
|
|
case NUMBER2:
|
|
n = 2; c = NUMBER; goto getnum;
|
|
case NUMBER3:
|
|
n = 3; c = NUMBER; goto getnum;
|
|
case NUMBER:
|
|
n = 4;
|
|
getnum:
|
|
v = 0;
|
|
while (--n >= 0) {
|
|
v <<= 8;
|
|
v |= getc(tempfile);
|
|
}
|
|
yylval.y_valu = v;
|
|
return(c);
|
|
case IDENT:
|
|
case FBSYM:
|
|
n = sizeof(item_t *);
|
|
p = (char *) &yylval.y_item; break;
|
|
#ifdef ASLD
|
|
case MODULE:
|
|
n = sizeof(char *);
|
|
p = (char *) &yylval.y_strp; break;
|
|
#endif
|
|
case STRING:
|
|
getval(getc(tempfile)+128);
|
|
stringlen = n = yylval.y_valu;
|
|
p = stringbuf;
|
|
p[n] = '\0'; break;
|
|
case OP_EQ:
|
|
case OP_NE:
|
|
case OP_LE:
|
|
case OP_GE:
|
|
case OP_LL:
|
|
case OP_RR:
|
|
case OP_OO:
|
|
case OP_AA:
|
|
break;
|
|
default:
|
|
n = sizeof(word_t);
|
|
p = (char *) &yylval.y_word; break;
|
|
}
|
|
while (--n >= 0)
|
|
*p++ = getc(tempfile);
|
|
return(c);
|
|
}
|
|
|
|
/* ---------- lexical scan in pass 1 ---------- */
|
|
|
|
nextchar()
|
|
{
|
|
register c;
|
|
|
|
if (peekc != -1) {
|
|
c = peekc;
|
|
peekc = -1;
|
|
return(c);
|
|
}
|
|
#ifdef ASLD
|
|
if (archmode && --archsize < 0)
|
|
return(0);
|
|
#endif
|
|
if ((c = getc(input)) == EOF)
|
|
return(0);
|
|
if (isascii(c) == 0)
|
|
fatal("non-ascii character");
|
|
#ifdef LISTING
|
|
if (listflag & 0440)
|
|
putc(c, listfile);
|
|
#endif
|
|
return(c);
|
|
}
|
|
|
|
readcode(n)
|
|
{
|
|
register c;
|
|
|
|
yylval.y_valu = 0;
|
|
do {
|
|
if (
|
|
#ifdef ASLD
|
|
(archmode && --archsize < 0)
|
|
||
|
|
#endif
|
|
(c = getc(input)) == EOF
|
|
)
|
|
fatal("unexpected EOF in compact input");
|
|
yylval.y_valu <<= 8;
|
|
yylval.y_valu |= c;
|
|
} while (--n);
|
|
}
|
|
|
|
induo(c)
|
|
register c;
|
|
{
|
|
static short duo[] = {
|
|
('='<<8) | '=', OP_EQ,
|
|
('<'<<8) | '>', OP_NE,
|
|
('<'<<8) | '=', OP_LE,
|
|
('>'<<8) | '=', OP_GE,
|
|
('<'<<8) | '<', OP_LL,
|
|
('>'<<8) | '>', OP_RR,
|
|
('|'<<8) | '|', OP_OO,
|
|
('&'<<8) | '&', OP_AA,
|
|
};
|
|
register short *p;
|
|
|
|
c = (c<<8) | nextchar();
|
|
for (p = duo; *p; p++)
|
|
if (*p++ == c)
|
|
return(*p++);
|
|
peekc = c & 0377;
|
|
return(c>>8);
|
|
}
|
|
|
|
static char name[NAMEMAX+1];
|
|
|
|
inident(c)
|
|
register c;
|
|
{
|
|
register char *p = name;
|
|
register item_t *ip;
|
|
register n = NAMEMAX;
|
|
|
|
do {
|
|
if (--n >= 0)
|
|
*p++ = c;
|
|
c = nextchar();
|
|
} while (ISALNUM(c));
|
|
*p = '\0';
|
|
peekc = c;
|
|
ip = item_search(name);
|
|
if (ip == 0) {
|
|
ip = item_alloc(S_UND);
|
|
ip->i_name = remember(name);
|
|
/* printf("ident %s %o\n", ip->i_name, ip); */
|
|
unresolved++;
|
|
item_insert(ip, H_LOCAL + (hashindex%H_SIZE));
|
|
} else if (hashindex < H_SIZE) {
|
|
assert(H_KEY == 0);
|
|
yylval.y_word = (word_t) ip->i_valu;
|
|
return(ip->i_type);
|
|
}
|
|
yylval.y_item = ip;
|
|
return(IDENT);
|
|
}
|
|
|
|
#ifdef ASLD
|
|
char *
|
|
readident(c)
|
|
register c;
|
|
{
|
|
register n = NAMEMAX;
|
|
register char *p = name;
|
|
|
|
do {
|
|
if (--n >= 0)
|
|
*p++ = c;
|
|
c = nextchar();
|
|
} while (ISALNUM(c));
|
|
*p++ = '\0';
|
|
peekc = c;
|
|
return(name);
|
|
}
|
|
#endif
|
|
|
|
innumber(c)
|
|
register c;
|
|
{
|
|
register char *p;
|
|
register radix;
|
|
static char num[20+1];
|
|
|
|
p = num;
|
|
radix = 20;
|
|
do {
|
|
if (--radix < 0)
|
|
fatal("number too long");
|
|
if (isupper(c))
|
|
c += ('a' - 'A');
|
|
*p++ = c;
|
|
c = nextchar();
|
|
} while (isalnum(c));
|
|
peekc = c;
|
|
*p = '\0';
|
|
c = *--p;
|
|
p = num;
|
|
radix = 10;
|
|
if (*p == '0') {
|
|
radix = 8;
|
|
p++;
|
|
if (*p == 'x') {
|
|
radix = 16;
|
|
p++;
|
|
} else if (*p == 'b') {
|
|
radix = 2;
|
|
p++;
|
|
}
|
|
}
|
|
if (radix != 16 && (c == 'f' || c == 'b'))
|
|
return(infbsym(num));
|
|
yylval.y_valu = 0;
|
|
while (c = *p++) {
|
|
if (c > '9')
|
|
c -= ('a' - '9' - 1);
|
|
c -= '0';
|
|
if ((unsigned)c >= radix)
|
|
serror("digit exceeds radix");
|
|
yylval.y_valu = yylval.y_valu * radix + c;
|
|
}
|
|
return(NUMBER);
|
|
}
|
|
|
|
instring(termc)
|
|
{
|
|
register char *p;
|
|
register c;
|
|
static int maxstring = 0;
|
|
|
|
if (! maxstring) {
|
|
maxstring = STRINGMAX;
|
|
if ((stringbuf = malloc(maxstring)) == 0) {
|
|
fatal("out of memory");
|
|
}
|
|
}
|
|
p = stringbuf;
|
|
for (;;) {
|
|
c = nextchar();
|
|
if (c == '\n' || c == '\0') {
|
|
peekc = c;
|
|
serror("non-terminated string");
|
|
break;
|
|
}
|
|
if (c == termc)
|
|
break;
|
|
if (c == '\\')
|
|
c = inescape();
|
|
if (p >= &stringbuf[maxstring - 1]) {
|
|
int cnt = p - stringbuf;
|
|
|
|
if ((stringbuf = realloc(stringbuf, maxstring += 256)) == 0) {
|
|
fatal("out of memory");
|
|
}
|
|
p = stringbuf + cnt;
|
|
}
|
|
*p++ = c;
|
|
}
|
|
stringlen = p - stringbuf;
|
|
*p = '\0';
|
|
return(STRING);
|
|
}
|
|
|
|
inescape()
|
|
{
|
|
register c, j, r;
|
|
|
|
c = nextchar();
|
|
if (c >= '0' && c <= '7') {
|
|
r = c - '0';
|
|
for (j = 0; j < 2; j++) {
|
|
c = nextchar();
|
|
if (c < '0' || c > '7') {
|
|
peekc = c;
|
|
return(r);
|
|
}
|
|
r <<= 3;
|
|
r += (c - '0');
|
|
}
|
|
return(r);
|
|
}
|
|
switch (c) {
|
|
case 'b': return('\b');
|
|
case 'f': return('\f');
|
|
case 'n': return('\n');
|
|
case 'r': return('\r');
|
|
case 't': return('\t');
|
|
case '\'': return('\'');
|
|
case '"': return('"');
|
|
}
|
|
return(c);
|
|
}
|
|
|
|
infbsym(p)
|
|
register char *p;
|
|
{
|
|
register lab;
|
|
register item_t *ip;
|
|
|
|
lab = *p++ - '0';
|
|
if ((unsigned)lab < 10) {
|
|
if (*p++ == 'f') {
|
|
ip = fb_ptr[FB_FORW+lab];
|
|
if (ip == 0) {
|
|
ip = fb_alloc(lab);
|
|
fb_ptr[FB_FORW+lab] = ip;
|
|
}
|
|
goto ok;
|
|
}
|
|
ip = fb_ptr[FB_BACK+lab];
|
|
if (ip != 0 && *p == 0)
|
|
goto ok;
|
|
}
|
|
serror("bad numeric label");
|
|
ip = fb_alloc(0);
|
|
ok:
|
|
yylval.y_item = ip;
|
|
return(FBSYM);
|
|
}
|
|
|
|
hash(p)
|
|
register char *p;
|
|
{
|
|
register unsigned short h;
|
|
register c;
|
|
|
|
h = 0;
|
|
while (c = *p++) {
|
|
h <<= 2;
|
|
h += c;
|
|
}
|
|
return(h % H_SIZE);
|
|
}
|
|
|
|
item_t *
|
|
item_search(p)
|
|
char *p;
|
|
{
|
|
register h;
|
|
register item_t *ip;
|
|
|
|
for (h = hash(p); h < H_TOTAL; h += H_SIZE) {
|
|
ip = hashtab[h];
|
|
while (ip != 0) {
|
|
if (strcmp(p, ip->i_name) == 0)
|
|
goto done;
|
|
ip = ip->i_next;
|
|
}
|
|
}
|
|
done:
|
|
hashindex = h;
|
|
return(ip);
|
|
}
|
|
|
|
item_insert(ip, h)
|
|
item_t *ip;
|
|
{
|
|
ip->i_next = hashtab[h];
|
|
hashtab[h] = ip;
|
|
}
|
|
|
|
item_t *
|
|
item_alloc(typ)
|
|
{
|
|
register item_t *ip;
|
|
static nleft = 0;
|
|
static item_t *next;
|
|
|
|
if (--nleft < 0) {
|
|
next = (item_t *) malloc(MEMINCR);
|
|
if (next == 0)
|
|
fatal("out of memory");
|
|
nleft += (MEMINCR / sizeof(item_t));
|
|
}
|
|
ip = next++;
|
|
ip->i_next = 0;
|
|
ip->i_type = typ;
|
|
ip->i_name = 0;
|
|
ip->i_valu = 0;
|
|
return(ip);
|
|
}
|
|
|
|
item_t *
|
|
fb_alloc(lab)
|
|
register lab;
|
|
{
|
|
register item_t *ip, *p;
|
|
|
|
ip = item_alloc(S_UND);
|
|
p = fb_ptr[FB_TAIL+lab];
|
|
if (p == 0)
|
|
fb_ptr[FB_HEAD+lab] = ip;
|
|
else
|
|
p->i_next = ip;
|
|
fb_ptr[FB_TAIL+lab] = ip;
|
|
return(ip);
|
|
}
|
|
|
|
item_t *
|
|
fb_shift(lab)
|
|
register lab;
|
|
{
|
|
register item_t *ip;
|
|
|
|
ip = fb_ptr[FB_FORW+lab];
|
|
if (ip == 0)
|
|
if (pass == PASS_1)
|
|
ip = fb_alloc(lab);
|
|
else
|
|
ip = fb_ptr[FB_HEAD+lab];
|
|
fb_ptr[FB_BACK+lab] = ip;
|
|
fb_ptr[FB_FORW+lab] = ip->i_next;
|
|
return(ip);
|
|
}
|