ref: 61f4c085c402af665b436f6d010d61107551d8a3
dir: /sys/src/cmd/dtracy/lex.c/
#include <u.h>
#include <libc.h>
#include <ctype.h>
#include <dtracy.h>
#include <bio.h>
#include "dat.h"
#include "fns.h"
#include "y.tab.h"
char *str, *strp, *stre;
int lineno = 1;
int errors;
typedef struct Keyword Keyword;
struct Keyword {
char *name;
int tok;
};
/* both tables must be sorted */
Keyword kwtab[] = {
"if", TIF,
"print", TPRINT,
"printf", TPRINTF,
"s16", TS16,
"s32", TS32,
"s64", TS64,
"s8", TS8,
"string", TSTRING,
"u16", TU16,
"u32", TU32,
"u64", TU64,
"u8", TU8,
};
Keyword optab[] = {
"!=", TNE,
"&&", TAND,
"<<", TLSL,
"<=", TLE,
"==", TEQ,
">=", TGE,
">>", TLSR,
"||", TOR,
};
Keyword *kwchar[128], *opchar[128];
void
lexinit(void)
{
Keyword *kw;
for(kw = kwtab; kw < kwtab + nelem(kwtab); kw++)
if(kwchar[*kw->name] == nil)
kwchar[*kw->name] = kw;
for(kw = optab; kw < optab + nelem(optab); kw++)
if(opchar[*kw->name] == nil)
opchar[*kw->name] = kw;
}
void
lexstring(char *s)
{
str = strp = s;
stre = str + strlen(str);
}
void
error(char *fmt, ...)
{
Fmt f;
char buf[128];
va_list va;
fmtfdinit(&f, 2, buf, sizeof(buf));
fmtprint(&f, "%d ", lineno);
va_start(va, fmt);
fmtvprint(&f, fmt, va);
fmtrune(&f, '\n');
va_end(va);
fmtfdflush(&f);
errors++;
}
void
yyerror(char *msg)
{
error("%s", msg);
}
static int
getch(void)
{
if(strp >= stre){
strp++;
return -1;
}
return *strp++;
}
static void
ungetch(void)
{
assert(strp > str);
strp--;
}
int
yylex(void)
{
int ch;
static char buf[512];
char *p;
Keyword *kw;
u64int v;
again:
while(ch = getch(), ch >= 0 && isspace(ch)){
if(ch == '\n')
lineno++;
}
if(ch < 0)
return -1;
if(ch == '/'){
ch = getch();
if(ch == '/'){
while(ch = getch(), ch >= 0 && ch != '\n')
;
if(ch == '\n')
lineno++;
goto again;
}
if(ch == '*'){
s1:
ch = getch();
if(ch < 0) return -1;
if(ch == '\n') lineno++;
if(ch != '*') goto s1;
s2:
ch = getch();
if(ch < 0) return -1;
if(ch == '\n') lineno++;
if(ch == '*') goto s2;
if(ch != '/') goto s1;
goto again;
}
ungetch();
return '/';
}
if(isalnum(ch) || ch == '_' || ch >= 0x80 || ch == ':'){
p = buf;
*p++ = ch;
while(ch = getch(), isalnum(ch) || ch == '_' || ch >= 0x80 || ch == ':')
if(p < buf + sizeof(buf) - 1)
*p++ = ch;
*p = 0;
ungetch();
v = strtoull(buf, &p, 0);
if(p != buf && *p == 0){
yylval.num = v;
return TNUM;
}
if(strcmp(buf, ":") == 0)
return ':';
if((uchar)buf[0] < 0x80 && kwchar[buf[0]] != nil)
for(kw = kwchar[buf[0]]; kw < kwtab + nelem(kwtab) && kw->name[0] == buf[0]; kw++)
if(strcmp(kw->name, buf) == 0)
return kw->tok;
yylval.sym = getsym(buf);
return TSYM;
}
if(ch == '"'){
p = buf;
while(ch = getch(), ch >= 0 && ch != '"'){
if(ch == '\n')
error("unterminated string");
if(ch == '\\')
switch(ch = getch()){
case 'n': ch = '\n'; break;
case 'r': ch = '\r'; break;
case 't': ch = '\t'; break;
case 'v': ch = '\v'; break;
case 'b': ch = '\b'; break;
case 'a': ch = '\a'; break;
case '"': case '\\': break;
default: error("unknown escape code \\%c", ch);
}
if(p < buf + sizeof(buf) - 1)
*p++ = ch;
}
if(ch < 0) error("unterminated string");
*p = 0;
yylval.str = strdup(buf);
return TSTR;
}
if(opchar[ch] != nil){
buf[0] = ch;
buf[1] = getch();
for(kw = opchar[buf[0]]; kw < optab + nelem(optab) && kw->name[0] == buf[0]; kw++)
if(buf[1] == kw->name[1]){
buf[2] = getch();
buf[3] = 0;
if(kw + 1 < optab + nelem(optab) && strcmp(kw[1].name, buf) == 0)
return kw[1].tok;
ungetch();
return kw->tok;
}
ungetch();
}
return ch;
}
int
nodetfmt(Fmt *f)
{
int t;
static char *nodestr[] = {
[OINVAL] "OINVAL",
[OBIN] "OBIN",
[OLNOT] "OLNOT",
[OSYM] "OSYM",
[ONUM] "ONUM",
[OSTR] "OSTR",
[OTERN] "OTERN",
[ORECORD] "ORECORD",
[OCAST] "OCAST",
};
t = va_arg(f->args, int);
if(t >= nelem(nodestr) || nodestr[t] == nil)
return fmtprint(f, "??? (%d)", t);
else
return fmtprint(f, "%s", nodestr[t]);
}
Node *
node(int type, ...)
{
va_list va;
Node *n;
n = emalloc(sizeof(Node));
n->type = type;
n->line = lineno;
va_start(va, type);
switch(type){
case OBIN:
n->op = va_arg(va, int);
n->n1 = va_arg(va, Node *);
n->n2 = va_arg(va, Node *);
break;
case OLNOT:
n->n1 = va_arg(va, Node *);
break;
case OSYM:
n->sym = va_arg(va, Symbol *);
break;
case ONUM:
n->num = va_arg(va, s64int);
break;
case OTERN:
n->n1 = va_arg(va, Node *);
n->n2 = va_arg(va, Node *);
n->n3 = va_arg(va, Node *);
break;
case ORECORD:
n->n1 = va_arg(va, Node *);
break;
case OCAST:
n->typ = va_arg(va, Type *);
n->n1 = va_arg(va, Node *);
break;
case OSTR:
n->str = va_arg(va, char *);
break;
default:
sysfatal("node: unknown type %α", type);
}
va_end(va);
return n;
}
SymTab globals;
static u64int
hash(char *s)
{
u64int h;
h = 0xcbf29ce484222325ULL;
for(; *s != 0; s++){
h ^= *s;
h *= 0x100000001b3ULL;
}
return h;
}
Symbol *
getsym(char *name)
{
u64int h;
Symbol **sp, *s;
h = hash(name);
for(sp = &globals.sym[h % SYMHASH]; s = *sp, s != nil; sp = &s->next)
if(strcmp(s->name, name) == 0)
return s;
*sp = s = emalloc(sizeof(Symbol));
s->name = strdup(name);
return s;
}
int
typetfmt(Fmt *f)
{
int t;
static char *tstr[] = {
[TYPINVAL] "TYPINVAL",
[TYPINT] "TYPINT",
[TYPPTR] "TYPPTR",
[TYPSTRING] "TYPSTRING",
};
t = va_arg(f->args, int);
if(t >= nelem(tstr) || tstr[t] == nil)
return fmtprint(f, "??? (%d)", t);
else
return fmtprint(f, "%s", tstr[t]);
}
int
typefmt(Fmt *f)
{
Type *t;
t = va_arg(f->args, Type *);
switch(t->type){
case TYPINT: return fmtprint(f, "%c%d", t->sign ? 's' : 'u', t->size * 8);
case TYPSTRING: return fmtprint(f, "string");
case TYPPTR: return fmtprint(f, "%τ*", t->ref);
default: return fmtprint(f, "%t", t->type);
}
}
static Type typu8 = {.type TYPINT, .size 1, .sign 0};
static Type typs8 = {.type TYPINT, .size 1, .sign 1};
static Type typu16 = {.type TYPINT, .size 2, .sign 0};
static Type typs16 = {.type TYPINT, .size 2, .sign 1};
static Type typu32 = {.type TYPINT, .size 4, .sign 0};
static Type typs32 = {.type TYPINT, .size 4, .sign 1};
static Type typu64 = {.type TYPINT, .size 8, .sign 0};
static Type typs64 = {.type TYPINT, .size 8, .sign 1};
static Type typstr = {.type TYPSTRING, .size DTSTRMAX };
static Type *typereg;
static Type *
mkptr(Type *t)
{
Type *s;
for(s = typereg; s != nil; s = s->typenext)
if(s->type == TYPPTR && s->ref == t)
return s;
s = emalloc(sizeof(Type));
s->type = TYPPTR;
s->ref = t;
return s;
}
Type *
type(int typ, ...)
{
int size, sign;
va_list va;
va_start(va, typ);
switch(typ){
case TYPINT:
size = va_arg(va, int);
sign = va_arg(va, int);
switch(size << 4 | sign){
case 0x10: return &typu8;
case 0x11: return &typs8;
case 0x20: return &typu16;
case 0x21: return &typs16;
case 0x40: return &typu32;
case 0x41: return &typs32;
case 0x80: return &typu64;
case 0x81: return &typs64;
default: sysfatal("type: invalid (size,sign) = (%d,%d)\n", size, sign); return nil;
}
case TYPSTRING: return &typstr;
case TYPPTR: return mkptr(va_arg(va, Type *));
default: sysfatal("type: unknown %t", typ); return nil;
}
}