public override TypeT CheckType() { left.CheckType(); right.CheckType(); type = left.type == TypeT.IntT && right.type == TypeT.IntT ? TypeT.IntT : TypeT.DoubleT; return(type); }
public override TypeT CheckType() { expression.CheckType(); TypeT argType = expression.type; type = TypeT.VoidT; switch (kind) { case Tokens.Minus: if (argType == TypeT.IntT || argType == TypeT.DoubleT) { type = argType; } break; case Tokens.BitNeg: if (argType == TypeT.IntT) { type = argType; } break; case Tokens.LogicNeg: if (argType == TypeT.BoolT) { type = argType; } break; case Tokens.Int: if (argType != TypeT.VoidT) { type = TypeT.IntT; } break; case Tokens.Double: if (argType != TypeT.VoidT) { type = TypeT.DoubleT; } break; default: SetError("internal gencode error", line); break; } return(type); }
public override void GenCode() { expr.CheckType(); switch (expr.type) { case TypeT.IntT: expr.GenCode(); Compiler.EmitCode("call void [mscorlib]System.Console::Write(int32)"); break; case TypeT.DoubleT: Compiler.EmitCode("call class [mscorlib]System.Globalization.CultureInfo [mscorlib]System.Globalization.CultureInfo::get_InvariantCulture()"); Compiler.EmitCode("ldstr \"{0:0.000000}\""); expr.GenCode(); Compiler.EmitCode("box [mscorlib]System.Double"); Compiler.EmitCode("call string [mscorlib]System.String::Format(class [mscorlib]System.IFormatProvider,string,object)"); Compiler.EmitCode("call void [mscorlib]System.Console::Write(string)"); break; case TypeT.BoolT: expr.GenCode(); Compiler.EmitCode("call void [mscorlib]System.Console::Write(bool)"); break; default: SetError("internal gencode error", line); break; } Compiler.EmitCode(""); }
public SingleExprInstruction(SyntaxTree e, int ln) { expr = e; line = ln; expr.CheckType(); }
public override char CheckType() { left.CheckType(); right.CheckType(); type = left.type == 'i' && right.type == 'i' ? 'i' : 'r'; return(type); }
public AssignOp(SyntaxTree r, string name, int ln) { line = ln; rightExpr = r; variableName = string.Concat("_", name); if (!declaredVariables.ContainsKey(variableName)) { SetError($"Variable {name} undeclared", line); } rightExpr.CheckType(); TypeT varType = declaredVariables[variableName]; if (varType == TypeT.IntT || varType == TypeT.BoolT) { if (varType != rightExpr.type) { SetError($"Wrong type in assigment - expected {TypeToStr(varType)}, was {TypeToStr(rightExpr.type)}", line); } } else if (varType == TypeT.DoubleT) { if (rightExpr.type != TypeT.DoubleT && rightExpr.type != TypeT.IntT) { SetError($"Wrong type in assigment - expected {TypeToStr(varType)}, was {TypeToStr(rightExpr.type)}", line); } } }
public override char CheckType() { if (toWrite.CheckType() == 'e') { return('e'); } return('o'); }
public ExprList(SyntaxTree s, SyntaxTree el, int ln) { line = ln; exprList = el; stmt = s; stmt.CheckType(); exprList.CheckType(); }
public override char CheckType() { exp.CheckType(); if (id[0] == '@' && exp.type != 'i') { throw new ErrorException($" line {line,3}: semantic error - cannot convert real to int", false); } return(' '); }
public UnaryOp(SyntaxTree e, Tokens k, int ln) { expression = e; kind = k; line = ln; expression.CheckType(); ValidateTypes(expression.type, k); }
public ProgramTree(SyntaxTree el, int ln) { line = ln; exprList = el; if (exprList != null) { exprList.CheckType(); } }
public override char CheckType() { char type1 = additiveExpression.CheckType(); if (type1 == 'I') { type1 = FindIndentType(((Leaf)additiveExpression).value); } char type2 = relationalExpression.CheckType(); if (type2 == 'I') { type2 = FindIndentType(((Leaf)relationalExpression).value); } if (type1 == 'e' || type2 == 'e') { return('e'); } if (op.Equals("==") || op.Equals("!=")) { if ((type1 == 'b' && type2 != type1) || (type2 == 'b' && type1 != type2)) { CallAnError(line_number, "Incorrect types"); return('e'); } } else { if (type1 == 'b' || type2 == 'b') { CallAnError(line_number, "Incorrect types"); return('e'); } } if (type1 != type2) { if (type1 == 'd') { relationalExpression = new IntToDouble(relationalExpression); type2 = relationalExpression.CheckType(); } else { additiveExpression = new IntToDouble(additiveExpression); type1 = additiveExpression.CheckType(); } if (type1 != type2) { CallAnError(line_number, "Incorrect type. Both arguments of operand must be of the same type."); return('e'); } } type = 'b'; return('b'); }
public WriteExprOp(SyntaxTree e, int l) { expr = e; line = l; expr.CheckType(); if (expr.type != TypeT.IntT && expr.type != TypeT.BoolT && expr.type != TypeT.DoubleT) { SetError($"Wrong argument type in write operation - expected int, double or bool.", line); } }
public override char CheckType() { if (child.CheckType() != 'e') { return('o'); } else { return('e'); } }
public IfOp(SyntaxTree c, SyntaxTree s, int ln) { line = ln; condition = c; stmt = s; condition.CheckType(); if (condition.type != TypeT.BoolT) { SetError($"Wrong condition type in if statement- expected {TypeToStr(TypeT.BoolT)}, was {TypeToStr(condition.type)}", line); } }
public override char CheckType() { if (!variables.ContainsKey(ident)) { CallAnError(line_number, "Undeclared variable"); return('e'); } Var_type variable_type = variables[ident]; type = assignExpression.CheckType(); if (type == 'I') { type = FindIndentType(((Leaf)assignExpression).value); } switch (variable_type) { case Var_type.real: if (type == 'b') { CallAnError(line_number, "Incorrect type. Cannot be bool"); return('e'); } if (type == 'i') { assignExpression = new IntToDouble(assignExpression); type = assignExpression.CheckType(); if (type != 'd') { CallAnError(line_number, "Incorrect type. Must be double"); return('e'); } } break; case Var_type.integer: if (type != 'i') { CallAnError(line_number, "Incorrect type. Must be int"); return('e'); } break; case Var_type.boolean: if (type != 'b') { CallAnError(line_number, "Incorrect type. Must be bool"); return('e'); } break; } return(type); }
public BinaryOpLogical(SyntaxTree l, SyntaxTree r, Tokens k, int ln) { left = l; right = r; kind = k; line = ln; left.CheckType(); right.CheckType(); if (left.type != TypeT.BoolT || right.type != TypeT.BoolT) { SetError($"Wrong argument type in logical operation - expected bool, was {TypeToStr(left.type)} and {TypeToStr(right.type)}", line); } }
public BinaryOpBitwise(SyntaxTree l, SyntaxTree r, Tokens k, int ln) { left = l; right = r; kind = k; line = ln; left.CheckType(); right.CheckType(); if (left.type != TypeT.IntT || right.type != TypeT.IntT) { SetError($"Wrong argument type in bitwise operation - expected int, was {TypeToStr(left.type)} and {TypeToStr(right.type)}", line); } }
public override char CheckType() { char childType = child.CheckType(); if (childType == 'I') { childType = FindIndentType(((Leaf)child).value); } if (childType != 'i') { CallAnError(line_number, "Cannot cast to double"); return('e'); } return(type); }
public BinaryOpAddMul(SyntaxTree l, SyntaxTree r, Tokens k, int ln) { left = l; right = r; kind = k; line = ln; left.CheckType(); right.CheckType(); if (left.type == TypeT.BoolT || left.type == TypeT.VoidT || right.type == TypeT.BoolT || left.type == TypeT.VoidT) { SetError($"Wrong argument type in {kind.ToString()} operation - expected int or double, was {TypeToStr(left.type)} and {TypeToStr(right.type)}", line); } }
public override char CheckType() { type = expression.CheckType(); if (type == 'e') { return('e'); } if (type == 'I') { type = FindIndentType(((Leaf)expression).value); } switch (op) { case "-": if (type == 'b') { CallAnError(line_number, "Incorrect type. Cannot be bool"); return('e'); } break; case "~": if (type != 'i') { CallAnError(line_number, "Incorrect type. Must be int"); return('e'); } break; case "!": if (type != 'b') { CallAnError(line_number, "Incorrect type. Must be bool"); return('e'); } break; case "toI": type = 'i'; break; case "toD": type = 'd'; break; } return(type); }
public override char CheckType() { char type1 = multiplicativeExpression.CheckType(); if (type1 == 'I') { type1 = FindIndentType(((Leaf)multiplicativeExpression).value); } char type2 = bitExpression.CheckType(); if (type2 == 'I') { type2 = FindIndentType(((Leaf)bitExpression).value); } if (type1 == 'b' || type2 == 'b') { CallAnError(line_number, "Incorrect type. Cannot be bool"); return('e'); } if (type1 == type2) { type = type1; } else { if (type1 == 'd') { bitExpression = new IntToDouble(bitExpression); type2 = bitExpression.CheckType(); } else { multiplicativeExpression = new IntToDouble(multiplicativeExpression); type1 = multiplicativeExpression.CheckType(); } if (type1 != type2) { CallAnError(line_number, "Incorrect type. Both arguments of operand must be of the same type."); return('e'); } type = 'd'; } return(type); }
public BinaryOpRelation(SyntaxTree l, SyntaxTree r, Tokens k, int ln) { left = l; right = r; kind = k; line = ln; left.CheckType(); right.CheckType(); if (left.type == TypeT.BoolT && right.type == TypeT.BoolT) { } else if (left.type != TypeT.DoubleT && left.type != TypeT.IntT) { SetError($"Wrong argument type in binary relation operation - expected int or double, was {TypeToStr(left.type)}", line); } else if (right.type != TypeT.DoubleT && right.type != TypeT.IntT) { SetError($"Wrong argument type in binary relation operation - expected int or double, was {TypeToStr(right.type)}", line); } }
public override void GenCode() { TypeT varType = declaredVariables[variableName]; rightExpr.CheckType(); rightExpr.GenCode(); if (varType == TypeT.IntT || varType == TypeT.BoolT) { Compiler.EmitCode("stloc {0}", variableName); } if (varType == TypeT.DoubleT) { if (rightExpr.type == TypeT.IntT) { Compiler.EmitCode("conv.r8"); } Compiler.EmitCode("stloc {0}", variableName); } Compiler.EmitCode("ldloc {0}", variableName); }
public override char CheckType() { char type1 = unaryExpression.CheckType(); if (type1 == 'I') { type1 = FindIndentType(((Leaf)unaryExpression).value); } char type2 = bitExpression.CheckType(); if (type2 == 'I') { type2 = FindIndentType(((Leaf)bitExpression).value); } if (type1 != 'i' || type2 != 'i') { CallAnError(line_number, "Incorrect type. Must be int"); return('e'); } type = 'i'; return(type); }
public override char CheckType() { type = relationalExpression.CheckType(); if (type == 'I') { type = FindIndentType(((Leaf)relationalExpression).value); } char type2 = logicalExpression.CheckType(); if (type2 == 'I') { type2 = FindIndentType(((Leaf)logicalExpression).value); } if (type == 'e' || type2 == 'e') { return('e'); } if (type != 'b' || type2 != 'b') { CallAnError(line_number, "Incorrect type. Must be bool"); return('e'); } return(type); }
public override char CheckType() { exp.CheckType(); return(' '); }
public override void GenCode() { left.CheckType(); right.CheckType(); left.GenCode(); right.GenCode(); if (left.type == TypeT.BoolT && right.type == TypeT.BoolT) { switch (kind) { case Tokens.Equal: Compiler.EmitCode("ceq"); break; case Tokens.NotEqual: Compiler.EmitCode("ceq"); Compiler.EmitCode("ldc.i4 0"); Compiler.EmitCode("ceq"); break; default: SetError("internal gencode error", line); break; } return; } // uzgodnienie typów SetTypesOnStack(left.type, right.type); switch (kind) { case Tokens.Equal: Compiler.EmitCode("ceq"); break; case Tokens.NotEqual: Compiler.EmitCode("ceq"); Compiler.EmitCode("ldc.i4 0"); Compiler.EmitCode("ceq"); break; case Tokens.More: Compiler.EmitCode("cgt"); break; case Tokens.MoreEqual: Compiler.EmitCode("clt"); Compiler.EmitCode("ldc.i4 0"); Compiler.EmitCode("ceq"); break; case Tokens.Less: Compiler.EmitCode("clt"); break; case Tokens.LessEqual: Compiler.EmitCode("cgt"); Compiler.EmitCode("ldc.i4 0"); Compiler.EmitCode("ceq"); break; default: SetError("internal gencode error", line); break; } }
public override char CheckType() { type = assign.CheckType(); return(type); }