shithub: semblance

Info  •  Files  •  Log  •  Branches

parse declarations

--- a/builtin.c

+++ b/builtin.c

@@ -72,6 +72,24 @@

 	return -1;

 }

+int

+vartype(int tt)

+{

+	switch(tt){

+	case TDOUBLE: return TYPDOUBLE;

+	case TPT2: return TYPPT2;

+	case TPT3: return TYPPT3;

+	case TVEC2: return TYPVEC2;

+	case TVEC3: return TYPVEC3;

+	case TNORMAL2: return TYPNORMAL2;

+	case TNORMAL3: return TYPNORMAL3;

+	case TQUAT: return TYPQUAT;

+	case TMAT3: return TYPMAT3;

+	case TMAT4: return TYPMAT4;

+	}

+	return -1;

+}

+

 void

 initsyms(void)

 {

@@ -78,7 +96,8 @@

 	int i;

 	for(i = 0; i < nelem(consts); i++)

-		declsym(consts[i].name, SYMCONST, consts[i].val);

+		if(declsym(consts[i].name, SYMCONST, consts[i].val) == nil)

+			sysfatal("could not declare constant: %r");

 }

 char *

@@ -85,30 +104,30 @@

 gettokenname(Token *t)

 {

 	static char *tab[] = {

-	 [TDOUBLE-TEOF]		"TDOUBLE",

-	 [TPT2-TEOF]		"TPT2",

-	 [TPT3-TEOF]		"TPT3",

-	 [TVEC2-TEOF]		"TVEC2",

-	 [TVEC3-TEOF]		"TVEC3",

-	 [TNORMAL2-TEOF]	"TNORMAL2",

-	 [TNORMAL3-TEOF]	"TNORMAL3",

-	 [TQUAT-TEOF]		"TQUAT",

-	 [TMAT3-TEOF]		"TMAT3",

-	 [TMAT4-TEOF]		"TMAT4",

-	 [TNUM-TEOF]		"TNUM",

-	 [TSTR-TEOF]		"TSTR",

-	 [TPP-TEOF]		"TPP",

-	 [TMM-TEOF]		"TMM",

-	 [TEQ-TEOF]		"TEQ",

-	 [TLAND-TEOF]		"TLAND",

-	 [TLOR-TEOF]		"TLOR",

-	 [TID-TEOF]		"TID",

+	 [TDOUBLE-TDOUBLE]	"TDOUBLE",

+	 [TPT2-TDOUBLE]		"TPT2",

+	 [TPT3-TDOUBLE]		"TPT3",

+	 [TVEC2-TDOUBLE]	"TVEC2",

+	 [TVEC3-TDOUBLE]	"TVEC3",

+	 [TNORMAL2-TDOUBLE]	"TNORMAL2",

+	 [TNORMAL3-TDOUBLE]	"TNORMAL3",

+	 [TQUAT-TDOUBLE]	"TQUAT",

+	 [TMAT3-TDOUBLE]	"TMAT3",

+	 [TMAT4-TDOUBLE]	"TMAT4",

+	 [TNUM-TDOUBLE]		"TNUM",

+	 [TSTR-TDOUBLE]		"TSTR",

+	 [TPP-TDOUBLE]		"TPP",

+	 [TMM-TDOUBLE]		"TMM",

+	 [TEQ-TDOUBLE]		"TEQ",

+	 [TLAND-TDOUBLE]	"TLAND",

+	 [TLOR-TDOUBLE]		"TLOR",

+	 [TID-TDOUBLE]		"TID",

 	};

-	if(t->type < TEOF || t->type >= TEOF + nelem(tab))

+	if(t->type < TDOUBLE || t->type >= TDOUBLE + nelem(tab))

 		return nil;

-	return tab[t->type-TEOF];

+	return tab[t->type-TDOUBLE];

 }

 void

--- a/dat.h

+++ b/dat.h

@@ -58,9 +58,12 @@

 enum {

 	TYPDOUBLE,

-	TYPPOINT,

-	TYPVECTOR,

-	TYPNORMAL,

+	TYPPT2,

+	TYPPT3,

+	TYPVEC2,

+	TYPVEC3,

+	TYPNORMAL2,

+	TYPNORMAL3,

 	TYPQUAT,

 	TYPMAT3,

 	TYPMAT4,

--- a/fns.h

+++ b/fns.h

@@ -4,13 +4,15 @@

 char *estrdup(char*);

 /* sym */

-Symbol *declsym(char*, int, double);

+Symbol *declsym(char*, int, ...);

 Symbol *getsym(char*);

+void printsymtab(void);

 /* builtin */

 int lookupkw(char*);

 int opstart(int);

 int findop(char*);

+int vartype(int);

 void initsyms(void);

 char *gettokenname(Token*);

 void printtoken(Token*);

@@ -18,3 +20,5 @@

 /* lexer */

 int lex(Lexer*);

 int peek(Lexer*);

+int expect(Lexer*, int);

+int gottype(Lexer*);

--- a/lexer.c

+++ b/lexer.c

@@ -178,3 +178,34 @@

 		l->peektok = scan(l);

 	return l->peektok.type;

 }

+

+int

+expect(Lexer *l, int t)

+{

+	if(lex(l) != t){

+		werrstr("expected '%C', got '%C' (%s)",

+			t, l->tok.type, gettokenname(&l->tok));

+		return 0;

+	}

+	return 1;

+}

+

+int

+gottype(Lexer *l)

+{

+	switch(peek(l)){

+	case TDOUBLE:

+	case TPT2:

+	case TPT3:

+	case TVEC2:

+	case TVEC3:

+	case TNORMAL2:

+	case TNORMAL3:

+	case TQUAT:

+	case TMAT3:

+	case TMAT4:

+		lex(l);

+		return 1;

+	}

+	return 0;

+}

--- a/sym.c

+++ b/sym.c

@@ -8,17 +8,35 @@

 static Symbol *symtab;

 Symbol *

-declsym(char *s, int t, double v)

+declsym(char *s, int t, ...)

 {

 	Symbol *sym;

+	va_list a;

+	va_start(a, t);

+

 	sym = emalloc(sizeof(Symbol));

 	sym->name = estrdup(s);

 	sym->type = t;

-	sym->cval = v;

-	sym->var.type = -1;

+

+	switch(t){

+	case SYMVAR:

+		sym->var = va_arg(a, Var);

+		break;

+	case SYMCONST:

+		sym->cval = va_arg(a, double);

+		break;

+	default:

+		va_end(a);

+		free(sym->name);

+		free(sym);

+		werrstr("unknown symbol type");

+		return nil;

+	}

 	sym->next = symtab;

 	symtab = sym;

+

+	va_end(a);

 	return sym;

 }

@@ -31,4 +49,26 @@

 		if(strcmp(sym->name, s) == 0)

 			return sym;

 	return nil;

+}

+

+void

+printsymtab(void)

+{

+	Symbol *sym;

+

+	for(sym = symtab; sym != nil; sym = sym->next){

+		print("sym name '%s' type", sym->name);

+		switch(sym->type){

+		case SYMVAR:

+			print(" var %d [%g,%g,%g,%g]\n",

+				sym->var.type,

+				sym->var.val[0], sym->var.val[1],

+				sym->var.val[2], sym->var.val[3]);

+			break;

+		case SYMCONST:

+			print(" const [%g]\n", sym->cval);

+			break;

+		}

+		print("\n");

+	}

 }

-- 

⑨