d0p1/ack
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Clang-format before editing.

Browse source
This commit is contained in:
David Given 2018-09-10 22:25:14 +02:00
parent 185e910246
commit 6275896a11
1 changed files with 352 additions and 286 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

638
mach/proto/as/comm5.c
View file

@ -5,26 +5,26 @@
*/ */
/* @(#)comm5.c 1.1 */ /* @(#)comm5.c 1.1 */
#include "comm0.h" #include "comm0.h"
#include "comm1.h" #include "comm1.h"
#include "y.tab.h" #include "y.tab.h"
extern YYSTYPE yylval; extern YYSTYPE yylval;
static void readcode(int); static void readcode(int);
static int induo(int); static int induo(int);
static int inident(int); static int inident(int);
static int innumber(int); static int innumber(int);
static int instring(int); static int instring(int);
static int inescape(void); static int inescape(void);
static int infbsym(const char *); static int infbsym(const char*);
int int yylex(void)
yylex(void)
{ {
int c, c0, c1; int c, c0, c1;
if (pass == PASS_1) { if (pass == PASS_1)
{
/* scan the input file */ /* scan the input file */
do do
c = nextchar(); c = nextchar();
@ -33,126 +33,149 @@ yylex(void)
c = inident(c); c = inident(c);
else if (isdigit(c)) else if (isdigit(c))
c = innumber(c); c = innumber(c);
else switch (c) { else
case '=': switch (c)
case '<': {
case '>': case '=':
case '|': case '<':
case '&': case '>':
c = induo(c); break; case '|':
case ASC_SQUO: case '&':
case ASC_DQUO: c = induo(c);
c = instring(c); break; break;
case ASC_COMM: case ASC_SQUO:
do case ASC_DQUO:
c = nextchar(); c = instring(c);
while (c != '\n' && c != '\0'); break;
break; case ASC_COMM:
case CTRL('A'): do
c = CODE1; readcode(1); break; c = nextchar();
case CTRL('B'): while (c != '\n' && c != '\0');
c = CODE2; readcode(2); break; break;
case CTRL('C'): case CTRL('A'):
c = CODE4; readcode(4); break; 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 */ /* produce the intermediate token file */
if (c <= 0) if (c <= 0)
return(0); return (0);
if (c < 256) { if (c < 256)
{
putc(c, tempfile); putc(c, tempfile);
putc(0, tempfile); putc(0, tempfile);
} else { }
else
{
putval(c); putval(c);
} }
} else { }
else
{
/* read from intermediate token file */ /* read from intermediate token file */
c0 = getc(tempfile); c0 = getc(tempfile);
if (c0 == EOF) if (c0 == EOF)
return(0); return (0);
c1 = getc(tempfile); c1 = getc(tempfile);
if (c1 == EOF) if (c1 == EOF)
return(0); return (0);
c = c0 + (c1 << 8); c = c0 + (c1 << 8);
if (c >= 256) if (c >= 256)
c = getval(c); c = getval(c);
} }
curr_token = c; curr_token = c;
return(c); return (c);
} }
void void putval(int c)
putval(int c)
{ {
valu_t v; valu_t v;
int n = 0; int n = 0;
char *p = 0; char* p = 0;
assert(c == (c & 0xffff)); assert(c == (c & 0xffff));
switch (c) { switch (c)
case CODE1: {
n = 1; goto putnum; case CODE1:
case CODE2: n = 1;
n = 2; goto putnum; goto putnum;
case CODE4: case CODE2:
n = 4; goto putnum; n = 2;
case NUMBER: goto putnum;
v = yylval.y_valu; case CODE4:
for (n = 0; n < sizeof(v); n++) { n = 4;
if (v == 0) goto putnum;
break; case NUMBER:
v >>= 8; v = yylval.y_valu;
} for (n = 0; n < sizeof(v); n++)
assert(n <= 4); {
c = NUMBER0 + n; if (v == 0)
putnum: break;
putc(c, tempfile); v >>= 8;
putc(c >> 8, tempfile); }
v = yylval.y_valu; assert(n <= 4);
while (--n >= 0) c = NUMBER0 + n;
putc((int) (v >> (n*8)), tempfile); putnum:
return; putc(c, tempfile);
case IDENT: putc(c >> 8, tempfile);
case FBSYM: v = yylval.y_valu;
n = sizeof(item_t *); while (--n >= 0)
p = (char *) &yylval.y_item; break; putc((int)(v >> (n * 8)), tempfile);
return;
case IDENT:
case FBSYM:
n = sizeof(item_t*);
p = (char*)&yylval.y_item;
break;
#ifdef ASLD #ifdef ASLD
case MODULE: case MODULE:
n = sizeof(char *); n = sizeof(char*);
p = (char *) &yylval.y_strp; break; p = (char*)&yylval.y_strp;
break;
#endif #endif
case STRING: case STRING:
v = stringlen; v = stringlen;
putc(c, tempfile); putc(c, tempfile);
putc(c >> 8, tempfile); putc(c >> 8, tempfile);
for (n = 0; n < sizeof(v); n++) { for (n = 0; n < sizeof(v); n++)
if (v == 0) {
break; if (v == 0)
v >>= 8; break;
} v >>= 8;
assert(n <= 4); }
putc(n, tempfile); assert(n <= 4);
v = stringlen; putc(n, tempfile);
while (--n >= 0) v = stringlen;
putc((int) (v >> (n*8)), tempfile); while (--n >= 0)
p = stringbuf; putc((int)(v >> (n * 8)), tempfile);
n = stringlen; p = stringbuf;
while (--n >= 0) n = stringlen;
putc(*p++, tempfile); while (--n >= 0)
return; putc(*p++, tempfile);
case OP_EQ: return;
case OP_NE: case OP_EQ:
case OP_LE: case OP_NE:
case OP_GE: case OP_LE:
case OP_LL: case OP_GE:
case OP_RR: case OP_LL:
case OP_OO: case OP_RR:
case OP_AA: case OP_OO:
break; case OP_AA:
default: break;
n = sizeof(word_t); default:
p = (char *) &yylval.y_word; break; n = sizeof(word_t);
p = (char*)&yylval.y_word;
break;
} }
putc(c, tempfile); putc(c, tempfile);
putc(c >> 8, tempfile); putc(c >> 8, tempfile);
@ -160,151 +183,171 @@ putval(int c)
putc(*p++, tempfile); putc(*p++, tempfile);
} }
int int getval(int c)
getval(int c)
{ {
int n = 0; int n = 0;
valu_t v; valu_t v;
char *p = 0; char* p = 0;
switch (c) { switch (c)
case CODE1: {
n = 1; goto getnum; case CODE1:
case CODE2: n = 1;
n = 2; goto getnum; goto getnum;
case CODE4: case CODE2:
n = 4; goto getnum; n = 2;
case NUMBER0: goto getnum;
c = NUMBER; goto getnum; case CODE4:
case NUMBER1: n = 4;
n = 1; c = NUMBER; goto getnum; goto getnum;
case NUMBER2: case NUMBER0:
n = 2; c = NUMBER; goto getnum; c = NUMBER;
case NUMBER3: goto getnum;
n = 3; c = NUMBER; goto getnum; case NUMBER1:
case NUMBER: n = 1;
n = 4; c = NUMBER;
getnum: goto getnum;
v = 0; case NUMBER2:
while (--n >= 0) { n = 2;
v <<= 8; c = NUMBER;
v |= getc(tempfile); goto getnum;
} case NUMBER3:
yylval.y_valu = v; n = 3;
return(c); c = NUMBER;
case IDENT: goto getnum;
case FBSYM: case NUMBER:
n = sizeof(item_t *); n = 4;
p = (char *) &yylval.y_item; break; 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 #ifdef ASLD
case MODULE: case MODULE:
n = sizeof(char *); n = sizeof(char*);
p = (char *) &yylval.y_strp; break; p = (char*)&yylval.y_strp;
break;
#endif #endif
case STRING: case STRING:
getval(getc(tempfile)+NUMBER0); getval(getc(tempfile) + NUMBER0);
stringlen = n = yylval.y_valu; stringlen = n = yylval.y_valu;
p = stringbuf; p = stringbuf;
p[n] = '\0'; break; p[n] = '\0';
case OP_EQ: break;
case OP_NE: case OP_EQ:
case OP_LE: case OP_NE:
case OP_GE: case OP_LE:
case OP_LL: case OP_GE:
case OP_RR: case OP_LL:
case OP_OO: case OP_RR:
case OP_AA: case OP_OO:
break; case OP_AA:
default: break;
n = sizeof(word_t); default:
p = (char *) &yylval.y_word; break; n = sizeof(word_t);
p = (char*)&yylval.y_word;
break;
} }
while (--n >= 0) while (--n >= 0)
*p++ = getc(tempfile); *p++ = getc(tempfile);
return(c); return (c);
} }
/* ---------- lexical scan in pass 1 ---------- */ /* ---------- lexical scan in pass 1 ---------- */
int int nextchar(void)
nextchar(void)
{ {
int c; int c;
if (peekc != -1) { if (peekc != -1)
{
c = peekc; c = peekc;
peekc = -1; peekc = -1;
return(c); return (c);
} }
#ifdef ASLD #ifdef ASLD
if (archmode && --archsize < 0) if (archmode && --archsize < 0)
return(0); return (0);
#endif #endif
if ((c = getc(input)) == EOF) if ((c = getc(input)) == EOF)
return(0); return (0);
if (isascii(c) == 0) if (isascii(c) == 0)
fatal("non-ascii character"); fatal("non-ascii character");
#ifdef LISTING #ifdef LISTING
if (listflag & 0440) if (listflag & 0440)
putc(c, listfile); putc(c, listfile);
#endif #endif
return(c); return (c);
} }
static void static void readcode(int n)
readcode(int n)
{ {
int c; int c;
yylval.y_valu = 0; yylval.y_valu = 0;
do { do
{
if ( if (
#ifdef ASLD #ifdef ASLD
(archmode && --archsize < 0) (archmode && --archsize < 0) ||
||
#endif #endif
(c = getc(input)) == EOF (c = getc(input)) == EOF)
)
fatal("unexpected EOF in compact input"); fatal("unexpected EOF in compact input");
yylval.y_valu <<= 8; yylval.y_valu <<= 8;
yylval.y_valu |= c; yylval.y_valu |= c;
} while (--n); } while (--n);
} }
static int static int induo(int c)
induo(int c)
{ {
static short duo[] = { static short duo[] = {
('='<<8) | '=', OP_EQ, ('=' << 8) | '=',
('<'<<8) | '>', OP_NE, OP_EQ,
('<'<<8) | '=', OP_LE, ('<' << 8) | '>',
('>'<<8) | '=', OP_GE, OP_NE,
('<'<<8) | '<', OP_LL, ('<' << 8) | '=',
('>'<<8) | '>', OP_RR, OP_LE,
('|'<<8) | '|', OP_OO, ('>' << 8) | '=',
('&'<<8) | '&', OP_AA, OP_GE,
0 /* terminates array */ ('<' << 8) | '<',
OP_LL,
('>' << 8) | '>',
OP_RR,
('|' << 8) | '|',
OP_OO,
('&' << 8) | '&',
OP_AA,
0 /* terminates array */
}; };
short *p; short* p;
c = (c<<8) | nextchar(); c = (c << 8) | nextchar();
for (p = duo; *p; p++) for (p = duo; *p; p++)
if (*p++ == c) if (*p++ == c)
return(*p++); return (*p++);
peekc = c & 0377; peekc = c & 0377;
return(c>>8); return (c >> 8);
} }
static char name[NAMEMAX+1]; static char name[NAMEMAX + 1];
static int static int inident(int c)
inident(int c)
{ {
char *p = name; char* p = name;
item_t *ip; item_t* ip;
int n = NAMEMAX; int n = NAMEMAX;
do { do
{
if (--n >= 0) if (--n >= 0)
*p++ = c; *p++ = c;
c = nextchar(); c = nextchar();
@ -312,49 +355,52 @@ inident(int c)
*p = '\0'; *p = '\0';
peekc = c; peekc = c;
ip = item_search(name); ip = item_search(name);
if (ip == 0) { if (ip == 0)
{
ip = item_alloc(S_UND); ip = item_alloc(S_UND);
ip->i_name = remember(name); ip->i_name = remember(name);
/* printf("ident %s %o\n", ip->i_name, ip); */ /* printf("ident %s %o\n", ip->i_name, ip); */
unresolved++; unresolved++;
item_insert(ip, H_LOCAL + (hashindex%H_SIZE)); item_insert(ip, H_LOCAL + (hashindex % H_SIZE));
} else if (hashindex < H_SIZE) { }
else if (hashindex < H_SIZE)
{
assert(H_KEY == 0); assert(H_KEY == 0);
yylval.y_word = (word_t) ip->i_valu; yylval.y_word = (word_t)ip->i_valu;
return(ip->i_type); return (ip->i_type);
} }
yylval.y_item = ip; yylval.y_item = ip;
return(IDENT); return (IDENT);
} }
#ifdef ASLD #ifdef ASLD
char * char* readident(int c)
readident(int c)
{ {
int n = NAMEMAX; int n = NAMEMAX;
char *p = name; char* p = name;
do { do
{
if (--n >= 0) if (--n >= 0)
*p++ = c; *p++ = c;
c = nextchar(); c = nextchar();
} while (ISALNUM(c)); } while (ISALNUM(c));
*p++ = '\0'; *p++ = '\0';
peekc = c; peekc = c;
return(name); return (name);
} }
#endif #endif
static int static int innumber(int c)
innumber(int c)
{ {
char *p; char* p;
int radix; int radix;
static char num[20+1]; static char num[20 + 1];
p = num; p = num;
radix = 20; radix = 20;
do { do
{
if (--radix < 0) if (--radix < 0)
fatal("number too long"); fatal("number too long");
if (isupper(c)) if (isupper(c))
@ -367,21 +413,26 @@ innumber(int c)
c = *--p; c = *--p;
p = num; p = num;
radix = 10; radix = 10;
if (*p == '0') { if (*p == '0')
{
radix = 8; radix = 8;
p++; p++;
if (*p == 'x') { if (*p == 'x')
{
radix = 16; radix = 16;
p++; p++;
} else if (*p == 'b') { }
else if (*p == 'b')
{
radix = 2; radix = 2;
p++; p++;
} }
} }
if (radix != 16 && (c == 'f' || c == 'b')) if (radix != 16 && (c == 'f' || c == 'b'))
return(infbsym(num)); return (infbsym(num));
yylval.y_valu = 0; yylval.y_valu = 0;
while (c = *p++) { while (c = *p++)
{
if (c > '9') if (c > '9')
c -= ('a' - '9' - 1); c -= ('a' - '9' - 1);
c -= '0'; c -= '0';
@ -389,26 +440,29 @@ innumber(int c)
serror("digit exceeds radix"); serror("digit exceeds radix");
yylval.y_valu = yylval.y_valu * radix + c; yylval.y_valu = yylval.y_valu * radix + c;
} }
return(NUMBER); return (NUMBER);
} }
static int static int instring(int termc)
instring(int termc)
{ {
char *p; char* p;
int c; int c;
static int maxstring = 0; static int maxstring = 0;
if (! maxstring) { if (!maxstring)
{
maxstring = STRINGMAX; maxstring = STRINGMAX;
if ((stringbuf = malloc(maxstring)) == 0) { if ((stringbuf = malloc(maxstring)) == 0)
{
fatal("out of memory"); fatal("out of memory");
} }
} }
p = stringbuf; p = stringbuf;
for (;;) { for (;;)
{
c = nextchar(); c = nextchar();
if (c == '\n' || c == '\0') { if (c == '\n' || c == '\0')
{
peekc = c; peekc = c;
serror("non-terminated string"); serror("non-terminated string");
break; break;
@ -417,10 +471,12 @@ instring(int termc)
break; break;
if (c == '\\') if (c == '\\')
c = inescape(); c = inescape();
if (p >= &stringbuf[maxstring - 1]) { if (p >= &stringbuf[maxstring - 1])
{
int cnt = p - stringbuf; int cnt = p - stringbuf;
if ((stringbuf = realloc(stringbuf, maxstring += 256)) == 0) { if ((stringbuf = realloc(stringbuf, maxstring += 256)) == 0)
{
fatal("out of memory"); fatal("out of memory");
} }
p = stringbuf + cnt; p = stringbuf + cnt;
@ -429,57 +485,69 @@ instring(int termc)
} }
stringlen = p - stringbuf; stringlen = p - stringbuf;
*p = '\0'; *p = '\0';
return(STRING); return (STRING);
} }
static int static int inescape(void)
inescape(void)
{ {
int c, j, r; int c, j, r;
c = nextchar(); c = nextchar();
if (c >= '0' && c <= '7') { if (c >= '0' && c <= '7')
{
r = c - '0'; r = c - '0';
for (j = 0; j < 2; j++) { for (j = 0; j < 2; j++)
{
c = nextchar(); c = nextchar();
if (c < '0' || c > '7') { if (c < '0' || c > '7')
{
peekc = c; peekc = c;
return(r); return (r);
} }
r <<= 3; r <<= 3;
r += (c - '0'); r += (c - '0');
} }
return(r); return (r);
} }
switch (c) { switch (c)
case 'b': return('\b'); {
case 'f': return('\f'); case 'b':
case 'n': return('\n'); return ('\b');
case 'r': return('\r'); case 'f':
case 't': return('\t'); return ('\f');
case '\'': return('\''); case 'n':
case '"': return('"'); return ('\n');
case 'r':
return ('\r');
case 't':
return ('\t');
case '\'':
return ('\'');
case '"':
return ('"');
} }
return(c); return (c);
} }
static int static int infbsym(const char* p)
infbsym(const char *p)
{ {
int lab; int lab;
item_t *ip; item_t* ip;
lab = *p++ - '0'; lab = *p++ - '0';
if ((unsigned)lab < 10) { if ((unsigned)lab < 10)
if (*p++ == 'f') { {
ip = fb_ptr[FB_FORW+lab]; if (*p++ == 'f')
if (ip == 0) { {
ip = fb_ptr[FB_FORW + lab];
if (ip == 0)
{
ip = fb_alloc(lab); ip = fb_alloc(lab);
fb_ptr[FB_FORW+lab] = ip; fb_ptr[FB_FORW + lab] = ip;
} }
goto ok; goto ok;
} }
ip = fb_ptr[FB_BACK+lab]; ip = fb_ptr[FB_BACK + lab];
if (ip != 0 && *p == 0) if (ip != 0 && *p == 0)
goto ok; goto ok;
} }
@ -487,32 +555,33 @@ infbsym(const char *p)
ip = fb_alloc(0); ip = fb_alloc(0);
ok: ok:
yylval.y_item = ip; yylval.y_item = ip;
return(FBSYM); return (FBSYM);
} }
int int hash(const char* p)
hash(const char *p)
{ {
unsigned short h; unsigned short h;
int c; int c;
h = 0; h = 0;
while (c = *p++) { while (c = *p++)
{
h <<= 2; h <<= 2;
h += c; h += c;
} }
return(h % H_SIZE); return (h % H_SIZE);
} }
item_t * item_t* item_search(const char* p)
item_search(const char *p)
{ {
int h; int h;
item_t *ip; item_t* ip;
for (h = hash(p); h < H_TOTAL; h += H_SIZE) { for (h = hash(p); h < H_TOTAL; h += H_SIZE)
{
ip = hashtab[h]; ip = hashtab[h];
while (ip != 0) { while (ip != 0)
{
if (strcmp(p, ip->i_name) == 0) if (strcmp(p, ip->i_name) == 0)
goto done; goto done;
ip = ip->i_next; ip = ip->i_next;
@ -520,25 +589,24 @@ item_search(const char *p)
} }
done: done:
hashindex = h; hashindex = h;
return(ip); return (ip);
} }
void void item_insert(item_t* ip, int h)
item_insert(item_t *ip, int h)
{ {
ip->i_next = hashtab[h]; ip->i_next = hashtab[h];
hashtab[h] = ip; hashtab[h] = ip;
} }
item_t * item_t* item_alloc(int typ)
item_alloc(int typ)
{ {
item_t *ip; item_t* ip;
static int nleft = 0; static int nleft = 0;
static item_t *next; static item_t* next;
if (--nleft < 0) { if (--nleft < 0)
next = (item_t *) malloc(MEMINCR); {
next = (item_t*)malloc(MEMINCR);
if (next == 0) if (next == 0)
fatal("out of memory"); fatal("out of memory");
nleft += (MEMINCR / sizeof(item_t)); nleft += (MEMINCR / sizeof(item_t));
@ -548,36 +616,34 @@ item_alloc(int typ)
ip->i_type = typ; ip->i_type = typ;
ip->i_name = 0; ip->i_name = 0;
ip->i_valu = 0; ip->i_valu = 0;
return(ip); return (ip);
} }
item_t * item_t* fb_alloc(int lab)
fb_alloc(int lab)
{ {
item_t *ip, *p; item_t *ip, *p;
ip = item_alloc(S_UND); ip = item_alloc(S_UND);
p = fb_ptr[FB_TAIL+lab]; p = fb_ptr[FB_TAIL + lab];
if (p == 0) if (p == 0)
fb_ptr[FB_HEAD+lab] = ip; fb_ptr[FB_HEAD + lab] = ip;
else else
p->i_next = ip; p->i_next = ip;
fb_ptr[FB_TAIL+lab] = ip; fb_ptr[FB_TAIL + lab] = ip;
return(ip); return (ip);
} }
item_t * item_t* fb_shift(int lab)
fb_shift(int lab)
{ {
item_t *ip; item_t* ip;
ip = fb_ptr[FB_FORW+lab]; ip = fb_ptr[FB_FORW + lab];
if (ip == 0) if (ip == 0)
if (pass == PASS_1) if (pass == PASS_1)
ip = fb_alloc(lab); ip = fb_alloc(lab);
else else
ip = fb_ptr[FB_HEAD+lab]; ip = fb_ptr[FB_HEAD + lab];
fb_ptr[FB_BACK+lab] = ip; fb_ptr[FB_BACK + lab] = ip;
fb_ptr[FB_FORW+lab] = ip->i_next; fb_ptr[FB_FORW + lab] = ip->i_next;
return(ip); return (ip);
} }