🎨 improve code format
delete option -v, --version, -l, --lex
This commit is contained in:
ValKmjolnir
parent
b0f080070a
commit
feea901e4d
75
main.cpp
75
main.cpp
|
|
@ -15,50 +15,48 @@
|
|||
|
||||
using ch_clk=std::chrono::high_resolution_clock;
|
||||
|
||||
const u32 VM_TOKEN =0x01;
|
||||
const u32 VM_AST =0x02;
|
||||
const u32 VM_CODE =0x04;
|
||||
const u32 VM_TIME =0x08;
|
||||
const u32 VM_EXEC =0x10;
|
||||
const u32 VM_DETAIL=0x20;
|
||||
const u32 VM_DEBUG =0x40;
|
||||
const u32 VM_OPT =0x80;
|
||||
const u32 VM_AST =0x01;
|
||||
const u32 VM_CODE =0x02;
|
||||
const u32 VM_TIME =0x04;
|
||||
const u32 VM_EXEC =0x08;
|
||||
const u32 VM_DETAIL=0x10;
|
||||
const u32 VM_DEBUG =0x20;
|
||||
const u32 VM_OPT =0x40;
|
||||
|
||||
void help()
|
||||
std::ostream& help(std::ostream& out)
|
||||
{
|
||||
std::clog
|
||||
out
|
||||
<<" ,--#-,\n"
|
||||
<<"<3 / \\____\\ <3\n"
|
||||
<<" |_|__A_|\n"
|
||||
#ifdef _WIN32
|
||||
<<"use command <chcp 65001> if want to use unicode.\n"
|
||||
<<"use command <chcp 65001> to use unicode.\n"
|
||||
#endif
|
||||
<<"nasal <option>\n"
|
||||
<<"\nnasal <option>\n"
|
||||
<<"option:\n"
|
||||
<<" -h, --help | get this help and exit.\n"
|
||||
<<" -v, --version | get version of nasal interpreter.\n\n"
|
||||
<<"nasal [option...] <file> [argv...]\n"
|
||||
<<" -h, --help | get help.\n"
|
||||
<<"\nnasal [option] <file> [argv]\n"
|
||||
<<"option:\n"
|
||||
<<" -l, --lex | view token info.\n"
|
||||
<<" -a, --ast | view abstract syntax tree.\n"
|
||||
<<" -c, --code | view bytecode.\n"
|
||||
<<" -e, --exec | execute.\n"
|
||||
<<" -t, --time | get the running time.\n"
|
||||
<<" -d, --detail | get detail runtime crash info.\n"
|
||||
<<" | get detail linker path-not-found info.\n"
|
||||
<<" | get garbage collector info if didn't crash.\n"
|
||||
<<" -o, --optimize | use optimizer(beta).\n"
|
||||
<<" | if want to use -op and run, please use -op -e/-t/-d.\n"
|
||||
<<" -dbg, --debug | debug mode (this will ignore -t -d).\n"
|
||||
<<" -a, --ast | view abstract syntax tree.\n"
|
||||
<<" -c, --code | view bytecode.\n"
|
||||
<<" -e, --exec | execute.\n"
|
||||
<<" -t, --time | show execute time.\n"
|
||||
<<" -d, --detail | get detail crash info.\n"
|
||||
<<" | get detail path-not-found info.\n"
|
||||
<<" | get detail gc info.\n"
|
||||
<<" -o, --optimize | use optimizer (beta).\n"
|
||||
<<" | use <-o -e> to run optimized code.\n"
|
||||
<<" -dbg, --debug | debug mode (ignore -t -d).\n"
|
||||
<<"file:\n"
|
||||
<<" input file name to execute.\n"
|
||||
<<" <filename> | execute file.\n"
|
||||
<<"argv:\n"
|
||||
<<" command line arguments used in program.\n";
|
||||
<<" <args> | cmd arguments used in program.\n";
|
||||
return out;
|
||||
}
|
||||
|
||||
void logo()
|
||||
std::ostream& logo(std::ostream& out)
|
||||
{
|
||||
std::clog
|
||||
out
|
||||
<<" __ _\n"
|
||||
<<" /\\ \\ \\__ _ ___ __ _| |\n"
|
||||
<<" / \\/ / _` / __|/ _` | |\n"
|
||||
|
|
@ -66,11 +64,11 @@ void logo()
|
|||
<<" \\_\\ \\/ \\__,_|___/\\__,_|_|\n"
|
||||
<<"version : "<<__nasver<<" ("<<__DATE__<<" "<<__TIME__<<")\n"
|
||||
<<"c++ std : "<<__cplusplus<<"\n"
|
||||
<<"thanks to : https://github.com/andyross/nasal\n"
|
||||
<<"code repo : https://github.com/ValKmjolnir/Nasal-Interpreter\n"
|
||||
<<"code repo : https://gitee.com/valkmjolnir/Nasal-Interpreter\n"
|
||||
<<"lang info : http://wiki.flightgear.org/Nasal_scripting_language\n"
|
||||
<<"lang wiki : https://wiki.flightgear.org/Nasal_scripting_language\n"
|
||||
<<"input <nasal -h> to get help .\n";
|
||||
return out;
|
||||
}
|
||||
|
||||
[[noreturn]]
|
||||
|
|
@ -93,8 +91,6 @@ void execute(const string& file,const std::vector<string>& argv,const u32 cmd)
|
|||
|
||||
// lexer scans file to get tokens
|
||||
lex.scan(file);
|
||||
if(cmd&VM_TOKEN)
|
||||
lex.print();
|
||||
|
||||
// parser gets lexer's token list to compile
|
||||
parse.compile(lex);
|
||||
|
|
@ -129,16 +125,14 @@ i32 main(i32 argc,const char* argv[])
|
|||
{
|
||||
if(argc<=1)
|
||||
{
|
||||
logo();
|
||||
std::clog<<logo;
|
||||
return 0;
|
||||
}
|
||||
if(argc==2)
|
||||
{
|
||||
string s(argv[1]);
|
||||
if(s=="-v" || s=="--version")
|
||||
std::clog<<"nasal "<<__nasver<<" ("<<__DATE__<<" "<<__TIME__<<")\n";
|
||||
else if(s=="-h" || s=="--help")
|
||||
help();
|
||||
if(s=="-h" || s=="--help")
|
||||
std::clog<<help;
|
||||
else if(s[0]!='-')
|
||||
execute(s,{},VM_EXEC);
|
||||
else
|
||||
|
|
@ -146,7 +140,6 @@ i32 main(i32 argc,const char* argv[])
|
|||
return 0;
|
||||
}
|
||||
std::unordered_map<string,u32> cmdlst={
|
||||
{"--lex",VM_TOKEN},{"-l",VM_TOKEN},
|
||||
{"--ast",VM_AST},{"-a",VM_AST},
|
||||
{"--code",VM_CODE},{"-c",VM_CODE},
|
||||
{"--exec",VM_EXEC},{"-e",VM_EXEC},
|
||||
|
|
@ -156,7 +149,7 @@ i32 main(i32 argc,const char* argv[])
|
|||
{"--debug",VM_DEBUG},{"-dbg",VM_DEBUG}
|
||||
};
|
||||
u32 cmd=0;
|
||||
string filename;
|
||||
string filename="";
|
||||
std::vector<string> vm_argv;
|
||||
for(i32 i=1;i<argc;++i)
|
||||
{
|
||||
|
|
|
|||
19
makefile
19
makefile
|
|
@ -1,4 +1,4 @@
|
|||
.PHONY:test
|
||||
.PHONY:test clean
|
||||
|
||||
SRC=\
|
||||
main.cpp\
|
||||
|
|
@ -27,28 +27,33 @@ stable-release:$(SRC)
|
|||
stable-release-mingw:$(SRC)
|
||||
$(CXX) -std=c++$(STD) -O2 main.cpp -o nasal.exe -fno-exceptions -Wshadow -Wall -static
|
||||
|
||||
clean:
|
||||
-@ rm ./nasal
|
||||
-@ rm ./nasal.exe
|
||||
|
||||
test:nasal
|
||||
@ ./nasal -o -e test/ascii-art.nas
|
||||
@ ./nasal -o -c test/auto_crash.nas
|
||||
@ ./nasal -o -a -c test/bf.nas
|
||||
@ ./nasal -o -a -c test/bfconvertor.nas
|
||||
@ ./nasal -o -e -d test/bfs.nas
|
||||
@ ./nasal -o -d test/bfs.nas
|
||||
@ ./nasal -o -t test/bigloop.nas
|
||||
@ ./nasal -o -e test/bp.nas
|
||||
@ ./nasal -o -e -d test/calc.nas
|
||||
@ ./nasal -o -d test/calc.nas
|
||||
@ ./nasal -o -e test/choice.nas
|
||||
@ ./nasal -o -e test/class.nas
|
||||
@ ./nasal -o -d test/coroutine.nas
|
||||
@ ./nasal -o -e test/coroutine.nas
|
||||
@ ./nasal -o -e test/diff.nas
|
||||
@ ./nasal -o -e test/donuts.nas
|
||||
-@ ./nasal -o -d test/exception.nas
|
||||
@ ./nasal -o -t -d test/fib.nas
|
||||
@ ./nasal -o -e test/filesystem.nas
|
||||
@ ./nasal -o -e -d test/hexdump.nas
|
||||
@ ./nasal -o -d test/hexdump.nas
|
||||
@ ./nasal -o -c test/httptest.nas
|
||||
@ ./nasal -o -e test/json.nas
|
||||
@ ./nasal -o -e test/leetcode1319.nas
|
||||
@ ./nasal -o -e -d test/lexer.nas
|
||||
@ ./nasal -o -e -d test/life.nas
|
||||
@ ./nasal -o -d test/lexer.nas
|
||||
@ ./nasal -o -d test/life.nas
|
||||
@ ./nasal -o -t test/loop.nas
|
||||
@ ./nasal -o -t -d test/mandel.nas
|
||||
@ ./nasal -o -t -d test/mandelbrot.nas
|
||||
|
|
|
|||
|
|
@ -1,5 +1,8 @@
|
|||
.PHONY=clean all mingw-all
|
||||
|
||||
dynamic_libs=libfib.so libkey.so libnasock.so
|
||||
dynamic_libs_dll=libfib.dll libkey.dll libnasock.dll
|
||||
|
||||
STD=14
|
||||
|
||||
libfib.so: fib.cpp
|
||||
|
|
@ -36,7 +39,11 @@ libnasock.dll: nasocket.cpp
|
|||
@ del nasocket.o
|
||||
|
||||
clean:
|
||||
-@ rm *.so *.dll *.dylib
|
||||
@ echo "[clean] so"
|
||||
-@ rm $(dynamic_libs)
|
||||
@ echo "[clean] dll"
|
||||
-@ rm $(dynamic_libs_dll)
|
||||
|
||||
all: libfib.so libkey.so libnasock.so
|
||||
@ echo "[build] done"
|
||||
mingw-all: libfib.dll libkey.dll libnasock.dll
|
||||
|
|
|
|||
73
nasal_ast.h
73
nasal_ast.h
|
|
@ -67,64 +67,21 @@ enum ast_node:u32
|
|||
|
||||
const char* ast_name[]=
|
||||
{
|
||||
"null",
|
||||
"root",
|
||||
"block",
|
||||
"file",
|
||||
"nil",
|
||||
"num",
|
||||
"str",
|
||||
"id",
|
||||
"func",
|
||||
"hash",
|
||||
"vec",
|
||||
"pair",
|
||||
"call",
|
||||
"callh",
|
||||
"callv",
|
||||
"callf",
|
||||
"subvec",
|
||||
"args",
|
||||
"default",
|
||||
"dynamic",
|
||||
"and",
|
||||
"or",
|
||||
"=",
|
||||
"+=",
|
||||
"-=",
|
||||
"*=",
|
||||
"/=",
|
||||
"~=",
|
||||
"==",
|
||||
"!=",
|
||||
"<",
|
||||
"<=",
|
||||
">",
|
||||
">=",
|
||||
"+",
|
||||
"-",
|
||||
"*",
|
||||
"/",
|
||||
"~",
|
||||
"neg",
|
||||
"!",
|
||||
"trino",
|
||||
"for",
|
||||
"forindex",
|
||||
"foreach",
|
||||
"while",
|
||||
"iter",
|
||||
"cond",
|
||||
"if",
|
||||
"elsif",
|
||||
"else",
|
||||
"multi-id",
|
||||
"tuple",
|
||||
"def",
|
||||
"multi-assign",
|
||||
"continue",
|
||||
"break",
|
||||
"return"
|
||||
"null", "root", "block", "file",
|
||||
"nil", "num", "str", "id",
|
||||
"func", "hash", "vec", "pair",
|
||||
"call", "callh", "callv", "callf",
|
||||
"subvec", "args", "default", "dynamic",
|
||||
"and", "or", "=", "+=",
|
||||
"-=", "*=", "/=" "~=",
|
||||
"==", "!=", "<", "<=",
|
||||
">", ">=", "+", "-",
|
||||
"*", "/", "~", "neg",
|
||||
"!", "trino", "for", "forindex",
|
||||
"foreach", "while", "iter", "cond",
|
||||
"if", "elsif", "else", "multi-id",
|
||||
"tuple", "def", "multi-assign", "continue",
|
||||
"break", "return"
|
||||
};
|
||||
|
||||
class ast
|
||||
|
|
|
|||
|
|
@ -85,7 +85,7 @@ enum op_code_type:u8
|
|||
op_ret // return
|
||||
};
|
||||
|
||||
const char* code_table[]=
|
||||
const char* opname[]=
|
||||
{
|
||||
"exit ","intg ","intl ","loadg ",
|
||||
"loadl ","loadu ","pnum ","pnil ",
|
||||
|
|
@ -148,7 +148,7 @@ public:
|
|||
<<std::setw(2)<<std::setfill('0')<<((num>>16)&0xff)<<" "
|
||||
<<std::setw(2)<<std::setfill('0')<<((num>>8)&0xff)<<" "
|
||||
<<std::setw(2)<<std::setfill('0')<<(num&0xff)<<" "
|
||||
<<code_table[op]<<" "<<std::dec;
|
||||
<<opname[op]<<" "<<std::dec;
|
||||
switch(op)
|
||||
{
|
||||
case op_addeq: case op_subeq: case op_muleq: case op_diveq:
|
||||
|
|
|
|||
|
|
@ -104,7 +104,7 @@ void debugger::callsort(const u64* arr)
|
|||
std::clog<<"\n ...";
|
||||
break;
|
||||
}
|
||||
std::clog<<"\n "<<code_table[i.first]
|
||||
std::clog<<"\n "<<opname[i.first]
|
||||
<<" : "<<i.second<<" ("<<rate<<"%)";
|
||||
}
|
||||
std::clog<<"\n total : "<<total<<'\n';
|
||||
|
|
@ -136,7 +136,7 @@ void debugger::interact()
|
|||
if(bytecode[pc].op==op_intg)
|
||||
{
|
||||
std::cout
|
||||
<<bold_cyan<<"[debug] "<<reset
|
||||
<<cyan<<"[debug] "<<reset
|
||||
<<"nasal debug mode\n"
|
||||
<<"input \'h\' to get help\n";
|
||||
}
|
||||
|
|
@ -309,7 +309,7 @@ vmexit:
|
|||
callsort(count);
|
||||
ngc.clear();
|
||||
imm.clear();
|
||||
std::cout<<bold_cyan<<"[debug] "<<reset<<"debugger exited\n";
|
||||
std::cout<<cyan<<"[debug] "<<reset<<"debugger exited\n";
|
||||
return;
|
||||
#ifndef _MSC_VER
|
||||
#define dbg(op,num) {\
|
||||
|
|
|
|||
58
nasal_err.h
58
nasal_err.h
|
|
@ -25,7 +25,7 @@ std::ostream& back_white(std::ostream& s)
|
|||
#endif
|
||||
return s;
|
||||
}
|
||||
std::ostream& bold_red(std::ostream& s)
|
||||
std::ostream& red(std::ostream& s)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),0x0c);
|
||||
|
|
@ -34,7 +34,7 @@ std::ostream& bold_red(std::ostream& s)
|
|||
#endif
|
||||
return s;
|
||||
}
|
||||
std::ostream& bold_cyan(std::ostream& s)
|
||||
std::ostream& cyan(std::ostream& s)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),0x03);
|
||||
|
|
@ -43,7 +43,7 @@ std::ostream& bold_cyan(std::ostream& s)
|
|||
#endif
|
||||
return s;
|
||||
}
|
||||
std::ostream& bold_orange(std::ostream& s)
|
||||
std::ostream& orange(std::ostream& s)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),0x0e);
|
||||
|
|
@ -52,7 +52,7 @@ std::ostream& bold_orange(std::ostream& s)
|
|||
#endif
|
||||
return s;
|
||||
}
|
||||
std::ostream& bold_white(std::ostream& s)
|
||||
std::ostream& white(std::ostream& s)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),0x0f);
|
||||
|
|
@ -85,7 +85,7 @@ public:
|
|||
std::ifstream in(f,std::ios::binary);
|
||||
if(in.fail())
|
||||
{
|
||||
std::cerr<<bold_red<<"src: "<<reset<<"cannot open <"<<f<<">\n";
|
||||
std::cerr<<red<<"src: "<<reset<<"cannot open <"<<f<<">\n";
|
||||
std::exit(1);
|
||||
}
|
||||
string line;
|
||||
|
|
@ -112,49 +112,49 @@ private:
|
|||
}
|
||||
public:
|
||||
error():cnt(0){}
|
||||
void err(const char* stage,const string& info)
|
||||
void err(const string& stage,const string& info)
|
||||
{
|
||||
++cnt;
|
||||
std::cerr<<bold_red<<stage<<": "
|
||||
<<bold_white<<info<<reset<<"\n\n";
|
||||
std::cerr<<red<<stage<<": "
|
||||
<<white<<info<<reset<<"\n\n";
|
||||
}
|
||||
void err(const char* stage,u32 line,u32 column,const string& info)
|
||||
void err(const string& stage,u32 line,u32 col,const string& info)
|
||||
{
|
||||
++cnt;
|
||||
const string& code=res[line-1];
|
||||
const string ident=identation(std::to_string(line).length());
|
||||
std::cerr<<bold_red<<stage<<": "
|
||||
<<bold_white<<info<<reset<<"\n"
|
||||
<<bold_cyan<<" --> "<<reset
|
||||
<<bold_orange<<file<<":"<<line<<":"<<column<<"\n";
|
||||
const string iden=identation(std::to_string(line).length());
|
||||
std::cerr<<red<<stage<<": "
|
||||
<<white<<info<<reset<<"\n"
|
||||
<<cyan<<" --> "<<reset
|
||||
<<orange<<file<<":"<<line<<":"<<col<<"\n";
|
||||
if(!line)
|
||||
{
|
||||
std::cerr<<"\n";
|
||||
return;
|
||||
}
|
||||
std::cerr<<bold_cyan<<ident<<" | "<<reset<<"\n"
|
||||
<<bold_cyan<<line<<" | "<<reset<<code<<"\n"
|
||||
<<bold_cyan<<ident<<" | "<<reset;
|
||||
for(i32 i=0;i<(i32)column-1;++i)
|
||||
std::cerr<<cyan<<iden<<" | "<<reset<<"\n"
|
||||
<<cyan<<line<<" | "<<reset<<code<<"\n"
|
||||
<<cyan<<iden<<" | "<<reset;
|
||||
for(i32 i=0;i<(i32)col-1;++i)
|
||||
std::cerr<<char(" \t"[code[i]=='\t']);
|
||||
std::cerr<<bold_red<<"^ "<<info<<reset<<"\n\n";
|
||||
std::cerr<<red<<"^ "<<info<<reset<<"\n\n";
|
||||
}
|
||||
void err(const char* stage,u32 line,const string& info)
|
||||
void err(const string& stage,u32 line,const string& info)
|
||||
{
|
||||
++cnt;
|
||||
const string ident=identation(std::to_string(line).length());
|
||||
std::cerr<<bold_red<<stage<<": "
|
||||
<<bold_white<<info<<reset<<"\n"
|
||||
<<bold_cyan<<" --> "<<reset
|
||||
<<bold_orange<<file<<":"<<line<<"\n";
|
||||
const string iden=identation(std::to_string(line).length());
|
||||
std::cerr<<red<<stage<<": "
|
||||
<<white<<info<<reset<<"\n"
|
||||
<<cyan<<" --> "<<reset
|
||||
<<orange<<file<<":"<<line<<"\n";
|
||||
if(!line)
|
||||
{
|
||||
std::cerr<<"\n";
|
||||
return;
|
||||
}
|
||||
std::cerr<<bold_cyan<<ident<<" | "<<reset<<"\n"
|
||||
<<bold_cyan<<line<<" | "<<reset<<res[line-1]<<"\n"
|
||||
<<bold_cyan<<ident<<" | "<<reset<<"\n\n";
|
||||
std::cerr<<cyan<<iden<<" | "<<reset<<"\n"
|
||||
<<cyan<<line<<" | "<<reset<<res[line-1]<<"\n"
|
||||
<<cyan<<iden<<" | "<<reset<<"\n\n";
|
||||
}
|
||||
void chkerr(){if(cnt)std::exit(1);}
|
||||
void chkerr() const {if(cnt)std::exit(1);}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -70,16 +70,16 @@ string linker::path(const ast& node)
|
|||
|
||||
string linker::findf(const string& fname)
|
||||
{
|
||||
std::vector<string> filepath={fname};
|
||||
std::vector<string> fpath={fname};
|
||||
for(auto&p:envpath)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
filepath.push_back(p+"\\"+fname);
|
||||
fpath.push_back(p+"\\"+fname);
|
||||
#else
|
||||
filepath.push_back(p+"/"+fname);
|
||||
fpath.push_back(p+"/"+fname);
|
||||
#endif
|
||||
}
|
||||
for(auto& i:filepath)
|
||||
for(auto& i:fpath)
|
||||
if(access(i.c_str(),F_OK)!=-1)
|
||||
return i;
|
||||
if(fname=="lib.nas")
|
||||
|
|
@ -94,7 +94,7 @@ string linker::findf(const string& fname)
|
|||
return "";
|
||||
}
|
||||
string paths="";
|
||||
for(auto& i:filepath)
|
||||
for(auto& i:fpath)
|
||||
paths+=" "+i+"\n";
|
||||
err.err("link","cannot find file <"+fname+"> in these paths:\n"+paths);
|
||||
return "";
|
||||
|
|
@ -192,25 +192,25 @@ ast linker::libimpt()
|
|||
|
||||
ast linker::load(ast& root,u16 fileindex)
|
||||
{
|
||||
ast new_root(0,0,ast_root);
|
||||
ast tree(0,0,ast_root);
|
||||
if(!lib_loaded)
|
||||
{
|
||||
link(new_root,libimpt());
|
||||
link(tree,libimpt());
|
||||
lib_loaded=true;
|
||||
}
|
||||
for(auto& i:root.child())
|
||||
{
|
||||
if(imptchk(i))
|
||||
link(new_root,fimpt(i));
|
||||
link(tree,fimpt(i));
|
||||
else
|
||||
break;
|
||||
}
|
||||
// add root to the back of new_root
|
||||
// add root to the back of tree
|
||||
ast file_head(0,0,ast_file);
|
||||
file_head.set_num(fileindex);
|
||||
new_root.add(std::move(file_head));
|
||||
link(new_root,std::move(root));
|
||||
return new_root;
|
||||
tree.add(std::move(file_head));
|
||||
link(tree,std::move(root));
|
||||
return tree;
|
||||
}
|
||||
|
||||
void linker::link(parse& parse,const string& self,bool spath=false)
|
||||
|
|
|
|||
127
nasal_lexer.h
127
nasal_lexer.h
|
|
@ -1,6 +1,7 @@
|
|||
#pragma once
|
||||
|
||||
#include <sstream>
|
||||
#include <unordered_map>
|
||||
#include <sys/stat.h>
|
||||
|
||||
#ifdef _MSC_VER
|
||||
|
|
@ -60,58 +61,6 @@ enum tok:u32{
|
|||
tok_eof // <eof> end of token list
|
||||
};
|
||||
|
||||
struct{
|
||||
const char* str;
|
||||
const u32 type;
|
||||
}tok_table[]={
|
||||
{"for" ,tok_for },
|
||||
{"forindex",tok_forindex },
|
||||
{"foreach" ,tok_foreach },
|
||||
{"while" ,tok_while },
|
||||
{"var" ,tok_var },
|
||||
{"func" ,tok_func },
|
||||
{"break" ,tok_break },
|
||||
{"continue",tok_continue },
|
||||
{"return" ,tok_ret },
|
||||
{"if" ,tok_if },
|
||||
{"elsif" ,tok_elsif },
|
||||
{"else" ,tok_else },
|
||||
{"nil" ,tok_nil },
|
||||
{"(" ,tok_lcurve },
|
||||
{")" ,tok_rcurve },
|
||||
{"[" ,tok_lbracket },
|
||||
{"]" ,tok_rbracket },
|
||||
{"{" ,tok_lbrace },
|
||||
{"}" ,tok_rbrace },
|
||||
{";" ,tok_semi },
|
||||
{"and" ,tok_and },
|
||||
{"or" ,tok_or },
|
||||
{"," ,tok_comma },
|
||||
{"." ,tok_dot },
|
||||
{"..." ,tok_ellipsis },
|
||||
{"?" ,tok_quesmark },
|
||||
{":" ,tok_colon },
|
||||
{"+" ,tok_add },
|
||||
{"-" ,tok_sub },
|
||||
{"*" ,tok_mult },
|
||||
{"/" ,tok_div },
|
||||
{"~" ,tok_link },
|
||||
{"!" ,tok_not },
|
||||
{"=" ,tok_eq },
|
||||
{"+=" ,tok_addeq },
|
||||
{"-=" ,tok_subeq },
|
||||
{"*=" ,tok_multeq },
|
||||
{"/=" ,tok_diveq },
|
||||
{"~=" ,tok_lnkeq },
|
||||
{"==" ,tok_cmpeq },
|
||||
{"!=" ,tok_neq },
|
||||
{"<" ,tok_less },
|
||||
{"<=" ,tok_leq },
|
||||
{">" ,tok_grt },
|
||||
{">=" ,tok_geq },
|
||||
{nullptr ,0 }
|
||||
};
|
||||
|
||||
struct token
|
||||
{
|
||||
u32 line;
|
||||
|
|
@ -134,7 +83,54 @@ private:
|
|||
usize ptr;
|
||||
string res;
|
||||
error& err;
|
||||
std::vector<token> tokens;
|
||||
std::vector<token> toks;
|
||||
std::unordered_map<string,u32> typetbl {
|
||||
{"for" ,tok_for },
|
||||
{"forindex",tok_forindex },
|
||||
{"foreach" ,tok_foreach },
|
||||
{"while" ,tok_while },
|
||||
{"var" ,tok_var },
|
||||
{"func" ,tok_func },
|
||||
{"break" ,tok_break },
|
||||
{"continue",tok_continue },
|
||||
{"return" ,tok_ret },
|
||||
{"if" ,tok_if },
|
||||
{"elsif" ,tok_elsif },
|
||||
{"else" ,tok_else },
|
||||
{"nil" ,tok_nil },
|
||||
{"(" ,tok_lcurve },
|
||||
{")" ,tok_rcurve },
|
||||
{"[" ,tok_lbracket },
|
||||
{"]" ,tok_rbracket },
|
||||
{"{" ,tok_lbrace },
|
||||
{"}" ,tok_rbrace },
|
||||
{";" ,tok_semi },
|
||||
{"and" ,tok_and },
|
||||
{"or" ,tok_or },
|
||||
{"," ,tok_comma },
|
||||
{"." ,tok_dot },
|
||||
{"..." ,tok_ellipsis },
|
||||
{"?" ,tok_quesmark },
|
||||
{":" ,tok_colon },
|
||||
{"+" ,tok_add },
|
||||
{"-" ,tok_sub },
|
||||
{"*" ,tok_mult },
|
||||
{"/" ,tok_div },
|
||||
{"~" ,tok_link },
|
||||
{"!" ,tok_not },
|
||||
{"=" ,tok_eq },
|
||||
{"+=" ,tok_addeq },
|
||||
{"-=" ,tok_subeq },
|
||||
{"*=" ,tok_multeq },
|
||||
{"/=" ,tok_diveq },
|
||||
{"~=" ,tok_lnkeq },
|
||||
{"==" ,tok_cmpeq },
|
||||
{"!=" ,tok_neq },
|
||||
{"<" ,tok_less },
|
||||
{"<=" ,tok_leq },
|
||||
{">" ,tok_grt },
|
||||
{">=" ,tok_geq }
|
||||
};
|
||||
|
||||
u32 get_type(const string&);
|
||||
bool is_id(char);
|
||||
|
|
@ -157,7 +153,7 @@ public:
|
|||
err(e){}
|
||||
void scan(const string&);
|
||||
void print();
|
||||
const std::vector<token>& result() const {return tokens;}
|
||||
const std::vector<token>& result() const {return toks;}
|
||||
};
|
||||
|
||||
bool lexer::is_id(char c)
|
||||
|
|
@ -221,9 +217,8 @@ void lexer::open(const string& file)
|
|||
|
||||
u32 lexer::get_type(const string& str)
|
||||
{
|
||||
for(u32 i=0;tok_table[i].str;++i)
|
||||
if(str==tok_table[i].str)
|
||||
return tok_table[i].type;
|
||||
if(typetbl.count(str))
|
||||
return typetbl.at(str);
|
||||
return tok_null;
|
||||
}
|
||||
|
||||
|
|
@ -415,17 +410,17 @@ void lexer::scan(const string& file)
|
|||
{
|
||||
str=id_gen();
|
||||
u32 type=get_type(str);
|
||||
tokens.push_back({line,column,type?type:tok_id,str});
|
||||
toks.push_back({line,column,type?type:tok_id,str});
|
||||
}
|
||||
else if(is_dec(res[ptr]))
|
||||
{
|
||||
str=num_gen(); // make sure column is correct
|
||||
tokens.push_back({line,column,tok_num,str});
|
||||
toks.push_back({line,column,tok_num,str});
|
||||
}
|
||||
else if(is_str(res[ptr]))
|
||||
{
|
||||
str=str_gen(); // make sure column is correct
|
||||
tokens.push_back({line,column,tok_str,str});
|
||||
toks.push_back({line,column,tok_str,str});
|
||||
}
|
||||
else if(is_single_opr(res[ptr]))
|
||||
{
|
||||
|
|
@ -434,7 +429,7 @@ void lexer::scan(const string& file)
|
|||
u32 type=get_type(str);
|
||||
if(!type)
|
||||
die("invalid operator `"+str+"`");
|
||||
tokens.push_back({line,column,type,str});
|
||||
toks.push_back({line,column,type,str});
|
||||
++ptr;
|
||||
}
|
||||
else if(res[ptr]=='.')
|
||||
|
|
@ -444,7 +439,7 @@ void lexer::scan(const string& file)
|
|||
str+="..";
|
||||
ptr+=str.length();
|
||||
column+=str.length();
|
||||
tokens.push_back({line,column,get_type(str),str});
|
||||
toks.push_back({line,column,get_type(str),str});
|
||||
}
|
||||
else if(is_calc_opr(res[ptr]))
|
||||
{
|
||||
|
|
@ -453,7 +448,7 @@ void lexer::scan(const string& file)
|
|||
if(ptr<res.size() && res[ptr]=='=')
|
||||
str+=res[ptr++];
|
||||
column+=str.length();
|
||||
tokens.push_back({line,column,get_type(str),str});
|
||||
toks.push_back({line,column,get_type(str),str});
|
||||
}
|
||||
else if(res[ptr]=='#')// avoid note, after this process ptr will point to a '\n', so next loop line counter+1
|
||||
while(++ptr<res.size() && res[ptr]!='\n');
|
||||
|
|
@ -464,13 +459,13 @@ void lexer::scan(const string& file)
|
|||
die("invalid character 0x"+chrhex(c));
|
||||
}
|
||||
}
|
||||
tokens.push_back({line,column,tok_eof,"<eof>"});
|
||||
toks.push_back({line,column,tok_eof,"<eof>"});
|
||||
res="";
|
||||
err.chkerr();
|
||||
}
|
||||
|
||||
void lexer::print()
|
||||
{
|
||||
for(auto& tok:tokens)
|
||||
std::cout<<"("<<tok.line<<" | "<<rawstr(tok.str,128)<<")\n";
|
||||
for(auto& tok:toks)
|
||||
std::cout<<"("<<tok.line<<" | "<<rawstr(tok.str,32)<<")\n";
|
||||
}
|
||||
|
|
|
|||
255
nasal_parse.h
255
nasal_parse.h
|
|
@ -39,15 +39,62 @@
|
|||
|
||||
class parse
|
||||
{
|
||||
#define error_line (tokens[ptr].line)
|
||||
#define err_line (toks[ptr].line)
|
||||
#define is_call(type) ((type)==tok_lcurve || (type)==tok_lbracket || (type)==tok_dot)
|
||||
private:
|
||||
u32 ptr;
|
||||
u32 in_func; // count function block
|
||||
u32 in_loop; // count loop block
|
||||
const token* tokens;// ref from lexer
|
||||
const token* toks;
|
||||
ast root;
|
||||
error& err;
|
||||
std::unordered_map<u32,string> tokname {
|
||||
{tok_for ,"for" },
|
||||
{tok_forindex,"forindex"},
|
||||
{tok_foreach ,"foreach" },
|
||||
{tok_while ,"while" },
|
||||
{tok_var ,"var" },
|
||||
{tok_func ,"func" },
|
||||
{tok_break ,"break" },
|
||||
{tok_continue,"continue"},
|
||||
{tok_ret ,"return" },
|
||||
{tok_if ,"if" },
|
||||
{tok_elsif ,"elsif" },
|
||||
{tok_else ,"else" },
|
||||
{tok_nil ,"nil" },
|
||||
{tok_lcurve ,"(" },
|
||||
{tok_rcurve ,")" },
|
||||
{tok_lbracket,"[" },
|
||||
{tok_rbracket,"]" },
|
||||
{tok_lbrace ,"{" },
|
||||
{tok_rbrace ,"}" },
|
||||
{tok_semi ,";" },
|
||||
{tok_and ,"and" },
|
||||
{tok_or ,"or" },
|
||||
{tok_comma ,"," },
|
||||
{tok_dot ,"." },
|
||||
{tok_ellipsis,"..." },
|
||||
{tok_quesmark,"?" },
|
||||
{tok_colon ,":" },
|
||||
{tok_add ,"+" },
|
||||
{tok_sub ,"-" },
|
||||
{tok_mult ,"*" },
|
||||
{tok_div ,"/" },
|
||||
{tok_link ,"~" },
|
||||
{tok_not ,"!" },
|
||||
{tok_eq ,"=" },
|
||||
{tok_addeq ,"+=" },
|
||||
{tok_subeq ,"-=" },
|
||||
{tok_multeq ,"*=" },
|
||||
{tok_diveq ,"/=" },
|
||||
{tok_lnkeq ,"~=" },
|
||||
{tok_cmpeq ,"==" },
|
||||
{tok_neq ,"!=" },
|
||||
{tok_less ,"<" },
|
||||
{tok_leq ,"<=" },
|
||||
{tok_grt ,">" },
|
||||
{tok_geq ,">=" }
|
||||
};
|
||||
|
||||
void die(u32,string,bool);
|
||||
void match(u32 type,const char* info=nullptr);
|
||||
|
|
@ -102,7 +149,7 @@ private:
|
|||
public:
|
||||
parse(error& e):
|
||||
ptr(0),in_func(0),in_loop(0),
|
||||
tokens(nullptr),root(0,0,ast_root),
|
||||
toks(nullptr),root(0,0,ast_root),
|
||||
err(e){}
|
||||
void print(){root.print_tree();}
|
||||
void compile(const lexer&);
|
||||
|
|
@ -111,7 +158,7 @@ public:
|
|||
};
|
||||
void parse::compile(const lexer& lexer)
|
||||
{
|
||||
tokens=lexer.result().data();
|
||||
toks=lexer.result().data();
|
||||
ptr=in_func=in_loop=0;
|
||||
|
||||
root={0,0,ast_root};
|
||||
|
|
@ -122,19 +169,19 @@ void parse::compile(const lexer& lexer)
|
|||
match(tok_semi);
|
||||
// the last expression can be recognized without semi
|
||||
else if(need_semi_check(root.child().back()) && !lookahead(tok_eof))
|
||||
die(error_line,"expected \";\"",true);
|
||||
die(err_line,"expected \";\"",true);
|
||||
}
|
||||
err.chkerr();
|
||||
}
|
||||
void parse::die(u32 line,string info,bool report_prev=false)
|
||||
{
|
||||
i32 col=(i32)tokens[ptr].col-(lookahead(tok_eof)?0:(i32)tokens[ptr].str.length());
|
||||
i32 col=(i32)toks[ptr].col-(lookahead(tok_eof)?0:(i32)toks[ptr].str.length());
|
||||
if(lookahead(tok_str))
|
||||
col-=2; // tok_str's str has no \"
|
||||
if(report_prev && ptr) // used to report lack of ',' ';'
|
||||
{
|
||||
line=tokens[ptr-1].line;
|
||||
col=tokens[ptr-1].col+1;
|
||||
line=toks[ptr-1].line;
|
||||
col=toks[ptr-1].col+1;
|
||||
}
|
||||
err.err("parse",line,col<0?0:col,info);
|
||||
}
|
||||
|
|
@ -144,15 +191,15 @@ void parse::match(u32 type,const char* info)
|
|||
{
|
||||
if(info)
|
||||
{
|
||||
die(error_line,info);
|
||||
die(err_line,info);
|
||||
return;
|
||||
}
|
||||
switch(type)
|
||||
{
|
||||
case tok_num:die(error_line,"expected number"); break;
|
||||
case tok_str:die(error_line,"expected string"); break;
|
||||
case tok_id: die(error_line,"expected identifier");break;
|
||||
default: die(error_line,"expected '"+string(tok_table[type-tok_for].str)+"'"); break;
|
||||
case tok_num:die(err_line,"expected number"); break;
|
||||
case tok_str:die(err_line,"expected string"); break;
|
||||
case tok_id: die(err_line,"expected identifier");break;
|
||||
default: die(err_line,"expected '"+tokname[type]+"'"); break;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
|
@ -162,14 +209,14 @@ void parse::match(u32 type,const char* info)
|
|||
}
|
||||
bool parse::lookahead(u32 type)
|
||||
{
|
||||
return tokens[ptr].type==type;
|
||||
return toks[ptr].type==type;
|
||||
}
|
||||
bool parse::check_comma(const u32* panic_set)
|
||||
{
|
||||
for(u32 i=0;panic_set[i];++i)
|
||||
if(lookahead(panic_set[i]))
|
||||
{
|
||||
die(error_line,"expected ',' between scalars",true);
|
||||
die(err_line,"expected ',' between scalars",true);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
|
|
@ -177,9 +224,9 @@ bool parse::check_comma(const u32* panic_set)
|
|||
bool parse::check_multi_scalar()
|
||||
{
|
||||
u32 check_ptr=ptr,curve=1,bracket=0,brace=0;
|
||||
while(tokens[++check_ptr].type!=tok_eof && curve)
|
||||
while(toks[++check_ptr].type!=tok_eof && curve)
|
||||
{
|
||||
switch(tokens[check_ptr].type)
|
||||
switch(toks[check_ptr].type)
|
||||
{
|
||||
case tok_lcurve: ++curve; break;
|
||||
case tok_lbracket: ++bracket; break;
|
||||
|
|
@ -188,7 +235,7 @@ bool parse::check_multi_scalar()
|
|||
case tok_rbracket: --bracket; break;
|
||||
case tok_rbrace: --brace; break;
|
||||
}
|
||||
if(curve==1 && !bracket && !brace && tokens[check_ptr].type==tok_comma)
|
||||
if(curve==1 && !bracket && !brace && toks[check_ptr].type==tok_comma)
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
|
|
@ -221,9 +268,9 @@ 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(tokens[++check_ptr].type!=tok_eof && curve)
|
||||
while(toks[++check_ptr].type!=tok_eof && curve)
|
||||
{
|
||||
switch(tokens[check_ptr].type)
|
||||
switch(toks[check_ptr].type)
|
||||
{
|
||||
case tok_lcurve: ++curve; break;
|
||||
case tok_lbracket: ++bracket;break;
|
||||
|
|
@ -233,9 +280,9 @@ bool parse::check_special_call()
|
|||
case tok_rbrace: --brace; break;
|
||||
}
|
||||
// m?1:0 will be recognized as normal parameter
|
||||
if(curve==1 && !bracket && !brace && tokens[check_ptr].type==tok_quesmark)
|
||||
if(curve==1 && !bracket && !brace && toks[check_ptr].type==tok_quesmark)
|
||||
return false;
|
||||
if(curve==1 && !bracket && !brace && tokens[check_ptr].type==tok_colon)
|
||||
if(curve==1 && !bracket && !brace && toks[check_ptr].type==tok_colon)
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
|
|
@ -262,30 +309,30 @@ void parse::check_memory_reachable(const ast& node)
|
|||
}
|
||||
ast parse::null()
|
||||
{
|
||||
return {tokens[ptr].line,tokens[ptr].col,ast_null};
|
||||
return {toks[ptr].line,toks[ptr].col,ast_null};
|
||||
}
|
||||
ast parse::nil()
|
||||
{
|
||||
return {tokens[ptr].line,tokens[ptr].col,ast_nil};
|
||||
return {toks[ptr].line,toks[ptr].col,ast_nil};
|
||||
}
|
||||
ast parse::num()
|
||||
{
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_num);
|
||||
node.set_num(str2num(tokens[ptr].str.c_str()));
|
||||
ast node(toks[ptr].line,toks[ptr].col,ast_num);
|
||||
node.set_num(str2num(toks[ptr].str.c_str()));
|
||||
match(tok_num);
|
||||
return node;
|
||||
}
|
||||
ast parse::str()
|
||||
{
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_str);
|
||||
node.set_str(tokens[ptr].str);
|
||||
ast node(toks[ptr].line,toks[ptr].col,ast_str);
|
||||
node.set_str(toks[ptr].str);
|
||||
match(tok_str);
|
||||
return node;
|
||||
}
|
||||
ast parse::id()
|
||||
{
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_id);
|
||||
node.set_str(tokens[ptr].str);
|
||||
ast node(toks[ptr].line,toks[ptr].col,ast_id);
|
||||
node.set_str(toks[ptr].str);
|
||||
match(tok_id);
|
||||
return node;
|
||||
}
|
||||
|
|
@ -300,7 +347,7 @@ ast parse::vec()
|
|||
tok_func,tok_var,tok_lcurve,
|
||||
tok_lbrace,tok_lbracket,tok_null
|
||||
};
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_vec);
|
||||
ast node(toks[ptr].line,toks[ptr].col,ast_vec);
|
||||
match(tok_lbracket);
|
||||
while(!lookahead(tok_rbracket))
|
||||
{
|
||||
|
|
@ -317,7 +364,7 @@ ast parse::vec()
|
|||
}
|
||||
ast parse::hash()
|
||||
{
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_hash);
|
||||
ast node(toks[ptr].line,toks[ptr].col,ast_hash);
|
||||
match(tok_lbrace);
|
||||
while(!lookahead(tok_rbrace))
|
||||
{
|
||||
|
|
@ -325,7 +372,7 @@ ast parse::hash()
|
|||
if(lookahead(tok_comma))
|
||||
match(tok_comma);
|
||||
else if(lookahead(tok_id) || lookahead(tok_str))// first set of hashmember
|
||||
die(error_line,"expected ',' between hash members",true);
|
||||
die(err_line,"expected ',' between hash members",true);
|
||||
else
|
||||
break;
|
||||
}
|
||||
|
|
@ -334,7 +381,7 @@ ast parse::hash()
|
|||
}
|
||||
ast parse::pair()
|
||||
{
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_pair);
|
||||
ast node(toks[ptr].line,toks[ptr].col,ast_pair);
|
||||
if(lookahead(tok_id))
|
||||
node.add(id());
|
||||
else if(lookahead(tok_str))
|
||||
|
|
@ -348,7 +395,7 @@ ast parse::pair()
|
|||
ast parse::func()
|
||||
{
|
||||
++in_func;
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_func);
|
||||
ast node(toks[ptr].line,toks[ptr].col,ast_func);
|
||||
match(tok_func);
|
||||
if(lookahead(tok_lcurve))
|
||||
node.add(args());
|
||||
|
|
@ -360,14 +407,14 @@ ast parse::func()
|
|||
}
|
||||
ast parse::args()
|
||||
{
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_args);
|
||||
ast node(toks[ptr].line,toks[ptr].col,ast_args);
|
||||
match(tok_lcurve);
|
||||
while(!lookahead(tok_rcurve))
|
||||
{
|
||||
ast tmp=id();
|
||||
if(lookahead(tok_eq) || lookahead(tok_ellipsis))
|
||||
{
|
||||
ast special_arg(tokens[ptr].line,tokens[ptr].col,ast_null);
|
||||
ast special_arg(toks[ptr].line,toks[ptr].col,ast_null);
|
||||
if(lookahead(tok_eq))
|
||||
{
|
||||
match(tok_eq);
|
||||
|
|
@ -388,7 +435,7 @@ ast parse::args()
|
|||
if(lookahead(tok_comma))
|
||||
match(tok_comma);
|
||||
else if(lookahead(tok_id))// first set of identifier
|
||||
die(error_line,"expected ',' between identifiers",true);
|
||||
die(err_line,"expected ',' between identifiers",true);
|
||||
else
|
||||
break;
|
||||
}
|
||||
|
|
@ -437,17 +484,17 @@ ast parse::args()
|
|||
}
|
||||
ast parse::lcurve_expr()
|
||||
{
|
||||
if(tokens[ptr+1].type==tok_var)
|
||||
if(toks[ptr+1].type==tok_var)
|
||||
return definition();
|
||||
return check_multi_scalar()?multi_assgin():calc();
|
||||
}
|
||||
ast parse::expr()
|
||||
{
|
||||
u32 type=tokens[ptr].type;
|
||||
u32 type=toks[ptr].type;
|
||||
if((type==tok_break || type==tok_continue) && !in_loop)
|
||||
die(error_line,"should use break/continue in loops");
|
||||
die(err_line,"should use break/continue in loops");
|
||||
if(type==tok_ret && !in_func)
|
||||
die(error_line,"should use return in functions");
|
||||
die(err_line,"should use return in functions");
|
||||
switch(type)
|
||||
{
|
||||
case tok_nil:
|
||||
|
|
@ -471,20 +518,20 @@ ast parse::expr()
|
|||
case tok_ret: return ret_expr(); break;
|
||||
case tok_semi: break;
|
||||
default:
|
||||
die(error_line,"incorrect token <"+tokens[ptr].str+">");
|
||||
die(err_line,"incorrect token <"+toks[ptr].str+">");
|
||||
++ptr;
|
||||
break;
|
||||
}
|
||||
return {tokens[ptr].line,tokens[ptr].col,ast_null};
|
||||
return {toks[ptr].line,toks[ptr].col,ast_null};
|
||||
}
|
||||
ast parse::exprs()
|
||||
{
|
||||
if(lookahead(tok_eof))
|
||||
{
|
||||
die(error_line,"expected expression block");
|
||||
die(err_line,"expected expression block");
|
||||
return null();
|
||||
}
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_block);
|
||||
ast node(toks[ptr].line,toks[ptr].col,ast_block);
|
||||
if(lookahead(tok_lbrace))
|
||||
{
|
||||
match(tok_lbrace);
|
||||
|
|
@ -495,7 +542,7 @@ ast parse::exprs()
|
|||
match(tok_semi);
|
||||
// the last expression can be recognized without semi
|
||||
else if(need_semi_check(node.child().back()) && !lookahead(tok_rbrace))
|
||||
die(error_line,"expected ';'",true);
|
||||
die(err_line,"expected ';'",true);
|
||||
}
|
||||
match(tok_rbrace,"expected '}' when generating expressions");
|
||||
}
|
||||
|
|
@ -513,7 +560,7 @@ ast parse::calc()
|
|||
if(lookahead(tok_quesmark))
|
||||
{
|
||||
// trinocular calculation
|
||||
ast tmp(tokens[ptr].line,tokens[ptr].col,ast_trino);
|
||||
ast tmp(toks[ptr].line,toks[ptr].col,ast_trino);
|
||||
match(tok_quesmark);
|
||||
tmp.add(std::move(node));
|
||||
tmp.add(calc());
|
||||
|
|
@ -521,13 +568,13 @@ ast parse::calc()
|
|||
tmp.add(calc());
|
||||
node=std::move(tmp);
|
||||
}
|
||||
else if(tok_eq<=tokens[ptr].type && tokens[ptr].type<=tok_lnkeq)
|
||||
else if(tok_eq<=toks[ptr].type && toks[ptr].type<=tok_lnkeq)
|
||||
{
|
||||
check_memory_reachable(node);
|
||||
// tok_eq~tok_lnkeq is 37 to 42,ast_equal~ast_lnkeq is 21~26
|
||||
ast tmp(tokens[ptr].line,tokens[ptr].col,tokens[ptr].type-tok_eq+ast_equal);
|
||||
ast tmp(toks[ptr].line,toks[ptr].col,toks[ptr].type-tok_eq+ast_equal);
|
||||
tmp.add(std::move(node));
|
||||
match(tokens[ptr].type);
|
||||
match(toks[ptr].type);
|
||||
tmp.add(calc());
|
||||
node=std::move(tmp);
|
||||
}
|
||||
|
|
@ -538,7 +585,7 @@ ast parse::or_expr()
|
|||
ast node=and_expr();
|
||||
while(lookahead(tok_or))
|
||||
{
|
||||
ast tmp(tokens[ptr].line,tokens[ptr].col,ast_or);
|
||||
ast tmp(toks[ptr].line,toks[ptr].col,ast_or);
|
||||
tmp.add(std::move(node));
|
||||
match(tok_or);
|
||||
tmp.add(and_expr());
|
||||
|
|
@ -551,7 +598,7 @@ ast parse::and_expr()
|
|||
ast node=cmp_expr();
|
||||
while(lookahead(tok_and))
|
||||
{
|
||||
ast tmp(tokens[ptr].line,tokens[ptr].col,ast_and);
|
||||
ast tmp(toks[ptr].line,toks[ptr].col,ast_and);
|
||||
tmp.add(std::move(node));
|
||||
match(tok_and);
|
||||
tmp.add(cmp_expr());
|
||||
|
|
@ -562,12 +609,12 @@ ast parse::and_expr()
|
|||
ast parse::cmp_expr()
|
||||
{
|
||||
ast node=additive_expr();
|
||||
while(tok_cmpeq<=tokens[ptr].type && tokens[ptr].type<=tok_geq)
|
||||
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(tokens[ptr].line,tokens[ptr].col,tokens[ptr].type-tok_cmpeq+ast_cmpeq);
|
||||
ast tmp(toks[ptr].line,toks[ptr].col,toks[ptr].type-tok_cmpeq+ast_cmpeq);
|
||||
tmp.add(std::move(node));
|
||||
match(tokens[ptr].type);
|
||||
match(toks[ptr].type);
|
||||
tmp.add(additive_expr());
|
||||
node=std::move(tmp);
|
||||
}
|
||||
|
|
@ -578,15 +625,15 @@ ast parse::additive_expr()
|
|||
ast node=multive_expr();
|
||||
while(lookahead(tok_add) || lookahead(tok_sub) || lookahead(tok_link))
|
||||
{
|
||||
ast tmp(tokens[ptr].line,tokens[ptr].col,ast_null);
|
||||
switch(tokens[ptr].type)
|
||||
ast tmp(toks[ptr].line,toks[ptr].col,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_link: tmp.set_type(ast_link); break;
|
||||
}
|
||||
tmp.add(std::move(node));
|
||||
match(tokens[ptr].type);
|
||||
match(toks[ptr].type);
|
||||
tmp.add(multive_expr());
|
||||
node=std::move(tmp);
|
||||
}
|
||||
|
|
@ -597,9 +644,9 @@ ast parse::multive_expr()
|
|||
ast node=(lookahead(tok_sub) || lookahead(tok_not))?unary():scalar();
|
||||
while(lookahead(tok_mult) || lookahead(tok_div))
|
||||
{
|
||||
ast tmp(tokens[ptr].line,tokens[ptr].col,tokens[ptr].type-tok_mult+ast_mult);
|
||||
ast tmp(toks[ptr].line,toks[ptr].col,toks[ptr].type-tok_mult+ast_mult);
|
||||
tmp.add(std::move(node));
|
||||
match(tokens[ptr].type);
|
||||
match(toks[ptr].type);
|
||||
tmp.add((lookahead(tok_sub) || lookahead(tok_not))?unary():scalar());
|
||||
node=std::move(tmp);
|
||||
}
|
||||
|
|
@ -607,8 +654,8 @@ ast parse::multive_expr()
|
|||
}
|
||||
ast parse::unary()
|
||||
{
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_null);
|
||||
switch(tokens[ptr].type)
|
||||
ast node(toks[ptr].line,toks[ptr].col,ast_null);
|
||||
switch(toks[ptr].type)
|
||||
{
|
||||
case tok_sub:node.set_type(ast_neg);match(tok_sub);break;
|
||||
case tok_not:node.set_type(ast_not);match(tok_not);break;
|
||||
|
|
@ -618,7 +665,7 @@ ast parse::unary()
|
|||
}
|
||||
ast parse::scalar()
|
||||
{
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_null);
|
||||
ast node(toks[ptr].line,toks[ptr].col,ast_null);
|
||||
if(lookahead(tok_nil)) {node=nil();match(tok_nil);}
|
||||
else if(lookahead(tok_num)) node=num();
|
||||
else if(lookahead(tok_str)) node=str();
|
||||
|
|
@ -642,36 +689,36 @@ ast parse::scalar()
|
|||
}
|
||||
else
|
||||
{
|
||||
die(error_line,"expected scalar");
|
||||
die(err_line,"expected scalar");
|
||||
return node;
|
||||
}
|
||||
// check call and avoid ambiguous syntax
|
||||
if(is_call(tokens[ptr].type) && !(lookahead(tok_lcurve) && tokens[ptr+1].type==tok_var))
|
||||
if(is_call(toks[ptr].type) && !(lookahead(tok_lcurve) && toks[ptr+1].type==tok_var))
|
||||
{
|
||||
ast tmp=std::move(node);
|
||||
node={tokens[ptr].line,tokens[ptr].col,ast_call};
|
||||
node={toks[ptr].line,toks[ptr].col,ast_call};
|
||||
node.add(std::move(tmp));
|
||||
while(is_call(tokens[ptr].type))
|
||||
while(is_call(toks[ptr].type))
|
||||
node.add(call_scalar());
|
||||
}
|
||||
return node;
|
||||
}
|
||||
ast parse::call_scalar()
|
||||
{
|
||||
switch(tokens[ptr].type)
|
||||
switch(toks[ptr].type)
|
||||
{
|
||||
case tok_lcurve: return callf(); break;
|
||||
case tok_lbracket: return callv(); break;
|
||||
case tok_dot: return callh(); break;
|
||||
}
|
||||
// should never run this expression
|
||||
return {tokens[ptr].line,tokens[ptr].col,ast_nil};
|
||||
return {toks[ptr].line,toks[ptr].col,ast_nil};
|
||||
}
|
||||
ast parse::callh()
|
||||
{
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_callh);
|
||||
ast node(toks[ptr].line,toks[ptr].col,ast_callh);
|
||||
match(tok_dot);
|
||||
node.set_str(tokens[ptr].str);
|
||||
node.set_str(toks[ptr].str);
|
||||
match(tok_id,"expected hashmap key"); // get key
|
||||
return node;
|
||||
}
|
||||
|
|
@ -687,7 +734,7 @@ ast parse::callv()
|
|||
tok_lbrace,tok_lbracket,tok_colon,
|
||||
tok_null
|
||||
};
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_callv);
|
||||
ast node(toks[ptr].line,toks[ptr].col,ast_callv);
|
||||
match(tok_lbracket);
|
||||
while(!lookahead(tok_rbracket))
|
||||
{
|
||||
|
|
@ -715,7 +762,7 @@ ast parse::callf()
|
|||
tok_func,tok_var,tok_lcurve,
|
||||
tok_lbrace,tok_lbracket,tok_null
|
||||
};
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_callf);
|
||||
ast node(toks[ptr].line,toks[ptr].col,ast_callf);
|
||||
bool special_call=check_special_call();
|
||||
match(tok_lcurve);
|
||||
while(!lookahead(tok_rcurve))
|
||||
|
|
@ -746,15 +793,15 @@ ast parse::subvec()
|
|||
}
|
||||
ast parse::definition()
|
||||
{
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_def);
|
||||
ast node(toks[ptr].line,toks[ptr].col,ast_def);
|
||||
if(lookahead(tok_var))
|
||||
{
|
||||
match(tok_var);
|
||||
switch(tokens[ptr].type)
|
||||
switch(toks[ptr].type)
|
||||
{
|
||||
case tok_id: node.add(id());break;
|
||||
case tok_lcurve: node.add(outcurve_def());break;
|
||||
default: die(error_line,"expected identifier");break;
|
||||
default: die(err_line,"expected identifier");break;
|
||||
}
|
||||
}
|
||||
else if(lookahead(tok_lcurve))
|
||||
|
|
@ -787,19 +834,19 @@ ast parse::outcurve_def()
|
|||
}
|
||||
ast parse::multi_id()
|
||||
{
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_multi_id);
|
||||
ast node(toks[ptr].line,toks[ptr].col,ast_multi_id);
|
||||
while(!lookahead(tok_eof))
|
||||
{
|
||||
node.add(id());
|
||||
if(is_call(tokens[ptr].type))
|
||||
if(is_call(toks[ptr].type))
|
||||
{
|
||||
call_scalar();// recognize calls but this is still a syntax error
|
||||
die(error_line,"cannot call identifier in multi-definition");
|
||||
die(err_line,"cannot call identifier in multi-definition");
|
||||
}
|
||||
if(lookahead(tok_comma))
|
||||
match(tok_comma);
|
||||
else if(lookahead(tok_id))// first set of identifier
|
||||
die(error_line,"expected ',' between identifiers",true);
|
||||
die(err_line,"expected ',' between identifiers",true);
|
||||
else
|
||||
break;
|
||||
}
|
||||
|
|
@ -814,7 +861,7 @@ ast parse::multi_scalar(bool check_call_memory)
|
|||
tok_func,tok_var,tok_lcurve,
|
||||
tok_lbrace,tok_lbracket,tok_null
|
||||
};
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_tuple);
|
||||
ast node(toks[ptr].line,toks[ptr].col,ast_tuple);
|
||||
match(tok_lcurve);
|
||||
while(!lookahead(tok_rcurve))
|
||||
{
|
||||
|
|
@ -833,12 +880,12 @@ ast parse::multi_scalar(bool check_call_memory)
|
|||
}
|
||||
ast parse::multi_assgin()
|
||||
{
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_multi_assign);
|
||||
ast node(toks[ptr].line,toks[ptr].col,ast_multi_assign);
|
||||
node.add(multi_scalar(true));
|
||||
match(tok_eq);
|
||||
if(lookahead(tok_eof))
|
||||
{
|
||||
die(error_line,"expected value list");
|
||||
die(err_line,"expected value list");
|
||||
return node;
|
||||
}
|
||||
if(lookahead(tok_lcurve))
|
||||
|
|
@ -854,7 +901,7 @@ ast parse::loop()
|
|||
{
|
||||
++in_loop;
|
||||
ast node(0,0,ast_null);
|
||||
switch(tokens[ptr].type)
|
||||
switch(toks[ptr].type)
|
||||
{
|
||||
case tok_while: node=while_loop(); break;
|
||||
case tok_for: node=for_loop(); break;
|
||||
|
|
@ -866,7 +913,7 @@ ast parse::loop()
|
|||
}
|
||||
ast parse::while_loop()
|
||||
{
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_while);
|
||||
ast node(toks[ptr].line,toks[ptr].col,ast_while);
|
||||
match(tok_while);
|
||||
match(tok_lcurve);
|
||||
node.add(calc());
|
||||
|
|
@ -876,12 +923,12 @@ ast parse::while_loop()
|
|||
}
|
||||
ast parse::for_loop()
|
||||
{
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_for);
|
||||
ast node(toks[ptr].line,toks[ptr].col,ast_for);
|
||||
match(tok_for);
|
||||
match(tok_lcurve);
|
||||
// first expression
|
||||
if(lookahead(tok_eof))
|
||||
die(error_line,"expected definition");
|
||||
die(err_line,"expected definition");
|
||||
if(lookahead(tok_semi))
|
||||
node.add(null());
|
||||
else if(lookahead(tok_var))
|
||||
|
|
@ -893,7 +940,7 @@ ast parse::for_loop()
|
|||
match(tok_semi,"expected ';' in for(;;)");
|
||||
// conditional expression
|
||||
if(lookahead(tok_eof))
|
||||
die(error_line,"expected conditional expr");
|
||||
die(err_line,"expected conditional expr");
|
||||
if(lookahead(tok_semi))
|
||||
node.add(null());
|
||||
else
|
||||
|
|
@ -901,7 +948,7 @@ ast parse::for_loop()
|
|||
match(tok_semi,"expected ';' in for(;;)");
|
||||
//after loop expression
|
||||
if(lookahead(tok_eof))
|
||||
die(error_line,"expected calculation");
|
||||
die(err_line,"expected calculation");
|
||||
if(lookahead(tok_rcurve))
|
||||
node.add(null());
|
||||
else
|
||||
|
|
@ -912,8 +959,8 @@ ast parse::for_loop()
|
|||
}
|
||||
ast parse::forei_loop()
|
||||
{
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_null);
|
||||
switch(tokens[ptr].type)
|
||||
ast node(toks[ptr].line,toks[ptr].col,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;
|
||||
|
|
@ -922,11 +969,11 @@ ast parse::forei_loop()
|
|||
// first expression
|
||||
// foreach/forindex must have an iterator to loop through
|
||||
if(!lookahead(tok_var) && !lookahead(tok_id))
|
||||
die(error_line,"expected iterator");
|
||||
die(err_line,"expected iterator");
|
||||
node.add(iter_gen());
|
||||
match(tok_semi,"expected ';' in foreach/forindex(iter;vector)");
|
||||
if(lookahead(tok_eof))
|
||||
die(error_line,"expected vector");
|
||||
die(err_line,"expected vector");
|
||||
node.add(calc());
|
||||
match(tok_rcurve);
|
||||
node.add(exprs());
|
||||
|
|
@ -934,7 +981,7 @@ ast parse::forei_loop()
|
|||
}
|
||||
ast parse::iter_gen()
|
||||
{
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_null);
|
||||
ast node(toks[ptr].line,toks[ptr].col,ast_null);
|
||||
if(lookahead(tok_var))
|
||||
{
|
||||
match(tok_var);
|
||||
|
|
@ -945,7 +992,7 @@ ast parse::iter_gen()
|
|||
{
|
||||
node.set_type(ast_call);
|
||||
node.add(id());
|
||||
while(is_call(tokens[ptr].type))
|
||||
while(is_call(toks[ptr].type))
|
||||
node.add(call_scalar());
|
||||
check_memory_reachable(node);
|
||||
}
|
||||
|
|
@ -953,8 +1000,8 @@ ast parse::iter_gen()
|
|||
}
|
||||
ast parse::cond()
|
||||
{
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_cond);
|
||||
ast ifnode(tokens[ptr].line,tokens[ptr].col,ast_if);
|
||||
ast node(toks[ptr].line,toks[ptr].col,ast_cond);
|
||||
ast ifnode(toks[ptr].line,toks[ptr].col,ast_if);
|
||||
match(tok_if);
|
||||
match(tok_lcurve);
|
||||
ifnode.add(calc());
|
||||
|
|
@ -963,7 +1010,7 @@ ast parse::cond()
|
|||
node.add(std::move(ifnode));
|
||||
while(lookahead(tok_elsif))
|
||||
{
|
||||
ast elsifnode(tokens[ptr].line,tokens[ptr].col,ast_elsif);
|
||||
ast elsifnode(toks[ptr].line,toks[ptr].col,ast_elsif);
|
||||
match(tok_elsif);
|
||||
match(tok_lcurve);
|
||||
elsifnode.add(calc());
|
||||
|
|
@ -973,7 +1020,7 @@ ast parse::cond()
|
|||
}
|
||||
if(lookahead(tok_else))
|
||||
{
|
||||
ast elsenode(tokens[ptr].line,tokens[ptr].col,ast_else);
|
||||
ast elsenode(toks[ptr].line,toks[ptr].col,ast_else);
|
||||
match(tok_else);
|
||||
elsenode.add(exprs());
|
||||
node.add(std::move(elsenode));
|
||||
|
|
@ -982,21 +1029,21 @@ ast parse::cond()
|
|||
}
|
||||
ast parse::continue_expr()
|
||||
{
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_continue);
|
||||
ast node(toks[ptr].line,toks[ptr].col,ast_continue);
|
||||
match(tok_continue);
|
||||
return node;
|
||||
}
|
||||
ast parse::break_expr()
|
||||
{
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_break);
|
||||
ast node(toks[ptr].line,toks[ptr].col,ast_break);
|
||||
match(tok_break);
|
||||
return node;
|
||||
}
|
||||
ast parse::ret_expr()
|
||||
{
|
||||
ast node(tokens[ptr].line,tokens[ptr].col,ast_ret);
|
||||
ast node(toks[ptr].line,toks[ptr].col,ast_ret);
|
||||
match(tok_ret);
|
||||
u32 type=tokens[ptr].type;
|
||||
u32 type=toks[ptr].type;
|
||||
if(type==tok_nil || type==tok_num ||
|
||||
type==tok_str || type==tok_id ||
|
||||
type==tok_func || type==tok_sub ||
|
||||
|
|
|
|||
|
|
@ -46,6 +46,7 @@ var testfile=[
|
|||
"class.nas",
|
||||
"coroutine.nas",
|
||||
"diff.nas",
|
||||
"donuts.nas",
|
||||
"exception.nas",
|
||||
"fib.nas",
|
||||
"filesystem.nas",
|
||||
|
|
|
|||
|
|
@ -0,0 +1,51 @@
|
|||
var mod=func(n,a){
|
||||
return n-int(n/a)*a;
|
||||
}
|
||||
|
||||
var main=func(run_time){
|
||||
var (sin,cos)=(math.sin,math.cos);
|
||||
|
||||
var (A,B)=(0,0);
|
||||
var (z,b)=([],[]);
|
||||
setsize(z,1760);
|
||||
setsize(b,1760);
|
||||
|
||||
print("\e[2J");
|
||||
for(var run=0;run<run_time;run+=1){
|
||||
forindex(var i;b)
|
||||
b[i]=32;
|
||||
forindex(var i;z)
|
||||
z[i]=0;
|
||||
for(var j=0;j<6.28;j+=0.07){
|
||||
for(var i=0;i<6.28;i+=0.02){
|
||||
var (c,d,e,f,g)=(sin(i),cos(j),sin(A),sin(j),cos(A));
|
||||
var h=d+2;
|
||||
var D=1/(c*h*e+f*g+5);
|
||||
var (l,m,n)=(cos(i),cos(B),sin(B));
|
||||
var t=c*h*g-f*e;
|
||||
var x=int(40+30*D*(l*h*m-t*n));
|
||||
var y=int(12+15*D*(l*h*n+t*m));
|
||||
var o=int(x+80*y);
|
||||
var N=int(8*((f*e-c*d*g)*m-c*d*e-f*g-l*d*n));
|
||||
if(22>y and y>0 and x>0 and 80>x and D>z[o]){
|
||||
z[o]=D;
|
||||
b[o]=".,-~:;=!*#$@"[N>0?N:0];
|
||||
}
|
||||
}
|
||||
}
|
||||
print("\e[H");
|
||||
var screen="";
|
||||
for(var k=0;k<1761;k+=1) {
|
||||
screen~=(mod(k,80)?chr(b[k]):chr(10));
|
||||
A+=0.00004;
|
||||
B+=0.00002;
|
||||
}
|
||||
print(screen);
|
||||
}
|
||||
}
|
||||
|
||||
var frames=5e2;
|
||||
var ts=maketimestamp();
|
||||
ts.stamp();
|
||||
main(frames);
|
||||
println(int(frames/(ts.elapsedMSec()/1000))," fps");
|
||||
|
|
@ -46,6 +46,7 @@ var filechecksum=func(){
|
|||
"./test/bp.nas", "./test/calc.nas",
|
||||
"./test/choice.nas", "./test/class.nas",
|
||||
"./test/coroutine.nas", "./test/diff.nas",
|
||||
"./test/donuts.nas",
|
||||
"./test/exception.nas", "./test/fib.nas",
|
||||
"./test/filesystem.nas", "./test/hexdump.nas",
|
||||
"./test/httptest.nas", "./test/json.nas",
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
# wave collapse function 2022/4/10
|
||||
# by ValKmjolnir
|
||||
srand();
|
||||
var interval=1/120;
|
||||
var interval=1/160;
|
||||
var table=[
|
||||
# c ,w,a,s,d
|
||||
["═",0,1,0,1],
|
||||
|
|
|
|||
Loading…
Reference in New Issue