public DeclarationStatement(List <Identifier> Identifiers, MiniPascalType Type) { foreach (Identifier ident in Identifiers) { variables.Add(new Variable(ident, Type, false)); } this.Type = Type; }
public void CallRead(MiniPascalType Type) { generator.Emit(OpCodes.Call, typeof(Console).GetMethod(nameof(Console.ReadLine))); if (Type.SimpleType.Equals(SimpleType.Integer)) { generator.Emit(OpCodes.Call, typeof(int).GetMethod(nameof(int.Parse), SimpleType.String.CLRTypeArray)); } else if (Type.SimpleType.Equals(SimpleType.Real)) { generator.Emit(OpCodes.Call, typeof(CultureInfo).GetProperty(nameof(CultureInfo.InvariantCulture)).GetGetMethod()); generator.Emit(OpCodes.Call, typeof(float).GetMethod(nameof(float.Parse), new[] { typeof(string), typeof(IFormatProvider) })); } else if (Type.SimpleType.Equals(SimpleType.Boolean)) { generator.Emit(OpCodes.Call, typeof(bool).GetMethod(nameof(bool.Parse), SimpleType.String.CLRTypeArray)); } }
public virtual MiniPascalType NodeType(Scope Current) { Type = firstExpression.NodeType(Current); foreach (OperatorPair <T> expr in simpleExpressions) { MiniPascalType anotherType = expr.Operand.NodeType(Current); if (!Type.Equals(anotherType)) { throw new InvalidTypeException(anotherType, Type); } if (!Type.HasOperatorDefined(expr.Operator)) { throw new UndefinedOperatorException(Type, expr.Operator); } Type = anotherType.BinaryOperation(expr.Operator).ReturnType; } return(Type); }
public void CallPrint(MiniPascalType Type) { if (Type.Equals(MiniPascalType.Boolean)) { Label trueRes = generator.DefineLabel(); Label end = generator.DefineLabel(); generator.Emit(OpCodes.Ldc_I4_1); generator.Emit(OpCodes.Ceq); generator.Emit(OpCodes.Brtrue_S, trueRes); PushString(bool.FalseString); generator.Emit(OpCodes.Br, end); generator.MarkLabel(trueRes); PushString(bool.TrueString); generator.MarkLabel(end); generator.Emit(OpCodes.Call, typeof(Console).GetMethod(nameof(Console.Write), SimpleType.String.CLRTypeArray)); } else { generator.Emit(OpCodes.Call, typeof(Console).GetMethod(nameof(Console.Write), Type.SimpleType.CLRTypeArray)); } }
public TypeMismatchException(MiniPascalType Expected, MiniPascalType Found) { this.Expected = Expected; this.Found = Found; }
public UndefinedOperatorException(MiniPascalType Type, OperatorType Operator) { this.Type = Type; this.Operator = Operator; }
public InvalidArrayIndexTypeException(MiniPascalType Found) { this.Found = Found; }
public InvalidTypeException(MiniPascalType Found, params MiniPascalType[] Expected) { this.Expected = Expected; this.Found = Found; }
public ArrayAssigmentExpection(SimpleType Expected, MiniPascalType Found) { this.Expected = Expected; this.Found = Found; }
public CILEmitter StartProcedure(Identifier Identifier, Parameters Parameters, MiniPascalType ReturnType) { List <Type> types = new List <Type>(); foreach (Variable variable in Parameters.All) { Type type = variable.Type.SimpleType.CLRType; bool byRef = variable.IsReference; bool array = variable.Type.IsArray; if (array) { type = type.MakeArrayType(); } if (byRef) { type = type.MakeByRefType(); } types.Add(type); } Type ret = ReturnType == null ? null : ReturnType.SimpleType.CLRType; MethodBuilder mb = mainType.DefineMethod(Identifier.ToString(), MethodAttributes.Private | MethodAttributes.Static, ret, types.ToArray()); procedures.Add(Identifier, mb); return(new CILEmitter(mb.GetILGenerator(), mainType, mb, scope, Parameters, this)); }
public void CreateSimpleVariable(Identifier Identifier, MiniPascalType Type) { CreateVariable(Identifier, Type.SimpleType.CLRType); }
public void CreateArrayVariable(Identifier Identifier, MiniPascalType Type) { CreateVariable(Identifier, Type.SimpleType.CLRType.MakeArrayType()); }
public void PushArray(MiniPascalType Type) { generator.Emit(OpCodes.Newarr, Type.SimpleType.CLRType); }
public void LoadArrayIndexAddress(MiniPascalType Type) { generator.Emit(OpCodes.Ldelema, Type.SimpleType.CLRType); }
public ArrayRequiredException(MiniPascalType Found) { this.Found = Found; }