public void AddNode(IExecutionTreeNode node) { if (node != null) { m_Children.Add(node); } }
public ErrorInfo(ErrorLevel level, ErrorCode code, IExecutionTreeNode node, params object[] extra) { Level = level; Code = code; Character = node.Character; Line = node.Line; Extra = extra; }
public static IExecutionTreeNode ExplicitCast(IExecutionTreeNode node, ScriptVariableType fromType, ScriptVariableType toType) { TypeCastExecutionNode typeCast = new TypeCastExecutionNode(node.Parent, node.Line, node.Character); node.Parent = typeCast; typeCast.CastFromType = fromType; typeCast.CastToType = toType; typeCast.Value = node; return(typeCast); }
public override ScriptVariableType Process(ScriptParser parser, int level) { base.Process(parser, level); Condition = TypeCastExecutionNode.ImplicitCast(parser, level + 1, ScriptVariableType.Bool, Condition); if (TrueNode != null) { TrueNode.Process(parser, level + 1); } if (FalseNode != null) { FalseNode.Process(parser, level + 1); } return(ScriptVariableType.Undefined); }
public override ScriptVariableType Process(ScriptParser parser, int level) { base.Process(parser, level); ResultType = ScriptVariableType.Undefined; try { ScriptVariableDefinition v = parser.GetVariable(VarName.Value); ResultType = v.VarType; } catch { parser.Errors.Add(new ErrorInfo(ErrorLevel.Error, ErrorCode.UndefinedVariable, VarName, VarName.Value)); } Value = TypeCastExecutionNode.ImplicitCast(parser, level + 1, ResultType, Value); return(ResultType); }
public override ScriptVariableType Process(ScriptParser parser, int level) { base.Process(parser, level); if (Condition != null) { Condition = TypeCastExecutionNode.ImplicitCast(parser, level + 1, ScriptVariableType.Bool, Condition); } if (Code != null) { Code.Process(parser, level + 1); } if (Code == null && Condition == null) { parser.Errors.Add(new ErrorInfo(ErrorLevel.Error, ErrorCode.LoopWithNoConditionNorCode, this)); } return(ScriptVariableType.Undefined); }
public override ScriptVariableType Process(ScriptParser parser, int level) { base.Process(parser, level); parser.IncrementScopeLevel(false); if (Init != null) { Init.Process(parser, level + 1); } if (Condition != null) { Condition = TypeCastExecutionNode.ImplicitCast(parser, level + 1, ScriptVariableType.Bool, Condition); } if (Final != null) { Final.Process(parser, level + 1); } if (Code != null) { Code.Process(parser, level + 1); } parser.DecrementScopeLevel(false); return(ScriptVariableType.Undefined); }
public override ScriptVariableType Process(ScriptParser parser, int level) { base.Process(parser, level); if (parser.RequiredReturnType != ScriptVariableType.Undefined) { // Within a function if (parser.RequiredReturnType == ScriptVariableType.Void && ReturnValue != null) { parser.Errors.Add(new ErrorInfo(ErrorLevel.Error, ErrorCode.FunctionMustNotReturnAValue, this)); } else if (parser.RequiredReturnType != ScriptVariableType.Void) { if (ReturnValue == null) { parser.Errors.Add(new ErrorInfo(ErrorLevel.Error, ErrorCode.FunctionMustReturnAValue, this)); } else { ReturnValue = TypeCastExecutionNode.ImplicitCast(parser, level + 1, parser.RequiredReturnType, ReturnValue); ReturnValueType = parser.RequiredReturnType; } } IsInGlobalScope = false; } else { // Within the global scope. Anything or nothing may be returned (works same as 'exit'). if (ReturnValue != null) { ReturnValueType = ReturnValue.Process(parser, level + 1); } IsInGlobalScope = true; } return(ScriptVariableType.Undefined); }
public FunctionNode(IExecutionTreeNode rootNode, int line, int character) : base(rootNode, line, character) { }
public CmpEExecutionNode(IExecutionTreeNode parent, int line, int character) : base(parent, line, character) { }
public VarDefinitionExecutionNode(IExecutionTreeNode parent, int line, int character) : base(parent, line, character) { }
public Definition(ScriptIdentifierToken name, IExecutionTreeNode defaultValue) { Name = name; DefaultValue = defaultValue; UnassignedDefaultValue = null; }
public AssignmentExecutionNode(IExecutionTreeNode parent, int line, int character) : base(parent, line, character) { }
public static IExecutionTreeNode ImplicitCast(ScriptParser parser, int level, ScriptVariableType requiredType, IExecutionTreeNode node) { ScriptVariableType acceptableTypes = ScriptVariableType.Undefined; // implicit cast is allowed only in loseless cases (except floating point types) switch (requiredType) { case ScriptVariableType.Short: acceptableTypes = ScriptVariableType.Short | ScriptVariableType.Byte | ScriptVariableType.SByte; break; case ScriptVariableType.UShort: acceptableTypes = ScriptVariableType.UShort | ScriptVariableType.Byte; break; case ScriptVariableType.Int: acceptableTypes = ScriptVariableType.Int | ScriptVariableType.UShort | ScriptVariableType.Short | ScriptVariableType.Byte | ScriptVariableType.SByte; break; case ScriptVariableType.UInt: acceptableTypes = ScriptVariableType.UInt | ScriptVariableType.UShort | ScriptVariableType.Byte; break; case ScriptVariableType.Long: acceptableTypes = ScriptVariableType.Long | ScriptVariableType.UInt | ScriptVariableType.Int | ScriptVariableType.UShort | ScriptVariableType.Short | ScriptVariableType.Byte | ScriptVariableType.SByte; break; case ScriptVariableType.ULong: acceptableTypes = ScriptVariableType.ULong | ScriptVariableType.UInt | ScriptVariableType.UShort | ScriptVariableType.Byte; break; case ScriptVariableType.Float: acceptableTypes = ScriptVariableType.Float | ScriptVariableType.UInt | ScriptVariableType.Int | ScriptVariableType.UShort | ScriptVariableType.Short | ScriptVariableType.Byte | ScriptVariableType.SByte; break; case ScriptVariableType.Double: acceptableTypes = ScriptVariableType.Double | ScriptVariableType.Float | ScriptVariableType.ULong | ScriptVariableType.Long | ScriptVariableType.UInt | ScriptVariableType.Int | ScriptVariableType.UShort | ScriptVariableType.Short | ScriptVariableType.Byte | ScriptVariableType.SByte; break; case ScriptVariableType.Decimal: acceptableTypes = ScriptVariableType.Decimal | ScriptVariableType.Double | ScriptVariableType.Float | ScriptVariableType.ULong | ScriptVariableType.Long | ScriptVariableType.UInt | ScriptVariableType.Int | ScriptVariableType.UShort | ScriptVariableType.Short | ScriptVariableType.Byte | ScriptVariableType.SByte; break; } acceptableTypes = acceptableTypes | requiredType; ScriptVariableType type = node.Process(parser, level); if (type == requiredType) { return(node); } if ((type & acceptableTypes) == ScriptVariableType.Undefined) { parser.Errors.Add(new ErrorInfo(ErrorLevel.Error, ErrorCode.NoImplicitConversion, node, type, requiredType)); return(node); // assume when the error is fixed no implicit cast will be required } TypeCastExecutionNode typeCast = new TypeCastExecutionNode(node.Parent, node.Line, node.Character); node.Parent = typeCast; typeCast.CastFromType = type; typeCast.CastToType = requiredType; typeCast.Value = node; typeCast.IsImplicit = true; typeCast.CastToSystemType = typeCast.CastToType.GetSystemType(); if (parser.DebugParsing) { Utils.IndentedOutput(level, "Inserting implicit cast from '{0}' to '{1}' ({2})", typeCast.CastFromType, typeCast.CastToType, typeCast.CastToSystemType); } return(typeCast); }
public ExecutionTreeNode(IExecutionTreeNode parent, int line, int character) { m_Parent = parent; m_Line = line; m_Character = character; }
public BooleanXorExecutionNode(IExecutionTreeNode parent, int line, int character) : base(parent, line, character) { }
public PreIncrementExecutionNode(IExecutionTreeNode parent, int line, int character) : base(parent, line, character) { }
public BinaryAndExecutionNode(IExecutionTreeNode parent, int line, int character) : base(parent, line, character) { }
public RemainderExecutionNode(IExecutionTreeNode parent, int line, int character) : base(parent, line, character) { }
public ExecutionSequence(IExecutionTreeNode parent, int line, int character) : base(parent, line, character) { }
public WhileLoopExecutionNode(IExecutionTreeNode parent, int line, int character) : base(parent, line, character) { }
public override ScriptVariableType Process(ScriptParser parser, int level) { base.Process(parser, level); IExecutionTreeNode node = null; if (m_Parent != null && CreateOwnVariableScope) { parser.IncrementScopeLevel(false); } int i, processCount = 0; bool exitFound = false; for (i = 0; i < m_Children.Count; i++) { node = m_Children[i]; exitFound = (node is ReturnExecutionNode || node is ExitExecutionNode); if (exitFound && i < m_Children.Count - 1) { parser.Errors.Add(new ErrorInfo(ErrorLevel.Warning, ErrorCode.UnreachableCode, m_Children[i + 1])); break; } processCount++; } if (level == 0 && !exitFound) { if (m_Parent != null && parser.RequiredReturnType != ScriptVariableType.Undefined && parser.RequiredReturnType != ScriptVariableType.Void) { parser.Errors.Add(new ErrorInfo(ErrorLevel.Error, ErrorCode.NotAllCodePathsReturnAValue, this)); // return; } if (m_Parent == null && node != null && node.HasResult) { // Not within a function, but at the very end of the script. // Make result of the last statement to be returned as an // exit data of the script. This is needed to simplify // scripts that work as conditions of some scripted objects // like dialogues or quests. ExitExecutionNode exitNode = new ExitExecutionNode(this, node.Line, node.Character); exitNode.ExitValue = node; node.Parent = exitNode; m_Children[m_Children.Count - 1] = exitNode; } } // processing has to be done AFTER virtual exit node is incorporated for (i = 0; i < processCount; i++) { node = m_Children[i]; try { node.Process(parser, level + 1); } catch (ScriptCriticalErrorException) {} if ((node is ReturnExecutionNode || node is ExitExecutionNode) && i < m_Children.Count - 1) { break; } } // Don't decrement scope level for root node to keep global // variables in the variable stack. This is required for functions // to know what global variables they will have access to while // parsing. if (m_Parent != null && CreateOwnVariableScope) { parser.DecrementScopeLevel(false); } return(ScriptVariableType.Undefined); }
public ErrorInfo(ErrorLevel level, ErrorCode code, IExecutionTreeNode node) : this(level, code, node, null) { }