C# MasterList.InsertLast方法代码示例

        private MasterList<CsToken> GetGenericArgumentList(Reference<ICodePart> genericTypeReference, bool unsafeCode, CsToken name, int startIndex, out int endIndex)
        {
            Param.AssertNotNull(genericTypeReference, "genericTypeReference");
            Param.Ignore(unsafeCode);
            Param.Ignore(name);
            Param.AssertGreaterThanOrEqualToZero(startIndex, "startIndex");

            endIndex = -1;
            MasterList<CsToken> genericArgumentListTokens = null;

            // Move past whitespace and comments.
            int index = startIndex;
            while (true)
            {
                Symbol next = this.symbols.Peek(index);
                if (next == null
                    || (next.SymbolType != SymbolType.WhiteSpace && next.SymbolType != SymbolType.EndOfLine && next.SymbolType != SymbolType.SingleLineComment
                        && next.SymbolType != SymbolType.MultiLineComment && next.SymbolType != SymbolType.PreprocessorDirective))
                {
                    break;
                }

                ++index;
            }

            // The next symbol should be an opening bracket, if this is a generic.
            Symbol symbol = this.symbols.Peek(index);
            if (symbol != null && symbol.SymbolType == SymbolType.LessThan)
            {
                // This might be a generic. Assume that it is and start creating tokens.
                genericArgumentListTokens = new MasterList<CsToken>();

                // Add the name if one was provided.
                if (name != null)
                {
                    genericArgumentListTokens.Add(name);
                }

                Node<CsToken> openingGenericBracketNode = null;

                // Add everything up to the opening bracket into the token list.
                for (int i = startIndex; i <= index; ++i)
                {
                    symbol = this.symbols.Peek(i);
                    Debug.Assert(symbol != null, "The next symbol should not be null");

                    if (symbol.SymbolType == SymbolType.LessThan)
                    {
                        if (openingGenericBracketNode != null)
                        {
                            // This is not a generic statement.
                            return null;
                        }

                        Bracket openingGenericBracket = new Bracket(
                            symbol.Text, CsTokenType.OpenGenericBracket, symbol.Location, genericTypeReference, this.symbols.Generated);
                        openingGenericBracketNode = genericArgumentListTokens.InsertLast(openingGenericBracket);
                    }
                    else
                    {
                        genericArgumentListTokens.Add(this.ConvertSymbol(symbol, TokenTypeFromSymbolType(symbol.SymbolType), genericTypeReference));
                    }
                }

                // Loop through the rest of the symbols.
                while (true)
                {
                    symbol = this.symbols.Peek(++index);
                    if (symbol == null)
                    {
                        // The code ran out before we found the end of the generic.
                        throw new SyntaxException(this.document.SourceCode, name.LineNumber);
                    }
                    else if (symbol.SymbolType == SymbolType.GreaterThan)
                    {
                        if (openingGenericBracketNode == null)
                        {
                            // This is not a generic statement.
                            return null;
                        }

                        // This is the end of the generic statement. Add the closing bracket to the token list.
                        Bracket closingGenericBracket = new Bracket(
                            symbol.Text, CsTokenType.CloseGenericBracket, symbol.Location, genericTypeReference, this.symbols.Generated);
                        Node<CsToken> closingGenericBracketNode = genericArgumentListTokens.InsertLast(closingGenericBracket);

                        ((Bracket)openingGenericBracketNode.Value).MatchingBracketNode = closingGenericBracketNode;
                        closingGenericBracket.MatchingBracketNode = openingGenericBracketNode;

                        endIndex = index;
                        break;
                    }
                    else if (symbol.SymbolType == SymbolType.Out || symbol.SymbolType == SymbolType.In)
                    {
                        // Get the in or out keyword.
                        genericArgumentListTokens.Add(
                            this.ConvertSymbol(symbol, symbol.SymbolType == SymbolType.In ? CsTokenType.In : CsTokenType.Out, genericTypeReference));
                    }
                    else if (symbol.SymbolType == SymbolType.Other)
                    {
//.........这里部分代码省略.........

        /// <summary>
        /// Parses one or more type constraint clauses.
        /// </summary>
        /// <param name="elementReference">A reference to the element being created.</param>
        /// <param name="unsafeCode">Indicates whether the code is marked as unsafe.</param>
        /// <returns>Returns the clauses.</returns>
        private ICollection<TypeParameterConstraintClause> ParseTypeConstraintClauses(
            Reference<ICodePart> elementReference, bool unsafeCode)
        {
            Param.AssertNotNull(elementReference, "elementReference");
            Param.Ignore(unsafeCode);

            List<TypeParameterConstraintClause> constraintClauses = new List<TypeParameterConstraintClause>();

            Symbol symbol = this.GetNextSymbol(elementReference);

            while (symbol.Text == "where")
            {
                var constraintClauseReference = new Reference<ICodePart>();

                Node<CsToken> firstToken = this.tokens.InsertLast(this.GetToken(CsTokenType.Where, SymbolType.Other, constraintClauseReference));
                Node<CsToken> typeToken = this.tokens.InsertLast(this.GetToken(CsTokenType.Other, SymbolType.Other, constraintClauseReference));
                this.tokens.Add(this.GetToken(CsTokenType.WhereColon, SymbolType.Colon, constraintClauseReference));

                List<CsToken> constraints = new List<CsToken>();

                while (true)
                {
                    symbol = this.GetNextSymbol(constraintClauseReference);

                    CsToken constraintToken = null;

                    if (symbol.SymbolType == SymbolType.Class ||
                        symbol.SymbolType == SymbolType.Struct)
                    {
                        // A constraint of type class or struct.
                        constraintToken = this.GetToken(CsTokenType.Other, symbol.SymbolType, constraintClauseReference);
                    }
                    else if (symbol.SymbolType == SymbolType.New)
                    {
                        var constructorConstraintReference = new Reference<ICodePart>();

                        // A constructor constraint.
                        MasterList<CsToken> childTokens = new MasterList<CsToken>();
                        childTokens.Add(this.GetToken(CsTokenType.Other, SymbolType.New, constraintClauseReference));

                        Bracket openParenthesis = this.GetBracketToken(CsTokenType.OpenParenthesis, SymbolType.OpenParenthesis, constraintClauseReference);
                        Bracket closeParenthesis = this.GetBracketToken(CsTokenType.CloseParenthesis, SymbolType.CloseParenthesis, constraintClauseReference);

                        Node<CsToken> openParenthesisNode = childTokens.InsertLast(openParenthesis);
                        Node<CsToken> closeParenthesisNode = childTokens.InsertLast(closeParenthesis);

                        openParenthesis.MatchingBracketNode = closeParenthesisNode;
                        closeParenthesis.MatchingBracketNode = openParenthesisNode;

                        constraintToken = new ConstructorConstraint(
                            childTokens,
                            CsToken.JoinLocations(childTokens.First, childTokens.Last),
                            constraintClauseReference,
                            childTokens.First.Value.Generated);

                        constructorConstraintReference.Target = constraintToken;
                    }
                    else
                    {
                        // A type constraint.
                        constraintToken = this.GetTypeToken(constraintClauseReference, unsafeCode, true);
                    }

                    this.tokens.Add(constraintToken);
                    constraints.Add(constraintToken);

                    symbol = this.GetNextSymbol(constraintClauseReference);
                    if (symbol.SymbolType != SymbolType.Comma)
                    {
                        break;
                    }

                    this.tokens.Add(this.GetToken(CsTokenType.Comma, SymbolType.Comma, constraintClauseReference));
                }

                // Add the constraints as a read-only collection in a constraint clause.
                var constraintClause = new TypeParameterConstraintClause(
                    new CsTokenList(this.tokens, firstToken, this.tokens.Last), typeToken.Value, constraints.ToArray(), elementReference);

                constraintClauseReference.Target = constraintClause;
                constraintClauses.Add(constraintClause);

                symbol = this.GetNextSymbol(elementReference);
            }

            // Return the constraint clauses as a read-only collection.
            return constraintClauses.ToArray();
        }

        /// <summary>
        /// Gets array brackets symbol for a type token, if they exist.
        /// </summary>
        /// <param name="typeTokenReference">A reference to the type token.</param>
        /// <param name="typeTokens">The tokens within the type token.</param>
        /// <param name="startIndex">The start index within the symbols.</param>
        private void GetTypeTokenArrayBrackets(Reference<ICodePart> typeTokenReference, MasterList<CsToken> typeTokens, ref int startIndex)
        {
            Param.AssertNotNull(typeTokenReference, "typeTokenReference");
            Param.AssertNotNull(typeTokens, "typeTokens");
            Param.AssertGreaterThanOrEqualToZero(startIndex, "startIndex");

            int index = this.GetNextCodeSymbolIndex(startIndex);
            if (index != -1)
            {
                Symbol symbol = this.symbols.Peek(index);
                if (symbol.SymbolType == SymbolType.OpenSquareBracket)
                {
                    // Add the tokens up to this point.
                    for (int i = startIndex; i <= index - 1; ++i)
                    {
                        Symbol symbolToConvert = this.symbols.Peek(startIndex);
                        typeTokens.Add(this.ConvertSymbol(symbolToConvert, TokenTypeFromSymbolType(symbolToConvert.SymbolType), typeTokenReference));

                        ++startIndex;
                    }

                    // Now collect the brackets.
                    Node<CsToken> openingBracketNode = null;
                    while (true)
                    {
                        symbol = this.symbols.Peek(startIndex);
                        if (symbol.SymbolType == SymbolType.WhiteSpace ||
                            symbol.SymbolType == SymbolType.EndOfLine ||
                            symbol.SymbolType == SymbolType.SingleLineComment ||
                            symbol.SymbolType == SymbolType.MultiLineComment ||
                            symbol.SymbolType == SymbolType.PreprocessorDirective)
                        {
                            typeTokens.Add(this.ConvertSymbol(symbol, TokenTypeFromSymbolType(symbol.SymbolType), typeTokenReference));
                            ++startIndex;
                        }
                        else if (symbol.SymbolType == SymbolType.Number)
                        {
                            typeTokens.Add(this.ConvertSymbol(symbol, CsTokenType.Number, typeTokenReference));
                            ++startIndex;
                        }
                        else if (symbol.SymbolType == SymbolType.Other)
                        {
                            // A const used in place of a number.
                            typeTokens.Add(this.ConvertSymbol(symbol, CsTokenType.Other, typeTokenReference));
                            ++startIndex;
                        }
                        else if (symbol.SymbolType == SymbolType.Comma)
                        {
                            typeTokens.Add(this.ConvertSymbol(symbol, CsTokenType.Comma, typeTokenReference));
                            ++startIndex;
                        }
                        else if (symbol.SymbolType == SymbolType.OpenSquareBracket)
                        {
                            if (openingBracketNode != null)
                            {
                                throw new SyntaxException(this.document.SourceCode, symbol.LineNumber);
                            }

                            Bracket openingBracket = new Bracket(
                                symbol.Text, CsTokenType.OpenSquareBracket, symbol.Location, typeTokenReference, this.symbols.Generated);
                            openingBracketNode = typeTokens.InsertLast(openingBracket);
                            ++startIndex;
                        }
                        else if (symbol.SymbolType == SymbolType.CloseSquareBracket)
                        {
                            if (openingBracketNode == null)
                            {
                                throw new SyntaxException(this.document.SourceCode, symbol.LineNumber);
                            }

                            Bracket closingBracket = new Bracket(
                                symbol.Text, CsTokenType.CloseSquareBracket, symbol.Location, typeTokenReference, this.symbols.Generated);
                            Node<CsToken> closingBracketNode = typeTokens.InsertLast(closingBracket);
                            ++startIndex;

                            ((Bracket)openingBracketNode.Value).MatchingBracketNode = closingBracketNode;
                            closingBracket.MatchingBracketNode = openingBracketNode;

                            openingBracketNode = null;

                            // Check whether the next character is another opening bracket.
                            int temp = this.GetNextCodeSymbolIndex(startIndex);
                            if (temp != -1 && this.symbols.Peek(temp).SymbolType != SymbolType.OpenSquareBracket)
                            {
                                break;
                            }
                        }
                        else
                        {
                            if (openingBracketNode != null)
                            {
                                throw new SyntaxException(this.document.SourceCode, symbol.LineNumber);
                            }

//.........这里部分代码省略.........

 private ICollection<TypeParameterConstraintClause> ParseTypeConstraintClauses(bool unsafeCode)
 {
     List<TypeParameterConstraintClause> list = new List<TypeParameterConstraintClause>();
     for (Symbol symbol = this.GetNextSymbol(); symbol.Text == "where"; symbol = this.GetNextSymbol())
     {
         Microsoft.StyleCop.Node<CsToken> firstItemNode = this.tokens.InsertLast(this.GetToken(CsTokenType.Other, SymbolType.Other));
         Microsoft.StyleCop.Node<CsToken> node2 = this.tokens.InsertLast(this.GetToken(CsTokenType.Other, SymbolType.Other));
         this.tokens.Add(this.GetToken(CsTokenType.WhereColon, SymbolType.Colon));
         List<CsToken> list2 = new List<CsToken>();
     Label_005A:
         symbol = this.GetNextSymbol();
         CsToken item = null;
         if ((symbol.SymbolType == SymbolType.Class) || (symbol.SymbolType == SymbolType.Struct))
         {
             item = this.GetToken(CsTokenType.Other, symbol.SymbolType);
         }
         else if (symbol.SymbolType == SymbolType.New)
         {
             MasterList<CsToken> childTokens = new MasterList<CsToken>();
             childTokens.Add(this.GetToken(CsTokenType.Other, SymbolType.New));
             Bracket bracketToken = this.GetBracketToken(CsTokenType.OpenParenthesis, SymbolType.OpenParenthesis);
             Bracket bracket2 = this.GetBracketToken(CsTokenType.CloseParenthesis, SymbolType.CloseParenthesis);
             Microsoft.StyleCop.Node<CsToken> node3 = childTokens.InsertLast(bracketToken);
             Microsoft.StyleCop.Node<CsToken> node4 = childTokens.InsertLast(bracket2);
             bracketToken.MatchingBracketNode = node4;
             bracket2.MatchingBracketNode = node3;
             item = new ConstructorConstraint(childTokens, CodeLocation.Join<CsToken>(childTokens.First, childTokens.Last), childTokens.First.Value.Generated);
         }
         else
         {
             item = this.GetTypeToken(unsafeCode, true);
         }
         this.tokens.Add(item);
         list2.Add(item);
         if (this.GetNextSymbol().SymbolType == SymbolType.Comma)
         {
             this.tokens.Add(this.GetToken(CsTokenType.Comma, SymbolType.Comma));
             goto Label_005A;
         }
         list.Add(new TypeParameterConstraintClause(new CsTokenList(this.tokens, firstItemNode, this.tokens.Last), node2.Value, list2.ToArray()));
     }
     return list.ToArray();
 }

 private void GetTypeTokenArrayBrackets(MasterList<CsToken> typeTokens, ref int startIndex)
 {
     Symbol symbol;
     int nextCodeSymbolIndex = this.GetNextCodeSymbolIndex(startIndex);
     if ((nextCodeSymbolIndex == -1) || (this.symbols.Peek(nextCodeSymbolIndex).SymbolType != SymbolType.OpenSquareBracket))
     {
         return;
     }
     for (int i = startIndex; i <= (nextCodeSymbolIndex - 1); i++)
     {
         Symbol symbol2 = this.symbols.Peek(startIndex);
         typeTokens.Add(this.ConvertSymbol(symbol2, TokenTypeFromSymbolType(symbol2.SymbolType)));
         startIndex++;
     }
     Microsoft.StyleCop.Node<CsToken> node = null;
     Label_0067:
     symbol = this.symbols.Peek(startIndex);
     if (((symbol.SymbolType == SymbolType.WhiteSpace) || (symbol.SymbolType == SymbolType.EndOfLine)) || (((symbol.SymbolType == SymbolType.SingleLineComment) || (symbol.SymbolType == SymbolType.MultiLineComment)) || (symbol.SymbolType == SymbolType.PreprocessorDirective)))
     {
         typeTokens.Add(this.ConvertSymbol(symbol, TokenTypeFromSymbolType(symbol.SymbolType)));
         startIndex++;
         goto Label_0067;
     }
     if (symbol.SymbolType == SymbolType.Number)
     {
         typeTokens.Add(this.ConvertSymbol(symbol, CsTokenType.Number));
         startIndex++;
         goto Label_0067;
     }
     if (symbol.SymbolType == SymbolType.Other)
     {
         typeTokens.Add(this.ConvertSymbol(symbol, CsTokenType.Other));
         startIndex++;
         goto Label_0067;
     }
     if (symbol.SymbolType == SymbolType.Comma)
     {
         typeTokens.Add(this.ConvertSymbol(symbol, CsTokenType.Comma));
         startIndex++;
         goto Label_0067;
     }
     if (symbol.SymbolType == SymbolType.OpenSquareBracket)
     {
         if (node != null)
         {
             throw new SyntaxException(this.document.SourceCode, symbol.LineNumber);
         }
         Bracket item = new Bracket(symbol.Text, CsTokenType.OpenSquareBracket, symbol.Location, this.symbols.Generated);
         node = typeTokens.InsertLast(item);
         startIndex++;
         goto Label_0067;
     }
     if (symbol.SymbolType == SymbolType.CloseSquareBracket)
     {
         if (node == null)
         {
             throw new SyntaxException(this.document.SourceCode, symbol.LineNumber);
         }
         Bracket bracket2 = new Bracket(symbol.Text, CsTokenType.CloseSquareBracket, symbol.Location, this.symbols.Generated);
         Microsoft.StyleCop.Node<CsToken> node2 = typeTokens.InsertLast(bracket2);
         startIndex++;
         ((Bracket) node.Value).MatchingBracketNode = node2;
         bracket2.MatchingBracketNode = node;
         node = null;
         int count = this.GetNextCodeSymbolIndex(startIndex);
         if ((count != -1) && (this.symbols.Peek(count).SymbolType != SymbolType.OpenSquareBracket))
         {
             return;
         }
         goto Label_0067;
     }
     if (node != null)
     {
         throw new SyntaxException(this.document.SourceCode, symbol.LineNumber);
     }
 }

 private MasterList<CsToken> GetGenericArgumentList(bool unsafeCode, CsToken name, int startIndex, out int endIndex)
 {
     endIndex = -1;
     MasterList<CsToken> list = null;
     int count = startIndex;
     while (true)
     {
         Symbol symbol = this.symbols.Peek(count);
         if ((symbol == null) || (((symbol.SymbolType != SymbolType.WhiteSpace) && (symbol.SymbolType != SymbolType.EndOfLine)) && (((symbol.SymbolType != SymbolType.SingleLineComment) && (symbol.SymbolType != SymbolType.MultiLineComment)) && (symbol.SymbolType != SymbolType.PreprocessorDirective))))
         {
             break;
         }
         count++;
     }
     Symbol symbol2 = this.symbols.Peek(count);
     if ((symbol2 == null) || (symbol2.SymbolType != SymbolType.LessThan))
     {
         return list;
     }
     list = new MasterList<CsToken>();
     if (name != null)
     {
         list.Add(name);
     }
     Microsoft.StyleCop.Node<CsToken> node = null;
     for (int i = startIndex; i <= count; i++)
     {
         symbol2 = this.symbols.Peek(i);
         if (symbol2.SymbolType == SymbolType.LessThan)
         {
             if (node != null)
             {
                 return null;
             }
             Bracket item = new Bracket(symbol2.Text, CsTokenType.OpenGenericBracket, symbol2.Location, this.symbols.Generated);
             node = list.InsertLast(item);
         }
         else
         {
             list.Add(this.ConvertSymbol(symbol2, TokenTypeFromSymbolType(symbol2.SymbolType)));
         }
     }
     Label_00F4:
     symbol2 = this.symbols.Peek(++count);
     if (symbol2 == null)
     {
         throw new SyntaxException(this.document.SourceCode, name.LineNumber);
     }
     if (symbol2.SymbolType == SymbolType.GreaterThan)
     {
         if (node == null)
         {
             return null;
         }
         Bracket bracket2 = new Bracket(symbol2.Text, CsTokenType.CloseGenericBracket, symbol2.Location, this.symbols.Generated);
         Microsoft.StyleCop.Node<CsToken> node2 = list.InsertLast(bracket2);
         ((Bracket) node.Value).MatchingBracketNode = node2;
         bracket2.MatchingBracketNode = node;
         endIndex = count;
         return list;
     }
     if (symbol2.SymbolType == SymbolType.Other)
     {
         int num3 = 0;
         CsToken token = this.GetTypeTokenAux(unsafeCode, true, false, count, out num3);
         if (token == null)
         {
             throw new SyntaxException(this.document.SourceCode, symbol2.LineNumber);
         }
         count = num3;
         list.Add(token);
         goto Label_00F4;
     }
     if (((symbol2.SymbolType == SymbolType.WhiteSpace) || (symbol2.SymbolType == SymbolType.EndOfLine)) || (((symbol2.SymbolType == SymbolType.SingleLineComment) || (symbol2.SymbolType == SymbolType.MultiLineComment)) || (symbol2.SymbolType == SymbolType.PreprocessorDirective)))
     {
         list.Add(this.ConvertSymbol(symbol2, TokenTypeFromSymbolType(symbol2.SymbolType)));
         goto Label_00F4;
     }
     if (symbol2.SymbolType == SymbolType.Comma)
     {
         list.Add(this.ConvertSymbol(symbol2, CsTokenType.Comma));
         goto Label_00F4;
     }
     return null;
 }