// castExpr ::= 'int' '(' expr ')'
// | 'string' '(' expr ')'
// | 'bool' '(' expr ')'
std::unique_ptr<Expr> FlowParser::castExpr()
{
FNTRACE();
FlowLocation sloc(location());
FlowToken targetTypeToken = token();
nextToken();
if (!consume(FlowToken::RndOpen))
return nullptr;
std::unique_ptr<Expr> e(expr());
if (!consume(FlowToken::RndClose))
return nullptr;
if (!e)
return nullptr;
Opcode targetType = makeOperator(targetTypeToken, e.get());
if (targetType == Opcode::EXIT) {
reportError("Type cast error. No cast implementation found for requested cast from %s to %s.",
tos(e->getType()).c_str(), targetTypeToken.c_str());
return nullptr;
}
if (targetType == Opcode::NOP) {
return e;
}
printf("Type cast from %s to %s: %s\n", tos(e->getType()).c_str(), targetTypeToken.c_str(), mnemonic(targetType));
return std::make_unique<UnaryExpr>(targetType, std::move(e), sloc.update(end()));
}
std::unique_ptr<Expr> FlowParser::powExpr()
{
// powExpr ::= primaryExpr ('**' powExpr)*
FNTRACE();
FlowLocation sloc(location());
std::unique_ptr<Expr> left = primaryExpr();
if (!left)
return nullptr;
while (token() == FlowToken::Pow) {
nextToken();
std::unique_ptr<Expr> right = powExpr();
if (!right)
return nullptr;
auto opc = makeOperator(FlowToken::Pow, left.get(), right.get());
if (opc == Opcode::EXIT) {
reportError("Type error in binary expression (%s versus %s).",
tos(left->getType()).c_str(), tos(right->getType()).c_str());
return nullptr;
}
left = std::make_unique<BinaryExpr>(opc, std::move(left), std::move(right));
}
return left;
}
// compoundStmt ::= '{' varDecl* stmt* '}'
std::unique_ptr<Stmt> FlowParser::compoundStmt()
{
FNTRACE();
FlowLocation sloc(location());
nextToken(); // '{'
std::unique_ptr<CompoundStmt> cs = std::make_unique<CompoundStmt>(sloc);
while (token() == FlowToken::Var) {
if (std::unique_ptr<Variable> var = varDecl())
scope()->appendSymbol(std::move(var));
else
return nullptr;
}
for (;;) {
if (consumeIf(FlowToken::End)) {
cs->location().update(end());
return std::unique_ptr<Stmt>(cs.release());
}
if (std::unique_ptr<Stmt> s = stmt())
cs->push_back(std::move(s));
else
return nullptr;
}
}
std::unique_ptr<Stmt> FlowParser::ifStmt()
{
// ifStmt ::= 'if' expr ['then'] stmt ['else' stmt]
FNTRACE();
FlowLocation sloc(location());
consume(FlowToken::If);
std::unique_ptr<Expr> cond(expr());
consumeIf(FlowToken::Then);
std::unique_ptr<Stmt> thenStmt(stmt());
if (!thenStmt)
return nullptr;
std::unique_ptr<Stmt> elseStmt;
if (consumeIf(FlowToken::Else)) {
elseStmt = std::move(stmt());
if (!elseStmt) {
return nullptr;
}
}
return std::make_unique<CondStmt>(std::move(cond),
std::move(thenStmt), std::move(elseStmt), sloc.update(end()));
}
std::unique_ptr<Expr> FlowParser::interpolatedStr()
{
FNTRACE();
FlowLocation sloc(location());
std::unique_ptr<Expr> result = std::make_unique<StringExpr>(stringValue(), sloc.update(end()));
nextToken(); // interpolation start
std::unique_ptr<Expr> e(expr());
if (!e)
return nullptr;
result = asString(std::move(result));
if (!result) {
reportError("Cast error in string interpolation.");
return nullptr;
}
while (token() == FlowToken::InterpolatedStringFragment) {
FlowLocation tloc = sloc.update(end());
result = std::make_unique<BinaryExpr>(
Opcode::SADD,
std::move(result),
std::make_unique<StringExpr>(stringValue(), tloc)
);
nextToken();
e = expr();
if (!e)
return nullptr;
e = asString(std::move(e));
if (!e) {
reportError("Cast error in string interpolation.");
return nullptr;
}
result = std::make_unique<BinaryExpr>(Opcode::SADD, std::move(result), std::move(e));
}
if (!consume(FlowToken::InterpolatedStringEnd))
return nullptr;
if (!stringValue().empty()) {
result = std::make_unique<BinaryExpr>(
Opcode::SADD,
std::move(result),
std::make_unique<StringExpr>(stringValue(), sloc.update(end()))
);
}
nextToken();
return result;
}
// }}}
// {{{ stmt
std::unique_ptr<Stmt> FlowParser::stmt()
{
FNTRACE();
switch (token()) {
case FlowToken::If:
return ifStmt();
case FlowToken::Begin:
return compoundStmt();
case FlowToken::Ident:
return callStmt();
case FlowToken::Semicolon: {
FlowLocation sloc(location());
nextToken();
return std::make_unique<CompoundStmt>(sloc.update(end()));
}
default:
reportError("Unexpected token '%s'. Expected a statement instead.", token().c_str());
return nullptr;
}
}
void ReinitEden()
{
OurGrid & mainGrid = GetGrid();
OurStatsRenderer & srend = GetStatsRenderer();
OurAtom atom(Element_Dreg<OurCoreConfig>::THE_INSTANCE.GetDefaultAtom());
OurAtom sorter(Element_Sorter<OurCoreConfig>::THE_INSTANCE.GetDefaultAtom());
OurAtom emtr(Element_Emitter<OurCoreConfig>::THE_INSTANCE.GetDefaultAtom());
OurAtom cnsr(Element_Consumer<OurCoreConfig>::THE_INSTANCE.GetDefaultAtom());
m_sortingSlots[0].Set(mainGrid, "Data in",
Element_Emitter<OurCoreConfig>::THE_INSTANCE.GetType(),
Element_Emitter<OurCoreConfig>::DATUMS_EMITTED_SLOT,
Element_Emitter<OurCoreConfig>::DATA_SLOT_COUNT,
true);
m_sortingSlots[1].Set(mainGrid, "Overflow",
Element_Emitter<OurCoreConfig>::THE_INSTANCE.GetType(),
Element_Emitter<OurCoreConfig>::DATUMS_REJECTED_SLOT,
Element_Emitter<OurCoreConfig>::DATA_SLOT_COUNT,
true);
m_sortingSlots[2].Set(mainGrid, "Data out",
Element_Consumer<OurCoreConfig>::THE_INSTANCE.GetType(),
Element_Consumer<OurCoreConfig>::DATUMS_CONSUMED_SLOT,
Element_Consumer<OurCoreConfig>::DATA_SLOT_COUNT,
true);
m_sortingSlots[3].Set(mainGrid, "Sort error",
Element_Consumer<OurCoreConfig>::THE_INSTANCE.GetType(),
Element_Consumer<OurCoreConfig>::TOTAL_BUCKET_ERROR_SLOT,
Element_Consumer<OurCoreConfig>::DATA_SLOT_COUNT,
true);
for (u32 i = 0; i < 4; ++i)
srend.DisplayDataReporter(&m_sortingSlots[i]);
// sorter.SetStateField(0,32,DATA_MINVAL + ((DATA_MAXVAL - DATA_MINVAL) / 2)); // Default threshold
sorter.SetStateField(0,32, DATA_MINVAL); // Default threshold
u32 realWidth = P::TILE_WIDTH - P::EVENT_WINDOW_RADIUS * 2;
SPoint aloc(20, 30);
SPoint sloc(20, 10);
SPoint eloc(GRID_WIDTH*realWidth-2, GRID_HEIGHT*realWidth/2);
SPoint cloc(0, GRID_HEIGHT*realWidth/2);
for(u32 x = 0; x < mainGrid.GetWidth(); x++)
{
for(u32 y = 0; y < mainGrid.GetHeight(); y++)
{
for(u32 z = 0; z < 4; z++)
{
aloc.Set(10 + x * realWidth + z, 14 + y * realWidth);
sloc.Set(11 + x * realWidth + z, 15 + y * realWidth);
mainGrid.PlaceAtom(sorter, sloc);
mainGrid.PlaceAtom(atom, aloc);
}
}
}
mainGrid.PlaceAtom(emtr, eloc);
mainGrid.PlaceAtom(cnsr, cloc);
}
void symboltable::check_types() const
{
s_ptr<typecontext> global(new typecontext());
ltypecontext c(global);
substitution s;
std::map<sid, s_ptr<const sl_polytype_exists>> init_types;
for(size_t i = 0; i < index.size(); i++)
if(index[i].t == symbolref::t_var || index[i].t == symbolref::t_fun)
{
const s_ptr<const sl_polytype_exists> t(new sl_polytype_exists());
init_types[i] = t;
c.register_type(i, std::static_pointer_cast<const sl_polytype>(t));
}
for(const sid i : select_all(symbolref::symbolreftype::t_construct))
s = conss[index[i].i]->declare_type(c).composite(s);
ltypecontext corig = c;
for(const sid i : select_all(symbolref::symbolreftype::t_var))
{
ltypecontext ctmp = corig;
s = vars[index[i].i]->declare_type(ctmp).composite(s);
c.register_type(i, ctmp[i]); //Copy result from ctmp to c;
}
for(const sid i : select_all(symbolref::symbolreftype::t_fun))
{
ltypecontext ctmp = corig;
s = funs[index[i].i]->declare_type(ctmp).composite(s);
c.register_type(i, ctmp[i]); //Copy result from ctmp to c;
}
std::vector<sid> prop_index;
for(const std::pair<sid, s_ptr<const sl_polytype_exists>> p : init_types)
prop_index.push_back(p.first);
while(!prop_index.empty())
{
bool changed = false;
for(size_t i = 0; i < prop_index.size(); i++)
{
const s_ptr<const sl_polytype_exists> t = init_types[prop_index[i]];
std::vector<s_ptr<const sl_type_unbound>> blacklist;
for(size_t j = 0; j < prop_index.size(); j++)
if(i != j)
for(const auto tmp : init_types[prop_index[j]]->fetch_bindings())
add_to<s_ptr<const sl_type_unbound>>(tmp->apply(s)->tv(), blacklist);
if(any_is_in_ptr<const sl_type_unbound>(std::dynamic_pointer_cast<const sl_polytype_forall>(c[prop_index[i]])->unbind_maintain()->apply(s)->tv(), blacklist))
continue;
s = t->propagate_findings(c, c[prop_index[i]]->apply(c, s), s);
prop_index.erase(prop_index.begin()+i);
i--;
changed = true;
break;
}
if(!prop_index.empty() && !changed)
{
for(size_t i = 0; i < prop_index.size(); i++)
{
print_name(prop_index[i], std::cout << std::endl);
for(const auto t : std::dynamic_pointer_cast<const sl_polytype_forall>(c[prop_index[i]])->unbind_maintain()->apply(s)->tv())
t->print(std::cout << ' ');
}
throw std::runtime_error("Cyclic dependency in definitions, cannot infer type");
}
}
for(const sid i : select_all(symbolref::symbolreftype::t_type))
c.register_type(i, sl_polytype::not_qualify(c.create_fresh(sloc())));
typecontext gtmp = global->apply_maintain(s);
substitution stmp;
for(const sid i : select_all(symbolref::symbolreftype::t_var))
{
gtmp = gtmp.apply(stmp);
stmp = vars[index[i].i]->fetch_assigned_type(gtmp)->unify(gtmp[i]->unbind(gtmp)).composite(stmp);
}
for(const sid i : select_all(symbolref::symbolreftype::t_fun))
{
gtmp = gtmp.apply(stmp);
stmp = funs[index[i].i]->fetch_assigned_type(gtmp)->unify(gtmp[i]->unbind(gtmp)).composite(stmp);
}
for(const sid i : select_all(symbolref::symbolreftype::t_arg))
{
gtmp = gtmp.apply(stmp);
stmp = args[index[i].i]->fetch_assigned_type(gtmp)->unify(gtmp[i]->unbind(gtmp)).composite(stmp);
}
for(const sid i : select_all(symbolref::symbolreftype::t_local_var))
{
gtmp = gtmp.apply(stmp);
stmp = local_vars[index[i].i]->fetch_assigned_type(gtmp)->unify(gtmp[i]->unbind(gtmp)).composite(stmp);
}
print(global->apply_maintain(stmp.composite(s)), std::cout << "Typecontext final: " << std::endl);
}
