public override void TypeCheck(MiniPL.Runnable context)
{
// if initial value specified check it agaist the type
if (initialValue != null)
{
initialValue.TypeCheck(context);
switch (type)
{
case ValueType.Boolean:
if (initialValue.Type(context) == ValueType.String)
{
context.errors.Add(new SemanticError(Token, "cannot assign string value to boolean " + identifier));
}
break;
case ValueType.Integer:
if (initialValue.Type(context) != ValueType.Integer)
{
context.errors.Add(new SemanticError(Token, "expected integer type value for " + identifier));
}
break;
case ValueType.String:
if (initialValue.Type(context) != ValueType.String)
{
context.errors.Add(new SemanticError(Token, "expected string type value for " + identifier));
}
break;
}
}
}
public override void TypeCheck(MiniPL.Runnable context)
{
// typecheck value
expr.TypeCheck(context);
// check that value type matches variable
switch (context.declarations[identifier].Type)
{
case ValueType.Boolean:
if (expr.Type(context) == ValueType.String)
{
context.errors.Add(new SemanticError(Token, "cannot assign string value to boolean " + identifier));
}
break;
case ValueType.Integer:
if (expr.Type(context) != ValueType.Integer)
{
context.errors.Add(new SemanticError(Token, "expected integer type value for " + identifier));
}
break;
case ValueType.String:
if (expr.Type(context) != ValueType.String)
{
context.errors.Add(new SemanticError(Token, "expected string type value for " + identifier));
}
break;
}
}
// recursively check operands and check that their types are compatible with operation
override public void TypeCheck(MiniPL.Runnable context)
{
rhs.TypeCheck(context);
lhs.TypeCheck(context);
switch (op)
{
case '+':
if (!((rhs.Type(context) == ValueType.Integer && lhs.Type(context) == ValueType.Integer) ||
(rhs.Type(context) == ValueType.String && lhs.Type(context) == ValueType.String)))
{
context.errors.Add(new SemanticError(Token, "bad operand types for '+' operation"));
}
break;
case '-':
if (!(rhs.Type(context) == ValueType.Integer && lhs.Type(context) == ValueType.Integer))
{
context.errors.Add(new SemanticError(Token, "bad operand types for '-' operation"));
}
break;
case '*':
if (!(rhs.Type(context) == ValueType.Integer && lhs.Type(context) == ValueType.Integer))
{
context.errors.Add(new SemanticError(Token, "bad operand types for '*' operation"));
}
break;
case '/':
if (!(rhs.Type(context) == ValueType.Integer && lhs.Type(context) == ValueType.Integer))
{
context.errors.Add(new SemanticError(Token, "bad operand types for '/' operation"));
}
break;
case '<':
if (!(rhs.Type(context) == ValueType.Integer && lhs.Type(context) == ValueType.Integer))
{
context.errors.Add(new SemanticError(Token, "bad operand types for '<' operation"));
}
break;
case '=':
if (!(rhs.Type(context) == lhs.Type(context)))
{
context.errors.Add(new SemanticError(Token, "bad operand types for '=' operation"));
}
break;
case '&':
if (rhs.Type(context) == ValueType.String || lhs.Type(context) == ValueType.String)
{
context.errors.Add(new SemanticError(Token, "bad operand types for '&' operation"));
}
break;
}
}
override public void TypeCheck(MiniPL.Runnable context)
{
expr.TypeCheck(context);
if (expr.Type(context) != ValueType.Boolean &&
expr.Type(context) != ValueType.Integer)
{
context.errors.Add(new SemanticError(Token, "bad type for '!' operation"));
}
}
public override void TypeCheck(MiniPL.Runnable context)
{
// typecheck parameter
expr.TypeCheck(context);
// Mini-PL spec only defines print for integer and boolean values
if (expr.Type(context) == ValueType.Boolean)
{
context.errors.Add(new SemanticError(Token, "cannot print a boolean value"));
}
}
public override void TypeCheck(MiniPL.Runnable context)
{
// typecheck parameter
expr.TypeCheck(context);
// only defined for boolean parameter, but we'll allow integers too..
if (expr.Type(context) == ValueType.String)
{
context.errors.Add(new SemanticError(Token, "cannot assert a string value"));
}
}
public override void TypeCheck(MiniPL.Runnable context)
{
// typecheck parameters, control variable, and every statement in loop
startVal.TypeCheck(context);
endVal.TypeCheck(context);
if (context.declarations[identifier].Type != ValueType.Integer)
{
context.errors.Add(new SemanticError(Token, "bad for-loop control type"));
}
if (startVal.Type(context) != ValueType.Integer)
{
context.errors.Add(new SemanticError(startVal.Token, "bad for-loop start value type"));
}
if (endVal.Type(context) != ValueType.Integer)
{
context.errors.Add(new SemanticError(startVal.Token, "bad for-loop end value type"));
}
foreach (Statement stmt in block)
{
stmt.TypeCheck(context);
}
}