528 lines
13 KiB
C++
528 lines
13 KiB
C++
#include "work.h"
|
|
#include <assert.h>
|
|
|
|
using namespace std;
|
|
|
|
size_t pt;
|
|
vector<Token> tokens;
|
|
|
|
// void printTokens() {
|
|
// wstring_convert<codecvt_utf8<wchar_t>> cvt;
|
|
// for (auto u : tokens) {
|
|
// cout << token_mp[static_cast<int>(u.type)] << " " << u.line << " " <<
|
|
// cvt.to_bytes(u.s)
|
|
// << endl;
|
|
// }
|
|
// cout << endl;
|
|
// }
|
|
|
|
struct Def {
|
|
enum Type {
|
|
TEMPLATE,
|
|
STRUCT,
|
|
VAR
|
|
};
|
|
virtual Def::Type type() const = 0;
|
|
virtual ~Def() = default;
|
|
};
|
|
|
|
struct DefTemplate : Def {
|
|
Def::Type type() const override {
|
|
return Def::TEMPLATE;
|
|
}
|
|
shared_ptr<TemplateType> def_template;
|
|
};
|
|
|
|
struct DefStruct : Def {
|
|
Def::Type type() const override {
|
|
return Def::STRUCT;
|
|
}
|
|
shared_ptr<Struct> def_struct;
|
|
};
|
|
|
|
struct DefVar : Def {
|
|
Def::Type type() const override {
|
|
return Def::VAR;
|
|
}
|
|
shared_ptr<ValType> def_var;
|
|
};
|
|
|
|
map<int, shared_ptr<Def>> ndefs;
|
|
|
|
bool preview(vector<TokenType> v) {
|
|
if (pt + v.size() > tokens.size()) {
|
|
return false;
|
|
}
|
|
for (size_t i = 0; i < v.size(); i++) {
|
|
if (tokens[pt + i].type != v[i]) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
bool preview(TokenType t) {
|
|
return preview(vector<TokenType>{t});
|
|
}
|
|
int jump(TokenType t) {
|
|
if (preview(t)) {
|
|
return tokens[pt++].s;
|
|
}
|
|
if (pt < tokens.size()) {
|
|
printf("error on line %d", tokens[pt].line);
|
|
} else {
|
|
puts("error on end");
|
|
}
|
|
exit(1);
|
|
}
|
|
|
|
shared_ptr<ValType> _createVal(shared_ptr<StructType> t);
|
|
shared_ptr<ValType> createVal();
|
|
vector<shared_ptr<ValType>> createVals();
|
|
shared_ptr<ValType> _createType(shared_ptr<Struct>);
|
|
shared_ptr<ValType> createType();
|
|
vector<shared_ptr<ValType>> createTypes();
|
|
vector<pair<int, shared_ptr<TemplateType>>> createTems();
|
|
vector<pair<int, shared_ptr<ValType>>> createPars(map<int, shared_ptr<ValType>>* = nullptr);
|
|
pair<int, shared_ptr<Struct>> createStruct();
|
|
pair<int, shared_ptr<ValType>> createVar();
|
|
|
|
shared_ptr<ValType> _createVal(shared_ptr<StructType> ft) {
|
|
auto str = ft->str;
|
|
auto s = jump(TokenType::ID);
|
|
if (str->vars.find(s) == str->vars.end()) {
|
|
printf("error on line %d", tokens[pt - 1].line), exit(0);
|
|
}
|
|
auto t = struct_replace(str->vars[s], ft);
|
|
while (t->type() == ValType::FUNCTION
|
|
&& (preview(TokenType::LT) || preview(TokenType::LP))) {
|
|
auto tt = static_pointer_cast<FunctionType>(t);
|
|
vector<shared_ptr<ValType>> types;
|
|
if (preview(TokenType::LT)) {
|
|
types = createTypes();
|
|
}
|
|
if (tt->c1.size() != types.size()) {
|
|
printf("error on line %d", tokens[pt - 1].line), exit(0);
|
|
}
|
|
map<shared_ptr<TemplateType>, shared_ptr<ValType>> mp;
|
|
for (size_t i = 0; i < types.size(); i++) {
|
|
mp[tt->c1[i]] = types[i];
|
|
}
|
|
auto vals = createVals();
|
|
bool legal = tt->c2.size() == vals.size();
|
|
if (legal) {
|
|
for (size_t i = 0; i < vals.size(); i++) {
|
|
if (!sameType(vals[i], function_replace(tt->c2[i], mp))) {
|
|
legal = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!legal) {
|
|
printf("error on line %d", tokens[pt - 1].line), exit(0);
|
|
}
|
|
t = function_replace(tt->c3, mp);
|
|
}
|
|
if (!preview(TokenType::DOT)) {
|
|
return t;
|
|
}
|
|
if (t->type() != ValType::STRUCT) {
|
|
printf("error on line %d", tokens[pt].line), exit(0);
|
|
}
|
|
pt++;
|
|
return _createVal(static_pointer_cast<StructType>(t));
|
|
}
|
|
|
|
shared_ptr<ValType> createVal() {
|
|
shared_ptr<ValType> t;
|
|
if (preview(TokenType::FN)) {
|
|
pt++;
|
|
auto tt = make_shared<FunctionType>();
|
|
vector<pair<int, shared_ptr<TemplateType>>> tems;
|
|
if (preview(TokenType::LT)) {
|
|
tems = createTems();
|
|
}
|
|
for (const auto& pr : tems) {
|
|
tt->c1.push_back(pr.second);
|
|
}
|
|
auto pars = createPars();
|
|
for (const auto& pr : pars) {
|
|
tt->c2.push_back(pr.second);
|
|
}
|
|
jump(TokenType::IMPLY);
|
|
tt->c3 = createType();
|
|
|
|
jump(TokenType::LB);
|
|
vector<int> defs;
|
|
while (!preview(TokenType::RETURN)) {
|
|
if (preview({TokenType::STRUCT, TokenType::ID})) {
|
|
defs.push_back(createStruct().first);
|
|
jump(TokenType::SEMI);
|
|
} else {
|
|
defs.push_back(createVar().first);
|
|
}
|
|
}
|
|
pt++;
|
|
auto ret = createVal();
|
|
jump(TokenType::SEMI);
|
|
if (!sameType(tt->c3, ret)) {
|
|
printf("error on line %d", tokens[pt - 1].line), exit(0);
|
|
}
|
|
for (const auto& pr : tems) {
|
|
ndefs.erase(pr.first);
|
|
}
|
|
for (const auto& pr : pars) {
|
|
ndefs.erase(pr.first);
|
|
}
|
|
for (const auto& s : defs) {
|
|
ndefs.erase(s);
|
|
}
|
|
jump(TokenType::RB);
|
|
|
|
t = static_pointer_cast<ValType>(tt);
|
|
} else if (preview(TokenType::ADMIT)) {
|
|
pt++;
|
|
jump(TokenType::LT);
|
|
t = createType();
|
|
jump(TokenType::RT);
|
|
jump(TokenType::LP);
|
|
jump(TokenType::RP);
|
|
} else {
|
|
bool flag = 0; // 新实例
|
|
if (preview(TokenType::TYPEOF)) {
|
|
flag = 1;
|
|
} else if (preview(TokenType::ID)) {
|
|
auto s = tokens[pt].s;
|
|
if (ndefs.find(s) != ndefs.end() && ndefs[s]->type() == Def::STRUCT) {
|
|
flag = 1;
|
|
}
|
|
}
|
|
|
|
if (flag) {
|
|
t = createType();
|
|
if (t->type() != ValType::STRUCT) {
|
|
printf("error on line %d", tokens[pt - 1].line), exit(0);
|
|
}
|
|
auto tt = static_pointer_cast<StructType>(t);
|
|
auto vals = createVals();
|
|
bool legal = vals.size() == tt->str->c2.size();
|
|
if (legal) {
|
|
for (size_t i = 0; i < vals.size(); i++) {
|
|
if (!sameType(vals[i],
|
|
struct_replace(tt->str->c2[i], tt))) {
|
|
legal = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!legal) {
|
|
printf("error on line %d", tokens[pt - 1].line), exit(0);
|
|
}
|
|
} else {
|
|
auto s = jump(TokenType::ID);
|
|
if (ndefs.find(s) == ndefs.end() || ndefs[s]->type() != Def::VAR) {
|
|
printf("error on line %d", tokens[pt - 1].line), exit(0);
|
|
}
|
|
t = static_pointer_cast<DefVar>(ndefs[s])->def_var;
|
|
}
|
|
}
|
|
while (t->type() == ValType::FUNCTION
|
|
&& (preview(TokenType::LT) || preview(TokenType::LP))) {
|
|
auto tt = static_pointer_cast<FunctionType>(t);
|
|
vector<shared_ptr<ValType>> types;
|
|
if (preview(TokenType::LT)) {
|
|
types = createTypes();
|
|
}
|
|
if (tt->c1.size() != types.size()) {
|
|
printf("error on line %d", tokens[pt - 1].line), exit(0);
|
|
}
|
|
map<shared_ptr<TemplateType>, shared_ptr<ValType>> mp;
|
|
for (size_t i = 0; i < types.size(); i++) {
|
|
mp[tt->c1[i]] = types[i];
|
|
}
|
|
auto vals = createVals();
|
|
bool legal = tt->c2.size() == vals.size();
|
|
if (legal) {
|
|
for (size_t i = 0; i < vals.size(); i++) {
|
|
if (!sameType(vals[i], function_replace(tt->c2[i], mp))) {
|
|
legal = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!legal) {
|
|
printf("error on line %d", tokens[pt - 1].line), exit(0);
|
|
}
|
|
t = function_replace(tt->c3, mp);
|
|
}
|
|
if (!preview(TokenType::DOT)) {
|
|
return t;
|
|
}
|
|
if (t->type() != ValType::STRUCT) {
|
|
printf("error on line %d", tokens[pt].line), exit(0);
|
|
}
|
|
pt++;
|
|
return _createVal(static_pointer_cast<StructType>(t));
|
|
}
|
|
|
|
vector<shared_ptr<ValType>> createVals() {
|
|
vector<shared_ptr<ValType>> vals;
|
|
jump(TokenType::LP);
|
|
if (!preview(TokenType::RP)) {
|
|
auto single = [&]() { vals.push_back(createVal()); };
|
|
for (single(); preview(TokenType::COMMA); pt++, single()) {}
|
|
}
|
|
jump(TokenType::RP);
|
|
return vals;
|
|
}
|
|
|
|
shared_ptr<ValType> _createType(shared_ptr<StructType> t) {
|
|
auto str = t->str;
|
|
auto s = jump(TokenType::ID);
|
|
if (str->structs.find(s) == str->structs.end()) {
|
|
printf("error on line %d", tokens[pt - 1].line), exit(0);
|
|
}
|
|
auto tt = make_shared<StructType>();
|
|
tt->str = str->structs[s], tt->mp = t->mp;
|
|
vector<shared_ptr<ValType>> types;
|
|
if (tt->str->c1.size() || preview(TokenType::LT)) {
|
|
types = createTypes();
|
|
}
|
|
if (tt->str->c1.size() != types.size()) {
|
|
printf("error on line %d", tokens[pt - 1].line), exit(0);
|
|
}
|
|
for (size_t i = 0; i < types.size(); i++) {
|
|
tt->mp[tt->str->c1[i]] = types[i];
|
|
}
|
|
if (!preview(TokenType::SCOPE)) {
|
|
return static_pointer_cast<ValType>(tt);
|
|
}
|
|
pt++;
|
|
return _createType(tt);
|
|
}
|
|
|
|
shared_ptr<ValType> createType() {
|
|
if (preview(TokenType::FN)) {
|
|
pt++;
|
|
auto t = make_shared<FunctionType>();
|
|
jump(TokenType::LP);
|
|
auto tems = createTems();
|
|
for (const auto& pr : tems) {
|
|
t->c1.push_back(pr.second);
|
|
}
|
|
jump(TokenType::COMMA);
|
|
t->c2 = createTypes();
|
|
jump(TokenType::COMMA);
|
|
t->c3 = createType();
|
|
jump(TokenType::RP);
|
|
for (const auto& pr : tems) {
|
|
ndefs.erase(pr.first);
|
|
}
|
|
return t;
|
|
}
|
|
shared_ptr<ValType> t;
|
|
if (preview(TokenType::TYPEOF)) {
|
|
pt++;
|
|
jump(TokenType::LP);
|
|
t = createVal();
|
|
jump(TokenType::RP);
|
|
} else {
|
|
auto s = jump(TokenType::ID);
|
|
if (ndefs.find(s) == ndefs.end() || ndefs[s]->type() == Def::VAR) {
|
|
printf("error on line %d", tokens[pt - 1].line), exit(0);
|
|
}
|
|
if (ndefs[s]->type() == Def::STRUCT) {
|
|
auto tt = make_shared<StructType>();
|
|
tt->str = static_pointer_cast<DefStruct>(ndefs[s])->def_struct;
|
|
vector<shared_ptr<ValType>> types;
|
|
if (tt->str->c1.size() || preview(TokenType::LT)) {
|
|
types = createTypes();
|
|
}
|
|
if (tt->str->c1.size() != types.size()) {
|
|
printf("error on line %d", tokens[pt - 1].line), exit(0);
|
|
}
|
|
for (size_t i = 0; i < types.size(); i++) {
|
|
tt->mp[tt->str->c1[i]] = types[i];
|
|
}
|
|
t = static_pointer_cast<ValType>(tt);
|
|
} else {
|
|
t = static_pointer_cast<ValType>(
|
|
static_pointer_cast<DefTemplate>(ndefs[s])->def_template);
|
|
}
|
|
}
|
|
if (!preview(TokenType::SCOPE)) {
|
|
return t;
|
|
}
|
|
if (t->type() != ValType::STRUCT) {
|
|
printf("error on line %d", tokens[pt].line), exit(0);
|
|
}
|
|
pt++;
|
|
return _createType(static_pointer_cast<StructType>(t));
|
|
}
|
|
|
|
vector<shared_ptr<ValType>> createTypes() {
|
|
vector<shared_ptr<ValType>> types;
|
|
jump(TokenType::LT);
|
|
if (!preview(TokenType::RT)) {
|
|
auto single = [&]() { types.push_back(createType()); };
|
|
for (single(); preview(TokenType::COMMA); pt++, single()) {}
|
|
}
|
|
jump(TokenType::RT);
|
|
return types;
|
|
}
|
|
|
|
vector<pair<int, shared_ptr<TemplateType>>> createTems() {
|
|
vector<pair<int, shared_ptr<TemplateType>>> tems;
|
|
jump(TokenType::LT);
|
|
if (preview(TokenType::ID)) {
|
|
auto single = [&]() {
|
|
auto s = jump(TokenType::ID);
|
|
if (ndefs.find(s) != ndefs.end()) {
|
|
printf("error on line %d", tokens[pt - 1].line), exit(0);
|
|
}
|
|
auto x = make_shared<TemplateType>();
|
|
auto d = make_shared<DefTemplate>();
|
|
d->def_template = x;
|
|
ndefs[s] = static_pointer_cast<Def>(d);
|
|
tems.push_back({s, x});
|
|
};
|
|
for (single(); preview(TokenType::COMMA); pt++, single()) {}
|
|
}
|
|
jump(TokenType::RT);
|
|
return tems;
|
|
}
|
|
|
|
vector<pair<int, shared_ptr<ValType>>> createPars(map<int, shared_ptr<ValType>>* vars) {
|
|
vector<pair<int, shared_ptr<ValType>>> pars;
|
|
jump(TokenType::LP);
|
|
if (!preview(TokenType::RP)) {
|
|
auto single = [&]() {
|
|
bool pub = 1;
|
|
if (preview(TokenType::PRIVATE)) {
|
|
pub = 0, pt++;
|
|
}
|
|
auto s = jump(TokenType::ID);
|
|
if (ndefs.find(s) != ndefs.end()) {
|
|
printf("error on line %d", tokens[pt - 1].line), exit(0);
|
|
}
|
|
jump(TokenType::COLON);
|
|
auto t = createType();
|
|
auto d = make_shared<DefVar>();
|
|
d->def_var = t;
|
|
ndefs[s] = static_pointer_cast<Def>(d);
|
|
pars.push_back({s, t});
|
|
if (vars != nullptr && pub) (*vars)[s]=t;
|
|
};
|
|
for (single(); preview(TokenType::COMMA); pt++, single()) {}
|
|
}
|
|
jump(TokenType::RP);
|
|
return pars;
|
|
}
|
|
|
|
pair<int, shared_ptr<Struct>> createStruct() {
|
|
jump(TokenType::STRUCT);
|
|
int s = 0;
|
|
vector<pair<int, shared_ptr<TemplateType>>> tems;
|
|
vector<pair<int, shared_ptr<ValType>>> pars;
|
|
auto t = make_shared<Struct>();
|
|
|
|
bool constructor = 1;
|
|
if (preview(TokenType::ID)) {
|
|
s = tokens[pt++].s;
|
|
if (preview(TokenType::LT)) {
|
|
tems = createTems();
|
|
}
|
|
if(preview({TokenType::LP,TokenType::DELETE})) {
|
|
constructor = 0;
|
|
pt += 2, jump(TokenType::RP);
|
|
} else {
|
|
pars = createPars(&t->vars);
|
|
}
|
|
}
|
|
for (const auto& pr : tems) {
|
|
t->c1.push_back(pr.second);
|
|
}
|
|
if(constructor) {
|
|
for (const auto& pr : pars) {
|
|
t->c2.push_back(pr.second);
|
|
}
|
|
} else {
|
|
static auto null_type = static_pointer_cast<ValType>(make_shared<TemplateType>());
|
|
t->c2.push_back(null_type);
|
|
}
|
|
|
|
jump(TokenType::LB);
|
|
vector<int> defs;
|
|
vector<shared_ptr<Struct>> subs;
|
|
while (!preview(TokenType::RB)) {
|
|
bool pub = 1;
|
|
if (preview(TokenType::PRIVATE)) {
|
|
pub = 0, pt++;
|
|
}
|
|
if (preview({TokenType::STRUCT, TokenType::ID})) {
|
|
auto tt = createStruct();
|
|
jump(TokenType::SEMI);
|
|
subs.push_back(tt.second);
|
|
defs.push_back(tt.first);
|
|
if (pub) {
|
|
t->structs[tt.first] = tt.second;
|
|
}
|
|
} else {
|
|
auto tt = createVar();
|
|
defs.push_back(tt.first);
|
|
if (pub) {
|
|
t->vars[tt.first] = tt.second;
|
|
}
|
|
}
|
|
}
|
|
jump(TokenType::RB);
|
|
|
|
for (auto str : subs) {
|
|
str->fa = t;
|
|
}
|
|
for (const auto& pr : tems) {
|
|
ndefs.erase(pr.first);
|
|
}
|
|
for (const auto& pr : pars) {
|
|
ndefs.erase(pr.first);
|
|
}
|
|
for (const auto& ss : defs) {
|
|
ndefs.erase(ss);
|
|
}
|
|
|
|
if (s) {
|
|
auto tt = make_shared<DefStruct>();
|
|
tt->def_struct = t;
|
|
ndefs[s] = static_pointer_cast<Def>(tt);
|
|
}
|
|
return {s, t};
|
|
}
|
|
|
|
pair<int, shared_ptr<ValType>> createVar() {
|
|
int s;
|
|
shared_ptr<ValType> t;
|
|
if (preview(TokenType::STRUCT)) {
|
|
auto pr = createStruct();
|
|
s = jump(TokenType::ID);
|
|
jump(TokenType::SEMI);
|
|
auto tt = make_shared<StructType>();
|
|
tt->str = pr.second;
|
|
t = static_pointer_cast<ValType>(tt);
|
|
} else {
|
|
s = jump(TokenType::ID);
|
|
jump(TokenType::ASSIGN);
|
|
t = createVal();
|
|
jump(TokenType::SEMI);
|
|
}
|
|
if (ndefs.find(s) != ndefs.end()) {
|
|
printf("error on line %d", tokens[pt - 1].line), exit(0);
|
|
}
|
|
auto d = make_shared<DefVar>();
|
|
d->def_var = t;
|
|
ndefs[s] = static_pointer_cast<Def>(d);
|
|
return {s, t};
|
|
}
|
|
|
|
void work(vector<Token> _tokens) {
|
|
tokens = _tokens;
|
|
createVar();
|
|
} |