C# Framework.Token类代码示例

 public ArrayTypeNode(Token arrayKeywordNode, Token openBracketNode, ListNode<DelimitedItemNode<AstNode>> indexListNode, Token closeBracketNode, Token ofKeywordNode, AstNode typeNode)
 {
     _arrayKeywordNode = arrayKeywordNode;
     _openBracketNode = openBracketNode;
     _indexListNode = indexListNode;
     _closeBracketNode = closeBracketNode;
     _ofKeywordNode = ofKeywordNode;
     _typeNode = typeNode;
 }

 public AnonMethodHeadingNode(Token methodType, Token openParenthesis, ListNode<DelimitedItemNode<ParameterNode>> parameterList, Token closeParenthesis, Token colon, AstNode returnType)
 {
     MethodType = methodType;
     OpenParenthesis = openParenthesis;
     ParameterList = parameterList;
     CloseParenthesis = closeParenthesis;
     Colon = colon;
     ReturnType = returnType;
 }

        public Token NextToken()
        {
            while(_index < _source.Length && Char.IsWhiteSpace(_source[_index]))
                ++_index;
            if(_index >= _source.Length)
                return null;

            Match match = NextMatch();
            if(match == null)
                throw new LexException("Unrecognized character '" + _source[_index] + "'", Location);
            string text = _source.Substring(_index, match.Length);
            Token result = new Token(match.TokenType, Location, text, match.ParsedText);
            _index += match.Length;
            return result;
        }

 private IEnumerable<Token> GetSourceTokensForInclude(Token token, string baseName)
 {
     string currentDirectory = token.Location.Directory;
     string fileName = _fileLoader.ExpandFileName(currentDirectory, baseName);
     string source = _fileLoader.Load(fileName);
     Lexer lexer = new Lexer(source, fileName);
     return lexer.Tokens;
 }

 public virtual void VisitToken(Token token)
 {
 }

 public ConstantDeclNode(Token nameNode, Token colonNode, AstNode typeNode, Token equalSignNode, AstNode valueNode, ListNode<Token> portabilityDirectiveListNode, Token semicolonNode)
 {
     _nameNode = nameNode;
     _colonNode = colonNode;
     _typeNode = typeNode;
     _equalSignNode = equalSignNode;
     _valueNode = valueNode;
     _portabilityDirectiveListNode = portabilityDirectiveListNode;
     _semicolonNode = semicolonNode;
 }

 public ClassOfNode(Token classKeywordNode, Token ofKeywordNode, AstNode typeNode)
 {
     _classKeywordNode = classKeywordNode;
     _ofKeywordNode = ofKeywordNode;
     _typeNode = typeNode;
 }

 public WhileStatementNode(Token whileKeywordNode, AstNode conditionNode, Token doKeywordNode, AstNode statementNode)
 {
     _whileKeywordNode = whileKeywordNode;
     _conditionNode = conditionNode;
     _doKeywordNode = doKeywordNode;
     _statementNode = statementNode;
 }

 public UnaryOperationNode(Token operatorNode, AstNode operandNode)
 {
     _operatorNode = operatorNode;
     _operandNode = operandNode;
 }

 public CaseStatementNode(Token caseKeywordNode, AstNode expressionNode, Token ofKeywordNode, ListNode<CaseSelectorNode> selectorListNode, Token elseKeywordNode, ListNode<DelimitedItemNode<AstNode>> elseStatementListNode, Token endKeywordNode)
 {
     _caseKeywordNode = caseKeywordNode;
     _expressionNode = expressionNode;
     _ofKeywordNode = ofKeywordNode;
     _selectorListNode = selectorListNode;
     _elseKeywordNode = elseKeywordNode;
     _elseStatementListNode = elseStatementListNode;
     _endKeywordNode = endKeywordNode;
 }

 public TypeSectionNode(Token typeKeywordNode, ListNode<AstNode> typeListNode)
 {
     _typeKeywordNode = typeKeywordNode;
     _typeListNode = typeListNode;
 }

 public TypeHelperNode(Token typeKeywordNode, Token helperSemikeywordNode, Token openParenthesisNode, AstNode baseHelperTypeNode, Token closeParenthesisNode, Token forKeywordNode, AstNode typeNode, ListNode<VisibilitySectionNode> contentListNode, Token endKeywordNode)
 {
     _typeKeywordNode = typeKeywordNode;
     _helperSemikeywordNode = helperSemikeywordNode;
     _openParenthesisNode = openParenthesisNode;
     _baseHelperTypeNode = baseHelperTypeNode;
     _closeParenthesisNode = closeParenthesisNode;
     _forKeywordNode = forKeywordNode;
     _typeNode = typeNode;
     _contentListNode = contentListNode;
     _endKeywordNode = endKeywordNode;
 }

 public TypeForwardDeclarationNode(Token nameNode, Token equalSignNode, Token typeNode, Token semicolonNode)
 {
     _nameNode = nameNode;
     _equalSignNode = equalSignNode;
     _typeNode = typeNode;
     _semicolonNode = semicolonNode;
 }

 public TypeDeclNode(Token nameNode, Token equalSignNode, Token typeKeywordNode, AstNode typeNode, ListNode<Token> portabilityDirectiveListNode, Token semicolonNode)
 {
     _nameNode = nameNode;
     _equalSignNode = equalSignNode;
     _typeKeywordNode = typeKeywordNode;
     _typeNode = typeNode;
     _portabilityDirectiveListNode = portabilityDirectiveListNode;
     _semicolonNode = semicolonNode;
 }

 public TryFinallyNode(Token tryKeywordNode, ListNode<DelimitedItemNode<AstNode>> tryStatementListNode, Token finallyKeywordNode, ListNode<DelimitedItemNode<AstNode>> finallyStatementListNode, Token endKeywordNode)
 {
     _tryKeywordNode = tryKeywordNode;
     _tryStatementListNode = tryStatementListNode;
     _finallyKeywordNode = finallyKeywordNode;
     _finallyStatementListNode = finallyStatementListNode;
     _endKeywordNode = endKeywordNode;
 }