示例#1
0
        private Statement GetNextStatement(Reference<ICodePart> parentReference, bool unsafeCode, VariableCollection variables)
        {
            Param.AssertNotNull(parentReference, "parentReference");
            Param.Ignore(unsafeCode);
            Param.Ignore(variables);

            // Saves the next statement.
            Statement statement = null;

            // Move past comments and whitepace.
            if (this.MoveToStatement(parentReference))
            {
                // Get the next symbol.
                Symbol symbol = this.GetNextSymbol(parentReference);
                if (symbol != null)
                {
                    switch (symbol.SymbolType)
                    {
                        case SymbolType.True:
                        case SymbolType.False:
                        case SymbolType.Other:
                        case SymbolType.Number:
                        case SymbolType.String:
                            if (symbol.Text == "yield")
                            {
                                statement = this.ParseYieldStatement(parentReference, unsafeCode);
                                if (statement != null)
                                {
                                    break;
                                }
                            }

                            if (symbol.Text == "await")
                            {
                                statement = this.ParseAwaitStatement(parentReference, unsafeCode);
                                if (statement != null)
                                {
                                    break;
                                }
                            }

                            statement = this.ParseOtherStatement(parentReference, unsafeCode, variables);
                            break;

                        case SymbolType.OpenCurlyBracket:
                            statement = this.ParseBlockStatement(unsafeCode);
                            break;

                        case SymbolType.If:
                            statement = this.ParseIfStatement(parentReference, unsafeCode);
                            break;

                        case SymbolType.While:
                            statement = this.ParseWhileStatement(parentReference, unsafeCode);
                            break;

                        case SymbolType.Do:
                            statement = this.ParseDoWhileStatement(parentReference, unsafeCode);
                            break;

                        case SymbolType.For:
                            statement = this.ParseForStatement(parentReference, unsafeCode);
                            break;

                        case SymbolType.Foreach:
                            statement = this.ParseForeachStatement(parentReference, unsafeCode);
                            break;

                        case SymbolType.Switch:
                            statement = this.ParseSwitchStatement(parentReference, unsafeCode);
                            break;

                        case SymbolType.Try:
                            statement = this.ParseTryStatement(parentReference, unsafeCode);
                            break;

                        case SymbolType.Lock:
                            statement = this.ParseLockStatement(parentReference, unsafeCode);
                            break;

                        case SymbolType.Using:
                            statement = this.ParseUsingStatement(parentReference, unsafeCode);
                            break;

                        case SymbolType.Checked:
                            statement = this.ParseCheckedStatement(parentReference, unsafeCode);
                            break;

                        case SymbolType.Unchecked:
                            statement = this.ParseUncheckedStatement(parentReference, unsafeCode);
                            break;

                        case SymbolType.Fixed:
                            statement = this.ParseFixedStatement(parentReference, unsafeCode);
                            break;

                        case SymbolType.Unsafe:
                            statement = this.ParseUnsafeStatement(parentReference);
                            break;

                        case SymbolType.Break:
                            statement = this.ParseBreakStatement(parentReference);
                            break;

                        case SymbolType.Continue:
                            statement = this.ParseContinueStatement(parentReference);
                            break;

                        case SymbolType.Goto:
                            statement = this.ParseGotoStatement(parentReference, unsafeCode);
                            break;

                        case SymbolType.Return:
                            statement = this.ParseReturnStatement(parentReference, unsafeCode);
                            break;

                        case SymbolType.Throw:
                            statement = this.ParseThrowStatement(parentReference, unsafeCode);
                            break;

                        case SymbolType.Typeof:
                        case SymbolType.Sizeof:
                        case SymbolType.Default:
                            statement = this.ParseExpressionStatement(unsafeCode);
                            break;

                        case SymbolType.Const:
                            statement = this.ParseVariableDeclarationStatement(parentReference, unsafeCode, variables);
                            break;

                        case SymbolType.Increment:
                        case SymbolType.Decrement:
                        case SymbolType.New:
                        case SymbolType.This:
                        case SymbolType.Base:
                        case SymbolType.OpenParenthesis:
                            statement = this.ParseExpressionStatement(unsafeCode);
                            break;

                        case SymbolType.Semicolon:
                            Reference<ICodePart> emptyStatementReference = new Reference<ICodePart>();
                            Node<CsToken> tokenNode = this.tokens.InsertLast(this.GetToken(CsTokenType.Semicolon, SymbolType.Semicolon, emptyStatementReference));

                            statement = new EmptyStatement(new CsTokenList(this.tokens, tokenNode, tokenNode));
                            emptyStatementReference.Target = statement;
                            break;

                        case SymbolType.Multiplication:
                            if (!unsafeCode)
                            {
                                goto default;
                            }

                            statement = this.ParseExpressionStatement(unsafeCode);
                            break;

                        case SymbolType.LogicalAnd:
                            if (!unsafeCode)
                            {
                                goto default;
                            }

                            statement = this.ParseExpressionStatement(unsafeCode);
                            break;

                        default:
                            throw new SyntaxException(this.document.SourceCode, symbol.LineNumber);
                    }
                }
            }

            return statement;
        }
 /// <summary>
 /// The save.
 /// </summary>
 /// <param name="emptyStatement">
 /// The empty statement.
 /// </param>
 private void Save(EmptyStatement emptyStatement)
 {
 }