protected override void StateStarted()
{
Game.RenderSystem.Window.Clear();
Window win = new Window(Game.RenderSystem.Window);
win.Title = "Dungeon1";
MapStack ms = new MapStack(new Size(30, 30), 100, 100, "Map", Game.RenderSystem.Window);
}
protected override void StateStarted()
{
Game.RenderSystem.Window.Focus();
map = new MapStack(Game.RenderSystem.Window.Size, 20, 15, "SandboxMap", Game.RenderSystem.Window);
map.AddPage(new BuildingPage(map.PageSize), new Vector3(0, 0, 0));
hacker = new PlayerEntity(map);
hacker.Location = new Vector3(10, 8, 0);
map.ViewFrom(hacker);
Game.InputSystem.Command.CommandSet = "World";
}
private MSOFormula<BDD> ConvertEq(MonaExpr t1, MonaExpr t2, MapStack<string, MonaParam> locals)
{
if (t1.type == MonaExprType.INT)
{
MSOFormula<BDD> psi_x;
Variable x = ConvertTerm1(t1, locals, out psi_x);
MSOFormula<BDD> psi_y;
Variable y = ConvertTerm1(t2, locals, out psi_y);
return AddConstraints(psi_x, x, psi_y, y, new MSOEq<BDD>(x, y));
}
else
{
MSOFormula<BDD> psi_x;
Variable x = ConvertTerm2(t1, locals, out psi_x);
MSOFormula<BDD> psi_y;
Variable y = ConvertTerm2(t2, locals, out psi_y);
return AddConstraints(psi_x, x, psi_y, y, new MSOEq<BDD>(x, y));
}
}
internal override void TypeCheck(Dictionary<string, MonaDecl> glob, MapStack<string, MonaParam> loc)
{
if (univs != null)
foreach (var u in univs)
{
MonaDecl d;
if (!glob.TryGetValue(u.text, out d))
throw new MonaParseException(MonaParseExceptionKind.UndeclaredIdentifier, u.Location, u.text);
if (d.kind != MonaDeclKind.universe)
throw new MonaParseException(MonaParseExceptionKind.InvalidUniverseReference, u.Location, u.text);
}
MonaParamKind paramkind = (this.kind == MonaDeclKind.var1 ? MonaParamKind.var1 : MonaParamKind.var2);
foreach (var vw in vars)
if (vw.where != null)
vw.where.TypeCheck(glob, loc.Push(vw.name, new MonaVarParam(vw, paramkind)));
}
internal override void TypeCheck(Dictionary<string, MonaDecl> globals, MapStack<string, MonaParam> locals)
{
arg1.TypeCheck(globals, locals);
arg2.TypeCheck(globals, locals);
switch (kind)
{
case MonaSetOpKind.INTER:
case MonaSetOpKind.SETMINUS:
case MonaSetOpKind.UNION:
{
if (arg1.type != MonaExprType.SET)
throw new MonaParseException(MonaParseExceptionKind.TypeMismatch, arg1.symbol.Location, string.Format("expecting SET not {0}", arg1.type.ToString()));
if (arg2.type != MonaExprType.SET)
throw new MonaParseException(MonaParseExceptionKind.TypeMismatch, arg2.symbol.Location, string.Format("expecting SET not {0}", arg2.type.ToString()));
return;
}
default:
{
if (arg1.type != MonaExprType.SET)
throw new MonaParseException(MonaParseExceptionKind.TypeMismatch, arg1.symbol.Location, string.Format("expecting SET not {0}", arg1.type.ToString()));
if (arg2.type != MonaExprType.INT)
throw new MonaParseException(MonaParseExceptionKind.TypeMismatch, arg2.symbol.Location, string.Format("expecting INT not {0}", arg2.type.ToString()));
return;
}
}
}
internal override void TypeCheck(Dictionary<string, MonaDecl> globals, MapStack<string, MonaParam> locals)
{
foreach (var e in elems)
{
e.TypeCheck(globals, locals);
}
}
static void Main()
{
Game.Initialize(".");
AbstractWindow gwin;
String glyphPath = Game.PathTo("curses_640x300.png");
using (Stream imgstream = File.OpenRead(glyphPath))
{
GlyphPalette pal = new GlyphPalette(imgstream, 16, 16);
Int32 width = 80 * pal.GlyphDimensions.Width;
Int32 height = 25 * pal.GlyphDimensions.Height;
try
{
Game.SetRenderSystem("OpenTK");
gwin = Game.RenderSystem.CreateWindow(new Size(width, height), pal);
Game.SetInputSystem("OpenTK");
}
catch (System.NullReferenceException e)
{
Console.WriteLine("Error when loading plugin: " + e.Message + "\n" + e.Source);
return;
}
}
Game.InputSystem.LoadConfiguration(Game.PathTo("commands.ini"));
gwin.Clear();
map = new MapStack(Game.RenderSystem.Window.WindowSize, 20, 15, "SandboxMap");
map.AddPage(new YellowWallPage(map.PageSize), new Vector3(0, 0, 0));
map.AddPage(new YellowWallPage(map.PageSize), new Vector3(1, 0, 0));
map.AddPage(new YellowWallPage(map.PageSize), new Vector3(0, 1, 0));
map.AddPage(new YellowWallPage(map.PageSize), new Vector3(1, 1, 0));
map.AddPage(new YellowWallPage(map.PageSize), new Vector3(-1, 0, 0));
map.AddPage(new YellowWallPage(map.PageSize), new Vector3(1, 1, 1));
map.AddPage(new YellowWallPage(map.PageSize), new Vector3(-1, 0, 1));
cache = new ZColdCachingAlgorithm(map);
ent = new WanderingEntity();
ent.Location = new Vector3(2, 2, 0);
ent.Map = map;
gwin.AddRegion(map);
Sharplike.UI.Controls.Label l = new UI.Controls.Label(new Size(50, 1), new Point(0, 0));
l.Text = "Label on the map.";
map.AddRegion(l);
Sharplike.UI.Controls.Window win = new UI.Controls.Window(new Size(20, 10), new Point(5, 5));
win.Title = "Dialog Window";
win.BackgroundColor = Color.FromArgb(100, 0, 0, 200);
map.AddRegion(win);
Game.OnGameInitialization += new EventHandler <EventArgs>(game_OnGameInitialization);
Game.GameProcessing += new EventHandler <EventArgs>(game_GameProcessing);
StepwiseGameLoop loop = new StepwiseGameLoop(RunGame);
Game.Run(loop);
Game.Terminate();
}
private MSOFormula<BDD> ConvertIsEmpty(MonaExpr set, MapStack<string, MonaParam> locals)
{
MSOFormula<BDD> psi_X;
Variable X = ConvertTerm2(set, locals, out psi_X);
MSOFormula<BDD> isempty = new MSOIsEmpty<BDD>(X);
if (psi_X != null)
isempty = new MSOExists<BDD>(X, new MSOAnd<BDD>(psi_X, isempty));
return isempty;
}
internal override void TypeCheck(Dictionary<string, MonaDecl> globals, MapStack<string, MonaParam> locals)
{
foreach (var let in lets)
{
let.Item2.TypeCheck(globals, locals);
if (let.Item2.type != letType)
throw new MonaParseException(MonaParseExceptionKind.TypeMismatch, let.Item2.symbol.Location, let.Item2.symbol.text);
}
formula.TypeCheck(globals, locals.Push(let_vars));
}
internal abstract void TypeCheck(Dictionary<string, MonaDecl> globals, MapStack<string, MonaParam> locals);
private Variable ConvertUnion(MonaExpr set1, MonaExpr set2, MapStack<string, MonaParam> locals, out MSOFormula<BDD> pred)
{
MSOFormula<BDD> psi1;
var X1 = ConvertTerm2(set1, locals, out psi1);
MSOFormula<BDD> psi2;
var X2 = ConvertTerm2(set2, locals, out psi2);
var X = MkNewVar2();
var x = MkNewVar1();
MSOFormula<BDD> union = new MSOForall<BDD>(x,
new MSOEquiv<BDD>(new MSOIn<BDD>(x, X),
new MSOOr<BDD>(new MSOIn<BDD>(x, X1),
new MSOIn<BDD>(x, X2))));
pred = AddConstraints(psi2, X2, psi1, X1, union);
return X;
}
/// <summary>
/// If t is a variable name then returns t as a f-o variable and sets psi=null.
/// Else returns a fresh f-o variable x and outputs psi(x) s.t. psi(x) iff x=t.
/// </summary>
Variable ConvertTerm1(MonaExpr t, MapStack<string, MonaParam> locals, out MSOFormula<BDD> psi)
{
switch (t.symbol.Kind)
{
case Tokens.NAME:
{
MonaParam p;
if (locals.TryGetValue(t.symbol.text, out p))
{
if (p.kind == MonaParamKind.var1)
{
psi = null;
return new Variable(t.symbol.text, true);
}
else
throw new NotImplementedException(t.ToString());
}
else
{
MonaDecl d;
if (globals.TryGetValue(t.symbol.text, out d))
{
if (d.kind == MonaDeclKind.constant)
{
int n = ((MonaConstDecl)d).def.ToInt(globals);
Variable x = MkNewVar1();
var pred = new MSOeqN<BDD>(x, n);
psi = pred;
return x;
}
else if (d.kind == MonaDeclKind.var1)
{
psi = null;
return new Variable(t.symbol.text, true);
}
else
throw new NotImplementedException(t.ToString());
}
else
throw new NotImplementedException(t.ToString());
}
}
case Tokens.PLUS:
{
Variable y = MkNewVar1();
if (t[0].symbol.Kind == Tokens.NAME)
{
int n = t[1].ToInt(globals);
Variable x = new Variable(t[0].symbol.text, true);
psi = new MSOSuccN<BDD>(x, y, n); // y = x + n
}
else
{
int n = t.ToInt(globals);
psi = new MSOeqN<BDD>(y, n); // y = n
}
return y;
}
case Tokens.MIN:
{
MSOFormula<BDD> X_psi;
Variable X = ConvertTerm2(t[0], locals, out X_psi);
Variable x = MkNewVar1();
MSOFormula<BDD> min = new MSOMin<BDD>(x, X);
if (X_psi != null)
min = new MSOExists<BDD>(X, new MSOAnd<BDD>(X_psi, min));
psi = min;
return x;
}
case Tokens.MAX:
{
MSOFormula<BDD> X_psi;
Variable X = ConvertTerm2(t[0], locals, out X_psi);
Variable x = MkNewVar1();
MSOFormula<BDD> max = new MSOMax<BDD>(x, X);
if (X_psi != null)
max = new MSOExists<BDD>(X, new MSOAnd<BDD>(X_psi, max));
psi = max;
return x;
}
case Tokens.NUMBER:
{
Variable x = MkNewVar1();
int num = t.symbol.ToInt();
psi = new MSOeqN<BDD>(x,num);
return x;
}
default:
throw new NotImplementedException(t.ToString());
}
}
/// <summary>
/// If t is a variable name then returns t as a s-o variable and sets psi=null.
/// Else returns a fresh s-o variable X and outputs psi(X) s.t. psi(X) iff X=t.
/// </summary>
private Variable ConvertTerm2(MonaExpr t, MapStack<string, MonaParam> locals, out MSOFormula<BDD> psi)
{
switch (t.symbol.Kind)
{
case Tokens.NAME:
{
psi = null;
return new Variable(t.symbol.text, false);
}
case Tokens.INTER:
return ConvertInter(t[0], t[1], locals, out psi);
case Tokens.UNION:
return ConvertUnion(t[0], t[1], locals, out psi);
case Tokens.SETMINUS:
return ConvertSetminus(t[0], t[1], locals, out psi);
case Tokens.EMPTY:
return ConvertEmptyset(out psi);
case Tokens.LBRACE:
return ConvertSet(t, locals, out psi);
default:
throw new NotImplementedException(t.ToString());
}
}
private MSOFormula<BDD> ConvertSubset(MonaExpr t1, MonaExpr t2, MapStack<string, MonaParam> locals)
{
MSOFormula<BDD> psi_x;
Variable x = ConvertTerm2(t1, locals, out psi_x);
MSOFormula<BDD> psi_y;
Variable y = ConvertTerm2(t2, locals, out psi_y);
return AddConstraints(psi_x, x, psi_y, y, new MSOSubset<BDD>(x, y));
}
private Variable ConvertSet(MonaExpr set, MapStack<string, MonaParam> locals, out MSOFormula<BDD> psi)
{
if (set.NrOfSubexprs == 0)
return ConvertEmptyset(out psi);
MSOFormula<BDD> disj = null;
Variable x = MkNewVar1();
Variable X = MkNewVar2();
for (int i=0; i < set.NrOfSubexprs; i++)
{
MonaExpr t = set[i];
if (t.symbol.Kind == Tokens.RANGE)
{
MSOFormula<BDD> from_psi;
Variable from = ConvertTerm1(t[0], locals, out from_psi);
MSOFormula<BDD> to_psi;
Variable to = ConvertTerm1(t[1], locals, out to_psi);
MSOFormula<BDD> range = AddConstraints(from_psi, from, to_psi, to,
new MSOAnd<BDD>(new MSOLe<BDD>(from, x), new MSOLe<BDD>(x, to)));
if (disj == null)
disj = range;
else
disj = new MSOOr<BDD>(disj, range);
}
else
{
MSOFormula<BDD> y_psi;
Variable y = ConvertTerm1(t, locals, out y_psi);
MSOFormula<BDD> elem = new MSOEq<BDD>(x, y);
if (y_psi != null)
elem = new MSOExists<BDD>(y, new MSOAnd<BDD>(y_psi, elem));
if (disj == null)
disj = elem;
else
disj = new MSOOr<BDD>(disj, elem);
}
}
var pred = new MSOForall<BDD>(x, new MSOEquiv<BDD>(new MSOIn<BDD>(x, X), disj));
psi = pred;
return X;
}
private MSOFormula<BDD> ConvertPredApp(MonaPredApp predApp, MapStack<string, MonaParam> locals)
{
var predDef = predMap[predApp.symbol.text];
var predDecl = (MonaPredDecl)globals[predApp.symbol.text];
int k = predDecl.parameters.Count;
if (k != predApp.NrOfSubexprs)
throw new ArgumentException("invalid call of " + predDecl.name);
if (k == 0)
return predDef;
var newVars = new Variable[k];
Dictionary<string, Variable> substitution = new Dictionary<string, Variable>();
var argPreds = new MSOFormula<BDD>[k];
var argVars = new Variable[k];
for (int i = 0; i < k; i++)
{
if (predDecl.parameters[i].kind != MonaParamKind.var1 && predDecl.parameters[i].kind != MonaParamKind.var2)
throw new NotImplementedException("parameter kind " + predDecl.parameters[i].kind.ToString());
MSOFormula<BDD> argPreds_i;
Variable argVars_i;
if (predDecl.parameters[i].kind == MonaParamKind.var1)
{
argVars_i = ConvertTerm1(predApp[i], locals, out argPreds_i);
if (argPreds_i == null)
{
var tmp1 = MkNewVar1();
argPreds_i = new MSOEq<BDD>(tmp1, argVars_i);
argVars_i = tmp1;
}
}
else
{
argVars_i = ConvertTerm2(predApp[i], locals, out argPreds_i);
if (argPreds_i == null)
{
var tmp2 = MkNewVar2();
argPreds_i = new MSOEq<BDD>(tmp2, argVars_i);
argVars_i = tmp2;
}
}
argPreds[i] = argPreds_i;
argVars[i] = argVars_i;
substitution[predDecl.parameters[i].Token.text] = argVars_i;
}
MSOFormula<BDD> psi = predDef.SubstituteVariables(substitution);
for (int i = k - 1; i >= 0; i--)
psi = new MSOExists<BDD>(argVars[i], argPreds[i] & psi);
return psi;
}
internal override void TypeCheck(Dictionary<string, MonaDecl> globals, MapStack<string, MonaParam> locals)
{
term1.TypeCheck(globals, locals);
term2.TypeCheck(globals, locals);
switch (symbol.Kind)
{
case Tokens.GE:
case Tokens.LE:
case Tokens.LT:
case Tokens.GT:
{
if (term1.type != MonaExprType.INT)
throw new MonaParseException(MonaParseExceptionKind.TypeMismatch, term1.symbol.Location, string.Format("expecting INT not {0}", term1.type.ToString()));
if (term2.type != MonaExprType.INT)
throw new MonaParseException(MonaParseExceptionKind.TypeMismatch, term2.symbol.Location, string.Format("expecting INT not {0}", term2.type.ToString()));
return;
}
case Tokens.EQ:
case Tokens.NE:
{
if (term1.type != term2.type)
throw new MonaParseException(MonaParseExceptionKind.TypeMismatch, term2.symbol.Location, string.Format("expecting {0} not {1}", term1.type.ToString(), term2.type.ToString()));
return;
}
case Tokens.IN:
case Tokens.NOTIN:
{
if (term1.type != MonaExprType.INT)
throw new MonaParseException(MonaParseExceptionKind.TypeMismatch, term1.symbol.Location, string.Format("expecting INT not {0}", term1.type.ToString()));
if (term2.type != MonaExprType.SET)
throw new MonaParseException(MonaParseExceptionKind.TypeMismatch, term2.symbol.Location, string.Format("expecting SET not {0}", term2.type.ToString()));
return;
}
case Tokens.SUBSET:
{
if (term1.type != MonaExprType.SET)
throw new MonaParseException(MonaParseExceptionKind.TypeMismatch, term1.symbol.Location, string.Format("expecting SET not {0}", term1.type.ToString()));
if (term2.type != MonaExprType.SET)
throw new MonaParseException(MonaParseExceptionKind.TypeMismatch, term2.symbol.Location, string.Format("expecting SET not {0}", term2.type.ToString()));
return;
}
default:
throw new MonaParseException(MonaParseExceptionKind.InternalError, symbol.Location, string.Format("unexpected token '{0}'", symbol.text));
}
}
private MSOFormula<BDD> ConvertEq(bool fo, MonaExpr t1, MonaExpr t2, MapStack<string, MonaParam> locals)
{
MSOFormula<BDD> psi_x;
Variable x = (fo ? ConvertTerm1(t1, locals, out psi_x) : ConvertTerm2(t1, locals, out psi_x));
MSOFormula<BDD> psi_y;
Variable y = (fo ? ConvertTerm1(t2, locals, out psi_y) : ConvertTerm2(t1, locals, out psi_y));
return AddConstraints(psi_x, x, psi_y, y, new MSOEq<BDD>(x, y));
}
internal override void TypeCheck(Dictionary<string, MonaDecl> glob, MapStack<string, MonaParam> loc)
{
MonaParamKind paramkind = (isSecondOrder ? MonaParamKind.var2 : MonaParamKind.var1);
formula.TypeCheck(glob, loc.Push(param.text, new MonaVarParam(new MonaVarWhere(param,null), paramkind)));
}
internal override void TypeCheck(Dictionary<string, MonaDecl> globals, MapStack<string, MonaParam> locals)
{
if (set.type != MonaExprType.SET)
throw new MonaParseException(MonaParseExceptionKind.TypeMismatch, set.symbol.Location, string.Format("expecting SET not {0}", set.type.ToString()));
}
internal override void TypeCheck(Dictionary<string, MonaDecl> glob, MapStack<string, MonaParam> loc)
{
formula.TypeCheck(glob, loc);
}
MonaExprType GetExprType(Dictionary<string, MonaDecl> globals, MapStack<string, MonaParam> locals)
{
var x = symbol;
MonaParam xp = null;
MonaDecl xd = null;
if (locals.TryGetValue(x.text, out xp))
{
if (xp.kind == MonaParamKind.universe || xp.kind == MonaParamKind.var2)
return MonaExprType.SET;
else if (xp.kind == MonaParamKind.var1)
return MonaExprType.INT;
else
return MonaExprType.BOOL;
}
else if (globals.TryGetValue(x.text, out xd))
{
if (xd.kind == MonaDeclKind.constant || xd.kind == MonaDeclKind.var1)
return MonaExprType.INT;
else if (xd.kind == MonaDeclKind.universe || xd.kind == MonaDeclKind.var2)
return MonaExprType.SET;
else if (xd.kind == MonaDeclKind.var0 || ((xd.kind == MonaDeclKind.macro || xd.kind == MonaDeclKind.pred)
&& ((MonaPredDecl)xd).IsNullary))
return MonaExprType.BOOL;
else if (xd.kind == MonaDeclKind.macro || xd.kind == MonaDeclKind.pred)
throw new MonaParseException(MonaParseExceptionKind.InvalidUseOfPredicateOrMacroName, x.Location);
}
throw new MonaParseException(MonaParseExceptionKind.UndeclaredIdentifier, x.Location, x.text);
}
internal override void TypeCheck(Dictionary<string, MonaDecl> glob, MapStack<string, MonaParam> loc)
{
return;
}
private MSOFormula<BDD> ConvertFormula(MonaExpr expr, MapStack<string,MonaParam> locals)
{
switch (expr.symbol.Kind)
{
case Tokens.TRUE:
return new MSOTrue<BDD>();
case Tokens.FALSE:
return new MSOFalse<BDD>();
case Tokens.NOT:
return new MSONot<BDD>(ConvertFormula(expr[0], locals));
case Tokens.AND:
return new MSOAnd<BDD>(ConvertFormula(expr[0], locals), ConvertFormula(expr[1], locals));
case Tokens.OR:
return new MSOOr<BDD>(ConvertFormula(expr[0], locals), ConvertFormula(expr[1], locals));
case Tokens.IMPLIES:
return new MSOImplies<BDD>(ConvertFormula(expr[0], locals), ConvertFormula(expr[1], locals));
case Tokens.EQUIV:
return new MSOEquiv<BDD>(ConvertFormula(expr[0], locals), ConvertFormula(expr[1], locals));
case Tokens.EQ:
return ConvertEq(expr[0], expr[1], locals);
case Tokens.NE:
return new MSONot<BDD>(ConvertEq(expr[0], expr[1], locals));
case Tokens.LT:
return ConvertLt(expr[0], expr[1], locals);
case Tokens.GT:
return ConvertLt(expr[1], expr[0], locals);
case Tokens.LE:
return ConvertLe(expr[0], expr[1], locals);
case Tokens.GE:
return ConvertLe(expr[1], expr[0], locals);
case Tokens.SUBSET:
return ConvertSubset(expr[1], expr[0], locals);
case Tokens.IN:
return ConvertIn(expr[0], expr[1], locals);
case Tokens.NOTIN:
return new MSONot<BDD>(ConvertIn(expr[0], expr[1], locals));
case Tokens.EMPTY:
return ConvertIsEmpty(expr[0], locals);
case Tokens.EX1:
case Tokens.EX2:
{
MonaQFormula phi = (MonaQFormula)expr;
if ((phi.universes != null && phi.universes.Count > 1) ||
phi.vars.Exists(vw => vw.where != null))
throw new NotImplementedException(expr.ToString());
MSOFormula<BDD> psi = ConvertFormula(phi.formula, locals.Push(phi.varmap));
foreach (var vw in phi.vars)
psi = new MSOExists<BDD>(new Variable(vw.name, phi.varmap[vw.name].type == MonaExprType.INT), psi);
return psi;
}
case Tokens.ALL1:
case Tokens.ALL2:
{
MonaQFormula phi = (MonaQFormula)expr;
if ((phi.universes != null && phi.universes.Count > 1) ||
phi.vars.Exists(vw => vw.where != null))
throw new NotImplementedException(expr.ToString());
MSOFormula<BDD> psi = ConvertFormula(phi.formula, locals.Push(phi.varmap));
foreach (var vw in phi.vars)
psi = new MSOForall<BDD>(new Variable(vw.name, phi.varmap[vw.name].type == MonaExprType.INT), psi);
return psi;
}
case Tokens.NAME:
{
var name = expr as MonaName;
if (name != null)
{
//must be a nullary predicate application (var0 is not supported)
var tmpPredApp = new MonaPredApp(name.symbol, Cons<MonaExpr>.Empty);
return ConvertPredApp(tmpPredApp, locals);
}
var predApp = expr as MonaPredApp;
if (predApp != null)
{
return ConvertPredApp(predApp, locals);
}
throw new NotImplementedException(expr.ToString());
}
default:
throw new NotImplementedException(expr.ToString());
}
}
internal override void TypeCheck(Dictionary<string, MonaDecl> globals, MapStack<string, MonaParam> locals)
{
var t = GetExprType(globals, locals);
if (type == MonaExprType.UNKNOWN)
type = t;
else if (type != t)
throw new MonaParseException(MonaParseExceptionKind.InternalError, symbol.Location,
string.Format("inconsistent types {0} and {1} for '{2}'", type.ToString(), t.ToString(), name));
}
internal override void TypeCheck(Dictionary<string, MonaDecl> globals, MapStack<string, MonaParam> locals)
{
if (!globals.ContainsKey(symbol.text))
throw new MonaParseException(MonaParseExceptionKind.UndeclaredPredicate, symbol.Location, symbol.text);
MonaDecl decl = globals[symbol.text];
MonaPredDecl pdecl = decl as MonaPredDecl;
if (pdecl == null)
{
throw new MonaParseException(MonaParseExceptionKind.InvalidUseOfName, symbol.Location, symbol.text);
}
if (pdecl.parameters.Count != expressions.Count)
{
throw new MonaParseException(MonaParseExceptionKind.InvalidNrOfParameters, symbol.Location, symbol.text);
}
for (int i = 0; i < expressions.Count; i++)
{
expressions[i].TypeCheck(globals, locals);
if (pdecl.parameters[i].type != expressions[i].type)
throw new MonaParseException(MonaParseExceptionKind.TypeMismatch, expressions[i].symbol.Location,
string.Format("parameter {0} of {1} must be of type {2} not {3}", pdecl.parameters[i].Token.text, pdecl.name.text, pdecl.parameters[i].type, expressions[i].type));
}
}
internal override void TypeCheck(Dictionary<string, MonaDecl> globals, MapStack<string, MonaParam> locals)
{
formula.TypeCheck(globals, locals);
if (formula.type != MonaExprType.BOOL)
throw new MonaParseException(MonaParseExceptionKind.TypeMismatch, formula.symbol.Location, string.Format("expecting BOOL not {0}", formula.type.ToString()));
}
internal override void TypeCheck(Dictionary<string, MonaDecl> globals, MapStack<string, MonaParam> locals)
{
arg1.TypeCheck(globals, locals);
arg2.TypeCheck(globals, locals);
if (arg1.type != MonaExprType.INT)
throw new MonaParseException(MonaParseExceptionKind.TypeMismatch, arg1.symbol.Location, string.Format("expecting INT not {0}", arg1.type.ToString()));
if (arg2.type != MonaExprType.INT)
throw new MonaParseException(MonaParseExceptionKind.TypeMismatch, arg2.symbol.Location, string.Format("expecting INT not {0}", arg2.type.ToString()));
}
