public virtual bool check()
{
if (!ReserveType.IsBoolean(First.Type) || !ReserveType.IsBoolean(Second.Type))
{
return(false);
}
return(true);
}
public Unary(Token tok, Expr exp) : base(tok, null)
{
Expr = exp;
Type = ReserveType.Max(ReserveType.Int32, Expr.Type);
if (Type == null)
{
throw new TypeCovertException(tok.Line, Type, Expr.Type);
}
}
public Arith(Token tok, Expr x1, Expr x2) : base(tok, null)
{
First = x1;
Second = x2;
Type = ReserveType.Max(First.Type, Second.Type);
if (Type == null)
{
throw new TypeCovertException(tok.Line, First.Type, Second.Type);
}
}
public Set(Temp i, Expr x) : base(x.lexline)
{
t = i;
Expr = x;
if (!ReserveType.ConvertableT1T2(i.Type, x.Type))
{
throw new TypeCovertException(lexline, Id.Type, Expr.Type);
}
}
public If(Expr x, Stmt s) : base(x.lexline)
{
Expr = x;
Stmt = s;
if (!ReserveType.IsBoolean(Expr.Type))
{
throw new TypeMisMatchException(s.lexline, Expr.Type, "Boolean");
}
}
public Set(Id i, Expr x) : base(x.lexline)
{
Id = i;
Expr = x;
Id.setInit();
if (!ReserveType.ConvertableT1T2(i.Type, x.Type))
{
throw new TypeCovertException(lexline, Id.Type, Expr.Type);
}
}
public void Init(Stmt s, Expr x)
{
Expr = x;
Stmt = s;
if (!ReserveType.IsBoolean(Expr.Type))
{
throw new TypeMisMatchException(this.lexline, Expr.Type, "Boolean");
}
}
public Else(Expr x, Stmt s1, Stmt s2) : base(x.lexline)
{
Expr = x;
Stmt1 = s1;
Stmt2 = s2;
if (!ReserveType.IsBoolean(Expr.Type))
{
throw new TypeMisMatchException(x.lexline, Expr.Type, "Boolean");
}
}
public SetElem(Access x, Expr y) : base(x.lexline)
{
Array = x.array;
Index = x.index;
Expr = y;
if (!ReserveType.ConvertableT1T2(y.Type, x.Type))
{
throw new TypeCovertException(this.lexline, y.Type, x.Type);
}
}
public static Document CreateTestDocument(string xmlString)
{
XElement root = XDocument.Parse(xmlString).Root;
Document document = new Document();
//Initialize Reserves
foreach (var t in root.Elements("Type"))
{
ReserveType type = new ReserveType();
type.Name = t.Attribute("name").Value;
document.AddModelObject<ReserveType>(type);
foreach (var c in t.Elements())
{
Reserve reserve = new Reserve(1000);
reserve.Name = c.Attribute("name").Value;
reserve.Type = type;
document.AddModelObject<Reserve>(reserve);
}
}
//Initialize Categories
foreach (var e in root.Element("Expenses").Elements("Item"))
{
createCategory(document, null, e, CategoryType.Expense);
}
foreach (var i in root.Element("Incomes").Elements("Source"))
{
createCategory(document, null, i, CategoryType.Income);
}
createTransactions(document);
Budget budget = new Budget(Period.CurrentWeek);
budget.Name = "Week Budget";
document.AddBudget(budget);
budget = new Budget(Period.CurrentMonth);
budget.Name = "Month Budget";
document.AddBudget(budget);
budget = new Budget(Period.CurrentQuarter);
budget.Name = "Quarter Budget";
document.AddBudget(budget);
budget = new Budget(Period.CurrentYear);
budget.Name = "Year Budget";
document.AddBudget(budget);
return document;
}
public override void gen(int begin, int after)
{
if (Parent.Params.ReturnType != ReserveType.Void)
{
if (!ReserveType.ConvertableT1T2(Parent.Params.ReturnType, ReturnVal.Type))
{
throw new TypeMisMatchException(this.lexline, ReturnVal.Type, Parent.Params.ReturnType.ToString());
}
Temp t = new Temp(Parent.Params.ReturnType);
CurrentGenerator.Temp(t);
new Set(t, ReturnVal).gen(begin, after);
CurrentGenerator.Return(t);
}
else
{
CurrentGenerator.Return(null);
}
//emitLabel(Parent.ExitLabel);
}
public override bool check()
{
if (First.Type is Symbols.Array || Second.Type is Symbols.Array)
{
return(false);
}
else if (First.Type == Second.Type)
{
return(true);
}
else if (ReserveType.IsNumberic(First.Type) && ReserveType.IsNumberic(Second.Type))
{
if (ReserveType.ConvertableT1T2(First.Type, Second.Type))
{
return(true);
}
return(false);
}
else
{
return(false);
}
}
public static ReserveType CreateReserveType(string name)
{
ReserveType type = new ReserveType();
type.Name = name;
return type;
}
