void OpOr::Apply(Expression *expression, Calculator *calculator, int32 recursions)
{
bool allBools(true);
bool result(false);
for(ExprVector::iterator leaf = expression->Leaves().begin(); leaf != expression->Leaves().end(); )
{
(*leaf)->Evaluate(calculator, recursions);
string symbolName = (*leaf)->SymbolName();
// All false values can be deleted from the leaves list
if(symbolName == "False")
{
expression->DeleteLeaf(leaf);
// Need not increment iterator
}
else if(symbolName == "True")
{
result = true;
break;
}
else
{
allBools = false;
++leaf;
}
}
if(result)
expression->MoveNotCloned(ExprPtr(new Expression("True")));
else if(allBools)
expression->MoveNotCloned(ExprPtr(new Expression("False")));
else
expression->ApplyOneIdentity();
}
void Not::Apply(Expression *expression, Calculator *calculator, int32 recursions)
{
if(expression->LeafCount() != 1)
throw ArgumentException("Not expects 1 argument.");
if(expression->Leaf(0)->SymbolName() == "True")
expression->MoveNotCloned(ExprPtr(new Expression("False")));
else if(expression->Leaf(0)->SymbolName() == "False")
expression->MoveNotCloned(ExprPtr(new Expression("True")));
}
ExprPtr Parser::patternMatch(bool se)
{
expect(TCase);
auto const& value = primaryExpression(false);
expect(TLBrace);
IntrusiveRefCntPtr<MatchExpr> matchExpr(new MatchExpr(value));
do
{
if(token == TTypeIdent || token == TIdent) // TODO: firstPattern set
{
enterScope(new Scope);
auto pt = pattern(false);
// TODO: Allow pattern = expr
auto body = exitScope<Expr>(block(true));
matchExpr->legs.push_back(MatchLeg(pt, body));
}
}
while(test(TSemicolon));
expect(TRBrace, se);
return ExprPtr(matchExpr.getPtr()); // TEMP
}
ExprPtr MatchSingleNonRejectExpr::resolve(ModuleBuilder& modBuilder)
{
value = value->doResolve(modBuilder);
pattern->doResolve(modBuilder, value->type);
type = tyUnit;
return ExprPtr(this);
}
ExprPtr ModuleBuilder::resolveIdent(string const& name)
{
auto i = module->functions.find(name);
if(i != module->functions.end())
return ExprPtr(new FuncRefExpr(i->second));
// Check imports
for(auto const& imp : imports)
{
auto t = imp->module->functions.find(name);
if(t != imp->module->functions.end())
{
return ExprPtr(new FuncRefExpr(t->second));
}
}
return ExprPtr();
}
ExprPtr Parser::statements()
{
unique_ptr<SeqExpr> seq(inScope(new SeqExpr()));
do
{
#if 0 // TODO. Disabled until we know how to handle return
if (test(TReturn))
{
seq->expressions.push_back(ExprPtr(inScope(
new ReturnExpr(expression(true)))));
break; // Return must be the last statement in a statement list
}
#endif
statement(*seq);
}
while(test(TSemicolon));
return ExprPtr(seq.release());
}
ExprPtr CreateExpr::resolve(ModuleBuilder& modBuilder)
{
for(auto& p : parameters)
p = p->doResolve(modBuilder);
ctor->doResolve(modBuilder);
// ctor->type will be a non-applied type.
type = ctor->type;
return ExprPtr(this);
}
ExprPtr Parser::controlSeqExpression(bool se)
{
if(test(TIf))
{
auto ifExpr = enterScope<IfExpr>(new IfExpr);
ifExpr->cond = expression(false);
enterScope(new Scope);
ifExpr->trueCase = exitScope<Expr>(controlSeqExpression(se));
exitScope<IfExpr>(ExprPtr());
ExprPtr ret = ifExpr;
if(test(TElse))
{
enterScope(new Scope);
auto falseCase = exitScope<Expr>(controlSeqExpression(se));
ret = inScope(new IfElseExpr(ifExpr, falseCase));
}
return ret;
}
/* TODO
else if (Test(Token.While))
{
var whileExpr = EnterScopeT<WhileExpr>();
whileExpr.Cond = Expression(false);
whileExpr.Body = ControlSeqExpression(se);
ExitScopeT<WhileExpr>(null);
return whileExpr;
}*/
else if(token == TLBrace)
{
return block(se);
}
assert(false);
return ExprPtr();
}
void OpHead::Apply(Expression *expression, Calculator *calculator, int32 recursions)
{
if(expression->LeafCount() != 1)
throw ArgumentException("Head expects 1 argument.");
Expression *leaf = expression->Leaf(0);
if(leaf->IsAtom())
{
Atom *atom = leaf->AtomHead();
expression->MoveNotCloned(ExprPtr(new Expression(atom->AtomName())));
}
else
{
ExprPtr head(leaf->Head()->Clone());
expression->MoveNotCloned(head);
}
}
void Parser::varDecl(SeqExpr& seqExpr, bool se)
{
expect(TLet);
do
{
auto const& pat = pattern(false);
expect(TEqual);
auto const& val = expression(se);
seqExpr.expressions.push_back(
ExprPtr(new MatchSingleNonRejectExpr(val, pat)));
}
while(test(TComma));
}
ExprPtr MatchExpr::resolve(ModuleBuilder& modBuilder)
{
value = value->doResolve(modBuilder);
for(auto& leg : legs)
{
leg.pattern->doResolve(modBuilder, value->type);
leg.body = leg.body->doResolve(modBuilder);
if(! type)
type = leg.body->type;
else
type = type->commonWith(leg.body->type);
}
return ExprPtr(this);
}
SharedSurfaceInfo::SharedSurfaceInfo(Rect2d region, Vec2i dicing):
region(region),
dicing(dicing),
vtx_buf_id(0),
idx_buf_id(0),
valid(false){
//do nothing else
}
SharedSurfaceInfo::~SharedSurfaceInfo(){
//todo: don't know what happens if OpenGL context isn't valid
this->release();
}
VisSurface::VisSurface(ExprPtr(Vec2d,Vec3d) surface):
surface(surface),
sharedInfo(new SharedSurfaceInfo(Rect2d(ZERO_VEC2d, ONE_VEC2d), Vec2i(64,64))){
//do nothing else
}
VisSurface::VisSurface(ExprPtr(Vec2d,Vec3d) surface, Rect2d region, Vec2i divisions):
surface(surface),
sharedInfo(new SharedSurfaceInfo(region, divisions)){
//do nothing else
}
VisSurface::~VisSurface() {
//do nothing: resource deallocation handled by shared_ptrs
}
ExpressionStatement::ExpressionStatement(Expression* expression)
: ExpressionStatement(ExprPtr(expression)) {
}
void Parser::constructor(string const& name, IntrusiveRefCntPtr<TypeDef> type, TypePtr const& typeRef)
{
IntrusiveRefCntPtr<TypeConstructor> ctor(new TypeConstructor(name));
type->constructors.push_back(ctor);
ctor->type = typeRef;
expect(TLParen);
if(token != TRParen)
{
do
{
bool isLet = test(TLet);
string name;
// TODO: Common pattern?
TypePtr type = maybeType(false);
if(! type)
{
name = expectIdent();
type = typeName(false);
}
ctor->members.push_back(TypeMember(name, type));
++ctor->ctorParams;
}
while(test(TComma));
}
{
string const& ctorName = name;
// Constructor function
IntrusiveRefCntPtr<FuncDef> ctorFunc(new FuncDef(ctorName));
enterFunction(ctorFunc);
enterScope(new Scope);
// Constructor function has the same type parameters
for(auto& p : type->typeParams)
ctorFunc->typeParams.push_back(p);
int dummy = 0;
IntrusiveRefCntPtr<CreateExpr> body(new CreateExpr());
body->ctor = ctor;
for(int i = 0; i < ctor->ctorParams; ++i)
{
auto& member = ctor->members[i];
auto p = declParam(ctorFunc, member.name, member.type->fresh(), &dummy);
body->parameters.push_back(ExprPtr(new VarRef(p)));
}
ctorFunc->body = exitScope<Expr>(body);
ctorFunc->returnType = typeRef;
// TODO: Check for name collision
mod->functions[ctorName] = ctorFunc;
mod->constructorDefs[ctorName] = ctor;
exitFunction();
}
expect(TRParen, true);
}
