public TryStatement( Token tryToken, Executable[] tryCode, IList <Token> catchTokens, IList <CSharpType> catchBlockTypes, IList <Token> catchBlockVariables, IList <Executable[]> catchBlockCode, Token finallyToken, Executable[] finallyCode, TopLevelEntity parent) : base(tryToken, parent) { this.TryCode = tryCode; List <CatchBlock> catches = new List <CatchBlock>(); for (int i = 0; i < catchBlockCode.Count; ++i) { catches.Add(new CatchBlock() { CatchToken = catchTokens[i], ExceptionType = catchBlockTypes[i], ExceptionVariable = catchBlockVariables[i], Code = catchBlockCode[i], }); } this.CatchBlocks = catches.ToArray(); this.FinallyToken = finallyToken; this.FinallyCode = finallyCode; }
internal static Expression AttemptToResolveDotFieldChainIntoDirectReference(IList <Token> chain, ParserContext context, Expression scope) { CSharpType cst = CSharpType.Fabricate(chain); ResolvedType existingThing = scope.DoTypeLookupFailSilently(cst, context); if (existingThing != null) { if (existingThing.IsEnum) { return(new EnumDefinitionReference(scope.FirstToken, scope.Parent, existingThing)); } else if (existingThing.CustomType != null) { TopLevelEntity tle = existingThing.CustomType; if (tle is ClassLikeDefinition) { return(new StaticClassReference(scope.FirstToken, scope.Parent, (ClassLikeDefinition)tle)); } else { throw new System.NotImplementedException(); } } else if (existingThing.FrameworkClass != null) { return(new StaticFrameworkClassReference(scope.FirstToken, scope.Parent, existingThing)); } else { throw new System.NotImplementedException(); } } return(null); }
public InterfaceDefinition( Token firstToken, Dictionary <string, Token> modifiers, Token classToken, Token classNameToken, List <CSharpType> subClassesAndSuch, TopLevelEntity parent) : base(firstToken, modifiers, classToken, classNameToken, subClassesAndSuch, parent) { }
public EnumDefinition( Token firstToken, Dictionary <string, Token> modifiers, Token name, TopLevelEntity parent) : base(firstToken, parent) { this.ApplyModifiers(modifiers); this.Name = name; }
public ConstDefinition( Token firstToken, Dictionary <string, Token> modifiers, CSharpType constType, Token name, TopLevelEntity parent) : base(firstToken, parent) { this.ApplyModifiers(modifiers); this.Name = name; this.Type = constType; }
public PropertyDefinition( Token firstToken, Dictionary <string, Token> topLevelModifiers, CSharpType type, Token name, TopLevelEntity parent) : base(firstToken, parent) { this.ApplyModifiers(topLevelModifiers); this.Type = type; this.Name = name; }
public ArrayInitialization( Token firstToken, CSharpType itemType, Expression arrayLength, IList <Expression> arrayElements, TopLevelEntity parent) : base(firstToken, parent) { this.ItemType = itemType; this.ArrayLengthExpression = arrayLength; this.ArrayItems = arrayElements == null ? null : arrayElements.ToArray(); }
public VerifiedFieldReference( Token firstToken, TopLevelEntity parent, Token methodName, Expression root, ResolvedType staticMethodSource) : base(firstToken, parent) { this.Name = methodName; this.RootValue = root; this.StaticMethodSource = staticMethodSource; this.Type = MethodRefType.UNKNOWN; }
public FunctionInvocation( Token firstToken, Expression root, Token openParen, IList <Expression> args, IList <Token> outTokens, TopLevelEntity parent) : base(firstToken, parent) { this.Root = root; this.OpenParen = openParen; this.Args = args.ToArray(); this.OutTokens = outTokens.ToArray(); }
public ClassLikeDefinition( Token firstToken, Dictionary <string, Token> modifiers, Token classToken, Token classNameToken, List <CSharpType> parentClassesAndSuch, TopLevelEntity parent) : base(firstToken, parent) { this.ClassToken = classToken; this.Name = classNameToken; this.ApplyModifiers(modifiers); this.RawParentClassInfoTokens = parentClassesAndSuch.ToArray(); }
public ConstructorDefinition( Token firstToken, Dictionary <string, Token> modifiers, IList <CSharpType> argTypes, IList <Token> argNames, IList <Token> argModifiers, TopLevelEntity parent) : base(firstToken, parent) { this.ApplyModifiers(modifiers); this.ArgTypes = argTypes.ToArray(); this.ArgNames = argNames.ToArray(); this.ArgModifiers = argModifiers.ToArray(); this.BaseConstructorInvocation = null; this.BaseConstructorArgs = null; }
public VariableDeclaration( Token firstToken, CSharpType variableType, Token variableName, Token assignmentToken, Expression value, TopLevelEntity parent) : base(firstToken, parent) { if (this.FirstToken.File.Contains("AssemblyDependencyResolver.cs") && this.FirstToken.Line == 53) { } this.VariableName = variableName; this.Type = variableType; this.AssignmentToken = assignmentToken; this.InitialValue = value; }
public SwitchStatement( Token firstToken, Expression condition, IList <Token> caseTokens, IList <Expression> caseConstants, IList <Executable[]> codeForCases, TopLevelEntity parent) : base(firstToken, parent) { this.Condition = condition; List <SwitchStatementChunk> chunks = new List <SwitchStatementChunk>(); List <Token> caseTokensForCurrentChunk = new List <Token>(); List <Expression> caseConstantsForCurrentChunk = new List <Expression>(); for (int i = 0; i < codeForCases.Count; ++i) { caseTokensForCurrentChunk.Add(caseTokens[i]); caseConstantsForCurrentChunk.Add(caseConstants[i]); if (codeForCases[i] == null || codeForCases[i].Length == 0) { // carry it over to the next chunk } else { chunks.Add(new SwitchStatementChunk() { Cases = caseConstantsForCurrentChunk.ToArray(), CaseTokens = caseTokensForCurrentChunk.ToArray(), Code = codeForCases[i], }); caseConstantsForCurrentChunk.Clear(); caseTokensForCurrentChunk.Clear(); } } if (caseConstantsForCurrentChunk.Count > 0) { throw new ParserException(caseTokens[0], "This case does not have any code and falls through to the bottom of the switch statement."); } this.Chunks = chunks.ToArray(); }
private void ResolveCustomFieldReference() { string fieldName = this.Name.Value; if (this.RootValue.ResolvedType.IsEnum) { if (!this.RootValue.ResolvedType.HasEnumField(fieldName)) { throw new ParserException(this.Name, this.RootValue.ResolvedType.ToString() + " doesn't have a field called " + fieldName + "."); } this.ResolvedType = ResolvedType.CreateEnumField(this.RootValue.ResolvedType); } else { ClassLikeDefinition rootType = (ClassLikeDefinition)this.RootValue.ResolvedType.CustomType; TopLevelEntity member = rootType.GetMember(fieldName).FirstOrDefault(); if (member == null) { throw new ParserException(this.Name, "Not implemented or not found."); // could be a framework field. } if (member is PropertyDefinition) { this.Property = (PropertyDefinition)member; this.ResolvedType = this.Property.ResolvedType; } else if (member is FieldDefinition) { this.Field = (FieldDefinition)member; this.ResolvedType = this.Field.ResolvedType; } else { throw new ParserException(this.FirstToken, "Not implemented"); } } }
public ForLoop(Token forToken, IList <Executable> initCode, Expression condition, IList <Executable> stepCode, IList <Executable> loopBody, TopLevelEntity parent) : base(forToken, parent) { this.InitCode = initCode.ToArray(); this.Condition = condition; this.StepCode = stepCode.ToArray(); this.Code = loopBody.ToArray(); }
public Lambda(Token firstToken, IList <Token> args, Token arrowToken, IList <Executable> code, TopLevelEntity parent) : base(firstToken, parent) { this.Args = args.ToArray(); this.ArrowToken = arrowToken; this.Code = code.ToArray(); }
public ForEachLoop(Token foreachToken, CSharpType type, Token variableToken, Expression listExpression, IList <Executable> loopBody, TopLevelEntity parent) : base(foreachToken, parent) { this.VariableType = type; this.VariableToken = variableToken; this.ListExpression = listExpression; this.Code = loopBody.ToArray(); }
public void AddMember(TopLevelEntity tle) { // TODO: check types this.members = null; this.membersBuilder.Add(tle); }
public OpChain(IList <Expression> expressions, IList <Token> ops, TopLevelEntity parent) : base(expressions[0].FirstToken, parent) { this.Expressions = expressions.ToArray(); this.Ops = ops.ToArray(); }
public FieldDefinition(Token firstToken, Dictionary <string, Token> modifiers, CSharpType type, Token name, Expression nullableInitialValue, TopLevelEntity parent) : base(firstToken, parent) { this.ApplyModifiers(modifiers); this.Type = type; this.Name = name; this.InitialValue = nullableInitialValue; }
public DoWhileLoop(Token doToken, Executable[] code, Expression condition, TopLevelEntity parent) : base(doToken, parent) { this.Code = code; this.Condition = condition; }
public ThisKeyword(Token firstToken, TopLevelEntity parent) : base(firstToken, parent) { }
public void AddMember(TopLevelEntity entity) { this.Members.Add(entity); }
public Namespace(Token firstToken, IList <Token> nameParts, TopLevelEntity parent) : base(firstToken, parent) { this.NameParts = nameParts.ToArray(); this.Members = new List <TopLevelEntity>(); }
public ReturnStatement(Token firstToken, Expression nullableExpression, TopLevelEntity parent) : base(firstToken, parent) { this.Value = nullableExpression; }
} // TODO: get rid of the field and just use this. public Executable(Token firstToken, TopLevelEntity parent) : base(firstToken) { this.parent = parent; }
public UsingStatement(Token firstToken, CSharpType variableType, Token variableName, Expression expression, IList <Executable> code, TopLevelEntity parent) : base(firstToken, parent) { this.Type = variableType; this.VariableName = variableName; this.Expression = expression; this.Code = code.ToArray(); }
public ThrowStatement(Token throwToken, Expression expr, TopLevelEntity parent) : base(throwToken, parent) { this.Expression = expr; }
public MultiVariableDeclaration(Token firstToken, CSharpType type, IList <Token> names, TopLevelEntity parent) : base(firstToken, parent) { this.Type = type; this.Names = names.ToArray(); }
public WhileLoop(Token whileToken, Expression condition, Executable[] code, TopLevelEntity parent) : base(whileToken, parent) { this.Condition = condition; this.Code = code; }