public override bool Parse(ParseContext context, IAstNode parent) { if (context.Tokens.CurrentToken.TokenType == RTokenType.Comma) { this.Comma = RParser.ParseToken(context, this); } return base.Parse(context, parent); }
public override bool Parse(ParseContext context, IAstNode parent) { foreach (RToken t in Tokens) { TokenNode n = new TokenNode(t); n.Parent = this; } return base.Parse(context, parent); }
protected bool ParseSemicolon(ParseContext context, IAstNode parent) { if (!context.Tokens.IsEndOfStream()) { if (!context.Tokens.IsLineBreakAfter(context.TextProvider, context.Tokens.Position - 1)) { if (context.Tokens.CurrentToken.TokenType == RTokenType.Semicolon) { this.Semicolon = RParser.ParseToken(context, this); } else { context.AddError(new ParseError(ParseErrorType.UnexpectedToken, ErrorLocation.Token, context.Tokens.CurrentToken)); return false; } } } return true; }
public override bool Parse(ParseContext context, IAstNode parent) { Debug.Assert(context.Tokens.CurrentToken.TokenType == RTokenType.Keyword); this.Keyword = RParser.ParseKeyword(context, this); this.Text = context.TextProvider.GetText(this.Keyword); bool result = base.Parse(context, parent); if (context.Tokens.CurrentToken.TokenType == RTokenType.Semicolon) { this.Semicolon = RParser.ParseToken(context, this); } return result; }
public override bool Parse(ParseContext context, IAstNode parent) { Debug.Assert(context.Tokens.CurrentToken.TokenType == RTokenType.Operator); OperatorType = TokenOperator.GetOperatorType(context.TextProvider.GetText(context.Tokens.CurrentToken)); OperatorToken = RParser.ParseToken(context, this); Associativity = OperatorAssociativity.GetAssociativity(OperatorType); // If operator is preceded by an operator, it is then unary // Look back two tokens since operator parsing already consumed its token. if (IsUnary || IsUnaryOperator(context.Tokens, context.TextProvider, OperatorType, -2)) { OperatorType = Operator.GetUnaryForm(OperatorType); IsUnary = true; Associativity = Associativity.Right; } return base.Parse(context, parent); }
public override bool Parse(ParseContext context, IAstNode parent) { TokenStream<RToken> tokens = context.Tokens; Debug.Assert(tokens.CurrentToken.TokenType == RTokenType.OpenBrace); this.OpenBrace = RParser.ParseToken(context, this); this.Content = new Expression(inGroup: true); this.Content.Parse(context, this); if (tokens.CurrentToken.TokenType == RTokenType.CloseBrace) { this.CloseBrace = RParser.ParseToken(context, this); } else { context.AddError(new MissingItemParseError(ParseErrorType.CloseBraceExpected, tokens.PreviousToken)); } return base.Parse(context, parent); }
public override bool Parse(ParseContext context, IAstNode parent) { TokenStream<RToken> tokens = context.Tokens; Debug.Assert(tokens.CurrentToken.TokenType == RTokenType.OpenSquareBracket || tokens.CurrentToken.TokenType == RTokenType.OpenDoubleSquareBracket); this.LeftBrackets = RParser.ParseToken(context, this); RTokenType terminatingTokenType = RParser.GetTerminatingTokenType(this.LeftBrackets.Token.TokenType); this.Arguments = new ArgumentList(terminatingTokenType); this.Arguments.Parse(context, this); if (tokens.CurrentToken.TokenType == terminatingTokenType) { this.RightBrackets = RParser.ParseToken(context, this); } else { context.AddError(new MissingItemParseError(ParseErrorType.CloseSquareBracketExpected, tokens.PreviousToken)); } return base.Parse(context, parent); }
public override bool Parse(ParseContext context, IAstNode parent) { if (ParseKeyword(context, parent)) { this.OpenBrace = RParser.ParseOpenBraceSequence(context, this); if (this.OpenBrace != null) { this.ParseExpression(context, this); // Even if expression is broken but we are at // the closing brace we want to recover and continue. if (context.Tokens.CurrentToken.TokenType == Tokens.RTokenType.CloseBrace) { this.CloseBrace = RParser.ParseCloseBraceSequence(context, this); if (this.CloseBrace != null) { this.Parent = parent; return true; } } } } return false; }
public override bool Parse(ParseContext context, IAstNode parent) { if (ParseKeyword(context, this)) { this.OpenBrace = RParser.ParseOpenBraceSequence(context, this); if (this.OpenBrace != null) { RToken token = context.Tokens.CurrentToken; if (token.TokenType == RTokenType.Identifier || token.TokenType == RTokenType.String) { this.Identifier = RParser.ParseToken(context, this); this.CloseBrace = RParser.ParseCloseBraceSequence(context, this); if (this.CloseBrace != null) { this.Parent = parent; return true; } } else { context.AddError(new ParseError(ParseErrorType.IndentifierExpected, ErrorLocation.Token, context.Tokens.CurrentToken)); } } } return false; }
public override bool Parse(ParseContext context, IAstNode parent) { this.Semicolon = RParser.ParseToken(context, this); return(base.Parse(context, parent)); }
public MatchTree(TokenNode matchTreeRoot, string language, double totalPossibleScore) { MatchTreeRoot = matchTreeRoot; Language = language; TotalPossibleScore = totalPossibleScore; }
public ArrayReferenceSyntax(TokenNode idNode, TokenNode openBracketNode, NewExpressionSyntax expressionNode, TokenNode closeBracketNode) : base(idNode, openBracketNode, expressionNode, closeBracketNode) { _id = idNode ?? throw new ArgumentNullException(nameof(idNode)); _open = openBracketNode ?? throw new ArgumentNullException(nameof(openBracketNode)); _expression = expressionNode ?? throw new ArgumentNullException(nameof(expressionNode)); _close = closeBracketNode ?? throw new ArgumentNullException(nameof(closeBracketNode)); }
public ExitStatementSyntax(TokenNode exitNode, NewExpressionSyntax expressionNode) : base(exitNode, expressionNode) { _exit = exitNode ?? throw new ArgumentNullException(nameof(exitNode)); _expression = expressionNode ?? throw new ArgumentNullException(nameof(exitNode)); }
public static Microsoft.CodeAnalysis.CSharp.SyntaxKind TranspileUnaryOperator(this TokenNode tokenNode) { _ = tokenNode ?? throw new ArgumentNullException(nameof(tokenNode)); switch (tokenNode.TokenType) { case SyntaxTokenType.PlusOperator: return(Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnaryPlusExpression); case SyntaxTokenType.MinusOperator: return(Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnaryMinusExpression); case SyntaxTokenType.NotOperator: return(Microsoft.CodeAnalysis.CSharp.SyntaxKind.LogicalNotExpression); default: throw new ArgumentException($"Cannot transpile token of type {tokenNode.TokenType} to an operator of a unary expression."); } }
public TypeSyntax(TokenNode typeNode) : base(typeNode) { _type = typeNode ?? throw new ArgumentNullException(nameof(typeNode)); }
public ExpressionSyntax(TokenNode idNode) : base(idNode) { _id = idNode ?? throw new ArgumentNullException(nameof(idNode)); }
public TypeIdentifierSyntax(TokenNode nothingNode) : base(nothingNode) { _nothing = nothingNode ?? throw new ArgumentNullException(nameof(nothingNode)); }
public IfStatementSyntax(TokenNode ifNode, NewExpressionSyntax expressionNode, TokenNode thenNode, LineDelimiterSyntax eolNode, StatementListSyntax statementListNode, EmptyNode emptyElseClauseNode, TokenNode endifNode) : base(ifNode, expressionNode, thenNode, eolNode, statementListNode, emptyElseClauseNode, endifNode) { _if = ifNode ?? throw new ArgumentNullException(nameof(ifNode)); _expression = expressionNode ?? throw new ArgumentNullException(nameof(expressionNode)); _then = thenNode ?? throw new ArgumentNullException(nameof(thenNode)); _eol = eolNode ?? throw new ArgumentNullException(nameof(eolNode)); _statements = statementListNode ?? throw new ArgumentNullException(nameof(statementListNode)); _emptyElseClause = emptyElseClauseNode ?? throw new ArgumentNullException(nameof(emptyElseClauseNode)); _endif = endifNode ?? throw new ArgumentNullException(nameof(endifNode)); }
public FunctionReferenceSyntax(TokenNode functionNode, TokenNode idNode) : base(functionNode, idNode) { _function = functionNode ?? throw new ArgumentNullException(nameof(functionNode)); _id = idNode ?? throw new ArgumentNullException(nameof(idNode)); }
public ElseifSyntax(TokenNode elseifNode, NewExpressionSyntax expressionNode, TokenNode thenNode, LineDelimiterSyntax eolNode, StatementListSyntax statementsNode, ElseClauseSyntax elseClauseNode) : base(elseifNode, expressionNode, thenNode, eolNode, statementsNode, elseClauseNode) { _elseif = elseifNode ?? throw new ArgumentNullException(nameof(elseifNode)); _expression = expressionNode ?? throw new ArgumentNullException(nameof(expressionNode)); _then = thenNode ?? throw new ArgumentNullException(nameof(thenNode)); _eol = eolNode ?? throw new ArgumentNullException(nameof(eolNode)); _statements = statementsNode ?? throw new ArgumentNullException(nameof(statementsNode)); _elseClause = elseClauseNode ?? throw new ArgumentNullException(nameof(elseClauseNode)); }
private void AddNode(TreeIter parent, TokenNode token) { parent = store.AppendValues(parent, "token", token); AddNode(parent, token.Body); }
public override bool Parse(ParseContext context, IAstNode parent) { this.Semicolon = RParser.ParseToken(context, this); return base.Parse(context, parent); }
public FileSyntax(LineDelimiterSyntax eolNode, DeclarationListSyntax declarationsNode, FunctionListSyntax functionsNode, TokenNode endOfFileNode) : base(eolNode, declarationsNode, functionsNode, endOfFileNode) { _eol = eolNode ?? throw new ArgumentNullException(nameof(eolNode)); _declrs = declarationsNode ?? throw new ArgumentNullException(nameof(declarationsNode)); _functions = functionsNode ?? throw new ArgumentNullException(nameof(functionsNode)); _eof = endOfFileNode ?? throw new ArgumentNullException(nameof(endOfFileNode)); }
public CommaSeparatedExpressionSyntax(TokenNode commaNode, NewExpressionSyntax expressionNode) : base(commaNode, expressionNode) { _comma = commaNode ?? throw new ArgumentNullException(nameof(commaNode)); _expression = expressionNode ?? throw new ArgumentNullException(nameof(expressionNode)); }
public FileSyntax(EmptyNode emptyNode, DeclarationListSyntax declarationsNode, FunctionListSyntax functionsNode, TokenNode endOfFileNode) : base(emptyNode, declarationsNode, functionsNode, endOfFileNode) { _empty = emptyNode ?? throw new ArgumentNullException(nameof(emptyNode)); _declrs = declarationsNode ?? throw new ArgumentNullException(nameof(declarationsNode)); _functions = functionsNode ?? throw new ArgumentNullException(nameof(functionsNode)); _eof = endOfFileNode ?? throw new ArgumentNullException(nameof(endOfFileNode)); }
public ParenthesizedExpressionSyntax(TokenNode openNode, NewExpressionSyntax expressionNode, TokenNode closeNode) : base(openNode, expressionNode, closeNode) { _open = openNode ?? throw new ArgumentNullException(nameof(openNode)); _expression = expressionNode ?? throw new ArgumentNullException(nameof(expressionNode)); _close = closeNode ?? throw new ArgumentNullException(nameof(closeNode)); }
public static Microsoft.CodeAnalysis.CSharp.SyntaxKind TranspileBinaryOperator(this TokenNode tokenNode) { _ = tokenNode ?? throw new ArgumentNullException(nameof(tokenNode)); switch (tokenNode.TokenType) { case SyntaxTokenType.PlusOperator: return(Microsoft.CodeAnalysis.CSharp.SyntaxKind.AddExpression); case SyntaxTokenType.MinusOperator: return(Microsoft.CodeAnalysis.CSharp.SyntaxKind.SubtractExpression); case SyntaxTokenType.MultiplicationOperator: return(Microsoft.CodeAnalysis.CSharp.SyntaxKind.MultiplyExpression); case SyntaxTokenType.DivisionOperator: return(Microsoft.CodeAnalysis.CSharp.SyntaxKind.DivideExpression); case SyntaxTokenType.GreaterThanOperator: return(Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanExpression); case SyntaxTokenType.LessThanOperator: return(Microsoft.CodeAnalysis.CSharp.SyntaxKind.LessThanExpression); case SyntaxTokenType.EqualityOperator: return(Microsoft.CodeAnalysis.CSharp.SyntaxKind.EqualsExpression); // rename EqualsOperator? case SyntaxTokenType.UnequalityOperator: return(Microsoft.CodeAnalysis.CSharp.SyntaxKind.NotEqualsExpression); // rename NotEqualsOperator? case SyntaxTokenType.GreaterOrEqualOperator: return(Microsoft.CodeAnalysis.CSharp.SyntaxKind.GreaterThanOrEqualExpression); case SyntaxTokenType.LessOrEqualOperator: return(Microsoft.CodeAnalysis.CSharp.SyntaxKind.LessThanOrEqualExpression); case SyntaxTokenType.AndOperator: return(Microsoft.CodeAnalysis.CSharp.SyntaxKind.LogicalAndExpression); case SyntaxTokenType.OrOperator: return(Microsoft.CodeAnalysis.CSharp.SyntaxKind.LogicalOrExpression); default: throw new ArgumentException($"Cannot transpile token of type {tokenNode.TokenType} to an operator of a binary expression."); } }
public IntegerSyntax(TokenNode tokenNode) : base(tokenNode) { _token = tokenNode ?? throw new ArgumentNullException(nameof(tokenNode)); }
public CommaSeparatedTypeReferenceSyntax(TokenNode commaNode, TypeReferenceSyntax typeReferenceNode) : base(commaNode, typeReferenceNode) { _comma = commaNode ?? throw new ArgumentNullException(nameof(commaNode)); _type = typeReferenceNode ?? throw new ArgumentNullException(nameof(typeReferenceNode)); }
public FunctionSyntax(EmptyNode emptyNode, TokenNode functionNode, FunctionDeclarationSyntax declarationNode, LineDelimiterSyntax eolNode1, LocalVariableListSyntax localVariableListNode, StatementListSyntax statementListNode, TokenNode endfunctionNode, LineDelimiterSyntax eolNode2) : base(emptyNode, functionNode, declarationNode, eolNode1, localVariableListNode, statementListNode, endfunctionNode, eolNode2) { _empty = emptyNode ?? throw new ArgumentNullException(nameof(emptyNode)); _function = functionNode ?? throw new ArgumentNullException(nameof(functionNode)); _declr = declarationNode ?? throw new ArgumentNullException(nameof(declarationNode)); _eol1 = eolNode1 ?? throw new ArgumentNullException(nameof(eolNode1)); _locals = localVariableListNode ?? throw new ArgumentNullException(nameof(localVariableListNode)); _statements = statementListNode ?? throw new ArgumentNullException(nameof(statementListNode)); _endfunction = endfunctionNode ?? throw new ArgumentNullException(nameof(endfunctionNode)); _eol2 = eolNode2 ?? throw new ArgumentNullException(nameof(eolNode2)); }
public TypeReferenceSyntax(TypeSyntax typeNode, TokenNode idNode) : base(typeNode, idNode) { _type = typeNode ?? throw new ArgumentNullException(nameof(typeNode)); _id = idNode ?? throw new ArgumentNullException(nameof(idNode)); }
public FunctionCallSyntax(TokenNode idNode, TokenNode openParensNode, ArgumentListSyntax argumentListNode, TokenNode closeParensNode) : base(idNode, openParensNode, argumentListNode, closeParensNode) { _id = idNode ?? throw new ArgumentNullException(nameof(idNode)); _open = openParensNode ?? throw new ArgumentNullException(nameof(openParensNode)); _args = argumentListNode ?? throw new ArgumentNullException(nameof(argumentListNode)); _close = closeParensNode ?? throw new ArgumentNullException(nameof(closeParensNode)); }
public GlobalsBlockSyntax(TokenNode globalsNode, LineDelimiterSyntax eolNode, GlobalsDeclarationListSyntax globalsListNode, TokenNode endglobalsNode) : base(globalsNode, eolNode, globalsListNode, endglobalsNode) { _globals = globalsNode ?? throw new ArgumentNullException(nameof(globalsNode)); _eol = eolNode ?? throw new ArgumentNullException(nameof(eolNode)); _globalsList = globalsListNode ?? throw new ArgumentNullException(nameof(globalsListNode)); _endglobals = endglobalsNode ?? throw new ArgumentNullException(nameof(endglobalsNode)); }
internal TokenNode(TokenNode original) : base(original) { this.ValueProvider = original.ValueProvider; this.Format = original.Format; }
public LoopStatementSyntax(TokenNode loopNode, LineDelimiterSyntax eolNode, StatementListSyntax statementListNode, TokenNode endloopNode) : base(loopNode, eolNode, statementListNode, endloopNode) { _loop = loopNode ?? throw new ArgumentNullException(nameof(loopNode)); _eol = eolNode ?? throw new ArgumentNullException(nameof(eolNode)); _statements = statementListNode ?? throw new ArgumentNullException(nameof(statementListNode)); _endloop = endloopNode ?? throw new ArgumentNullException(nameof(endloopNode)); }
public CallStatementSyntax(TokenNode callNode, TokenNode idNode, TokenNode openParensNode, EmptyNode emptyArgumentListNode, TokenNode closeParensNode) : base(callNode, idNode, openParensNode, emptyArgumentListNode, closeParensNode) { _call = callNode ?? throw new ArgumentNullException(nameof(callNode)); _id = idNode ?? throw new ArgumentNullException(nameof(idNode)); _open = openParensNode ?? throw new ArgumentNullException(nameof(openParensNode)); _emptyArgs = emptyArgumentListNode ?? throw new ArgumentNullException(nameof(emptyArgumentListNode)); _close = closeParensNode ?? throw new ArgumentNullException(nameof(closeParensNode)); }
public EqualsValueClauseSyntax(TokenNode assignmentNode, NewExpressionSyntax expressionNode) : base(assignmentNode, expressionNode) { _ass = assignmentNode ?? throw new ArgumentNullException(nameof(assignmentNode)); _expression = expressionNode ?? throw new ArgumentNullException(nameof(expressionNode)); }
public EndOfLineSyntax(TokenNode newlineNode) : base(newlineNode) { _newline = newlineNode ?? throw new ArgumentNullException(nameof(newlineNode)); }
public ReturnStatementSyntax(TokenNode returnNode, NewExpressionSyntax expressionNode) : base(returnNode, expressionNode) { _return = returnNode ?? throw new ArgumentNullException(nameof(returnNode)); _expression = expressionNode ?? throw new ArgumentNullException(nameof(expressionNode)); }
public FunctionDeclarationSyntax(TokenNode idNode, TokenNode takesNodes, ParameterListReferenceSyntax parameterListNode, TokenNode returnsNode, TypeIdentifierSyntax returnTypeNode) : base(idNode, takesNodes, parameterListNode, returnsNode, returnTypeNode) { _id = idNode ?? throw new ArgumentNullException(nameof(idNode)); _takes = takesNodes ?? throw new ArgumentNullException(nameof(takesNodes)); _params = parameterListNode ?? throw new ArgumentNullException(nameof(parameterListNode)); _returns = returnsNode ?? throw new ArgumentNullException(nameof(returnsNode)); _returnType = returnTypeNode ?? throw new ArgumentNullException(nameof(returnTypeNode)); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void extract(org.maltparser.core.syntaxgraph.PhraseStructure phraseStructure, int begin, int end, org.maltparser.core.syntaxgraph.node.PhraseStructureNode parent) throws org.maltparser.core.exception.MaltChainedException private void extract(PhraseStructure phraseStructure, int begin, int end, PhraseStructureNode parent) { SymbolTableHandler symbolTables = phraseStructure.SymbolTables; int index = -1; for (int i = begin; i < end; i++) { if (input[i] == STARTING_BRACKET && (i == begin || input[i - 1] != '\\')) { index = i; break; } } if (index == -1) { TokenNode t = phraseStructure.AddTokenNode(terminalCounter); if (t == null) { close(); throw new MaltChainedException("Bracket Reader error: could not create a terminal node. "); } terminalCounter++; Edge.Edge e = null; if (parent != null) { e = phraseStructure.addPhraseStructureEdge(parent, (PhraseStructureNode)t); } else { close(); throw new MaltChainedException("Bracket Reader error: could not find the parent node. "); } int start = begin; IEnumerator <string> inputColumnsIterator = inputColumns.Keys.GetEnumerator(); IEnumerator <string> edgeLabelsColumnsIterator = edgeLabelColumns.Keys.GetEnumerator(); bool noneNode = false; bool edgeLabels = false; for (int i = begin; i < end; i++) { if (input[i] == EDGELABEL_SEPARATOR || (input[i] == INPUT_SEPARATOR && (i == begin || input[i - 1] != '\\')) || i == end - 1) { if (i == begin && input[i] == EDGELABEL_SEPARATOR) { noneNode = true; } else if (start == begin) { if ((noneNode && input[i] != EDGELABEL_SEPARATOR) || !noneNode) { //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: if (inputColumnsIterator.hasNext()) { //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: t.addLabel(symbolTables.getSymbolTable(inputColumns[inputColumnsIterator.next()].Name), decodeString((i == end - 1)?input.substring(start, end - start):input.substring(start, i - start))); } start = i + 1; if (input[i] == EDGELABEL_SEPARATOR) { edgeLabels = true; } } } else if (edgeLabels && e != null) { //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: if (edgeLabelsColumnsIterator.hasNext()) { //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: e.addLabel(symbolTables.getSymbolTable(edgeLabelColumns[edgeLabelsColumnsIterator.next()].Name), (i == end - 1)?input.substring(start, end - start):input.substring(start, i - start)); } start = i + 1; if (input[i] == INPUT_SEPARATOR && (i == begin || input[i - 1] != '\\')) { edgeLabels = false; } } else if (input[i] == EDGELABEL_SEPARATOR && i != end - 1 && (input[i + 1] != INPUT_SEPARATOR && (i == begin || input[i - 1] != '\\'))) { } else { //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: if (inputColumnsIterator.hasNext()) { //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: t.addLabel(symbolTables.getSymbolTable(inputColumns[inputColumnsIterator.next()].Name), (i == end - 1)?input.substring(start, end - start):input.substring(start, i - start)); } start = i + 1; } } } } else { PhraseStructureNode nt; Edge.Edge e = null; if (parent == null) { nt = phraseStructure.PhraseStructureRoot; } else { nt = phraseStructure.addNonTerminalNode(nonTerminalCounter); if (nt == null) { close(); throw new MaltChainedException("Bracket Reader error: could not create a nonterminal node. "); } nonTerminalCounter++; e = phraseStructure.addPhraseStructureEdge(parent, nt); } IEnumerator <string> phraseLabelColumnsIterator = phraseLabelColumns.Keys.GetEnumerator(); IEnumerator <string> edgeLabelsColumnsIterator = edgeLabelColumns.Keys.GetEnumerator(); int newbegin = begin; int start = begin; for (int i = begin; i < index; i++) { if (input[i] == EDGELABEL_SEPARATOR || i == index - 1) { if (start == newbegin) { //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: if (phraseLabelColumnsIterator.hasNext()) { //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: nt.addLabel(symbolTables.getSymbolTable(phraseLabelColumns[phraseLabelColumnsIterator.next()].Name), (i == index - 1)?input.substring(start, index - start):input.substring(start, i - start)); } start = i + 1; } else if (e != null) { //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: if (edgeLabelsColumnsIterator.hasNext()) { //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: e.addLabel(symbolTables.getSymbolTable(edgeLabelColumns[edgeLabelsColumnsIterator.next()].Name), (i == index - 1)?input.substring(start, index - start):input.substring(start, i - start)); } start = i + 1; } } else if (input[i] == BLANK) { start++; newbegin++; } } bracketing(phraseStructure, index, end, nt); } }
public override bool Parse(ParseContext context, IAstNode parent) { EllipsisToken = RParser.ParseToken(context, this); return base.Parse(context, parent); }