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())); }