private static void Parse(MoveInfo parentInfo, ParsingInfo parsingInfo, ScriptInfo scriptInfo) { DoWhileStatement doWhileStatement = new DoWhileStatement(); MoveInfo moveInfo = new MoveInfo(parentInfo); doWhileStatement._doKeyword = (Token)moveInfo.Current; // statement moveInfo.FindNextBlack(SearchDirection.LeftToRight); if (!Statement.Check(moveInfo, parsingInfo, scriptInfo)) { throw new SyntaxException("Could not parse do-while statement", parentInfo.GetErrorInfo()); } doWhileStatement._statement = (Statement)moveInfo.Current; // while IElement tryWhile = moveInfo.FindNextBlack(SearchDirection.LeftToRight); if (tryWhile == null || !tryWhile.IsTT(TokenType.Word) || !tryWhile.ToString().EqualCode("while")) { throw new SyntaxException("Could not find do-while while part", parentInfo.GetErrorInfo()); } doWhileStatement._whileKeyword = (Token)tryWhile; // expression IElement tryExpGroup = moveInfo.FindNextBlack(SearchDirection.LeftToRight); if (tryExpGroup == null || !(tryExpGroup is ParenthesesGroup)) { throw new SyntaxException("Could not find do-while expression", parentInfo.GetErrorInfo()); } ParenthesesGroup expGroup = (ParenthesesGroup)tryExpGroup; MoveInfo expGroupInfo = new MoveInfo(expGroup, SearchTree.ContentBlock, 0, parentInfo); Expression exp = Expression.Parse(expGroupInfo, parsingInfo, scriptInfo); if (exp == null || expGroupInfo.FindNextBlack(SearchDirection.LeftToRight) != null) { throw new SyntaxException("Could not parse do-while expression", parentInfo.GetErrorInfo()); } doWhileStatement._expParentGroup = expGroup; // terminal IElement tryTerminal = moveInfo.FindNextBlack(SearchDirection.LeftToRight); if (tryTerminal == null || !tryTerminal.IsTT(TokenType.SemiColon)) { throw new SyntaxException("Missing directive ';'?", parentInfo.GetErrorInfo()); } // build int startIndex = parentInfo.CurrentIndex; int length = (moveInfo.CurrentIndex + 1) - startIndex; doWhileStatement.AddChildren(parentInfo.CurrentElements.GetRange(startIndex, length)); parentInfo.Replace(length, doWhileStatement); }
private void CheckSemanticLocal(MoveInfo treeInfo, ScriptInfo scriptInfo, CheckingInfo checkingInfo) { _funcInfo = scriptInfo.FindLocalFunc(_name); if (_funcInfo == null) // find in includes { _funcInfo = scriptInfo.FindIncludesFunc(_name); if (_funcInfo == null) { scriptInfo.SF.Errors.Add( new SemanticError("Unknown function '" + _name + "'", treeInfo.GetErrorInfo(treeInfo.Current))); return; } if (_funcInfo.Access == MemberAccess.Private) { scriptInfo.SF.Errors.Add( new SemanticError("Cannot access member '" + _funcInfo.ToString() + "'", treeInfo.GetErrorInfo(treeInfo.Current))); } } scriptInfo.References.Add(new FuncRefInfo(scriptInfo.SF, _funcInfo, this.CharIndex, this.CharLength, checkingInfo.SC.SourceCode.Substring(this.CharIndex, this.CharLength), false)); }
public override void CheckSemantic(MoveInfo treeInfo, ScriptInfo scriptInfo, CheckingInfo checkingInfo) { ScriptFile sf = scriptInfo.SF.Manager.GetSF(_usingInfo.SFPath); if (sf == null || sf.SI == null) { scriptInfo.SF.Errors.Add(new SemanticError("Could not find file '" + _usingInfo.SFPath + "'", treeInfo.GetErrorInfo(treeInfo.Current))); } string upperName = this._usingInfo.Name.ToUpperInvariant(); List <IMemberInfo> members = scriptInfo.SF.SI.GetAvailableMembers(); foreach (IMemberInfo m in members) { if (m is UsingInfo && m.Name.ToUpperInvariant() == upperName) { if ((m as UsingInfo) != this._usingInfo) { scriptInfo.SF.Errors.Add( new SemanticError("Using '" + this._usingInfo.Name + "' already defined(" + m.SF.SFPath + "::" + m.Name + ")", treeInfo.GetErrorInfo(treeInfo.Current))); } } } }
private void CheckSemanticLocal(MoveInfo treeInfo, ScriptInfo scriptInfo, CheckingInfo checkingInfo) { _funcInfo = scriptInfo.FindLocalFunc(_name); if (_funcInfo == null) { _funcInfo = scriptInfo.FindGlobalsFunc(_name); } if (_funcInfo == null) // find in includes { _funcInfo = scriptInfo.FindIncludesFunc(_name); if (_funcInfo == null) { scriptInfo.SF.Errors.Add( new SemanticError("Unknown function '" + _name + "'", treeInfo.GetErrorInfo(treeInfo.Current))); return; } if (_funcInfo.Access != MemberAccess.Public) // private member in include { scriptInfo.SF.Errors.Add( new SemanticError("Cannot access function '" + _funcInfo.ToString() + "'", treeInfo.GetErrorInfo(treeInfo.Current))); } } }
private static void Parse(MoveInfo parentInfo, ParsingInfo parsingInfo, ScriptInfo scriptInfo) { WaitStatement waitStatement = new WaitStatement(); MoveInfo moveInfo = new MoveInfo(parentInfo); IElement tryExp = moveInfo.FindNextBlack(SearchDirection.LeftToRight); if (tryExp == null) { throw new SyntaxException("Could not find wait expression", parentInfo.GetErrorInfo()); } Expression exp = Expression.Parse(moveInfo, parsingInfo, scriptInfo); if (exp == null) { throw new SyntaxException("Could not parse wait expression", parentInfo.GetErrorInfo()); } IElement terminalTry = moveInfo.FindNextBlack(SearchDirection.LeftToRight); // terminal if (terminalTry == null || !terminalTry.IsTT(TokenType.SemiColon)) { throw new SyntaxException("Missing directive ';'?", parentInfo.GetErrorInfo()); } // build int startIndex = parentInfo.CurrentIndex; int length = (moveInfo.CurrentIndex + 1) - startIndex; waitStatement.AddChildren(parentInfo.CurrentElements.GetRange(startIndex, length)); parentInfo.Replace(length, waitStatement); }
private static void Parse(MoveInfo parentInfo, ParsingInfo parsingInfo, ScriptInfo scriptInfo) { Assign assign = new Assign(); int startIndex; int length; // find var define MoveInfo varInfo = new MoveInfo(parentInfo); IElement var = varInfo.FindNextBlack(SearchDirection.RightToLeft); if (var == null || !(var is ExpressionOperand) || !(var is VarName)) { throw new SyntaxException("Could not parse Assign VarName", parentInfo.GetErrorInfo()); } assign.VarName = (VarName)var; startIndex = varInfo.CurrentIndex; // parse expression MoveInfo moveInfo = new MoveInfo(parentInfo); moveInfo.FindNextBlack(SearchDirection.LeftToRight); // move behind = Expression exp = Expression.Parse(moveInfo, parsingInfo, scriptInfo, false, true, true); if (exp == null) { throw new SyntaxException("Could not parse Assign Expression", parentInfo.GetErrorInfo()); } assign.Exp = exp; // build length = (moveInfo.CurrentIndex + 1) - startIndex; assign.AddChildren(parentInfo.CurrentElements.GetRange(startIndex, length)); parentInfo.MoveToIndex(startIndex); parentInfo.Replace(length, assign); // add local var def IElement baseVar = ((VarName)var).GetChildren()[0]; string baseVarName = baseVar.ToString(); foreach (string tStr in ScriptManager.GlobalVariables) { if (baseVarName.EqualCode(tStr)) { return; } } LocalVarInfo tryVarInfo = parsingInfo.CurrentFunc.LocalVars.Find(a => a.Name.EqualCode(baseVarName)); // there is maybe var with this name... if (tryVarInfo == null) { parsingInfo.CurrentFunc.LocalVars.Add(new LocalVarInfo(parsingInfo.SF, baseVarName, baseVar.CharIndex, baseVar.CharLength, assign, (VarName)var)); } }
private static void Parse(MoveInfo parentInfo, ParsingInfo parsingInfo, ScriptInfo scriptInfo) { IfElseStatement ifElse = new IfElseStatement(); MoveInfo moveInfo = new MoveInfo(parentInfo); IElement expTry = moveInfo.FindNextBlack(SearchDirection.LeftToRight); if (expTry == null || !(expTry is ParenthesesGroup)) { throw new SyntaxException("Could not find if expression", parentInfo.GetErrorInfo()); } ParenthesesGroup expGroup = (ParenthesesGroup)expTry; MoveInfo expInfo = new MoveInfo(expGroup, SearchTree.ContentBlock, 0, moveInfo); Expression exp = Expression.Parse(expInfo, parsingInfo, scriptInfo); if (exp == null) { throw new SyntaxException("Could not find if expression", parentInfo.GetErrorInfo()); } if (expInfo.FindNextBlack(SearchDirection.LeftToRight) != null) { throw new SyntaxException("Could not parse if expression", parentInfo.GetErrorInfo()); } moveInfo.Move(SearchDirection.LeftToRight); if (!Statement.Check(moveInfo, parsingInfo, scriptInfo)) { throw new SyntaxException("Could not find statement", parentInfo.GetErrorInfo()); } int endIndex = moveInfo.CurrentIndex; IElement tryElse = moveInfo.FindNextBlack(SearchDirection.LeftToRight); if (tryElse != null && tryElse.IsTT(TokenType.Word) && moveInfo.Current.ToString() == "else") { moveInfo.Move(SearchDirection.LeftToRight); if (!Statement.Check(moveInfo, parsingInfo, scriptInfo)) { throw new SyntaxException("Could not find statement", parentInfo.GetErrorInfo()); } endIndex = moveInfo.CurrentIndex; } int totalLength = (endIndex + 1) - parentInfo.CurrentIndex; List <IElement> children = parentInfo.CurrentElements.GetRange(parentInfo.CurrentIndex, totalLength); ifElse.AddChildren(children); parentInfo.Replace(totalLength, ifElse); }
private void CheckSemanticExtern(MoveInfo treeInfo, ScriptInfo scriptInfo, CheckingInfo checkingInfo) { _path = _pathOrUsing; #region Finding using UsingInfo usingInfoTry = scriptInfo.FindUsing(_path); if (usingInfoTry != null) { if (usingInfoTry.SF != scriptInfo.SF && usingInfoTry.Access != MemberAccess.Public) { scriptInfo.SF.Errors.Add(new SemanticError("Could not access using '" + usingInfoTry.SF.SFPath + "::" + usingInfoTry.Name + "'", treeInfo.GetErrorInfo(_pathElem))); return; } _path = usingInfoTry.SFPath; UsingName usingName = UsingName.ConvertToMe(this, _pathElem, usingInfoTry); scriptInfo.References.Add(new UsingRefInfo(scriptInfo.SF, usingInfoTry, usingName.CharIndex, usingName.CharLength, checkingInfo.SC.SourceCode.Substring(usingName.CharIndex, usingName.CharLength))); } #endregion ScriptFile sf = scriptInfo.SF.Manager.GetSF(_path); if (sf == null) { scriptInfo.SF.Errors.Add( new SemanticError("Could not find file '" + _path + "'", treeInfo.GetErrorInfo(treeInfo.Current))); return; } else if (sf.SI == null) { scriptInfo.SF.Errors.Add( new WarningError("Could not read file '" + _path + "'", treeInfo.GetErrorInfo(treeInfo.Current))); return; } _funcInfo = sf.SI.FindLocalFunc(_name); if (_funcInfo == null) { scriptInfo.SF.Errors.Add( new SemanticError("Unknown function '" + _path + "::" + _name + "'", treeInfo.GetErrorInfo(treeInfo.Current))); return; } // member is private if (sf != scriptInfo.SF && _funcInfo.Access != MemberAccess.Public) { scriptInfo.SF.Errors.Add( new SemanticError("Cannot access function '" + _path + "::" + _name + "'", treeInfo.GetErrorInfo(treeInfo.Current))); } }
private static void Parse(MoveInfo parentInfo, ParsingInfo parsingInfo, ScriptInfo scriptInfo) { FuncArgs funcArgs = new FuncArgs(); ParenthesesGroup group = (ParenthesesGroup)parentInfo.Current; MoveInfo groupInfo = new MoveInfo(group, SearchTree.ContentBlock, 0, parentInfo); IElement next = groupInfo.Find(SearchDirection.LeftToRight, SearchVisibility.Visible); while (next != null) { Expression exp = Expression.Parse(groupInfo, parsingInfo, scriptInfo); next = groupInfo.FindNextBlack(SearchDirection.LeftToRight); // jump behind funcArg if (exp == null || (next != null && !next.IsTT(TokenType.Comma))) { throw new SyntaxException("Could not parse funcArg", parentInfo.GetErrorInfo()); } if (next != null) { next = groupInfo.FindNextBlack(SearchDirection.LeftToRight); // jump behind , if (next == null) { throw new SyntaxException("Could not parse funcArg", parentInfo.GetErrorInfo()); } } CheckOutParam(parsingInfo, exp, parentInfo); if (parsingInfo.CurrentCall != null && parsingInfo.CurrentCallArgIndex != null) { if (parsingInfo.CurrentCall is FuncCall) { ((FuncCall)parsingInfo.CurrentCall).Arguments.Add(exp); parsingInfo.CurrentCallArgIndex++; } else if (parsingInfo.CurrentCall is DelegateCall) { ((DelegateCall)parsingInfo.CurrentCall).Arguments.Add(exp); parsingInfo.CurrentCallArgIndex++; } else { throw new ArgumentException("parsingInfo.CurrentCall"); } } } funcArgs.AddChildren(group); parentInfo.Replace(1, funcArgs); }
private static void ParseExtern(MoveInfo parentInfo, ParsingInfo parsingInfo, ScriptInfo scriptInfo) { DelegateDef delegDef = new DelegateDef(); MoveInfo moveInfo = new MoveInfo(parentInfo); Path path = Path.Parse(moveInfo, parsingInfo, scriptInfo); if (path == null) { throw new SyntaxException("Bad path", parentInfo.GetErrorInfo()); } delegDef._pathOrUsing = path.ToString(); delegDef._pathElem = path; // :: moveInfo.FindNextBlack(SearchDirection.LeftToRight); delegDef._nameSpaceElem = (Token)moveInfo.Current; // name moveInfo.FindNextBlack(SearchDirection.LeftToRight); delegDef._name = moveInfo.Current.ToString(); int startIndex = parentInfo.CurrentIndex; int length = (moveInfo.CurrentIndex + 1) - startIndex; delegDef.AddChildren(parentInfo.CurrentElements.GetRange(startIndex, length)); parentInfo.Replace(length, delegDef); }
private static void Parse(MoveInfo parentInfo, ParsingInfo parsingInfo, ScriptInfo scriptInfo) { SubExpression subExp = new SubExpression(); ParenthesesGroup group = (ParenthesesGroup)parentInfo.Current; MoveInfo groupInfo = new MoveInfo(group, SearchTree.ContentBlock, 0, parentInfo); Expression exp = Expression.Parse(groupInfo, parsingInfo, scriptInfo); if (exp == null || groupInfo.FindNextBlack(SearchDirection.LeftToRight) != null) { throw new SyntaxException("Could not parse subExpression", parentInfo.GetErrorInfo()); } int startIndex = parentInfo.CurrentIndex; int length = 1; MoveInfo moveInfo = new MoveInfo(parentInfo); IElement next = null; do { length = (moveInfo.CurrentIndex + 1) - startIndex; next = moveInfo.FindNextBlack(SearchDirection.LeftToRight); }while (next != null && (ArrayIndexer.Check(moveInfo, parsingInfo, scriptInfo) || DataMember.Check(moveInfo, parsingInfo, scriptInfo))); subExp.AddChildren(parentInfo.CurrentElements.GetRange(startIndex, length)); parentInfo.Replace(length, subExp); }
public static bool Check(MoveInfo parentInfo, ParsingInfo parsingInfo, ScriptInfo scriptInfo) { if (parentInfo.Current is ParenthesesGroup) { ParenthesesGroup group = (ParenthesesGroup)parentInfo.Current; MoveInfo moveInfo = new MoveInfo(group, SearchTree.ContentBlock, 0, parentInfo); int i; for (i = 0; i < 2; i++) { IElement next = moveInfo.Find(SearchDirection.LeftToRight, SearchVisibility.Visible, a => a.IsTT(TokenType.Comma)); if (next == null) { break; } moveInfo.Move(SearchDirection.LeftToRight); } if (i == 0) { return(false); } else if (i == 2) { Parse(parentInfo, parsingInfo, scriptInfo); return(true); } else { throw new SyntaxException("Only 3D vector is allowed", parentInfo.GetErrorInfo()); } } return(false); }
private static void Parse(MoveInfo parentInfo, ParsingInfo parsingInfo, ScriptInfo scriptInfo) { PostfixIncDec postfixIncDec = new PostfixIncDec(); int startIndex = parentInfo.CurrentIndex; int length; // find operand MoveInfo operandInfo = new MoveInfo(parentInfo); IElement operand = operandInfo.FindNextBlack(SearchDirection.RightToLeft); if (operand != null && operand is ExpressionOperand) { startIndex = operandInfo.CurrentIndex; } else { throw new SyntaxException("Could not find PostfixIncDec operand", parentInfo.GetErrorInfo()); } // build length = (parentInfo.CurrentIndex + 1) - startIndex; postfixIncDec.AddChildren(parentInfo.CurrentElements.GetRange(startIndex, length)); parentInfo.MoveToIndex(startIndex); parentInfo.Replace(length, postfixIncDec); }
public override void CheckSemantic(MoveInfo treeInfo, ScriptInfo scriptInfo, CheckingInfo checkingInfo) { if (!String.IsNullOrEmpty(this._pathOrUsing)) { CheckSemanticExtern(treeInfo, scriptInfo, checkingInfo); } else { CheckSemanticLocal(treeInfo, scriptInfo, checkingInfo); } if (_funcInfo != null) { if (Arguments.Count > _funcInfo.Parameters.Count) { if (_funcInfo.SF.IsExtern) // codapi funcs -> only warning { scriptInfo.SF.Errors.Add( new WarningError("Function '" + _funcInfo.ToString() + "' has more arguments than parameters in the definition", treeInfo.GetErrorInfo(treeInfo.Current))); } else { scriptInfo.SF.Errors.Add( new SemanticError("Function '" + _funcInfo.ToString() + "' has more arguments than parameters in the definition", treeInfo.GetErrorInfo(treeInfo.Current))); } } if ((_funcInfo.OptParamStartIndex != null && Arguments.Count < _funcInfo.OptParamStartIndex) || (_funcInfo.OptParamStartIndex == null && Arguments.Count < _funcInfo.Parameters.Count)) { scriptInfo.SF.Errors.Add( new WarningError("Could not find enough arguments, function '" + _funcInfo.ToString() + "'", treeInfo.GetErrorInfo(treeInfo.Current))); } FuncRefInfo funcRefInfo = new FuncRefInfo(scriptInfo.SF, _funcInfo, this.CharIndex, this.CharLength, checkingInfo.SC.SourceCode.Substring(this.CharIndex, this.CharLength), true); foreach (Expression arg in this.Arguments) { funcRefInfo.AddArgument(arg.CharIndex, arg.CharLength); } scriptInfo.References.Add(funcRefInfo); } }
public static bool Check(MoveInfo parentInfo, ParsingInfo parsingInfo, ScriptInfo scriptInfo, bool isTerminated) { ExpressionStatement expStatement = new ExpressionStatement(); Expression exp = Expression.Parse(parentInfo, parsingInfo, scriptInfo, true, false, false); if (exp == null) { return(false); } expStatement._exp = exp; // exp content string error = "Only Assign, FuncCall, DelegateCall and PostfixIncDec is allowed as statement"; MoveInfo expInfo = new MoveInfo(exp, SearchTree.ChildrenBlock, 0, parentInfo); if (!((expInfo.Current is Assign || expInfo.Current is FuncCall || expInfo.Current is DelegateCall || expInfo.Current is PostfixIncDec ) && expInfo.FindNextBlack(SearchDirection.LeftToRight) == null)) { throw new SyntaxException(error, parentInfo.GetErrorInfo()); } // next token MoveInfo moveInfo = new MoveInfo(parentInfo); if (isTerminated) { IElement terminal = moveInfo.FindNextBlack(SearchDirection.LeftToRight); if (terminal == null || !terminal.IsTT(TokenType.SemiColon)) { throw new SyntaxException("Missing directive ';'?", parentInfo.GetErrorInfo()); } } // build int startIndex = parentInfo.CurrentIndex; int length = (moveInfo.CurrentIndex + 1) - startIndex; expStatement.AddChildren(parentInfo.CurrentElements.GetRange(startIndex, length)); parentInfo.Replace(length, expStatement); return(true); }
private static void Parse(MoveInfo parentInfo, ParsingInfo parsingInfo, ScriptInfo scriptInfo) { CaseSwitchStatement caseSwitch = new CaseSwitchStatement(); MoveInfo moveInfo = new MoveInfo(parentInfo); // expression IElement next = moveInfo.FindNextBlack(SearchDirection.LeftToRight); Expression exp = Expression.Parse(moveInfo, parsingInfo, scriptInfo); if (exp == null) { throw new SyntaxException("Could not parse case expression", parentInfo.GetErrorInfo()); } // terminal IElement tryTerminal = moveInfo.FindNextBlack(SearchDirection.LeftToRight); if (tryTerminal == null || !tryTerminal.IsTT(TokenType.Colon)) { throw new SyntaxException("Missing directive ':'?", parentInfo.GetErrorInfo()); } // statements IElement nextStatement = moveInfo.FindNextBlack(SearchDirection.LeftToRight); while (nextStatement != null) // end of switch { if (CaseSwitchStatement.Check(moveInfo, parsingInfo, scriptInfo, false) || DefaultSwitchStatement.Check(moveInfo, parsingInfo, scriptInfo, false)) { break; } Statement.Check(moveInfo, parsingInfo, scriptInfo); nextStatement = moveInfo.FindNextBlack(SearchDirection.LeftToRight); } // build int startIndex = parentInfo.CurrentIndex; int length = (moveInfo.CurrentIndex) - startIndex; caseSwitch.AddChildren(parentInfo.CurrentElements.GetRange(startIndex, length)); parentInfo.Replace(length, caseSwitch); }
public override void CheckSemantic(MoveInfo treeInfo, ScriptInfo scriptInfo, CheckingInfo checkingInfo) { // unreachable code MoveInfo blockInfo = new MoveInfo(treeInfo.CurrentBlock, SearchTree.ContentBlock, treeInfo.CurrentIndex, treeInfo); IElement nextTry = blockInfo.FindNextBlack(SearchDirection.LeftToRight); if (nextTry != null && nextTry is Statement) { scriptInfo.SF.Errors.Add( new WarningError("Unreachable code detected", blockInfo.GetErrorInfo(nextTry))); } }
public static FuncDefParam Parse(MoveInfo parentInfo, ParsingInfo parsingInfo, ScriptInfo scriptInfo) { FuncDefParam param = new FuncDefParam(); MoveInfo moveInfo = new MoveInfo(parentInfo); MoveInfo wordMoveInfo = moveInfo; IElement wordTry = moveInfo.Find(SearchDirection.LeftToRight, SearchVisibility.Visible); int startIndex = moveInfo.CurrentIndex; if (wordTry == null) { throw new SyntaxException("Could not parse FuncDef param", parentInfo.GetErrorInfo()); } if (wordTry is SQBracketGroup) { param._group = (SQBracketGroup)wordTry; param.Optional = true; MoveInfo bracketInfo = new MoveInfo((SQBracketGroup)wordTry, SearchTree.ContentBlock, 0, moveInfo); wordTry = bracketInfo.Find(SearchDirection.LeftToRight, SearchVisibility.Visible); wordMoveInfo = bracketInfo; } if (wordTry == null || !wordTry.IsTT(TokenType.Word)) { throw new SyntaxException("Could not parse FuncDef param", parentInfo.GetErrorInfo()); } VarName.Parse(wordMoveInfo, parsingInfo, scriptInfo); param.VarName = (VarName)wordMoveInfo.Current; param.Name = wordTry.ToString(); param.AddChildren(parentInfo.CurrentElements.GetRange(startIndex, moveInfo.CurrentIndex - startIndex + 1)); parentInfo.Replace((moveInfo.CurrentIndex + 1) - startIndex, param); return(param); }
public void CheckSemantic_OnLeaveFuncDef(ScriptInfo si) { foreach (LocalVarInfo v in LocalVars) { if (v.RefCount == 0 && v.VarNameDef != null) // ignore self { MoveInfo moveInfo = new MoveInfo(v.VarNameDef, SearchTree.ChildrenBlock, 0, si.SF); si.SF.Errors.Add( new WarningError("Variable '" + v.VarNameDef.ToString() + "' is defined, but its value is never used.", moveInfo.GetErrorInfo(v.VarNameDef))); } } }
private static void Parse(MoveInfo parentInfo, ParsingInfo parsingInfo, ScriptInfo scriptInfo) { ReturnStatement returnStatement = new ReturnStatement(); MoveInfo moveInfo = new MoveInfo(parentInfo); IElement tryExp = moveInfo.FindNextBlack(SearchDirection.LeftToRight); if (tryExp == null) { throw new SyntaxException("Missing directive ';'?", parentInfo.GetErrorInfo()); } // expression defined if (!tryExp.IsTT(TokenType.SemiColon)) { Expression exp = Expression.Parse(moveInfo, parsingInfo, scriptInfo, false, false, true); if (exp == null) { throw new SyntaxException("Could not parse return expression", parentInfo.GetErrorInfo()); } moveInfo.FindNextBlack(SearchDirection.LeftToRight); } // terminal if (moveInfo.Current == null || !moveInfo.Current.IsTT(TokenType.SemiColon)) { throw new SyntaxException("Missing directive ';'?", parentInfo.GetErrorInfo()); } // build int startIndex = parentInfo.CurrentIndex; int length = (moveInfo.CurrentIndex + 1) - startIndex; returnStatement.AddChildren(parentInfo.CurrentElements.GetRange(startIndex, length)); parentInfo.Replace(length, returnStatement); }
private static void Parse(MoveInfo parentInfo, ParsingInfo parsingInfo, ScriptInfo scriptInfo) { WhileStatement whileStatement = new WhileStatement(); MoveInfo moveInfo = new MoveInfo(parentInfo); // expression IElement expGroupTry = moveInfo.FindNextBlack(SearchDirection.LeftToRight); if (expGroupTry == null || !(expGroupTry is ParenthesesGroup)) { throw new SyntaxException("Could not find while expression", parentInfo.GetErrorInfo()); } ParenthesesGroup expGroup = (ParenthesesGroup)expGroupTry; MoveInfo expGroupInfo = new MoveInfo(expGroup, SearchTree.ContentBlock, 0, parentInfo); Expression exp = Expression.Parse(expGroupInfo, parsingInfo, scriptInfo); if (exp == null || expGroupInfo.FindNextBlack(SearchDirection.LeftToRight) != null) { throw new SyntaxException("Could not parse while expression", parentInfo.GetErrorInfo()); } // statement moveInfo.FindNextBlack(SearchDirection.LeftToRight); if (!Statement.Check(moveInfo, parsingInfo, scriptInfo)) { throw new SyntaxException("Could not parse while statement", parentInfo.GetErrorInfo()); } // build int startIndex = parentInfo.CurrentIndex; int length = (moveInfo.CurrentIndex + 1) - startIndex; whileStatement.AddChildren(parentInfo.CurrentElements.GetRange(startIndex, length)); parentInfo.Replace(length, whileStatement); }
private static void Parse(MoveInfo parentInfo, ParsingInfo parsingInfo, ScriptInfo scriptInfo) { SQBracketGroup group = (SQBracketGroup)parentInfo.Current; MoveInfo moveInfo = new MoveInfo(group, SearchTree.ContentBlock, 0, parentInfo); if (moveInfo.Find(SearchDirection.LeftToRight, SearchVisibility.Visible) != null) { throw new SyntaxException("Unknown tokens in ArrayDef", parentInfo.GetErrorInfo()); } ArrayDef arrayDef = new ArrayDef(); arrayDef.AddChildren(group); parentInfo.Replace(1, arrayDef); }
private static List <FuncDefParam> GetParameterList(MoveInfo parentInfo, ParsingInfo parsingInfo, ScriptInfo scriptInfo) { MoveInfo moveInfo = new MoveInfo(parentInfo); string error = "Could not parse function parameters"; List <FuncDefParam> defParams = new List <FuncDefParam>(); bool? isSeparator = null; IElement curElem = moveInfo.Find(SearchDirection.LeftToRight, SearchVisibility.Visible); while (curElem != null) { if (isSeparator == false || isSeparator == null) { FuncDefParam param = FuncDefParam.Parse(moveInfo, parsingInfo, scriptInfo); defParams.Add(param); isSeparator = true; } else { if (!curElem.IsTT(TokenType.Comma)) { throw new SyntaxException(error, parentInfo.GetErrorInfo()); } isSeparator = false; } curElem = moveInfo.FindNextBlack(SearchDirection.LeftToRight); } if (isSeparator == false) { throw new SyntaxException(error, parentInfo.GetErrorInfo()); } return(defParams); }
public static void Parse(MoveInfo parentInfo, ParsingInfo parsingInfo, ScriptInfo scriptInfo) { MoveInfo moveInfo = new MoveInfo(parentInfo); IElement next = moveInfo.FindNextBlack(SearchDirection.LeftToRight); if (next == null || !next.IsTT(TokenType.Word)) { throw new SyntaxException("Could not find member", parentInfo.GetErrorInfo()); } int length = (moveInfo.CurrentIndex + 1) - parentInfo.CurrentIndex; DataMember m = new DataMember(parentInfo.CurrentElements.GetRange(parentInfo.CurrentIndex, length)); parentInfo.Replace(length, m); }
private static void Parse(MoveInfo parentInfo, ParsingInfo parsingInfo, ScriptInfo scriptInfo) { ArrayIndexer aI = new ArrayIndexer(); SQBracketGroup SQGroup = (SQBracketGroup)parentInfo.Current; MoveInfo SQGroupInfo = new MoveInfo(SQGroup, SearchTree.ContentBlock, 0, parentInfo); Expression exp = Expression.Parse(SQGroupInfo, parsingInfo, scriptInfo); if (exp == null || SQGroupInfo.FindNextBlack(SearchDirection.LeftToRight) != null) { throw new SyntaxException("Could not parse array index", parentInfo.GetErrorInfo()); } aI.AddChildren(SQGroup); parentInfo.Replace(1, aI); }
public override void CheckSemantic(MoveInfo treeInfo, ScriptInfo scriptInfo, CheckingInfo checkingInfo) { if (!treeInfo.IsIn <IterationStatement>()) { throw new SyntaxException("Keyword 'continue' cannot use here!", treeInfo.GetErrorInfo()); } // unreachable code MoveInfo blockInfo = new MoveInfo(treeInfo.CurrentBlock, SearchTree.ContentBlock, treeInfo.CurrentIndex, treeInfo); IElement nextTry = blockInfo.FindNextBlack(SearchDirection.LeftToRight); if (nextTry != null && nextTry is Statement) { scriptInfo.SF.Errors.Add( new WarningError("Unreachable code detected", blockInfo.GetErrorInfo(nextTry))); } }
public override void CheckSemantic(MoveInfo treeInfo, ScriptInfo scriptInfo, CheckingInfo checkingInfo) { string upperName = this._constInfo.Name.ToUpperInvariant(); List <IMemberInfo> members = scriptInfo.SF.SI.GetAvailableMembers(); foreach (IMemberInfo m in members) { if (m.Name.ToUpperInvariant() == upperName) { if ((m as ConstInfo) != this._constInfo) { scriptInfo.SF.Errors.Add( new SemanticError("Member '" + this._constInfo.Name + "' already defined(" + m.SF.SFPath + "::" + m.Name + ")", treeInfo.GetErrorInfo(treeInfo.Current))); } } } }
private static void Parse(MoveInfo parentInfo, ParsingInfo parsingInfo, ScriptInfo scriptInfo) { ContinueStatement continueStatement = new ContinueStatement(); MoveInfo moveInfo = new MoveInfo(parentInfo); // terminal IElement terminalTry = moveInfo.FindNextBlack(SearchDirection.LeftToRight); if (terminalTry == null || !terminalTry.IsTT(TokenType.SemiColon)) { throw new SyntaxException("Missing directive ';'?", parentInfo.GetErrorInfo()); } // build int startIndex = parentInfo.CurrentIndex; int length = (moveInfo.CurrentIndex + 1) - startIndex; continueStatement.AddChildren(parentInfo.CurrentElements.GetRange(startIndex, length)); parentInfo.Replace(length, continueStatement); }
public static void ParseRegion(MoveInfo parentInfo, ParsingInfo parsingInfo, ScriptInfo scriptInfo) { MoveInfo moveInfo = new MoveInfo(parentInfo); List <IElement> content = new List <IElement>(); content.Add(moveInfo.Current); content.Add(moveInfo.Move(SearchDirection.LeftToRight)); moveInfo.Move(SearchDirection.LeftToRight); int nameStart = moveInfo.CurrentIndex; IElement end = moveInfo.Find(SearchDirection.LeftToRight, SearchVisibility.Unvisible, IsRegionEnd); if (end == null) { throw new SyntaxException("Bad region syntax", parentInfo.GetErrorInfo()); } content.AddRange(moveInfo.CurrentElements.GetRange(nameStart, moveInfo.CurrentIndex - nameStart)); IBlock region = new PreProcessorRegion(content); parentInfo.Replace(moveInfo.CurrentIndex - parentInfo.CurrentIndex, region); }
private static void Parse(MoveInfo parentInfo, ParsingInfo parsingInfo, ScriptInfo scriptInfo) { int startIndex = parentInfo.CurrentIndex; MoveInfo moveInfo = new MoveInfo(parentInfo); // modifier MemberAccess access; AccessModifier modifier = AccessModifier.GetModifier(moveInfo, out access); if (modifier != null) { startIndex = moveInfo.CurrentIndex; } // name moveInfo = new MoveInfo(parentInfo); IElement tryName = moveInfo.FindNextBlack(SearchDirection.LeftToRight); if (tryName == null || !tryName.IsTT(TokenType.Word)) { throw new SyntaxException("Could not find using name", parentInfo.GetErrorInfo()); } string name = tryName.ToString(); UsingDef usingDef = new UsingDef(moveInfo.Current.CharIndex, moveInfo.Current.CharLength, moveInfo.Current.LineIndex); // assign moveInfo.FindNextBlack(SearchDirection.LeftToRight); // = moveInfo.FindNextBlack(SearchDirection.LeftToRight); // behind = // expression Path pathTry = Path.Parse(moveInfo, parsingInfo, scriptInfo); if (pathTry == null) { throw new SyntaxException("Could not find using path", parentInfo.GetErrorInfo()); } // terminal IElement terminalTry = moveInfo.FindNextBlack(SearchDirection.LeftToRight); if (terminalTry == null || !(terminalTry.IsTT(TokenType.SemiColon))) { throw new SyntaxException("Missing directive ';'?", parentInfo.GetErrorInfo()); } int length = (moveInfo.CurrentIndex + 1) - startIndex; usingDef.AddChildren(parentInfo.CurrentElements.GetRange(startIndex, length)); parentInfo.MoveToIndex(startIndex); parentInfo.Replace(length, usingDef); // info // add const def to list parsingInfo.UsingDefList.Add(usingDef); /*if (scriptInfo.Constants.FindIndex(a => a.Name == name) != -1) * ErrorManager.Semantic("Constant '" + name + "' already defined", new ErrorInfo(parentInfo.ErrorInfo)); * else * {*/ UsingInfo usingInfo = new UsingInfo(scriptInfo.SF, name, pathTry.ToString(), access, usingDef); scriptInfo.AddUsing(usingInfo); usingDef._usingInfo = usingInfo; //} }