xxq250
/
Nasal-Interpreter
mirror of https://github.com/ValKmjolnir/Nasal-Interpreter.git
1
0
Fork 0
Code Issues Actions 1 Packages Projects Releases Wiki Activity
Nasal-Interpreter/nasal_parse.h

1112 lines
33 KiB
C++
Raw Blame History

#pragma once
#include <unordered_map>
#include "nasal.h"
#include "nasal_lexer.h"
#include "nasal_ast.h"
#include "nasal_err.h"
/*
_,,,_
.' `'.
/ ____ \ Fucking Nasal Parser
| .-'_ _\/ /
\_/ a a| /
(,` \ | .----.
| -' | /| '--.
\ '= / || ]| `-.
/`-.__.' || ]| ::|
.-'`-.__ \__ || ]| ::|
/ `` `. || ]| ::|
_ | \ \ \ \| ]| .-'
/ \| \ | \ L.__ .--'(
| |\ `. | \ ,---|_ \---------,
| | '. './\ \/ .--._|=- |_ /|
| \ '. `'.'. /`\/ .-' '. / |
| | `'. `;-:-;`)| |-./ |
| /_ `'--./_ ` )/'-------------')/) |
\ | `""""----"`\//`""`/,===..'`````````/ ( |
| | / `---` `===' / ) |
/ \ / / ( |
| '------. |'--------------------'| ) |
\ `-| | / |
`--...,______| | ( |
| | | | ) ,|
| | | | ( /||
| | | | )/ `"
/ \ | | (/
.' /I\ '.| | /)
.-'_.'/ \'. | | /
``` `"""` `| .-------------------.||
`"` `"`
*/
class parse {
#define thisspan (toks[ptr].loc)
#define prevspan (ptr!=0? toks[ptr-1].loc:toks[ptr].loc)
private:
u32 ptr;
u32 in_func; // count function block
u32 in_loop; // count loop block
const token* toks;
ast root;
error& err;
const std::unordered_map<tok,string> tokname {
{tok::rfor ,"for" },
{tok::forindex,"forindex"},
{tok::foreach ,"foreach" },
{tok::rwhile ,"while" },
{tok::var ,"var" },
{tok::func ,"func" },
{tok::brk ,"break" },
{tok::cont ,"continue"},
{tok::ret ,"return" },
{tok::rif ,"if" },
{tok::elsif ,"elsif" },
{tok::relse ,"else" },
{tok::tknil ,"nil" },
{tok::lcurve ,"(" },
{tok::rcurve ,")" },
{tok::lbracket,"[" },
{tok::rbracket,"]" },
{tok::lbrace ,"{" },
{tok::rbrace ,"}" },
{tok::semi ,";" },
{tok::opand ,"and" },
{tok::opor ,"or" },
{tok::comma ,"," },
{tok::dot ,"." },
{tok::ellipsis,"..." },
{tok::quesmark,"?" },
{tok::colon ,":" },
{tok::add ,"+" },
{tok::sub ,"-" },
{tok::mult ,"*" },
{tok::div ,"/" },
{tok::floater ,"~" },
{tok::btand ,"&" },
{tok::btor ,"|" },
{tok::btxor ,"^" },
{tok::opnot ,"!" },
{tok::eq ,"=" },
{tok::addeq ,"+=" },
{tok::subeq ,"-=" },
{tok::multeq ,"*=" },
{tok::diveq ,"/=" },
{tok::lnkeq ,"~=" },
{tok::btandeq ,"&=" },
{tok::btoreq ,"|=" },
{tok::btxoreq ,"^=" },
{tok::cmpeq ,"==" },
{tok::neq ,"!=" },
{tok::less ,"<" },
{tok::leq ,"<=" },
{tok::grt ,">" },
{tok::geq ,">=" }
};
void die(const span&,string);
void next() {++ptr;}
void match(tok type, const char* info=nullptr);
bool lookahead(tok);
bool is_call(tok);
bool check_comma(const tok*);
bool check_tuple();
bool check_func_end(const ast&);
bool check_special_call();
bool need_semi_check(const ast&);
ast null();
ast nil();
ast num();
ast str();
ast id();
ast bools();
ast vec();
ast hash();
ast pair();
ast func();
ast params();
ast lcurve_expr();
ast expr();
ast exprs();
ast calc();
ast bitwise_or();
ast bitwise_xor();
ast bitwise_and();
ast or_expr();
ast and_expr();
ast cmp_expr();
ast additive_expr();
ast multive_expr();
ast unary();
ast scalar();
ast call_scalar();
ast callh();
ast callv();
ast callf();
ast subvec();
ast definition();
ast incurve_def();
ast outcurve_def();
ast multi_id();
ast multi_scalar();
ast multi_assgin();
ast loop();
ast while_loop();
ast for_loop();
ast forei_loop();
ast iter_gen();
ast cond();
ast continue_expr();
ast break_expr();
ast ret_expr();
public:
parse(error& e):
ptr(0), in_func(0), in_loop(0),
toks(nullptr),
root({0, 0, 0, 0, ""}, ast_root),
err(e) {}
const error& compile(const lexer&);
ast& tree() {return root;}
const ast& tree() const {return root;}
};
const error& parse::compile(const lexer& lexer) {
toks=lexer.result().data();
ptr=in_func=in_loop=0;
root={toks[0].loc, ast_root};
while(!lookahead(tok::eof)) {
root.add(expr());
if (lookahead(tok::semi)) {
match(tok::semi);
} else if (need_semi_check(root.child().back()) && !lookahead(tok::eof)) {
// the last expression can be recognized without semi
die(prevspan, "expected \";\"");
}
}
root.update_span();
return err;
}
void parse::die(const span& loc, string info) {
err.err("parse", loc, info);
}
void parse::match(tok type,const char* info) {
if (!lookahead(type)) {
if (info) {
die(thisspan, info);
return;
}
switch(type) {
case tok::num:die(thisspan, "expected number"); break;
case tok::str:die(thisspan, "expected string"); break;
case tok::id: die(thisspan, "expected identifier");break;
default: die(thisspan, "expected '"+tokname.at(type)+"'"); break;
}
return;
}
if (lookahead(tok::eof)) {
return;
}
next();
}
bool parse::lookahead(tok type) {
return toks[ptr].type==type;
}
bool parse::is_call(tok type) {
return type==tok::lcurve || type==tok::lbracket || type==tok::dot;
}
bool parse::check_comma(const tok* panic_set) {
for(u32 i=0;panic_set[i]!=tok::null;++i) {
if (lookahead(panic_set[i])) {
die(prevspan, "expected ',' between scalars");
return true;
}
}
return false;
}
bool parse::check_tuple() {
u32 check_ptr=ptr, curve=1, bracket=0, brace=0;
while(toks[++check_ptr].type!=tok::eof && curve) {
switch(toks[check_ptr].type) {
case tok::lcurve: ++curve; break;
case tok::lbracket: ++bracket; break;
case tok::lbrace: ++brace; break;
case tok::rcurve: --curve; break;
case tok::rbracket: --bracket; break;
case tok::rbrace: --brace; break;
default: break;
}
if (curve==1 && !bracket && !brace && toks[check_ptr].type==tok::comma) {
return true;
}
}
return false;
}
bool parse::check_func_end(const ast& node) {
u32 type=node.type();
if (type==ast_func) {
return true;
} else if (type==ast_num || type==ast_id || type==ast_str || type==ast_nil || type==ast_vec || type==ast_hash) {
return false;
}
if (node.child().empty() || (
type!=ast_def &&
type!=ast_equal &&
type!=ast_addeq &&
type!=ast_subeq &&
type!=ast_multeq &&
type!=ast_diveq &&
type!=ast_lnkeq
)
) {
return false;
} else {
return check_func_end(node.child().back());
}
return false;
}
bool parse::check_special_call() {
// special call means like this: function_name(a:1,b:2,c:3);
u32 check_ptr=ptr, curve=1, bracket=0, brace=0;
while(toks[++check_ptr].type!=tok::eof && curve) {
switch(toks[check_ptr].type) {
case tok::lcurve: ++curve; break;
case tok::lbracket: ++bracket;break;
case tok::lbrace: ++brace; break;
case tok::rcurve: --curve; break;
case tok::rbracket: --bracket;break;
case tok::rbrace: --brace; break;
default: break;
}
// m?1:0 will be recognized as normal parameter
if (curve==1 && !bracket && !brace && toks[check_ptr].type==tok::quesmark) {
return false;
}
if (curve==1 && !bracket && !brace && toks[check_ptr].type==tok::colon) {
return true;
}
}
return false;
}
bool parse::need_semi_check(const ast& node) {
u32 type=node.type();
if (type==ast_for || type==ast_foreach || type==ast_forindex || type==ast_while || type==ast_cond) {
return false;
}
return !check_func_end(node);
}
ast parse::null() {
return {toks[ptr].loc, ast_null};
}
ast parse::nil() {
return {toks[ptr].loc, ast_nil};
}
ast parse::num() {
ast node(toks[ptr].loc, ast_num);
node.set_num(str2num(toks[ptr].str.c_str()));
match(tok::num);
return node;
}
ast parse::str() {
ast node(toks[ptr].loc, ast_str);
node.set_str(toks[ptr].str);
match(tok::str);
return node;
}
ast parse::id() {
ast node(toks[ptr].loc, ast_id);
node.set_str(toks[ptr].str);
match(tok::id);
return node;
}
ast parse::bools() {
ast node(toks[ptr].loc, ast_bool);
node.set_str(toks[ptr].str);
if (lookahead(tok::tktrue)) {
match(tok::tktrue);
} else {
match(tok::tkfalse);
}
return node;
}
ast parse::vec() {
// panic set for this token is not ','
// this is the FIRST set of calculation
// array end with tok::null=0
const tok panic[]={
tok::id,tok::str,tok::num,tok::tktrue,
tok::tkfalse,tok::opnot,tok::sub,tok::tknil,
tok::func,tok::var,tok::lcurve,tok::floater,
tok::lbrace,tok::lbracket,tok::null
};
ast node(toks[ptr].loc, ast_vec);
match(tok::lbracket);
while(!lookahead(tok::rbracket)) {
node.add(calc());
if (lookahead(tok::comma)) {
match(tok::comma);
} else if (lookahead(tok::eof)) {
break;
} else if (!lookahead(tok::rbracket) && !check_comma(panic)) {
break;
}
}
node.update_span(thisspan);
match(tok::rbracket, "expected ']' when generating vector");
return node;
}
ast parse::hash() {
ast node(toks[ptr].loc, ast_hash);
match(tok::lbrace);
while(!lookahead(tok::rbrace)) {
node.add(pair());
if (lookahead(tok::comma)) {
match(tok::comma);
} else if (lookahead(tok::id) || lookahead(tok::str)) { // first set of hashmember
die(prevspan, "expected ',' between hash members");
} else {
break;
}
}
node.update_span(thisspan);
match(tok::rbrace, "expected '}' when generating hash");
return node;
}
ast parse::pair() {
ast node(toks[ptr].loc, ast_pair);
if (lookahead(tok::id)) {
node.add(id());
} else if (lookahead(tok::str)) {
node.add(str());
} else {
match(tok::id, "expected hashmap key");
}
match(tok::colon);
node.add(calc());
node.update_span();
return node;
}
ast parse::func() {
++in_func;
ast node(toks[ptr].loc, ast_func);
match(tok::func);
if (lookahead(tok::lcurve)) {
node.add(params());
} else {
node.add(null());
}
node.add(exprs());
--in_func;
node.update_span();
return node;
}
ast parse::params() {
ast node(toks[ptr].loc, ast_params);
match(tok::lcurve);
while(!lookahead(tok::rcurve)) {
ast tmp=id();
if (lookahead(tok::eq) || lookahead(tok::ellipsis)) {
ast special_arg(toks[ptr].loc, ast_null);
if (lookahead(tok::eq)) {
match(tok::eq);
special_arg=std::move(tmp);
special_arg.set_type(ast_default);
special_arg.add(calc());
} else {
match(tok::ellipsis);
special_arg=std::move(tmp);
special_arg.set_type(ast_dynamic);
}
node.add(std::move(special_arg));
} else {
node.add(std::move(tmp));
}
if (lookahead(tok::comma)) {
match(tok::comma);
} else if (lookahead(tok::id)) { // first set of identifier
die(prevspan, "expected ',' between identifiers");
} else {
break;
}
}
node.update_span(thisspan);
match(tok::rcurve, "expected ')' after parameter list");
return node;
}
ast parse::lcurve_expr() {
if (toks[ptr+1].type==tok::var)
return definition();
return check_tuple()?multi_assgin():calc();
}
ast parse::expr() {
tok type=toks[ptr].type;
if ((type==tok::brk || type==tok::cont) && !in_loop) {
die(thisspan, "must use break/continue in loops");
}
if (type==tok::ret && !in_func) {
die(thisspan, "must use return in functions");
}
switch(type) {
case tok::tknil:
case tok::num:
case tok::str:
case tok::id:
case tok::tktrue:
case tok::tkfalse:
case tok::func:
case tok::lbracket:
case tok::lbrace:
case tok::sub:
case tok::floater:
case tok::opnot: return calc(); break;
case tok::var: return definition(); break;
case tok::lcurve: return lcurve_expr(); break;
case tok::rfor:
case tok::forindex:
case tok::foreach:
case tok::rwhile: return loop(); break;
case tok::rif: return cond(); break;
case tok::cont: return continue_expr(); break;
case tok::brk: return break_expr(); break;
case tok::ret: return ret_expr(); break;
case tok::semi: break;
default:
die(thisspan, "incorrect token <"+toks[ptr].str+">");
next();
break;
}
// unreachable
return {toks[ptr].loc, ast_null};
}
ast parse::exprs() {
if (lookahead(tok::eof)) {
die(thisspan, "expected expression block");
return null();
}
ast node(toks[ptr].loc, ast_block);
if (lookahead(tok::lbrace)) {
match(tok::lbrace);
while(!lookahead(tok::rbrace) && !lookahead(tok::eof)) {
node.add(expr());
if (lookahead(tok::semi)) {
match(tok::semi);
} else if (need_semi_check(node.child().back()) && !lookahead(tok::rbrace)) {
// the last expression can be recognized without semi
die(prevspan, "expected ';'");
}
}
match(tok::rbrace, "expected '}' when generating expressions");
} else {
node.add(expr());
if (lookahead(tok::semi))
match(tok::semi);
}
node.update_span();
return node;
}
ast parse::calc() {
ast node=bitwise_or();
if (lookahead(tok::quesmark)) {
// trinocular calculation
ast tmp(toks[ptr].loc, ast_trino);
match(tok::quesmark);
tmp.add(std::move(node));
tmp.add(calc());
match(tok::colon);
tmp.add(calc());
node=std::move(tmp);
} else if (tok::eq<=toks[ptr].type && toks[ptr].type<=tok::lnkeq) {
// tok::eq~tok::lnkeq is 37 to 42,ast_equal~ast_lnkeq is 21~26
ast tmp(toks[ptr].loc, (u32)toks[ptr].type-(u32)tok::eq+ast_equal);
tmp.add(std::move(node));
match(toks[ptr].type);
tmp.add(calc());
node=std::move(tmp);
} else if (toks[ptr].type==tok::btandeq || toks[ptr].type==tok::btoreq || toks[ptr].type==tok::btxoreq) {
ast tmp(toks[ptr].loc, (u32)toks[ptr].type-(u32)tok::btandeq+ast_btandeq);
tmp.add(std::move(node));
match(toks[ptr].type);
tmp.add(calc());
node=std::move(tmp);
}
node.update_span();
return node;
}
ast parse::bitwise_or() {
ast node=bitwise_xor();
while(lookahead(tok::btor)) {
ast tmp(toks[ptr].loc, ast_bitor);
tmp.add(std::move(node));
match(tok::btor);
tmp.add(bitwise_xor());
tmp.update_span();
node=std::move(tmp);
}
node.update_span();
return node;
}
ast parse::bitwise_xor() {
ast node=bitwise_and();
while(lookahead(tok::btxor)) {
ast tmp(toks[ptr].loc, ast_bitxor);
tmp.add(std::move(node));
match(tok::btxor);
tmp.add(bitwise_and());
tmp.update_span();
node=std::move(tmp);
}
node.update_span();
return node;
}
ast parse::bitwise_and() {
ast node=or_expr();
while(lookahead(tok::btand)) {
ast tmp(toks[ptr].loc, ast_bitand);
tmp.add(std::move(node));
match(tok::btand);
tmp.add(or_expr());
tmp.update_span();
node=std::move(tmp);
}
node.update_span();
return node;
}
ast parse::or_expr() {
ast node=and_expr();
while(lookahead(tok::opor)) {
ast tmp(toks[ptr].loc, ast_or);
tmp.add(std::move(node));
match(tok::opor);
tmp.add(and_expr());
tmp.update_span();
node=std::move(tmp);
}
node.update_span();
return node;
}
ast parse::and_expr() {
ast node=cmp_expr();
while(lookahead(tok::opand)) {
ast tmp(toks[ptr].loc, ast_and);
tmp.add(std::move(node));
match(tok::opand);
tmp.add(cmp_expr());
tmp.update_span();
node=std::move(tmp);
}
node.update_span();
return node;
}
ast parse::cmp_expr() {
ast node=additive_expr();
while(tok::cmpeq<=toks[ptr].type && toks[ptr].type<=tok::geq) {
// tok::cmpeq~tok::geq is 43~48,ast_cmpeq~ast_geq is 27~32
ast tmp(toks[ptr].loc, (u32)toks[ptr].type-(u32)tok::cmpeq+ast_cmpeq);
tmp.add(std::move(node));
match(toks[ptr].type);
tmp.add(additive_expr());
tmp.update_span();
node=std::move(tmp);
}
node.update_span();
return node;
}
ast parse::additive_expr() {
ast node=multive_expr();
while(lookahead(tok::add) || lookahead(tok::sub) || lookahead(tok::floater)) {
ast tmp(toks[ptr].loc, ast_null);
switch(toks[ptr].type) {
case tok::add: tmp.set_type(ast_add); break;
case tok::sub: tmp.set_type(ast_sub); break;
case tok::floater: tmp.set_type(ast_link); break;
default: break;
}
tmp.add(std::move(node));
match(toks[ptr].type);
tmp.add(multive_expr());
tmp.update_span();
node=std::move(tmp);
}
node.update_span();
return node;
}
ast parse::multive_expr() {
ast node=(lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar();
while(lookahead(tok::mult) || lookahead(tok::div)) {
ast tmp(toks[ptr].loc, (u32)toks[ptr].type-(u32)tok::mult+ast_mult);
tmp.add(std::move(node));
match(toks[ptr].type);
tmp.add((lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar());
tmp.update_span();
node=std::move(tmp);
}
node.update_span();
return node;
}
ast parse::unary() {
ast node(toks[ptr].loc,ast_null);
switch(toks[ptr].type) {
case tok::sub: node.set_type(ast_neg);match(tok::sub);break;
case tok::opnot: node.set_type(ast_lnot);match(tok::opnot);break;
case tok::floater: node.set_type(ast_bnot);match(tok::floater);break;
default: break;
}
node.add((lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar());
node.update_span();
return node;
}
ast parse::scalar() {
ast node(toks[ptr].loc, ast_null);
if (lookahead(tok::tknil)) {
node=nil();
match(tok::tknil);
} else if (lookahead(tok::num)) {
node=num();
} else if (lookahead(tok::str)) {
node=str();
} else if (lookahead(tok::id)) {
node=id();
} else if (lookahead(tok::tktrue) || lookahead(tok::tkfalse)) {
node=bools();
} else if (lookahead(tok::func)) {
node=func();
} else if (lookahead(tok::lbracket)) {
node=vec();
} else if (lookahead(tok::lbrace)) {
node=hash();
} else if (lookahead(tok::lcurve)) {
const auto& loc=toks[ptr].loc;
match(tok::lcurve);
node=calc();
node.set_begin(loc.begin_line, loc.begin_column);
node.update_span(thisspan);
match(tok::rcurve);
} else if (lookahead(tok::var)) {
match(tok::var);
node.set_type(ast_def);
node.add(id());
match(tok::eq);
node.add(calc());
} else {
die(thisspan, "expected scalar");
return node;
}
// check call and avoid ambiguous syntax
if (is_call(toks[ptr].type) && !(lookahead(tok::lcurve) && toks[ptr+1].type==tok::var)) {
ast tmp=std::move(node);
node={toks[ptr].loc, ast_call};
node.add(std::move(tmp));
while(is_call(toks[ptr].type)) {
node.add(call_scalar());
}
}
node.update_span();
return node;
}
ast parse::call_scalar() {
switch(toks[ptr].type) {
case tok::lcurve: return callf(); break;
case tok::lbracket: return callv(); break;
case tok::dot: return callh(); break;
default: break;
}
// unreachable
return {toks[ptr].loc, ast_nil};
}
ast parse::callh() {
ast node(toks[ptr].loc, ast_callh);
match(tok::dot);
node.set_str(toks[ptr].str);
node.set_end(toks[ptr].loc.end_line, toks[ptr].loc.end_column);
match(tok::id, "expected hashmap key"); // get key
return node;
}
ast parse::callv() {
// panic set for this token is not ','
// this is the FIRST set of subvec
// array end with tok::null=0
const tok panic[]={
tok::id,tok::str,tok::num,tok::tktrue,
tok::tkfalse,tok::opnot,tok::sub,tok::tknil,
tok::func,tok::var,tok::lcurve,tok::floater,
tok::lbrace,tok::lbracket,tok::colon,tok::null
};
ast node(toks[ptr].loc, ast_callv);
match(tok::lbracket);
while(!lookahead(tok::rbracket)) {
node.add(subvec());
if (lookahead(tok::comma)) {
match(tok::comma);
} else if (lookahead(tok::eof)) {
break;
} else if (!lookahead(tok::rbracket) && !check_comma(panic)) {
break;
}
}
if (node.size()==0) {
die(thisspan, "expected index value");
}
node.update_span(thisspan);
match(tok::rbracket, "expected ']' when calling vector");
return node;
}
ast parse::callf() {
// panic set for this token is not ','
// this is the FIRST set of calculation/hashmember
// array end with tok::null=0
const tok panic[]={
tok::id,tok::str,tok::num,tok::tktrue,
tok::tkfalse,tok::opnot,tok::sub,tok::tknil,
tok::func,tok::var,tok::lcurve,tok::floater,
tok::lbrace,tok::lbracket,tok::null
};
ast node(toks[ptr].loc, ast_callf);
bool special_call=check_special_call();
match(tok::lcurve);
while(!lookahead(tok::rcurve)) {
node.add(special_call?pair():calc());
if (lookahead(tok::comma))
match(tok::comma);
else if (lookahead(tok::eof))
break;
else if (!lookahead(tok::rcurve) && !check_comma(panic))
break;
}
node.update_span(thisspan);
match(tok::rcurve, "expected ')' when calling function");
return node;
}
ast parse::subvec() {
ast node=lookahead(tok::colon)?nil():calc();
if (lookahead(tok::colon)) {
ast tmp(toks[ptr].loc, ast_subvec);
match(tok::colon);
tmp.add(std::move(node));
tmp.add((lookahead(tok::comma) || lookahead(tok::rbracket))?nil():calc());
node=std::move(tmp);
}
node.update_span();
return node;
}
ast parse::definition() {
ast node(toks[ptr].loc, ast_def);
if (lookahead(tok::var)) {
match(tok::var);
switch(toks[ptr].type) {
case tok::id: node.add(id());break;
case tok::lcurve: node.add(outcurve_def());break;
default: die(thisspan, "expected identifier");break;
}
} else if (lookahead(tok::lcurve)) {
node.add(incurve_def());
}
match(tok::eq);
if (lookahead(tok::lcurve)) {
node.add(check_tuple()?multi_scalar():calc());
} else {
node.add(calc());
}
node.update_span();
return node;
}
ast parse::incurve_def() {
const auto& loc=toks[ptr].loc;
match(tok::lcurve);
match(tok::var);
ast node=multi_id();
node.update_span(thisspan);
match(tok::rcurve);
node.set_begin(loc.begin_line, loc.begin_column);
return node;
}
ast parse::outcurve_def() {
const auto& loc=toks[ptr].loc;
match(tok::lcurve);
ast node=multi_id();
node.update_span(thisspan);
match(tok::rcurve);
node.set_begin(loc.begin_line, loc.begin_column);
return node;
}
ast parse::multi_id() {
ast node(toks[ptr].loc, ast_multi_id);
while(!lookahead(tok::eof)) {
// only identifier is allowed here
// but we check it at codegen stage
node.add(calc());
if (lookahead(tok::comma)) {
match(tok::comma);
} else if (lookahead(tok::id)) { // first set of identifier
die(prevspan, "expected ',' between identifiers");
} else {
break;
}
}
node.update_span();
return node;
}
ast parse::multi_scalar() {
// if check_call_memory is true,we will check if value called here can reach a memory space
const tok panic[]={
tok::id,tok::str,tok::num,tok::tktrue,
tok::tkfalse,tok::opnot,tok::sub,tok::tknil,
tok::func,tok::var,tok::lcurve,tok::floater,
tok::lbrace,tok::lbracket,tok::null
};
ast node(toks[ptr].loc, ast_tuple);
match(tok::lcurve);
while(!lookahead(tok::rcurve)) {
node.add(calc());
if (lookahead(tok::comma)) {
match(tok::comma);
} else if (lookahead(tok::eof)) {
break;
} else if (!lookahead(tok::rcurve) && !check_comma(panic)) {
break;
}
}
node.update_span(thisspan);
match(tok::rcurve, "expected ')' after multi-scalar");
return node;
}
ast parse::multi_assgin() {
ast node(toks[ptr].loc, ast_multi_assign);
node.add(multi_scalar());
match(tok::eq);
if (lookahead(tok::eof)) {
die(thisspan, "expected value list");
return node;
}
if (lookahead(tok::lcurve)) {
node.add(check_tuple()?multi_scalar():calc());
} else {
node.add(calc());
}
node.update_span();
return node;
}
ast parse::loop() {
++in_loop;
ast node(toks[ptr].loc, ast_null);
switch(toks[ptr].type) {
case tok::rwhile: node=while_loop(); break;
case tok::rfor: node=for_loop(); break;
case tok::forindex:
case tok::foreach: node=forei_loop(); break;
default: break;
}
--in_loop;
return node;
}
ast parse::while_loop() {
ast node(toks[ptr].loc, ast_while);
match(tok::rwhile);
match(tok::lcurve);
node.add(calc());
match(tok::rcurve);
node.add(exprs());
node.update_span();
return node;
}
ast parse::for_loop() {
ast node(toks[ptr].loc, ast_for);
match(tok::rfor);
match(tok::lcurve);
// first expression
if (lookahead(tok::eof)) {
die(thisspan, "expected definition");
}
if (lookahead(tok::semi)) {
node.add(null());
} else if (lookahead(tok::var)) {
node.add(definition());
} else if (lookahead(tok::lcurve)) {
node.add(lcurve_expr());
} else {
node.add(calc());
}
match(tok::semi, "expected ';' in for(;;)");
// conditional expression
if (lookahead(tok::eof)) {
die(thisspan, "expected conditional expr");
}
if (lookahead(tok::semi)) {
node.add(null());
} else {
node.add(calc());
}
match(tok::semi, "expected ';' in for(;;)");
//after loop expression
if (lookahead(tok::eof)) {
die(thisspan, "expected calculation");
}
if (lookahead(tok::rcurve)) {
node.add(null());
} else {
node.add(calc());
}
match(tok::rcurve);
node.add(exprs());
node.update_span();
return node;
}
ast parse::forei_loop() {
ast node(toks[ptr].loc, ast_null);
switch(toks[ptr].type) {
case tok::forindex:node.set_type(ast_forindex);match(tok::forindex);break;
case tok::foreach: node.set_type(ast_foreach); match(tok::foreach); break;
default: break;
}
match(tok::lcurve);
// first expression
// foreach/forindex must have an iterator to loop through
if (!lookahead(tok::var) && !lookahead(tok::id)) {
die(thisspan, "expected iterator");
}
node.add(iter_gen());
match(tok::semi, "expected ';' in foreach/forindex(iter;vector)");
if (lookahead(tok::eof)) {
die(thisspan, "expected vector");
}
node.add(calc());
match(tok::rcurve);
node.add(exprs());
node.update_span();
return node;
}
ast parse::iter_gen() {
ast node(toks[ptr].loc, ast_null);
if (lookahead(tok::var)) {
match(tok::var);
node.set_type(ast_iter);
node.add(id());
} else {
node.set_type(ast_call);
node.add(id());
while(is_call(toks[ptr].type)) {
node.add(call_scalar());
}
}
node.update_span();
return node;
}
ast parse::cond() {
ast node(toks[ptr].loc, ast_cond);
// generate if
ast ifnode(toks[ptr].loc, ast_if);
match(tok::rif);
match(tok::lcurve);
ifnode.add(calc());
match(tok::rcurve);
ifnode.add(exprs());
ifnode.update_span();
node.add(std::move(ifnode));
// generate elsif
while(lookahead(tok::elsif)) {
ast elsifnode(toks[ptr].loc, ast_elsif);
match(tok::elsif);
match(tok::lcurve);
elsifnode.add(calc());
match(tok::rcurve);
elsifnode.add(exprs());
elsifnode.update_span();
node.add(std::move(elsifnode));
}
// generate else
if (lookahead(tok::relse)) {
ast elsenode(toks[ptr].loc, ast_else);
match(tok::relse);
elsenode.add(exprs());
elsenode.update_span();
node.add(std::move(elsenode));
}
node.update_span();
return node;
}
ast parse::continue_expr() {
ast node(toks[ptr].loc, ast_continue);
match(tok::cont);
return node;
}
ast parse::break_expr() {
ast node(toks[ptr].loc, ast_break);
match(tok::brk);
return node;
}
ast parse::ret_expr() {
ast node(toks[ptr].loc, ast_ret);
match(tok::ret);
tok type=toks[ptr].type;
if (type==tok::tknil || type==tok::num ||
type==tok::str || type==tok::id ||
type==tok::func || type==tok::sub ||
type==tok::opnot || type==tok::lcurve ||
type==tok::lbracket || type==tok::lbrace ||
type==tok::tktrue || type==tok::tkfalse
) {
node.add(calc());
}
node.update_span();
return node;
}
Reference in New Issue View Git Blame Copy Permalink