public FunctionDefinition ParseFunctionDefinition(TokenStream tokens) { PType returnType = PType.Parse(tokens); Token nameToken = EnsureTokenIsValidName(tokens.Pop(), "Expected function name"); tokens.PopExpected("("); List <PType> argTypes = new List <PType>(); List <Token> argNames = new List <Token>(); while (!tokens.PopIfPresent(")")) { if (argTypes.Count > 0) { tokens.PopExpected(","); } argTypes.Add(PType.Parse(tokens)); argNames.Add(EnsureTokenIsValidName(tokens.Pop(), "Invalid function arg name")); } FunctionDefinition funcDef = new FunctionDefinition(nameToken, returnType, argTypes, argNames, this.context, null); this.currentCodeOwner = funcDef; List <Executable> code = this.ParseCodeBlock(tokens, true); this.currentCodeOwner = null; funcDef.Code = code.ToArray(); return(funcDef); }
public ThisExpression(Token token, ICompilationEntity owner) : base(token, owner) { if (owner == null) { throw new Exception(); } }
public VariableScope(ICompilationEntity functionDef) { if (!(functionDef is FunctionDefinition) && !(functionDef is ConstructorDefinition)) { throw new System.InvalidOperationException(); } this.RootFunctionOrConstructorDefinition = functionDef; }
public Variable(Token token, ICompilationEntity owner) : base(token, owner) { this.IsFunctionInvocation = false; this.ApplyPrefix = true; if (BANNED_NAMES.Contains(token.Value)) { throw new ParserException(token, "The name '" + token.Value + "' is reserved for some platforms and cannot be used."); } }
public DependencyNamespaceReference(Token firstToken, PastelCompiler dep, ICompilationEntity owner) : base(firstToken, owner) { if (dep == null) { throw new ParserException(firstToken, "Could not resolve namespace: " + this.FirstToken.Value); } this.Scope = dep; }
public static InlineConstant Of(object value, ICompilationEntity owner) { Token dummyToken = Token.CreateDummyToken(value.ToString()); if (value is int) { return((InlineConstant) new InlineConstant(PType.INT, dummyToken, value, owner).ResolveType(null, null)); } throw new NotImplementedException(); }
internal override Expression ResolveType(VariableScope varScope, PastelCompiler compiler) { this.Root = this.Root.ResolveType(varScope, compiler); PType rootType = this.Root.ResolvedType; if (rootType.IsStructOrClass) { string fieldName = this.FieldName.Value; rootType.FinalizeType(compiler); if (rootType.IsStruct) { this.StructType = rootType.StructDef; int fieldIndex; if (!this.StructType.FlatFieldIndexByName.TryGetValue(fieldName, out fieldIndex)) { throw new ParserException(this.FieldName, "The struct '" + this.StructType.NameToken.Value + "' does not have a field called '" + fieldName + "'."); } this.ResolvedType = this.StructType.FlatFieldTypes[fieldIndex]; } else { this.ClassType = rootType.ClassDef; if (!this.ClassType.Members.ContainsKey(this.FieldName.Value)) { throw new ParserException(this.FieldName, "The class '" + this.ClassType.NameToken.Value + "' does not have a member called '" + fieldName + "'."); } ICompilationEntity ce = this.ClassType.Members[fieldName]; if (ce is FieldDefinition fd) { this.ResolvedType = fd.FieldType; } else { FunctionDefinition func = (FunctionDefinition)ce; this.ResolvedType = PType.FunctionOf(this.FieldName, func.ReturnType, func.ArgTypes); } } return(this); } this.CoreFunctionId = this.DetermineCoreFunctionId(this.Root.ResolvedType, this.FieldName.Value); if (this.CoreFunctionId != CoreFunction.NONE) { CoreFunctionReference cfr = new CoreFunctionReference(this.FirstToken, this.CoreFunctionId, this.Root, this.Owner); cfr.ResolvedType = new PType(this.Root.FirstToken, null, "@CoreFunc"); return(cfr); } throw new NotImplementedException(); }
private PythonFakeSwitchStatement( string functionName, int switchId, int defaultChunkId, Dictionary <InlineConstant, int> expressionsToChunkIds, Dictionary <int, Executable[]> chunkIdsToCode, ICompilationEntity owner) { this.owner = owner; this.functionName = functionName; this.switchId = switchId; this.DefaultId = defaultChunkId; this.expressionsToChunkIds = expressionsToChunkIds; this.chunkIdsToCode = chunkIdsToCode; }
public static PythonFakeSwitchStatement Build(SwitchStatement switchStatement, int switchId, string functionName) { ICompilationEntity owner = switchStatement.Condition.Owner; Dictionary <InlineConstant, int> expressionToId = new Dictionary <InlineConstant, int>(); Dictionary <int, Executable[]> codeById = new Dictionary <int, Executable[]>(); int?nullableDefaultId = null; Executable[] defaultCode = null; for (int i = 0; i < switchStatement.Chunks.Length; ++i) { SwitchStatement.SwitchChunk chunk = switchStatement.Chunks[i]; int currentId = i; Expression[] cases = chunk.Cases; for (int j = 0; j < cases.Length; ++j) { InlineConstant caze = (InlineConstant)cases[j]; if (caze == null) { nullableDefaultId = currentId; defaultCode = chunk.Code; } else { expressionToId[caze] = currentId; } } codeById[currentId] = chunk.Code; } int defaultId; if (nullableDefaultId != null) { defaultId = nullableDefaultId.Value; if (!codeById.ContainsKey(defaultId)) { codeById[defaultId] = defaultCode; } } else { defaultId = codeById.Count; codeById[defaultId] = new Executable[0]; } return(new PythonFakeSwitchStatement(functionName, switchId, defaultId, expressionToId, codeById, owner)); }
public EnumDefinition ParseEnumDefinition(TokenStream tokens) { Token enumToken = tokens.PopExpected("enum"); Token nameToken = EnsureTokenIsValidName(tokens.Pop(), "Invalid name for an enum."); EnumDefinition enumDef = new EnumDefinition(enumToken, nameToken, this.context); this.currentCodeOwner = enumDef; List <Token> valueTokens = new List <Token>(); List <Expression> valueExpressions = new List <Expression>(); tokens.PopExpected("{"); bool first = true; while (!tokens.PopIfPresent("}")) { if (!first) { tokens.PopExpected(","); } else { first = false; } if (tokens.PopIfPresent("}")) { break; } Token valueToken = EnsureTokenIsValidName(tokens.Pop(), "Invalid name for a enum value."); valueTokens.Add(valueToken); if (tokens.PopIfPresent("=")) { Expression value = ParseExpression(tokens); valueExpressions.Add(value); } else { valueExpressions.Add(null); } } enumDef.InitializeValues(valueTokens, valueExpressions); this.currentCodeOwner = null; return(enumDef); }
internal override void ResolveTypes(VariableScope varScope, PastelCompiler compiler) { // TODO: the variable scope should NOT be the messenger of this information. ICompilationEntity ce = varScope.RootFunctionOrConstructorDefinition; FunctionDefinition fd = ce as FunctionDefinition; if (fd != null) { if (this.Expression != null) { this.Expression = this.Expression.ResolveType(varScope, compiler); if (!PType.CheckReturnType(compiler, fd.ReturnType, this.Expression.ResolvedType)) { throw new ParserException(this.Expression.FirstToken, "This expression is not the expected return type of this function."); } } else { if (!fd.ReturnType.IsIdentical(compiler, PType.VOID)) { throw new ParserException(this.FirstToken, "Must return a value in this function."); } } } else // constructors { if (this.Expression == null) { // This is fine. } else { // This isn't. throw new ParserException(this.FirstToken, "You cannot return a value from a constructor."); } } }
public ClassDefinition ParseClassDefinition(TokenStream tokens) { Token classToken = tokens.PopExpected("class"); Token nameToken = tokens.PopIdentifier(); ClassDefinition cd = new ClassDefinition(this.context, classToken, nameToken); List <Token> inheritTokens = new List <Token>(); if (tokens.PopIfPresent(":")) { while (!tokens.IsNext("{")) { if (inheritTokens.Count > 0) { tokens.PopExpected(","); } inheritTokens.Add(tokens.PopIdentifier()); } } cd.InheritTokens = inheritTokens.ToArray(); tokens.PopExpected("{"); Dictionary <string, ICompilationEntity> members = new Dictionary <string, ICompilationEntity>(); while (!tokens.PopIfPresent("}")) { string next = tokens.PeekValue(); if (next == "constructor") { if (cd.Constructor != null) { throw new ParserException(tokens.Peek(), "Only one constructor is permitted per class."); } Token constructorToken = tokens.PopExpected("constructor"); tokens.PopExpected("("); List <PType> argTypes = new List <PType>(); List <Token> argNames = new List <Token>(); while (!tokens.PopIfPresent(")")) { if (argTypes.Count > 0) { tokens.PopExpected(","); } argTypes.Add(PType.Parse(tokens)); argNames.Add(tokens.PopIdentifier()); } cd.Constructor = new ConstructorDefinition(this.context, constructorToken, argTypes, argNames, cd); this.currentCodeOwner = cd.Constructor; cd.Constructor.Code = this.ParseCodeBlock(tokens, true).ToArray(); } else { ICompilationEntity entity; string entityName; PType memberType = PType.TryParse(tokens); Token memberName = tokens.PopIdentifier(); bool isMethod = tokens.IsNext("("); if (isMethod) { tokens.PopExpected("("); List <PType> argTypes = new List <PType>(); List <Token> argNames = new List <Token>(); while (!tokens.PopIfPresent(")")) { if (argTypes.Count > 0) { tokens.PopExpected(","); } argTypes.Add(PType.Parse(tokens)); argNames.Add(tokens.PopIdentifier()); } FunctionDefinition fd = new FunctionDefinition(memberName, memberType, argTypes, argNames, this.context, cd); this.currentCodeOwner = fd; List <Executable> code = this.ParseCodeBlock(tokens, true); fd.Code = code.ToArray(); entity = fd; entityName = fd.Name; } else { FieldDefinition fd = new FieldDefinition(this.context, memberType, memberName, cd); this.currentCodeOwner = fd; Expression initialValue = null; if (tokens.PopIfPresent("=")) { initialValue = this.ParseExpression(tokens); } else { if (memberType.IsNullable) { initialValue = new InlineConstant(memberType, memberName, null, cd); } else { switch (memberType.RootValue) { case "double": initialValue = new InlineConstant(memberType, memberName, 0.0, cd); break; case "int": initialValue = new InlineConstant(memberType, memberName, 0, cd); break; case "string": initialValue = new InlineConstant(memberType, memberName, null, cd); break; default: throw new NotImplementedException(); } } } tokens.PopExpected(";"); fd.Value = initialValue; entity = fd; entityName = fd.NameToken.Value; } if (members.ContainsKey(entityName)) { throw new ParserException(memberName, "There are conflicting members in the class '" + cd.NameToken.Value + "' for the name '" + entityName + "'."); } members[entityName] = entity; } } cd.AddMembers(members); return(cd); }
public CoreFunctionReference(Token firstToken, CoreFunction coreFunctionId, ICompilationEntity owner) : this(firstToken, coreFunctionId, null, owner) { }
public NamespaceReference(Token firstToken, ICompilationEntity owner) : base(firstToken, owner) { }
public CompileTimeFunctionReference(Token atToken, Token nameToken, ICompilationEntity owner) : base(atToken, owner) { this.NameToken = nameToken; }
public CoreFunctionInvocation(Token firstToken, CoreFunction function, IList <Expression> args, ICompilationEntity owner) : base(firstToken, owner) { this.Function = function; this.Args = args.ToArray(); }
public ConstructorInvocation(Token firstToken, PType type, IList <Expression> args, ICompilationEntity owner) : base(firstToken, owner) { this.Type = type; this.Args = args.ToArray(); this.ResolvedType = type; }
public ExtensibleFunctionReference(Token token, string name, ICompilationEntity owner) : base(token, owner) { this.Name = name; }
public CoreFunctionReference(Token firstToken, CoreFunction coreFunctionId, Expression context, ICompilationEntity owner) : base(firstToken, owner) { this.CoreFunctionId = coreFunctionId; this.Context = context; this.ReturnType = CoreFunctionUtil.GetCoreFunctionReturnType(this.CoreFunctionId); this.ArgTypes = CoreFunctionUtil.GetCoreFunctionArgTypes(this.CoreFunctionId); this.ArgTypesIsRepeated = CoreFunctionUtil.GetCoreFunctionIsArgTypeRepeated(this.CoreFunctionId); }
public CoreFunctionInvocation(Token firstToken, CoreFunction function, Expression context, IList <Expression> args, ICompilationEntity owner) : this(firstToken, function, PushInFront(context, args), owner) { }
public InlineConstant CloneWithNewTokenAndOwner(Token token, ICompilationEntity owner) { return(new InlineConstant(this.Type, token, this.Value, owner)); }
public Expression(Token firstToken, ICompilationEntity owner) { this.FirstToken = firstToken; this.Owner = owner; }
public FunctionReference(Token firstToken, FunctionDefinition functionDefinition, ICompilationEntity owner) : base(firstToken, owner) { this.Function = functionDefinition; this.IsLibraryScopedFunction = false; }
public EnumReference(Token firstToken, EnumDefinition enumDef, ICompilationEntity owner) : base(firstToken, owner) { this.EnumDef = enumDef; }
public VariableScope(VariableScope parent) { this.parent = parent; this.RootFunctionOrConstructorDefinition = parent.RootFunctionOrConstructorDefinition; }
public InlineConstant(PType type, Token firstToken, object value, ICompilationEntity owner) : base(firstToken, owner) { this.Type = type; this.ResolvedType = type; this.Value = value; }
public ConstructorReference(Token newToken, PType type, ICompilationEntity owner) : base(newToken, owner) { this.TypeToConstruct = type; }