spl

parser.spl (13506B)

---

 // Copyright 2023, Brian Swetland <swetland@frotz.net>
 // Licensed under the Apache License, Version 2.0.
 
 // ================================================================
 // parser
 
 fn expected(what str) {
 	error("expected ", what, ", found ", @str tnames[ctx.tok]);
 }
 
 fn expect(tok Token) {
 	if ctx.tok != tok {
 		expected(tnames[tok]);
 	}
 }
 
 fn require(tok Token) {
 	expect(tok);
 	next();
 }
 
 fn parse_name(what str) String {
 	if ctx.tok != tIDN {
 		expected(what);
 	}
 	var s String = ctx.ident;
 	next();
 	return s;
 }
 
 fn parse_symbol(what str) Ast {
 	var name String = parse_name(what);
 	var sym Symbol = symbol_find(name);
 	return ast_make_symbol(name, sym);
 }
 
 fn parse_ident() Ast {
 	var node Ast = parse_symbol("identifier");
 
 	if (node.sym == nil) && (ctx.tok != tOPAREN) {
 		error("undefined identifier '", @str node.name.text, "'");
 	}
 
 	if ctx.tok == tOPAREN {
 		// function call
 		next();
 		node = ast_make_l(AST_CALL, node);
 		var last Ast = nil;
 
 		while ctx.tok != tCPAREN {
 			if ctx.tok == tAT {
 				// type annotation for varargs hack
 				next();
 				parse_type(false);
 			}
 
 			var expr Ast = parse_expr();
 			if last != nil {
 				last.next = expr;
 			} else {
 				node.right = expr;
 			}
 			last = expr;
 
 			if ctx.tok != tCPAREN {
 				require(tCOMMA);
 			}
 		}
 		next();
 	}
 
 	while true {
 		if ctx.tok == tDOT {
 			// field access
 			next();
 			node = ast_make_lr(AST_FIELD, node, parse_symbol("field name"));
 		} else if ctx.tok == tOBRACK {
 			// array access
 			next();
 			node = ast_make_lr(AST_INDEX, node, parse_expr());
 			require(tCBRACK);
 		} else {
 			return node;
 		}
 	}
 
 	return nil; // unreachable
 }
 
 fn parse_primary_expr() Ast {
 	var node Ast;
 	if ctx.tok == tNUM {
 		node = ast_make_const(ctx.num, ctx.type_i32);
 		next();
 	} else if ctx.tok == tSTR {
 		node = ast_make_simple(AST_STRING, 0);
 		node.name = string_make(ctx.tmp, strlen(ctx.tmp));
 		next();
 	} else if ctx.tok == tTRUE {
 		node = ast_make_const(1, ctx.type_bool);
 		next();
 	} else if ctx.tok == tFALSE {
 		node = ast_make_const(0, ctx.type_bool);
 		next();
 	} else if ctx.tok == tNIL {
 		node = ast_make_const(0, ctx.type_nil);
 		next();
 	} else if ctx.tok == tOPAREN {
 		next();
 		node = parse_expr();
 		require(tCPAREN);
 	} else if ctx.tok == tNEW {
 		next();
 		require(tOPAREN);
 		node = ast_make_simple(AST_NEW, 0);
 		node.name = parse_name("type name");
 		require(tCPAREN);
 	} else if ctx.tok == tIDN {
 		node = parse_ident();
 	} else {
 		error("invalid expression");
 	}
 	return node;
 }
 
 fn parse_unary_expr() Ast {
 	var op u32 = ctx.tok;
 	if op == tPLUS {
 		next();
 		return parse_unary_expr();
 	} else if op == tMINUS {
 		next();
 		return ast_make_l(AST_NEG, parse_unary_expr());
 	} else if op == tBANG {
 		next();
 		return ast_make_l(AST_BOOL_NOT, parse_unary_expr());
 	} else if op == tNOT {
 		next();
 		return ast_make_l(AST_NOT, parse_unary_expr());
 	} else if op == tAMP {
 		error("dereference not supported");
 		//next();
 		//parse_unary_expr();
 	} else {
 		return parse_primary_expr();
 	}
 	return nil; // unreachable
 }
 
 fn parse_mul_expr() Ast {
 	var node Ast = parse_unary_expr();
 	while ctx.tok & tcMASK == tcMULOP {
 		var op u32 = (ctx.tok - tSTAR) + AST_MUL;
 		next();
 		node = ast_make_lr(op, node, parse_unary_expr());
 	}
 	return node;
 }
 
 fn parse_add_expr() Ast {
 	var node Ast = parse_mul_expr();
 	while ctx.tok & tcMASK == tcADDOP {
 		var op u32 = (ctx.tok - tPLUS) + AST_ADD;
 		next();
 		node = ast_make_lr(op, node, parse_mul_expr());
 	}
 	return node;
 }
 
 fn parse_rel_expr() Ast {
 	var node Ast = parse_add_expr();
 	if ctx.tok & tcMASK == tcRELOP {
 		var op u32 = (ctx.tok - tEQ) + AST_EQ;
 		next();
 		node = ast_make_lr(op, node, parse_add_expr());
 	}
 	return node;
 }
 
 fn parse_and_expr() Ast {
 	var node Ast = parse_rel_expr();
 	if ctx.tok == tAND {
 		while ctx.tok == tAND {
 			next();
 			node = ast_make_lr(AST_BOOL_AND, node, parse_rel_expr());
 		}
 	}
 	return node;
 }
 
 fn parse_expr() Ast {
 	var node Ast = parse_and_expr();
 	if ctx.tok == tOR {
 		while ctx.tok == tOR {
 			next();
 			node = ast_make_lr(AST_BOOL_OR, node, parse_and_expr());
 		}
 	}
 	return node;
 }
 
 fn parse_struct_type(name String) Type {
 	var type Type = type_find(name);
 
 	if type == nil {
 		type = type_make(name, TYPE_STRUCT, nil, nil, 0);
 	} else {
 		if type.kind == TYPE_UNDEFINED {
 			// resolve forward ref
 			type.kind = TYPE_STRUCT;
 		} else {
 			error("cannot redefine struct '", @str name.text, "'");
 		}
 	};
 	scope_push(SCOPE_STRUCT);
 	require(tOBRACE);
 	while true {
 		if ctx.tok == tCBRACE {
 			next();
 			break;
 		}
 		var fname String = parse_name("field name");
 		var kind SymbolKind = SYMBOL_FLD;
 		if ctx.tok == tSTAR {
 			next();
 			kind = SYMBOL_PTR;
 		}
 		var ftype Type = parse_type(true);
 		var sym Symbol = symbol_make(fname, ftype);
 		sym.kind = kind;
 		if ctx.tok != tCBRACE {
 			require(tCOMMA);
 		}
 	}
 	type.list = scope_pop();
 	return type;
 }
 
 
 fn parse_array_type() Type {
 	var type Type;
 	var nelem u32 = 0;
 	if ctx.tok == tCBRACK {
 		// TODO: slices
 		next();
 		type = type_make(nil, TYPE_ARRAY, parse_type(false), nil, 0);
 	} else {
 		if ctx.tok != tNUM {
 			error("array size must be numeric");
 		}
 		nelem = ctx.num;
 		next();
 		require(tCBRACK);
 		type = type_make(nil, TYPE_ARRAY, parse_type(false), nil, nelem);
 	}
 	// TODO: type.name?
 	return type;
 }
 
 fn parse_type(fwd_ref_ok u32) Type {
 	if ctx.tok == tSTAR { // pointer-to
 		error("pointer types not supported");
 		//next();
 		//return type_make(nil, TYPE_POINTER, parse_type(true), nil, 0);
 	} else if ctx.tok == tOBRACK { // array-of
 		next();
 		return parse_array_type();
 	} else if ctx.tok == tFN {
 		error("func types not supported");
 		//next();
 		//return parse_func_type();
 	} else if ctx.tok == tSTRUCT {
 		error ("anonymous struct types not supported");
 		//next();
 		//return parse_struct_type(nil);
 	} else if ctx.tok == tIDN {
 		var name String = ctx.ident;
 		next();
 		var type Type = type_find(name);
 		if type == nil {
 			if fwd_ref_ok {
 				type = type_make(name, TYPE_UNDEFINED, nil, nil, 0);
 			} else {
 				error("undefined type '", @str name.text, "' not usable here");
 			}
 		}
 		return type;
 	} else {
 		expected("type");
 	}
 	return nil;
 }
 
 fn parse_while() Ast {
 	// while expr { block }
 	var expr Ast = parse_expr();
 	require(tOBRACE);
 	scope_push(SCOPE_LOOP);
 	var block Ast = parse_block();
 	scope_pop();
 	return ast_make_lr(AST_WHILE, expr, block);
 }
 
 fn parse_if() Ast {
 	// if expr { block }
 
 	var expr Ast = parse_expr();
 	require(tOBRACE);
 	scope_push(SCOPE_BLOCK);
 	var block Ast = parse_block();
 	scope_pop();
 
 	var last Ast = ast_make_lr(AST_CASE, expr, block);
 	var stmt Ast = ast_make_l(AST_IF, last);
 
 	while ctx.tok == tELSE {
 		// ... else ...
 		next();
 		if ctx.tok == tIF {
 			// ... if expr { block }
 			next();
 			expr = parse_expr();
 			require(tOBRACE);
 			scope_push(SCOPE_BLOCK);
 			block = parse_block();
 			scope_pop();
 			last.next = ast_make_lr(AST_CASE, expr, block);
 			last = last.next;
 		} else {
 			// ... { block }
 			require(tOBRACE);
 			scope_push(SCOPE_BLOCK);
 			block = parse_block();
 			scope_pop();
 			last.next = ast_make_l(AST_ELSE, block);
 			break;
 		}
 	}
 	return stmt;
 }
 
 fn parse_return() Ast {
 	// TODO check for return required/type
 	var node Ast = ast_make_simple(AST_RETURN, 0);
 	if ctx.tok == tSEMI {
 		next();
 	} else {
 		//	error("return types do not match");
 		node.left = parse_expr();
 		require(tSEMI);
 	}
 	return node;
 }
 
 fn parse_break() Ast {
 	// TODO: break-to-labeled-loop support
 	var scope Scope = scope_find(SCOPE_LOOP);
 	if scope == nil {
 		error("break must be used from inside a looping construct");
 	}
 	require(tSEMI);
 	return ast_make_simple(AST_BREAK, 0);
 }
 
 fn parse_continue() Ast {
 	// TODO: continue-to-labeled-loop support
 	var scope Scope = scope_find(SCOPE_LOOP);
 	if scope == nil {
 		error("continue must be used from inside a looping construct");
 	}
 	require(tSEMI);
 	return ast_make_simple(AST_CONTINUE, 0);
 }
 
 fn parse_struct_init(sym Symbol) {
 	while true {
 		if ctx.tok == tCBRACE {
 			next();
 			break;
 		}
 		var name String = parse_name("field name");
 		var field Symbol = sym.type.list;
 		while true { // TODO: field_find
 			if field == nil {
 				error("structure has no '", @str name.text, "' field");
 			}
 			if field.name == name {
 				break;
 			}
 			field = field.next;
 		}
 		require(tCOLON);
 		if ctx.tok == tOBRACE {
 			next();
 			parse_struct_init(field);
 		} else {
 			parse_expr();
 		}
 		if ctx.tok != tCBRACE {
 			require(tCOMMA);
 		}
 	}
 }
 
 fn parse_array_init(sym Symbol) {
 	while true {
 		if ctx.tok == tCBRACE {
 			next();
 			break;
 		}
 		parse_expr();
 		if ctx.tok != tCBRACE {
 			require(tCOMMA);
 		}
 	}
 }
 
 fn parse_var() {
 	// TODO: global vs local
 	// TODO: generate assignment/initialization
 	var name String = parse_name("variable name");
 	var type Type = parse_type(false);
 	var sym Symbol = symbol_make(name, type);
 
 	if ctx.tok == tASSIGN {
 		next();
 		if ctx.tok == tOBRACE {
 			next();
 			if type.kind == TYPE_STRUCT {
 				parse_struct_init(sym);
 			} else if type.kind == TYPE_ARRAY {
 				parse_array_init(sym);
 			} else {
 				error("type ", @str type.name.text,
 					" cannot be initialized with {} expr");
 			}
 		} else {
 			parse_expr();
 		}
 	} else {
 		// default init
 	}
 	require(tSEMI);
 }
 
 fn _parse_expr_statement() Ast {
 	var node Ast = parse_expr();
 	var expr Ast = nil;
 	var op u32;
 
 	if ctx.tok == tASSIGN {
 		// basic assignment
 		next();
 		return ast_make_lr(AST_ASSIGN, node, parse_expr());
 	} else if (ctx.tok & tcMASK) == tcAEQOP {
 		// +=, etc
 		op = (ctx.tok - tADDEQ) + AST_ADD;
 		next();
 		expr = parse_expr();
 	} else if (ctx.tok & tcMASK) == tcMEQOP {
 		// *=, etc
 		op = (ctx.tok - tMULEQ) + AST_MUL;
 		next();
 		expr = parse_expr();
 	} else if (ctx.tok == tINC) {
 		op = AST_ADD;
 		next();
 		expr = ast_make_const(1, ctx.type_i32);
 	} else if (ctx.tok == tDEC) {
 		op = AST_SUB;
 		expr = ast_make_const(1, ctx.type_i32);
 	} else {
 		// simple expression
 		return node;
 	}
 
 	// TODO duplicate node instead of sharing it
 	expr = ast_make_lr(op, node, expr);
 	return ast_make_lr(AST_ASSIGN, node, expr);
 }
 
 fn parse_expr_statement() Ast {
 	var stmt Ast = ast_make_l(AST_EXPR, _parse_expr_statement());
 	require(tSEMI);
 	return stmt;
 }
 
 fn parse_block() Ast {
 	var block Ast = ast_make_simple(AST_BLOCK, 0);
 	var last Ast = nil;
 	var node Ast;
 	while true {
 		if ctx.tok == tCBRACE {
 			next();
 			break;
 		} else if ctx.tok == tRETURN {
 			next();
 			node = parse_return();
 		} else if ctx.tok == tBREAK {
 			next();
 			node = parse_break();
 		} else if ctx.tok == tCONTINUE {
 			next();
 			node = parse_continue();
 		} else if ctx.tok == tWHILE {
 			next();
 			node = parse_while();
 		} else if ctx.tok == tIF {
 			next();
 			node = parse_if();
 		} else if ctx.tok == tVAR {
 			next();
 			parse_var();
 		} else if ctx.tok == tSEMI {
 			next();
 			// empty statement
 			continue;
 		} else {
 			node = parse_expr_statement();
 		}
 		if last == nil {
 			block.left = node;
 		} else {
 			last.next = node;
 		}
 		last = node;
 	}
 	return block;
 }
 
 fn parse_param(fname String) Symbol {
 	var pname String = parse_name("parameter name");
 	var ptype Type = parse_type(false);
 	if symbol_find(pname) != nil {
 		error("duplicate parameter name '", @str pname.text, "'");
 	}
 	return symbol_make(pname, ptype);
 }
 
 fn parse_fn_body(sym Symbol) Ast {
 	ctx.cur_fn = sym;
 	require(tOBRACE);
 	scope_push(SCOPE_FUNC); // parameters, from fn
 	scope_push(SCOPE_BLOCK);
 	var node Ast = parse_block();
 	scope_pop(); // stow in node?
 	scope_pop();
 	ctx.cur_fn = nil;
 	return node;
 }
 
 fn parse_fn() Ast {
 	var fname String = parse_name("function name");
 	var rtype Type = ctx.type_void;
 
 	scope_push(SCOPE_FUNC);
 
 	require(tOPAREN);
 	var n u32 = 0;
 	if ctx.tok != tCPAREN {
 		parse_param(fname);
 		while ctx.tok == tCOMMA {
 			next();
 			parse_param(fname);
 		}
 		n++;
 	}
 	require(tCPAREN);
 
 	if ctx.tok != tOBRACE {
 		rtype = parse_type(false);
 	}
 
 	var sym Symbol = symbol_make_global(fname, rtype);
 	sym.kind = SYMBOL_FN;
 	sym.type = type_make(fname, TYPE_FN, rtype, nil, n);
 
 	var node Ast = ast_make_simple(AST_FUNC, 0);
 	node.name = fname;
 	node.sym = sym;
 	node.right = parse_fn_body(sym);
 
 	// save parameters
 	sym.type.list = scope_pop();
 
 	return node;
 }
 
 fn parse_enum_def() {
 	if ctx.tok == tIDN {
 		var name String = parse_name("enum name");
 		type_make(name, TYPE_ENUM, nil, nil, 0);
 	}
 
 	require(tOBRACE);
 	var val u32 = 0;
 	while ctx.tok != tCBRACE {
 		var name String = parse_name("enum tag name");
 		var sym Symbol = symbol_find(name);
 		if sym != nil {
 			error("cannot redfine '", @str name.text, "' as enum tag");
 		}
 		sym = symbol_make_global(name, ctx.type_u32);
 		sym.kind = SYMBOL_DEF;
 		if ctx.tok == tASSIGN {
 			next();
 			parse_expr();
 			// TODO val <- expr
 		} else {
 			val++;
 		}
 		require(tCOMMA);
 	}
 	require(tCBRACE);
 	require(tSEMI);
 }
 
 fn parse_init() {
 	ctx.program = ast_make_simple(AST_PROGRAM, 0);
 	ctx.last = nil;
 }
 
 fn parse_program() Ast {
 	while true {
 		if ctx.tok == tENUM {
 			next();
 			parse_enum_def();
 		} else if ctx.tok == tSTRUCT {
 			next();
 			var name String = parse_name("struct name");
 			parse_struct_type(name);
 			require(tSEMI);
 		} else if ctx.tok == tFN {
 			next();
 			var node Ast = parse_fn();
 			if ctx.last == nil {
 				ctx.program.left = node;
 			} else {
 				ctx.last.next = node;
 			}
 			ctx.last = node;
 		} else if ctx.tok == tVAR {
 			next();
 			parse_var();
 		} else if ctx.tok == tEOF {
 			break;
 		} else {
 			expected("function, variable, or type definition");
 		}
 	}
 	return ctx.program;
 }