private ExpressionAst ArrayLiteralRule() { ExpressionAst errorExpressionAst = this.UnaryExpressionRule(); ExpressionAst expressionAst = errorExpressionAst; Token token = this.PeekToken(); if (token.Kind != TokenKind.Comma || this._disableCommaOperator) { return errorExpressionAst; } else { List<ExpressionAst> expressionAsts = new List<ExpressionAst>(); expressionAsts.Add(errorExpressionAst); List<ExpressionAst> expressionAsts1 = expressionAsts; while (token.Kind == TokenKind.Comma) { this.SkipToken(); this.SkipNewlines(); errorExpressionAst = this.UnaryExpressionRule(); if (errorExpressionAst != null) { expressionAsts1.Add(errorExpressionAst); token = this.PeekToken(); } else { object[] text = new object[1]; text[0] = token.Text; this.ReportIncompleteInput(Parser.After(token), ParserStrings.MissingExpressionAfterToken, text); errorExpressionAst = new ErrorExpressionAst(token.Extent, null); expressionAsts1.Add(errorExpressionAst); break; } } return new ArrayLiteralAst(Parser.ExtentOf(expressionAst, errorExpressionAst), expressionAsts1); } }
public object VisitErrorExpression(ErrorExpressionAst errorExpressionAst) { throw new UnexpectedElementException(); }
public override AstVisitAction VisitErrorExpression(ErrorExpressionAst ast) { return CheckParent(ast); }
private RedirectionAst RedirectionRule(RedirectionToken redirectionToken, RedirectionAst[] redirections, ref IScriptExtent extent) { RedirectionAst fileRedirectionAst; string allStream; FileRedirectionToken fileRedirectionToken = redirectionToken as FileRedirectionToken; if (fileRedirectionToken != null || redirectionToken as InputRedirectionToken != null) { ExpressionAst singleCommandArgument = this.GetSingleCommandArgument(Parser.CommandArgumentContext.FileName); if (singleCommandArgument == null) { this.ReportError(Parser.After(redirectionToken), ParserStrings.MissingFileSpecification, new object[0]); singleCommandArgument = new ErrorExpressionAst(redirectionToken.Extent, null); } if (fileRedirectionToken != null) { fileRedirectionAst = new FileRedirectionAst(Parser.ExtentOf(fileRedirectionToken, singleCommandArgument), fileRedirectionToken.FromStream, singleCommandArgument, fileRedirectionToken.Append); } else { object[] text = new object[1]; text[0] = redirectionToken.Text; this.ReportError(redirectionToken.Extent, ParserStrings.RedirectionNotSupported, text); extent = Parser.ExtentOf(redirectionToken, singleCommandArgument); return null; } } else { MergingRedirectionToken mergingRedirectionToken = (MergingRedirectionToken)redirectionToken; RedirectionStream fromStream = mergingRedirectionToken.FromStream; RedirectionStream toStream = mergingRedirectionToken.ToStream; if (toStream == RedirectionStream.Output) { if (fromStream == toStream) { object[] objArray = new object[1]; objArray[0] = mergingRedirectionToken.Text; this.ReportError(redirectionToken.Extent, ParserStrings.RedirectionNotSupported, objArray); } } else { object[] text1 = new object[1]; text1[0] = mergingRedirectionToken.Text; this.ReportError(redirectionToken.Extent, ParserStrings.RedirectionNotSupported, text1); toStream = RedirectionStream.Output; } fileRedirectionAst = new MergingRedirectionAst(mergingRedirectionToken.Extent, mergingRedirectionToken.FromStream, toStream); } if (redirections[(int)fileRedirectionAst.FromStream] != null) { RedirectionStream redirectionStream = fileRedirectionAst.FromStream; if (redirectionStream == RedirectionStream.All) { allStream = ParserStrings.AllStream; } else if (redirectionStream == RedirectionStream.Output) { allStream = ParserStrings.OutputStream; } else if (redirectionStream == RedirectionStream.Error) { allStream = ParserStrings.ErrorStream; } else if (redirectionStream == RedirectionStream.Warning) { allStream = ParserStrings.WarningStream; } else if (redirectionStream == RedirectionStream.Verbose) { allStream = ParserStrings.VerboseStream; } else if (redirectionStream == RedirectionStream.Debug) { allStream = ParserStrings.DebugStream; } else if (redirectionStream == RedirectionStream.Host) { allStream = ParserStrings.HostStream; } else { throw PSTraceSource.NewArgumentOutOfRangeException("result.FromStream", (object)fileRedirectionAst.FromStream); } object[] objArray1 = new object[1]; objArray1[0] = allStream; this.ReportError(fileRedirectionAst.Extent, ParserStrings.StreamAlreadyRedirected, objArray1); } else { redirections[(int)fileRedirectionAst.FromStream] = fileRedirectionAst; } extent = fileRedirectionAst.Extent; return fileRedirectionAst; }
public object VisitErrorExpression(ErrorExpressionAst errorExpressionAst) { return ExpressionCache.Constant(1); }
/// <summary/> public virtual object VisitErrorExpression(ErrorExpressionAst errorExpressionAst) { return _decorated.VisitErrorExpression(errorExpressionAst); }
private ExpressionAst ElementAccessRule(ExpressionAst primaryExpression, Token lBracket) { //G element-access: //G primary-expression '[' new-lines:opt expression new-lines:opt ']' SkipNewlines(); ExpressionAst indexExpr = ExpressionRule(); if (indexExpr == null) { // ErrorRecovery: hope we see a closing bracket. If we don't, we'll pretend we saw // the closing bracket, but build an expression that can't compile. var errorExtent = After(lBracket); ReportIncompleteInput(errorExtent, () => ParserStrings.MissingArrayIndexExpression); indexExpr = new ErrorExpressionAst(lBracket.Extent); } SkipNewlines(); Token rBracket = NextToken(); if (rBracket.Kind != TokenKind.RBracket) { // ErrorRecovery: just pretend we had a closing bracket and continue parsing. UngetToken(rBracket); // Skip reporting the error if we've already reported a missing index. if (!(indexExpr is ErrorExpressionAst)) { ReportIncompleteInput(After(indexExpr), () => ParserStrings.MissingEndSquareBracket); } rBracket = null; } return new IndexExpressionAst(ExtentOf(primaryExpression, ExtentFromFirstOf(rBracket, indexExpr)), primaryExpression, indexExpr); }
public object VisitErrorExpression(ErrorExpressionAst errorExpressionAst) { throw PSTraceSource.NewArgumentException("ast"); }
private ExpressionAst ExpressionRule() { //G expression: //G logical-expression //G //G logical-expression: //G bitwise-expression //G logical-expression '-and' new-lines:opt bitwise-expression //G logical-expression '-or' new-lines:opt bitwise-expression //G logical-expression '-xor' new-lines:opt bitwise-expression //G //G bitwise-expression: //G comparison-expression //G bitwise-expression '-band' new-lines:opt comparison-expression //G bitwise-expression '-bor' new-lines:opt comparison-expression //G bitwise-expression '-bxor' new-lines:opt comparison-expression //G //G comparison-expression: //G additive-expression //G comparison-expression comparison-operator new-lines:opt additive-expression //G //G additive-expression: //G multiplicative-expression //G additive-expression '+' new-lines:opt multiplicative-expression //G additive-expression dash new-lines:opt multiplicative-expression //G //G multiplicative-expression: //G format-expression //G multiplicative-expression '*' new-lines:opt format-expression //G multiplicative-expression '/' new-lines:opt format-expression //G multiplicative-expression '%' new-lines:opt format-expression //G //G format-expression: //G range-expression //G format-expression format-operator new-lines:opt range-expression //G //G range-expression: //G array-literal-expression //G range-expression '..' new-lines:opt array-literal-expression RuntimeHelpers.EnsureSufficientExecutionStack(); var oldTokenizerMode = _tokenizer.Mode; try { SetTokenizerMode(TokenizerMode.Expression); ExpressionAst lhs, rhs; ExpressionAst expr = ArrayLiteralRule(); if (expr == null) { return null; } ParameterToken paramToken; Token token = PeekToken(); if (!token.Kind.HasTrait(TokenFlags.BinaryOperator)) { paramToken = token as ParameterToken; if (paramToken != null) { return ErrorRecoveryParameterInExpression(paramToken, expr); } return expr; } SkipToken(); Stack<ExpressionAst> operandStack = new Stack<ExpressionAst>(); Stack<Token> operatorStack = new Stack<Token>(); operandStack.Push(expr); operatorStack.Push(token); int precedence = token.Kind.GetBinaryPrecedence(); while (true) { SkipNewlines(); expr = ArrayLiteralRule(); if (expr == null) { // ErrorRecovery: create an error expression to fill out the ast and keep parsing. IScriptExtent extent = After(token); // Use token.Text, not token.Kind.Text() b/c the kind might not match the actual operator used // when a case insensitive operator is used. ReportIncompleteInput(extent, () => ParserStrings.ExpectedValueExpression, token.Text); expr = new ErrorExpressionAst(extent); } operandStack.Push(expr); token = NextToken(); if (!token.Kind.HasTrait(TokenFlags.BinaryOperator)) { // Remember the token that we stopped on, but only parameters, used for error recovery paramToken = token as ParameterToken; UngetToken(token); break; } int newPrecedence = token.Kind.GetBinaryPrecedence(); while (newPrecedence <= precedence) { rhs = operandStack.Pop(); lhs = operandStack.Pop(); Token op = operatorStack.Pop(); operandStack.Push(new BinaryExpressionAst(ExtentOf(lhs, rhs), lhs, op.Kind, rhs, op.Extent)); if (operatorStack.Count == 0) break; precedence = operatorStack.Peek().Kind.GetBinaryPrecedence(); } operatorStack.Push(token); precedence = newPrecedence; } rhs = operandStack.Pop(); Diagnostics.Assert(operandStack.Count == operatorStack.Count, "Stacks out of sync"); while (operandStack.Count > 0) { lhs = operandStack.Pop(); token = operatorStack.Pop(); rhs = new BinaryExpressionAst(ExtentOf(lhs, rhs), lhs, token.Kind, rhs, token.Extent); } if (paramToken != null) { return ErrorRecoveryParameterInExpression(paramToken, rhs); } return rhs; } finally { SetTokenizerMode(oldTokenizerMode); } }
private ExpressionAst ArrayLiteralRule() { //G array-literal-expression: //G unary-expression //G unary-expression ',' new-lines:opt array-literal-expression ExpressionAst lastExpr = UnaryExpressionRule(); ExpressionAst firstExpr = lastExpr; Token commaToken = PeekToken(); if (commaToken.Kind != TokenKind.Comma || _disableCommaOperator) { return lastExpr; } var arrayValues = new List<ExpressionAst> { lastExpr }; while (commaToken.Kind == TokenKind.Comma) { SkipToken(); SkipNewlines(); lastExpr = UnaryExpressionRule(); if (lastExpr == null) { // ErrorRecovery: create an error expression for the ast and break. ReportIncompleteInput(After(commaToken), () => ParserStrings.MissingExpressionAfterToken, commaToken.Text); lastExpr = new ErrorExpressionAst(commaToken.Extent); arrayValues.Add(lastExpr); break; } arrayValues.Add(lastExpr); commaToken = PeekToken(); } return new ArrayLiteralAst(ExtentOf(firstExpr, lastExpr), arrayValues); }
private RedirectionAst RedirectionRule(RedirectionToken redirectionToken, RedirectionAst[] redirections, ref IScriptExtent extent) { //G redirections: //G redirection //G redirections redirection //G redirection: //G merging-redirection-operator //G file-redirection-operator redirected-file-name //G redirected-file-name: //G command-argument //G primary-expression RedirectionAst result; var fileRedirectionToken = redirectionToken as FileRedirectionToken; if (fileRedirectionToken != null || (redirectionToken is InputRedirectionToken)) { // get location var filename = GetSingleCommandArgument(CommandArgumentContext.FileName); if (filename == null) { // ErrorRecovery: Just pretend we have a filename and continue parsing. ReportError(After(redirectionToken), () => ParserStrings.MissingFileSpecification); filename = new ErrorExpressionAst(redirectionToken.Extent); } if (fileRedirectionToken == null) { // Must be an input redirection ReportError(redirectionToken.Extent, () => ParserStrings.RedirectionNotSupported, redirectionToken.Text); extent = ExtentOf(redirectionToken, filename); return null; } result = new FileRedirectionAst(ExtentOf(fileRedirectionToken, filename), fileRedirectionToken.FromStream, filename, fileRedirectionToken.Append); } else { var mergingRedirectionToken = (MergingRedirectionToken)redirectionToken; RedirectionStream fromStream = mergingRedirectionToken.FromStream; RedirectionStream toStream = mergingRedirectionToken.ToStream; if (toStream != RedirectionStream.Output) { // Have we seen something like 1>&2 or 2>&3 // ErrorRecovery: This is just a semantic error, so no special recovery. ReportError(redirectionToken.Extent, () => ParserStrings.RedirectionNotSupported, mergingRedirectionToken.Text); toStream = RedirectionStream.Output; } else if (fromStream == toStream) { // Make sure 1>&1, 2>&2, etc. is an error. // ErrorRecovery: This is just a semantic error, so no special recovery. ReportError(redirectionToken.Extent, () => ParserStrings.RedirectionNotSupported, mergingRedirectionToken.Text); } result = new MergingRedirectionAst(mergingRedirectionToken.Extent, mergingRedirectionToken.FromStream, toStream); } if (redirections[(int)result.FromStream] == null) { redirections[(int)result.FromStream] = result; } else { string errorStream; switch (result.FromStream) { case RedirectionStream.All: errorStream = ParserStrings.AllStream; break; case RedirectionStream.Output: errorStream = ParserStrings.OutputStream; break; case RedirectionStream.Error: errorStream = ParserStrings.ErrorStream; break; case RedirectionStream.Warning: errorStream = ParserStrings.WarningStream; break; case RedirectionStream.Verbose: errorStream = ParserStrings.VerboseStream; break; case RedirectionStream.Debug: errorStream = ParserStrings.DebugStream; break; case RedirectionStream.Information: errorStream = ParserStrings.InformationStream; break; default: throw PSTraceSource.NewArgumentOutOfRangeException("result.FromStream", result.FromStream); } ReportError(result.Extent, () => ParserStrings.StreamAlreadyRedirected, errorStream); } extent = result.Extent; return result; }
/// <summary> /// Parse a dynamic keyword statement which will be either of the form /// keyword [parameters] [name] { a=1; b=2; } # constructor with properties /// or /// keyword [parameters] [name] { ... } # constructor with a simple body. /// or keywordcommand parameters /// This custom keyword does not introduce a new AST node type. Instead it generates a /// CommandAst that calls a PowerShell command to implement the keyword's logic. /// This command has one of two signatures: /// keywordImplCommand /// </summary> /// <param name="functionName">The name of the function to invoke</param> /// <param name="keywordData">The data for this keyword definition</param> /// <returns></returns> private StatementAst DynamicKeywordStatementRule(Token functionName, DynamicKeyword keywordData) { ////////////////////////////////////////////////////////////////////////////////// // If a custom action was provided. then invoke it ////////////////////////////////////////////////////////////////////////////////// if (keywordData.PreParse != null) { try { ParseError[] errors = keywordData.PreParse(keywordData); if (errors != null && errors.Length > 0) { foreach (var e in errors) { ReportError(e); } } } catch (Exception e) { ReportError(functionName.Extent, () => ParserStrings.DynamicKeywordPreParseException, keywordData.ResourceName, e.ToString()); return null; } } if (keywordData.IsReservedKeyword) { // ErrorRecovery: eat the token ReportError(functionName.Extent, () => ParserStrings.UnsupportedReservedKeyword, keywordData.Keyword); return null; } if (keywordData.HasReservedProperties) { // ErrorRecovery: eat the token ReportError(functionName.Extent, () => ParserStrings.UnsupportedReservedProperty, "'Require', 'Trigger', 'Notify', 'Before', 'After' and 'Subscribe'"); return null; } string elementName = string.Empty; DynamicKeywordStatementAst dynamicKeywordAst; if (keywordData.BodyMode == DynamicKeywordBodyMode.Command) { UngetToken(functionName); dynamicKeywordAst = (DynamicKeywordStatementAst)CommandRule(forDynamicKeyword: true); dynamicKeywordAst.Keyword = keywordData; dynamicKeywordAst.FunctionName = functionName; } else { SkipNewlines(); // The expression that returns the resource name or names. ExpressionAst instanceName = null; Token nameToken = NextToken(); if (nameToken.Kind == TokenKind.EndOfInput) { UngetToken(nameToken); if (keywordData.NameMode == DynamicKeywordNameMode.NameRequired || keywordData.NameMode == DynamicKeywordNameMode.SimpleNameRequired) { ReportIncompleteInput(After(functionName), () => ParserStrings.RequiredNameOrExpressionMissing); } else { // Name not required so report missing brace ReportIncompleteInput(After(functionName.Extent), () => ParserStrings.MissingBraceInObjectDefinition); } return null; } // If it's an lcurly, then no name was provided, and we skip to the body processing Token lCurly = null; if (nameToken.Kind == TokenKind.LCurly) { lCurly = nameToken; if (keywordData.NameMode == DynamicKeywordNameMode.NameRequired || keywordData.NameMode == DynamicKeywordNameMode.SimpleNameRequired) { ReportError(After(functionName), () => ParserStrings.RequiredNameOrExpressionMissing); UngetToken(nameToken); return null; } } else if (nameToken.Kind == TokenKind.Identifier || nameToken.Kind == TokenKind.DynamicKeyword) { if (keywordData.NameMode == DynamicKeywordNameMode.NoName) { ReportError(After(functionName), () => ParserStrings.UnexpectedNameForType, functionName.Text, nameToken.Text); UngetToken(nameToken); return null; } // If it's an identifier then this is the name for the data object elementName = nameToken.Text; // If only a simple name is allowed, then the string must be non-null. if ((keywordData.NameMode == DynamicKeywordNameMode.SimpleNameRequired || keywordData.NameMode == DynamicKeywordNameMode.SimpleOptionalName) && string.IsNullOrEmpty(elementName)) { ReportIncompleteInput(After(functionName), () => ParserStrings.RequiredNameOrExpressionMissing); UngetToken(nameToken); return null; } } else { // see if an expression was provided instead of a bare word... UngetToken(nameToken); instanceName = GetSingleCommandArgument(CommandArgumentContext.CommandName); if (instanceName == null) { if (keywordData.NameMode == DynamicKeywordNameMode.SimpleNameRequired || keywordData.NameMode == DynamicKeywordNameMode.SimpleOptionalName) { ReportError(After(functionName), () => ParserStrings.RequiredNameOrExpressionMissing); } else { // It wasn't an '{' and it wasn't a name expression so it's a unexpected token. ReportError(After(functionName), () => ParserStrings.UnexpectedToken, nameToken.Text); } return null; } // Ok, we got a name expression, but we're expecting no name, so it's and error. if (keywordData.NameMode == DynamicKeywordNameMode.NoName) { ReportError(After(functionName), () => ParserStrings.UnexpectedNameForType, functionName.Text, instanceName.ToString()); return null; } // We were expecting a simple name so report an error if (keywordData.NameMode == DynamicKeywordNameMode.SimpleNameRequired || keywordData.NameMode == DynamicKeywordNameMode.SimpleOptionalName) { // If no match, then this is an incomplete token BUGBUG fix message ReportError(nameToken.Extent, () => ParserStrings.UnexpectedToken, nameToken.Text); return null; } } // If we didn't get a resource expression AST, then we need to build one out of the // name that was specified. It may be the case that we don't have // a resource name in which case it will be the empty string. Even in the cases were // we aren't expecting a name, we still do this so that the signature of the implementing function remains // the same. ExpressionAst originalInstanceName = instanceName; if (instanceName == null) { instanceName = new StringConstantExpressionAst(nameToken.Extent, elementName, StringConstantType.BareWord); } SkipNewlines(); // // Now look for the body of the data statement. // if (lCurly == null) { lCurly = NextToken(); if (lCurly.Kind == TokenKind.EndOfInput) { UngetToken(lCurly); ReportIncompleteInput(After(functionName.Extent), () => ParserStrings.MissingBraceInObjectDefinition); // Preserve the name expression for tab completion return originalInstanceName == null ? null : new ErrorStatementAst(ExtentOf(functionName, originalInstanceName), GetNestedErrorAsts(originalInstanceName)); } if (lCurly.Kind != TokenKind.LCurly) { // We need to generate a reasonable error message for this case: // // Configuration C { // node $AllNode.NodeName{ # There is no space before curly, and we are converting scriptblock to and argument to call 'NodeName' // ... // } // } # we don't want to simple report an unexpected token here, it would be super-confusing. InvokeMemberExpressionAst instanceInvokeMemberExpressionAst = instanceName as InvokeMemberExpressionAst; if (instanceInvokeMemberExpressionAst != null && instanceInvokeMemberExpressionAst.Arguments.Count == 1 && instanceInvokeMemberExpressionAst.Arguments[0] is ScriptBlockExpressionAst && // the last condition checks that there is no space between "method" name and '{' instanceInvokeMemberExpressionAst.Member.Extent.EndOffset == instanceInvokeMemberExpressionAst.Arguments[0].Extent.StartOffset) { ReportError(LastCharacterOf(instanceInvokeMemberExpressionAst.Member.Extent), () => ParserStrings.UnexpectedTokenInDynamicKeyword, functionName.Text); } else { ReportError(lCurly.Extent, () => ParserStrings.UnexpectedToken, lCurly.Text); } if (lCurly.Kind == TokenKind.Dot && originalInstanceName != null && lCurly.Extent.StartOffset == originalInstanceName.Extent.EndOffset) { // Generate more useful ast for tab-completing extension methods on special DSC collection variables // e.g. configuration foo { node $AllNodes.<tab> IScriptExtent errorExtent = ExtentOf(originalInstanceName, lCurly); var errorExpr = new ErrorExpressionAst(errorExtent); var memberExpr = new MemberExpressionAst(originalInstanceName.Extent, originalInstanceName, errorExpr, @static: false); return new ErrorStatementAst(errorExtent, new[] { memberExpr }); } UngetToken(lCurly); // Preserve the name expression for tab completion return originalInstanceName == null ? null : new ErrorStatementAst(ExtentOf(functionName, originalInstanceName), GetNestedErrorAsts(originalInstanceName)); } } // // The keyword data is used to see // if a scriptblock or a hashtable is expected. // ExpressionAst body = null; if (keywordData.BodyMode == DynamicKeywordBodyMode.ScriptBlock) { var oldInConfiguraiton = _inConfiguration; try { _inConfiguration = false; body = ScriptBlockExpressionRule(lCurly); } finally { _inConfiguration = oldInConfiguraiton; } } else if (keywordData.BodyMode == DynamicKeywordBodyMode.Hashtable) { // Resource property value could be set to nested DSC resources except Script resource bool isScriptResource = String.Compare(functionName.Text, @"Script", StringComparison.OrdinalIgnoreCase) == 0; try { if (isScriptResource) DynamicKeyword.Push(); body = HashExpressionRule(lCurly, true /* parsingSchemaElement */); } finally { if (isScriptResource) DynamicKeyword.Pop(); } } // commandast // elements: instancename/dynamickeyword/hashtable or scripblockexpress if (body == null) { // Failed to read the statement body ReportIncompleteInput(After(lCurly), () => ParserStrings.MissingStatementAfterKeyword, keywordData.Keyword); // Preserve the name expression for tab completion return originalInstanceName == null ? null : new ErrorStatementAst(ExtentOf(functionName, originalInstanceName), GetNestedErrorAsts(originalInstanceName)); } ////////////////////////////////////////////////////////////////////////// // The statement is now fully parsed ////////////////////////////////////////////////////////////////////////// // // Create DynamicKeywordStatementAst // Collection<CommandElementAst> commandElements = new Collection<CommandElementAst> { new StringConstantExpressionAst(functionName.Extent, functionName.Text, StringConstantType.BareWord), (ExpressionAst)instanceName.Copy(), (ExpressionAst)body.Copy() }; Token nextToken = NextToken(); IScriptExtent dynamicKeywordExtent = ExtentOf(functionName, Before(nextToken)); UngetToken(nextToken); dynamicKeywordAst = new DynamicKeywordStatementAst(dynamicKeywordExtent, commandElements) { Keyword = keywordData, LCurly = lCurly, FunctionName = functionName, InstanceName = instanceName, OriginalInstanceName = originalInstanceName, BodyExpression = body, ElementName = elementName, }; } ////////////////////////////////////////////////////////////////////////////////// // If a custom action was provided. then invoke it ////////////////////////////////////////////////////////////////////////////////// if (keywordData.PostParse != null) { try { ParseError[] errors = keywordData.PostParse(dynamicKeywordAst); if (errors != null && errors.Length > 0) { foreach (var e in errors) { ReportError(e); } } } catch (Exception e) { ReportError(functionName.Extent, () => ParserStrings.DynamicKeywordPostParseException, keywordData.Keyword, e.ToString()); return null; } } return dynamicKeywordAst; }
private void AttributeArgumentsRule(ICollection<ExpressionAst> positionalArguments, ICollection<NamedAttributeArgumentAst> namedArguments, ref IScriptExtent lastItemExtent) { //G attribute-arguments: //G attribute-argument //G attribute-argument new-lines:opt ',' attribute-arguments //G attribute-argument: //G new-lines:opt expression //G new-lines:opt property-name '=' new-lines:opt expression bool oldDisableCommaOperator = _disableCommaOperator; Token commaToken = null; HashSet<string> keysSeen = new HashSet<string>(); try { _disableCommaOperator = true; while (true) { SkipNewlines(); StringConstantExpressionAst name = SimpleNameRule(); ExpressionAst expr; bool expressionOmitted = false; if (name != null) { Token token = PeekToken(); if (token.Kind == TokenKind.Equals) { token = NextToken(); SkipNewlines(); expr = ExpressionRule(); if (expr == null) { // ErrorRecovery: ? IScriptExtent errorPosition = After(token); ReportIncompleteInput(errorPosition, () => ParserStrings.MissingExpressionInNamedArgument); expr = new ErrorExpressionAst(errorPosition); SyncOnError(true, TokenKind.Comma, TokenKind.RParen, TokenKind.RBracket, TokenKind.NewLine); } lastItemExtent = expr.Extent; } else { // If the expression is missing, assume the value true // and record that it was defaulted for better error messages. expr = new ConstantExpressionAst(name.Extent, true); expressionOmitted = true; NoteV3FeatureUsed(); } } else { expr = ExpressionRule(); } if (name != null) { if (keysSeen.Contains(name.Value)) { // ErrorRecovery: this is a semantic error, so just keep parsing. ReportError(name.Extent, () => ParserStrings.DuplicateNamedArgument, name.Value); } else { namedArguments.Add(new NamedAttributeArgumentAst(ExtentOf(name, expr), name.Value, expr, expressionOmitted)); } } else if (expr != null) { positionalArguments.Add(expr); lastItemExtent = expr.Extent; } else if (commaToken != null) { // ErrorRecovery: Pretend we saw the argument and keep going. IScriptExtent errorExtent = After(commaToken); ReportIncompleteInput(errorExtent, () => ParserStrings.MissingExpressionAfterToken, commaToken.Kind.Text()); positionalArguments.Add(new ErrorExpressionAst(errorExtent)); lastItemExtent = errorExtent; } SkipNewlines(); commaToken = PeekToken(); if (commaToken.Kind != TokenKind.Comma) { break; } lastItemExtent = commaToken.Extent; SkipToken(); } } finally { _disableCommaOperator = oldDisableCommaOperator; } }
public override AstVisitAction VisitErrorExpression(ErrorExpressionAst ast) { return this.Check(ast); }
private ExpressionAst ElementAccessRule(ExpressionAst primaryExpression, Token lBracket) { this.SkipNewlines(); ExpressionAst errorExpressionAst = this.ExpressionRule(); if (errorExpressionAst == null) { IScriptExtent scriptExtent = Parser.After(lBracket); this.ReportIncompleteInput(scriptExtent, ParserStrings.MissingArrayIndexExpression, new object[0]); errorExpressionAst = new ErrorExpressionAst(lBracket.Extent, null); } this.SkipNewlines(); Token token = this.NextToken(); if (token.Kind != TokenKind.RBracket) { this.UngetToken(token); if (errorExpressionAst as ErrorExpressionAst == null) { this.ReportIncompleteInput(Parser.After(errorExpressionAst), ParserStrings.MissingEndSquareBracket, new object[0]); } token = null; } object[] objArray = new object[2]; objArray[0] = token; objArray[1] = errorExpressionAst; return new IndexExpressionAst(Parser.ExtentOf(primaryExpression, Parser.ExtentFromFirstOf(objArray)), primaryExpression, errorExpressionAst); }
public object VisitErrorExpression(ErrorExpressionAst errorExpressionAst) { return AutomationNull.Value; }
private void AttributeArgumentsRule(ICollection<ExpressionAst> positionalArguments, ICollection<NamedAttributeArgumentAst> namedArguments, ref IScriptExtent lastItemExtent) { ExpressionAst constantExpressionAst; bool flag = this._disableCommaOperator; Token token = null; HashSet<string> strs = new HashSet<string>(); try { this._disableCommaOperator = true; while (true) { this.SkipNewlines(); StringConstantExpressionAst stringConstantExpressionAst = this.SimpleNameRule(); bool flag1 = false; if (stringConstantExpressionAst == null) { constantExpressionAst = this.ExpressionRule(); } else { Token token1 = this.PeekToken(); if (token1.Kind != TokenKind.Equals) { constantExpressionAst = new ConstantExpressionAst(stringConstantExpressionAst.Extent, (object)(true)); flag1 = true; this.NoteV3FeatureUsed(); } else { token1 = this.NextToken(); this.SkipNewlines(); constantExpressionAst = this.ExpressionRule(); if (constantExpressionAst == null) { IScriptExtent scriptExtent = Parser.After(token1); this.ReportIncompleteInput(scriptExtent, ParserStrings.MissingExpressionInNamedArgument, new object[0]); constantExpressionAst = new ErrorExpressionAst(scriptExtent, null); TokenKind[] tokenKindArray = new TokenKind[4]; tokenKindArray[0] = TokenKind.Comma; tokenKindArray[1] = TokenKind.RParen; tokenKindArray[2] = TokenKind.RBracket; tokenKindArray[3] = TokenKind.NewLine; this.SyncOnError(tokenKindArray); } lastItemExtent = constantExpressionAst.Extent; } } if (stringConstantExpressionAst == null) { if (constantExpressionAst == null) { if (token != null) { IScriptExtent scriptExtent1 = Parser.After(token); object[] objArray = new object[1]; objArray[0] = token.Kind.Text(); this.ReportIncompleteInput(scriptExtent1, ParserStrings.MissingExpressionAfterToken, objArray); positionalArguments.Add(new ErrorExpressionAst(scriptExtent1, null)); lastItemExtent = scriptExtent1; } } else { positionalArguments.Add(constantExpressionAst); lastItemExtent = constantExpressionAst.Extent; } } else { if (!strs.Contains(stringConstantExpressionAst.Value)) { namedArguments.Add(new NamedAttributeArgumentAst(Parser.ExtentOf(stringConstantExpressionAst, constantExpressionAst), stringConstantExpressionAst.Value, constantExpressionAst, flag1)); } else { object[] value = new object[1]; value[0] = stringConstantExpressionAst.Value; this.ReportError(stringConstantExpressionAst.Extent, ParserStrings.DuplicateNamedArgument, value); } } this.SkipNewlines(); token = this.PeekToken(); if (token.Kind != TokenKind.Comma) { break; } lastItemExtent = token.Extent; this.SkipToken(); } } finally { this._disableCommaOperator = flag; } }
public virtual AstVisitAction VisitErrorExpression(ErrorExpressionAst errorExpressionAst) { return AstVisitAction.Continue; }
private ExpressionAst ExpressionRule() { ExpressionAst expressionAst; ExpressionAst binaryExpressionAst; ParameterToken parameterToken; ExpressionAst expressionAst1; RuntimeHelpers.EnsureSufficientExecutionStack(); TokenizerMode mode = this._tokenizer.Mode; try { this.SetTokenizerMode(TokenizerMode.Expression); ExpressionAst errorExpressionAst = this.ArrayLiteralRule(); if (errorExpressionAst != null) { Token token = this.PeekToken(); if (token.Kind.HasTrait(TokenFlags.BinaryOperator)) { this.SkipToken(); Stack<ExpressionAst> expressionAsts = new Stack<ExpressionAst>(); Stack<Token> tokens = new Stack<Token>(); expressionAsts.Push(errorExpressionAst); tokens.Push(token); int binaryPrecedence = token.Kind.GetBinaryPrecedence(); while (true) { this.SkipNewlines(); errorExpressionAst = this.ArrayLiteralRule(); if (errorExpressionAst == null) { IScriptExtent scriptExtent = Parser.After(token); object[] text = new object[1]; text[0] = token.Text; this.ReportIncompleteInput(scriptExtent, ParserStrings.ExpectedValueExpression, text); errorExpressionAst = new ErrorExpressionAst(scriptExtent, null); } expressionAsts.Push(errorExpressionAst); token = this.NextToken(); if (!token.Kind.HasTrait(TokenFlags.BinaryOperator)) { break; } int num = token.Kind.GetBinaryPrecedence(); while (num <= binaryPrecedence) { binaryExpressionAst = expressionAsts.Pop(); expressionAst = expressionAsts.Pop(); Token token1 = tokens.Pop(); expressionAsts.Push(new BinaryExpressionAst(Parser.ExtentOf(expressionAst, binaryExpressionAst), expressionAst, token1.Kind, binaryExpressionAst, token1.Extent)); if (tokens.Count == 0) { break; } binaryPrecedence = tokens.Peek().Kind.GetBinaryPrecedence(); } tokens.Push(token); binaryPrecedence = num; } parameterToken = token as ParameterToken; this.UngetToken(token); binaryExpressionAst = expressionAsts.Pop(); while (expressionAsts.Any<ExpressionAst>()) { expressionAst = expressionAsts.Pop(); token = tokens.Pop(); binaryExpressionAst = new BinaryExpressionAst(Parser.ExtentOf(expressionAst, binaryExpressionAst), expressionAst, token.Kind, binaryExpressionAst, token.Extent); } if (parameterToken == null) { expressionAst1 = binaryExpressionAst; } else { expressionAst1 = this.ErrorRecoveryParameterInExpression(parameterToken, binaryExpressionAst); } } else { parameterToken = token as ParameterToken; if (parameterToken == null) { expressionAst1 = errorExpressionAst; } else { expressionAst1 = this.ErrorRecoveryParameterInExpression(parameterToken, errorExpressionAst); } } } else { expressionAst1 = null; } } finally { this.SetTokenizerMode(mode); } return expressionAst1; }
/// <summary> /// Visit error expression /// </summary> /// <param name="errorExpressionAst"></param> /// <returns></returns> public object VisitErrorExpression(ErrorExpressionAst errorExpressionAst) { return null; }
private ExpressionAst MemberAccessRule(ExpressionAst targetExpr, Token operatorToken) { CommandElementAst commandElementAst = this.MemberNameRule(); if (commandElementAst != null) { Token token = this.NextInvokeMemberToken(); if (token != null) { return this.MemberInvokeRule(targetExpr, token, operatorToken, commandElementAst); } } else { this.ReportIncompleteInput(Parser.After(operatorToken), ParserStrings.MissingPropertyName, new object[0]); ExpressionAst singleCommandArgument = this.GetSingleCommandArgument(Parser.CommandArgumentContext.CommandArgument); CommandElementAst errorExpressionAst = singleCommandArgument; if (singleCommandArgument == null) { errorExpressionAst = new ErrorExpressionAst(Parser.ExtentOf(targetExpr, operatorToken), null); } commandElementAst = errorExpressionAst; } return new MemberExpressionAst(Parser.ExtentOf(targetExpr, commandElementAst), targetExpr, commandElementAst, operatorToken.Kind == TokenKind.ColonColon); }
public object VisitErrorExpression(ErrorExpressionAst errorExpressionAst) { return false; }
public object VisitErrorExpression(ErrorExpressionAst errorExpressionAst) { throw new NotImplementedException(); }