public virtual void VisitUnsafeStatement(UnsafeStatement unsafeStatement)
{
if (this.ThrowException)
{
throw (System.Exception) this.CreateException(unsafeStatement);
}
}
public virtual object Visit(UnsafeStatement unsafeStatement, object data)
{
Debug.Assert(unsafeStatement != null);
Debug.Assert(unsafeStatement.Block != null);
unsafeStatement.Block.AcceptVisitor(this, data);
return(data);
}
public virtual void VisitUnsafeStatement(UnsafeStatement unsafeStatement)
{
if (ThrowException)
{
throw (Exception)CreateException(unsafeStatement);
}
}
public override void VisitUnsafeStatement(UnsafeStatement unsafeStatement)
{
unsafeStateStack.Peek().UseUnsafeConstructs = true;
bool isRedundant = unsafeStateStack.Peek().InUnsafeContext;
unsafeStateStack.Push(new UnsafeState(true));
base.VisitUnsafeStatement(unsafeStatement);
isRedundant |= !unsafeStateStack.Pop().UseUnsafeConstructs;
if (isRedundant)
{
AddIssue(new CodeIssue(
unsafeStatement.UnsafeToken,
ctx.TranslateString("'unsafe' statement is redundant."),
ctx.TranslateString("Replace 'unsafe' statement with it's body"),
s => {
s.Remove(unsafeStatement.UnsafeToken);
s.Remove(unsafeStatement.Body.LBraceToken);
s.Remove(unsafeStatement.Body.RBraceToken);
s.FormatText(unsafeStatement.Parent);
}
));
}
}
public override object Visit (Unsafe unsafeStatement)
{
var result = new UnsafeStatement ();
result.AddChild (new CSharpTokenNode (Convert (unsafeStatement.loc), "unsafe".Length), UnsafeStatement.Roles.Keyword);
result.AddChild ((INode)unsafeStatement.Block.Accept (this), UnsafeStatement.Roles.Body);
return result;
}
public override void VisitUnsafeStatement(UnsafeStatement unsafeStatement) {
throw new InvalidOperationException("unsafe statement is not supported"); // Should be caught during the compilation step.
}
public override object VisitUnsafeStatement(UnsafeStatement unsafeStatement, object data)
{
base.VisitUnsafeStatement(unsafeStatement, data);
ReplaceCurrentNode(unsafeStatement.Block);
return(null);
}
public void CSharpUnsafeStatementTest()
{
UnsafeStatement unsafeStatement = ParseUtilCSharp.ParseStatement <UnsafeStatement>("unsafe { }");
Assert.IsFalse(unsafeStatement.Block.IsNull);
}
public StringBuilder VisitUnsafeStatement(UnsafeStatement unsafeStatement, int data)
{
throw new ASLException("ASL does not allow unsafe code.");
}
public virtual object VisitUnsafeStatement(UnsafeStatement unsafeStatement, object data) {
throw new global::System.NotImplementedException("UnsafeStatement");
}
public RedILNode VisitUnsafeStatement(UnsafeStatement unsafeStatement, State data)
{
throw new System.NotImplementedException();
}
private void EmbeddedStatement(out ICSharpCode.NRefactory.Parser.AST.Statement statement)
{
TypeReference type = null;
Expression expr = null;
ICSharpCode.NRefactory.Parser.AST.Statement statement2 = null;
statement = null;
if (this.la.kind == 0x10)
{
this.Block(out statement);
}
else if (this.la.kind == 11)
{
base.lexer.NextToken();
statement = new EmptyStatement();
}
else if (this.UnCheckedAndLBrace())
{
ICSharpCode.NRefactory.Parser.AST.Statement statement3;
bool flag = true;
if (this.la.kind == 0x39)
{
base.lexer.NextToken();
}
else if (this.la.kind == 0x75)
{
base.lexer.NextToken();
flag = false;
}
else
{
base.SynErr(170);
}
this.Block(out statement3);
statement = flag ? ((ICSharpCode.NRefactory.Parser.AST.Statement) new CheckedStatement(statement3)) : ((ICSharpCode.NRefactory.Parser.AST.Statement) new UncheckedStatement(statement3));
}
else if (this.la.kind == 0x4e)
{
base.lexer.NextToken();
ICSharpCode.NRefactory.Parser.AST.Statement statement4 = null;
base.Expect(20);
this.Expr(out expr);
base.Expect(0x15);
this.EmbeddedStatement(out statement2);
if (this.la.kind == 0x42)
{
base.lexer.NextToken();
this.EmbeddedStatement(out statement4);
}
statement = (statement4 != null) ? new IfElseStatement(expr, statement2, statement4) : new IfElseStatement(expr, statement2);
if ((statement4 is IfElseStatement) && ((statement4 as IfElseStatement).TrueStatement.Count == 1))
{
(statement as IfElseStatement).ElseIfSections.Add(new ElseIfSection((statement4 as IfElseStatement).Condition, (statement4 as IfElseStatement).TrueStatement[0]));
(statement as IfElseStatement).ElseIfSections.AddRange((statement4 as IfElseStatement).ElseIfSections);
(statement as IfElseStatement).FalseStatement = (statement4 as IfElseStatement).FalseStatement;
}
}
else if (this.la.kind == 0x6d)
{
base.lexer.NextToken();
List<ICSharpCode.NRefactory.Parser.AST.SwitchSection> switchSections = new List<ICSharpCode.NRefactory.Parser.AST.SwitchSection>();
base.Expect(20);
this.Expr(out expr);
base.Expect(0x15);
base.Expect(0x10);
while ((this.la.kind == 0x36) || (this.la.kind == 0x3e))
{
ICSharpCode.NRefactory.Parser.AST.SwitchSection section;
this.SwitchSection(out section);
switchSections.Add(section);
}
base.Expect(0x11);
statement = new SwitchStatement(expr, switchSections);
}
else if (this.la.kind == 0x7c)
{
base.lexer.NextToken();
base.Expect(20);
this.Expr(out expr);
base.Expect(0x15);
this.EmbeddedStatement(out statement2);
statement = new DoLoopStatement(expr, statement2, ConditionType.While, ConditionPosition.Start);
}
else if (this.la.kind == 0x40)
{
base.lexer.NextToken();
this.EmbeddedStatement(out statement2);
base.Expect(0x7c);
base.Expect(20);
this.Expr(out expr);
base.Expect(0x15);
base.Expect(11);
statement = new DoLoopStatement(expr, statement2, ConditionType.While, ConditionPosition.End);
}
else if (this.la.kind == 0x4b)
{
base.lexer.NextToken();
List<ICSharpCode.NRefactory.Parser.AST.Statement> initializer = null;
List<ICSharpCode.NRefactory.Parser.AST.Statement> iterator = null;
base.Expect(20);
if (this.StartOf(5))
{
this.ForInitializer(out initializer);
}
base.Expect(11);
if (this.StartOf(5))
{
this.Expr(out expr);
}
base.Expect(11);
if (this.StartOf(5))
{
this.ForIterator(out iterator);
}
base.Expect(0x15);
this.EmbeddedStatement(out statement2);
statement = new ForStatement(initializer, expr, iterator, statement2);
}
else if (this.la.kind == 0x4c)
{
base.lexer.NextToken();
base.Expect(20);
this.Type(out type);
base.Expect(1);
string val = this.t.val;
Point location = this.t.Location;
base.Expect(80);
this.Expr(out expr);
base.Expect(0x15);
this.EmbeddedStatement(out statement2);
statement = new ForeachStatement(type, val, expr, statement2);
statement.EndLocation = this.t.EndLocation;
}
else if (this.la.kind == 0x34)
{
base.lexer.NextToken();
base.Expect(11);
statement = new BreakStatement();
}
else if (this.la.kind == 60)
{
base.lexer.NextToken();
base.Expect(11);
statement = new ContinueStatement();
}
else if (this.la.kind == 0x4d)
{
this.GotoStatement(out statement);
}
else if (this.IsYieldStatement())
{
base.Expect(1);
if (this.la.kind == 100)
{
base.lexer.NextToken();
this.Expr(out expr);
statement = new YieldStatement(new ReturnStatement(expr));
}
else if (this.la.kind == 0x34)
{
base.lexer.NextToken();
statement = new YieldStatement(new BreakStatement());
}
else
{
base.SynErr(0xab);
}
base.Expect(11);
}
else if (this.la.kind == 100)
{
base.lexer.NextToken();
if (this.StartOf(5))
{
this.Expr(out expr);
}
base.Expect(11);
statement = new ReturnStatement(expr);
}
else if (this.la.kind == 0x6f)
{
base.lexer.NextToken();
if (this.StartOf(5))
{
this.Expr(out expr);
}
base.Expect(11);
statement = new ThrowStatement(expr);
}
else if (this.StartOf(5))
{
this.StatementExpr(out statement);
base.Expect(11);
}
else if (this.la.kind == 0x71)
{
this.TryStatement(out statement);
}
else if (this.la.kind == 0x55)
{
base.lexer.NextToken();
base.Expect(20);
this.Expr(out expr);
base.Expect(0x15);
this.EmbeddedStatement(out statement2);
statement = new LockStatement(expr, statement2);
}
else if (this.la.kind == 120)
{
ICSharpCode.NRefactory.Parser.AST.Statement stmt = null;
base.lexer.NextToken();
base.Expect(20);
this.ResourceAcquisition(out stmt);
base.Expect(0x15);
this.EmbeddedStatement(out statement2);
statement = new UsingStatement(stmt, statement2);
}
else if (this.la.kind == 0x76)
{
base.lexer.NextToken();
this.Block(out statement2);
statement = new UnsafeStatement(statement2);
}
else if (this.la.kind == 0x49)
{
base.lexer.NextToken();
base.Expect(20);
this.Type(out type);
if (type.PointerNestingLevel == 0)
{
this.Error("can only fix pointer types");
}
List<VariableDeclaration> pointerDeclarators = new List<VariableDeclaration>(1);
base.Expect(1);
string name = this.t.val;
base.Expect(3);
this.Expr(out expr);
pointerDeclarators.Add(new VariableDeclaration(name, expr));
while (this.la.kind == 14)
{
base.lexer.NextToken();
base.Expect(1);
name = this.t.val;
base.Expect(3);
this.Expr(out expr);
pointerDeclarators.Add(new VariableDeclaration(name, expr));
}
base.Expect(0x15);
this.EmbeddedStatement(out statement2);
statement = new FixedStatement(type, pointerDeclarators, statement2);
}
else
{
base.SynErr(0xac);
}
}
public virtual object VisitUnsafeStatement(UnsafeStatement unsafeStatement, object data) {
Debug.Assert((unsafeStatement != null));
Debug.Assert((unsafeStatement.Block != null));
nodeStack.Push(unsafeStatement.Block);
unsafeStatement.Block.AcceptVisitor(this, data);
unsafeStatement.Block = ((Statement)(nodeStack.Pop()));
return null;
}
public static Doc Print(SyntaxNode syntaxNode)
{
if (syntaxNode == null)
{
return(Doc.Null);
}
// TODO 0 kill? runtime repo has files that will fail on deep recursion
if (depth > 200)
{
throw new InTooDeepException();
}
depth++;
try
{
switch (syntaxNode)
{
case AliasQualifiedNameSyntax aliasQualifiedNameSyntax:
return(AliasQualifiedName.Print(aliasQualifiedNameSyntax));
case AnonymousMethodExpressionSyntax anonymousMethodExpressionSyntax:
return(AnonymousMethodExpression.Print(anonymousMethodExpressionSyntax));
case AnonymousObjectCreationExpressionSyntax anonymousObjectCreationExpressionSyntax:
return(AnonymousObjectCreationExpression.Print(
anonymousObjectCreationExpressionSyntax
));
case AnonymousObjectMemberDeclaratorSyntax anonymousObjectMemberDeclaratorSyntax:
return(AnonymousObjectMemberDeclarator.Print(
anonymousObjectMemberDeclaratorSyntax
));
case ArgumentListSyntax argumentListSyntax:
return(ArgumentList.Print(argumentListSyntax));
case ArgumentSyntax argumentSyntax:
return(Argument.Print(argumentSyntax));
case ArrayCreationExpressionSyntax arrayCreationExpressionSyntax:
return(ArrayCreationExpression.Print(arrayCreationExpressionSyntax));
case ArrayRankSpecifierSyntax arrayRankSpecifierSyntax:
return(ArrayRankSpecifier.Print(arrayRankSpecifierSyntax));
case ArrayTypeSyntax arrayTypeSyntax:
return(ArrayType.Print(arrayTypeSyntax));
case ArrowExpressionClauseSyntax arrowExpressionClauseSyntax:
return(ArrowExpressionClause.Print(arrowExpressionClauseSyntax));
case AssignmentExpressionSyntax assignmentExpressionSyntax:
return(AssignmentExpression.Print(assignmentExpressionSyntax));
case AttributeListSyntax attributeListSyntax:
return(AttributeList.Print(attributeListSyntax));
case AwaitExpressionSyntax awaitExpressionSyntax:
return(AwaitExpression.Print(awaitExpressionSyntax));
case BaseExpressionSyntax baseExpressionSyntax:
return(BaseExpression.Print(baseExpressionSyntax));
case BaseFieldDeclarationSyntax baseFieldDeclarationSyntax:
return(BaseFieldDeclaration.Print(baseFieldDeclarationSyntax));
case BaseListSyntax baseListSyntax:
return(BaseList.Print(baseListSyntax));
case BaseMethodDeclarationSyntax baseMethodDeclarationSyntax:
return(BaseMethodDeclaration.Print(baseMethodDeclarationSyntax));
case BasePropertyDeclarationSyntax basePropertyDeclarationSyntax:
return(BasePropertyDeclaration.Print(basePropertyDeclarationSyntax));
case BaseTypeDeclarationSyntax baseTypeDeclarationSyntax:
return(BaseTypeDeclaration.Print(baseTypeDeclarationSyntax));
case BinaryExpressionSyntax binaryExpressionSyntax:
return(BinaryExpression.Print(binaryExpressionSyntax));
case BinaryPatternSyntax binaryPatternSyntax:
return(BinaryPattern.Print(binaryPatternSyntax));
case BlockSyntax blockSyntax:
return(Block.Print(blockSyntax));
case BracketedArgumentListSyntax bracketedArgumentListSyntax:
return(BracketedArgumentList.Print(bracketedArgumentListSyntax));
case BracketedParameterListSyntax bracketedParameterListSyntax:
return(BracketedParameterList.Print(bracketedParameterListSyntax));
case BreakStatementSyntax breakStatementSyntax:
return(BreakStatement.Print(breakStatementSyntax));
case CasePatternSwitchLabelSyntax casePatternSwitchLabelSyntax:
return(CasePatternSwitchLabel.Print(casePatternSwitchLabelSyntax));
case CaseSwitchLabelSyntax caseSwitchLabelSyntax:
return(CaseSwitchLabel.Print(caseSwitchLabelSyntax));
case CastExpressionSyntax castExpressionSyntax:
return(CastExpression.Print(castExpressionSyntax));
case CatchClauseSyntax catchClauseSyntax:
return(CatchClause.Print(catchClauseSyntax));
case CheckedExpressionSyntax checkedExpressionSyntax:
return(CheckedExpression.Print(checkedExpressionSyntax));
case CheckedStatementSyntax checkedStatementSyntax:
return(CheckedStatement.Print(checkedStatementSyntax));
case ClassOrStructConstraintSyntax classOrStructConstraintSyntax:
return(ClassOrStructConstraint.Print(classOrStructConstraintSyntax));
case CompilationUnitSyntax compilationUnitSyntax:
return(CompilationUnit.Print(compilationUnitSyntax));
case ConditionalAccessExpressionSyntax conditionalAccessExpressionSyntax:
return(ConditionalAccessExpression.Print(conditionalAccessExpressionSyntax));
case ConditionalExpressionSyntax conditionalExpressionSyntax:
return(ConditionalExpression.Print(conditionalExpressionSyntax));
case ConstantPatternSyntax constantPatternSyntax:
return(ConstantPattern.Print(constantPatternSyntax));
case ConstructorConstraintSyntax constructorConstraintSyntax:
return(ConstructorConstraint.Print(constructorConstraintSyntax));
case ConstructorInitializerSyntax constructorInitializerSyntax:
return(ConstructorInitializer.Print(constructorInitializerSyntax));
case ContinueStatementSyntax continueStatementSyntax:
return(ContinueStatement.Print(continueStatementSyntax));
case DeclarationExpressionSyntax declarationExpressionSyntax:
return(DeclarationExpression.Print(declarationExpressionSyntax));
case DeclarationPatternSyntax declarationPatternSyntax:
return(DeclarationPattern.Print(declarationPatternSyntax));
case DefaultConstraintSyntax defaultConstraintSyntax:
return(DefaultConstraint.Print(defaultConstraintSyntax));
case DefaultExpressionSyntax defaultExpressionSyntax:
return(DefaultExpression.Print(defaultExpressionSyntax));
case DefaultSwitchLabelSyntax defaultSwitchLabelSyntax:
return(DefaultSwitchLabel.Print(defaultSwitchLabelSyntax));
case DelegateDeclarationSyntax delegateDeclarationSyntax:
return(DelegateDeclaration.Print(delegateDeclarationSyntax));
case DiscardDesignationSyntax discardDesignationSyntax:
return(DiscardDesignation.Print(discardDesignationSyntax));
case DiscardPatternSyntax discardPatternSyntax:
return(DiscardPattern.Print(discardPatternSyntax));
case DoStatementSyntax doStatementSyntax:
return(DoStatement.Print(doStatementSyntax));
case ElementAccessExpressionSyntax elementAccessExpressionSyntax:
return(ElementAccessExpression.Print(elementAccessExpressionSyntax));
case ElementBindingExpressionSyntax elementBindingExpressionSyntax:
return(ElementBindingExpression.Print(elementBindingExpressionSyntax));
case ElseClauseSyntax elseClauseSyntax:
return(ElseClause.Print(elseClauseSyntax));
case EmptyStatementSyntax emptyStatementSyntax:
return(EmptyStatement.Print(emptyStatementSyntax));
case EnumMemberDeclarationSyntax enumMemberDeclarationSyntax:
return(EnumMemberDeclaration.Print(enumMemberDeclarationSyntax));
case EqualsValueClauseSyntax equalsValueClauseSyntax:
return(EqualsValueClause.Print(equalsValueClauseSyntax));
case ExpressionStatementSyntax expressionStatementSyntax:
return(ExpressionStatement.Print(expressionStatementSyntax));
case ExternAliasDirectiveSyntax externAliasDirectiveSyntax:
return(ExternAliasDirective.Print(externAliasDirectiveSyntax));
case FinallyClauseSyntax finallyClauseSyntax:
return(FinallyClause.Print(finallyClauseSyntax));
case FixedStatementSyntax fixedStatementSyntax:
return(FixedStatement.Print(fixedStatementSyntax));
case ForEachStatementSyntax forEachStatementSyntax:
return(ForEachStatement.Print(forEachStatementSyntax));
case ForEachVariableStatementSyntax forEachVariableStatementSyntax:
return(ForEachVariableStatement.Print(forEachVariableStatementSyntax));
case ForStatementSyntax forStatementSyntax:
return(ForStatement.Print(forStatementSyntax));
case FromClauseSyntax fromClauseSyntax:
return(FromClause.Print(fromClauseSyntax));
case FunctionPointerTypeSyntax functionPointerTypeSyntax:
return(FunctionPointerType.Print(functionPointerTypeSyntax));
case GenericNameSyntax genericNameSyntax:
return(GenericName.Print(genericNameSyntax));
case GlobalStatementSyntax globalStatementSyntax:
return(GlobalStatement.Print(globalStatementSyntax));
case GotoStatementSyntax gotoStatementSyntax:
return(GotoStatement.Print(gotoStatementSyntax));
case GroupClauseSyntax groupClauseSyntax:
return(GroupClause.Print(groupClauseSyntax));
case IdentifierNameSyntax identifierNameSyntax:
return(IdentifierName.Print(identifierNameSyntax));
case IfStatementSyntax ifStatementSyntax:
return(IfStatement.Print(ifStatementSyntax));
case ImplicitArrayCreationExpressionSyntax implicitArrayCreationExpressionSyntax:
return(ImplicitArrayCreationExpression.Print(
implicitArrayCreationExpressionSyntax
));
case ImplicitElementAccessSyntax implicitElementAccessSyntax:
return(ImplicitElementAccess.Print(implicitElementAccessSyntax));
case ImplicitObjectCreationExpressionSyntax implicitObjectCreationExpressionSyntax:
return(ImplicitObjectCreationExpression.Print(
implicitObjectCreationExpressionSyntax
));
case ImplicitStackAllocArrayCreationExpressionSyntax implicitStackAllocArrayCreationExpressionSyntax:
return(ImplicitStackAllocArrayCreationExpression.Print(
implicitStackAllocArrayCreationExpressionSyntax
));
case IncompleteMemberSyntax incompleteMemberSyntax:
return(IncompleteMember.Print(incompleteMemberSyntax));
case InitializerExpressionSyntax initializerExpressionSyntax:
return(InitializerExpression.Print(initializerExpressionSyntax));
case InterpolatedStringExpressionSyntax interpolatedStringExpressionSyntax:
return(InterpolatedStringExpression.Print(
interpolatedStringExpressionSyntax
));
case InterpolatedStringTextSyntax interpolatedStringTextSyntax:
return(InterpolatedStringText.Print(interpolatedStringTextSyntax));
case InterpolationSyntax interpolationSyntax:
return(Interpolation.Print(interpolationSyntax));
case InvocationExpressionSyntax invocationExpressionSyntax:
return(InvocationExpression.Print(invocationExpressionSyntax));
case IsPatternExpressionSyntax isPatternExpressionSyntax:
return(IsPatternExpression.Print(isPatternExpressionSyntax));
case JoinClauseSyntax joinClauseSyntax:
return(JoinClause.Print(joinClauseSyntax));
case LabeledStatementSyntax labeledStatementSyntax:
return(LabeledStatement.Print(labeledStatementSyntax));
case LetClauseSyntax letClauseSyntax:
return(LetClause.Print(letClauseSyntax));
case LiteralExpressionSyntax literalExpressionSyntax:
return(LiteralExpression.Print(literalExpressionSyntax));
case LocalDeclarationStatementSyntax localDeclarationStatementSyntax:
return(LocalDeclarationStatement.Print(localDeclarationStatementSyntax));
case LocalFunctionStatementSyntax localFunctionStatementSyntax:
return(LocalFunctionStatement.Print(localFunctionStatementSyntax));
case LockStatementSyntax lockStatementSyntax:
return(LockStatement.Print(lockStatementSyntax));
case MakeRefExpressionSyntax makeRefExpressionSyntax:
return(MakeRefExpression.Print(makeRefExpressionSyntax));
case MemberAccessExpressionSyntax memberAccessExpressionSyntax:
return(MemberAccessExpression.Print(memberAccessExpressionSyntax));
case MemberBindingExpressionSyntax memberBindingExpressionSyntax:
return(MemberBindingExpression.Print(memberBindingExpressionSyntax));
case NameColonSyntax nameColonSyntax:
return(NameColon.Print(nameColonSyntax));
case NameEqualsSyntax nameEqualsSyntax:
return(NameEquals.Print(nameEqualsSyntax));
case NamespaceDeclarationSyntax namespaceDeclarationSyntax:
return(NamespaceDeclaration.Print(namespaceDeclarationSyntax));
case NullableTypeSyntax nullableTypeSyntax:
return(NullableType.Print(nullableTypeSyntax));
case ObjectCreationExpressionSyntax objectCreationExpressionSyntax:
return(ObjectCreationExpression.Print(objectCreationExpressionSyntax));
case OmittedArraySizeExpressionSyntax omittedArraySizeExpressionSyntax:
return(OmittedArraySizeExpression.Print(omittedArraySizeExpressionSyntax));
case OmittedTypeArgumentSyntax omittedTypeArgumentSyntax:
return(OmittedTypeArgument.Print(omittedTypeArgumentSyntax));
case OrderByClauseSyntax orderByClauseSyntax:
return(OrderByClause.Print(orderByClauseSyntax));
case ParameterListSyntax parameterListSyntax:
return(ParameterList.Print(parameterListSyntax));
case ParameterSyntax parameterSyntax:
return(Parameter.Print(parameterSyntax));
case ParenthesizedExpressionSyntax parenthesizedExpressionSyntax:
return(ParenthesizedExpression.Print(parenthesizedExpressionSyntax));
case ParenthesizedLambdaExpressionSyntax parenthesizedLambdaExpressionSyntax:
return(ParenthesizedLambdaExpression.Print(
parenthesizedLambdaExpressionSyntax
));
case ParenthesizedPatternSyntax parenthesizedPatternSyntax:
return(ParenthesizedPattern.Print(parenthesizedPatternSyntax));
case ParenthesizedVariableDesignationSyntax parenthesizedVariableDesignationSyntax:
return(ParenthesizedVariableDesignation.Print(
parenthesizedVariableDesignationSyntax
));
case PointerTypeSyntax pointerTypeSyntax:
return(PointerType.Print(pointerTypeSyntax));
case PostfixUnaryExpressionSyntax postfixUnaryExpressionSyntax:
return(PostfixUnaryExpression.Print(postfixUnaryExpressionSyntax));
case PredefinedTypeSyntax predefinedTypeSyntax:
return(PredefinedType.Print(predefinedTypeSyntax));
case PrefixUnaryExpressionSyntax prefixUnaryExpressionSyntax:
return(PrefixUnaryExpression.Print(prefixUnaryExpressionSyntax));
case PrimaryConstructorBaseTypeSyntax primaryConstructorBaseTypeSyntax:
return(PrimaryConstructorBaseType.Print(primaryConstructorBaseTypeSyntax));
case QualifiedNameSyntax qualifiedNameSyntax:
return(QualifiedName.Print(qualifiedNameSyntax));
case QueryBodySyntax queryBodySyntax:
return(QueryBody.Print(queryBodySyntax));
case QueryContinuationSyntax queryContinuationSyntax:
return(QueryContinuation.Print(queryContinuationSyntax));
case QueryExpressionSyntax queryExpressionSyntax:
return(QueryExpression.Print(queryExpressionSyntax));
case RangeExpressionSyntax rangeExpressionSyntax:
return(RangeExpression.Print(rangeExpressionSyntax));
case RecursivePatternSyntax recursivePatternSyntax:
return(RecursivePattern.Print(recursivePatternSyntax));
case RefExpressionSyntax refExpressionSyntax:
return(RefExpression.Print(refExpressionSyntax));
case RefTypeExpressionSyntax refTypeExpressionSyntax:
return(RefTypeExpression.Print(refTypeExpressionSyntax));
case RefTypeSyntax refTypeSyntax:
return(RefType.Print(refTypeSyntax));
case RefValueExpressionSyntax refValueExpressionSyntax:
return(RefValueExpression.Print(refValueExpressionSyntax));
case RelationalPatternSyntax relationalPatternSyntax:
return(RelationalPattern.Print(relationalPatternSyntax));
case ReturnStatementSyntax returnStatementSyntax:
return(ReturnStatement.Print(returnStatementSyntax));
case SelectClauseSyntax selectClauseSyntax:
return(SelectClause.Print(selectClauseSyntax));
case SimpleBaseTypeSyntax simpleBaseTypeSyntax:
return(SimpleBaseType.Print(simpleBaseTypeSyntax));
case SimpleLambdaExpressionSyntax simpleLambdaExpressionSyntax:
return(SimpleLambdaExpression.Print(simpleLambdaExpressionSyntax));
case SingleVariableDesignationSyntax singleVariableDesignationSyntax:
return(SingleVariableDesignation.Print(singleVariableDesignationSyntax));
case SizeOfExpressionSyntax sizeOfExpressionSyntax:
return(SizeOfExpression.Print(sizeOfExpressionSyntax));
case StackAllocArrayCreationExpressionSyntax stackAllocArrayCreationExpressionSyntax:
return(StackAllocArrayCreationExpression.Print(
stackAllocArrayCreationExpressionSyntax
));
case SwitchExpressionSyntax switchExpressionSyntax:
return(SwitchExpression.Print(switchExpressionSyntax));
case SwitchSectionSyntax switchSectionSyntax:
return(SwitchSection.Print(switchSectionSyntax));
case SwitchStatementSyntax switchStatementSyntax:
return(SwitchStatement.Print(switchStatementSyntax));
case ThisExpressionSyntax thisExpressionSyntax:
return(ThisExpression.Print(thisExpressionSyntax));
case ThrowExpressionSyntax throwExpressionSyntax:
return(ThrowExpression.Print(throwExpressionSyntax));
case ThrowStatementSyntax throwStatementSyntax:
return(ThrowStatement.Print(throwStatementSyntax));
case TryStatementSyntax tryStatementSyntax:
return(TryStatement.Print(tryStatementSyntax));
case TupleElementSyntax tupleElementSyntax:
return(TupleElement.Print(tupleElementSyntax));
case TupleExpressionSyntax tupleExpressionSyntax:
return(TupleExpression.Print(tupleExpressionSyntax));
case TupleTypeSyntax tupleTypeSyntax:
return(TupleType.Print(tupleTypeSyntax));
case TypeArgumentListSyntax typeArgumentListSyntax:
return(TypeArgumentList.Print(typeArgumentListSyntax));
case TypeConstraintSyntax typeConstraintSyntax:
return(TypeConstraint.Print(typeConstraintSyntax));
case TypeOfExpressionSyntax typeOfExpressionSyntax:
return(TypeOfExpression.Print(typeOfExpressionSyntax));
case TypeParameterConstraintClauseSyntax typeParameterConstraintClauseSyntax:
return(TypeParameterConstraintClause.Print(
typeParameterConstraintClauseSyntax
));
case TypeParameterListSyntax typeParameterListSyntax:
return(TypeParameterList.Print(typeParameterListSyntax));
case TypeParameterSyntax typeParameterSyntax:
return(TypeParameter.Print(typeParameterSyntax));
case TypePatternSyntax typePatternSyntax:
return(TypePattern.Print(typePatternSyntax));
case UnaryPatternSyntax unaryPatternSyntax:
return(UnaryPattern.Print(unaryPatternSyntax));
case UnsafeStatementSyntax unsafeStatementSyntax:
return(UnsafeStatement.Print(unsafeStatementSyntax));
case UsingDirectiveSyntax usingDirectiveSyntax:
return(UsingDirective.Print(usingDirectiveSyntax));
case UsingStatementSyntax usingStatementSyntax:
return(UsingStatement.Print(usingStatementSyntax));
case VariableDeclarationSyntax variableDeclarationSyntax:
return(VariableDeclaration.Print(variableDeclarationSyntax));
case VariableDeclaratorSyntax variableDeclaratorSyntax:
return(VariableDeclarator.Print(variableDeclaratorSyntax));
case VarPatternSyntax varPatternSyntax:
return(VarPattern.Print(varPatternSyntax));
case WhenClauseSyntax whenClauseSyntax:
return(WhenClause.Print(whenClauseSyntax));
case WhereClauseSyntax whereClauseSyntax:
return(WhereClause.Print(whereClauseSyntax));
case WhileStatementSyntax whileStatementSyntax:
return(WhileStatement.Print(whileStatementSyntax));
case WithExpressionSyntax withExpressionSyntax:
return(WithExpression.Print(withExpressionSyntax));
case YieldStatementSyntax yieldStatementSyntax:
return(YieldStatement.Print(yieldStatementSyntax));
default:
throw new Exception("Can't handle " + syntaxNode.GetType().Name);
}
}
finally
{
depth--;
}
}
private bool IsMatch(UnsafeStatement left, UnsafeStatement data)
{
return(false);
}
/// <inheritdoc/>
public virtual void VisitUnsafeStatement(UnsafeStatement syntax)
{
VisitNode(syntax);
}
public override object VisitUnsafeStatement(UnsafeStatement unsafeStatement, object data)
{
FixStatementIndentation(unsafeStatement.StartLocation);
Console.WriteLine(unsafeStatement.Block);
return(FixEmbeddedStatment(policy.StatementBraceStyle, BraceForcement.DoNotChange, unsafeStatement.Block));
}
public override void VisitUnsafeStatement(UnsafeStatement syntax)
{
_underlyingVisitor.VisitUnsafeStatement(syntax);
}
public void VisitUnsafeStatement(UnsafeStatement node)
{
NotSupported(node);
}
public virtual void VisitUnsafeStatement(UnsafeStatement unsafeStatement)
{
if (this.ThrowException)
{
throw (Exception)this.CreateException(unsafeStatement);
}
}
public object VisitUnsafeStatement(UnsafeStatement unsafeStatement, object data)
{
throw new NotImplementedException();
}
public override object Visit(Unsafe unsafeStatement)
{
var result = new UnsafeStatement();
result.AddChild(new CSharpTokenNode(Convert(unsafeStatement.loc), UnsafeStatement.UnsafeKeywordRole), UnsafeStatement.UnsafeKeywordRole);
if (unsafeStatement.Block != null)
result.AddChild((BlockStatement)unsafeStatement.Block.Accept(this), Roles.Body);
return result;
}
public virtual S VisitUnsafeStatement(UnsafeStatement unsafeStatement, T data)
{
return(VisitChildren(unsafeStatement, data));
}
public sealed override object VisitUnsafeStatement(UnsafeStatement unsafeStatement, object data) {
BeginVisit(unsafeStatement);
object result = TrackedVisitUnsafeStatement(unsafeStatement, data);
EndVisit(unsafeStatement);
return result;
}
public void VisitUnsafeStatement(UnsafeStatement unsafeStatement)
{
JsonObject statement = CreateJsonStatement(unsafeStatement);
AddKeyword(statement, UnsafeStatement.UnsafeKeywordRole);
statement.AddJsonValue("body", GenStatement(unsafeStatement.Body));
Push(statement);
throw new FirstTimeUseException();
}
public void VisitUnsafeStatement(UnsafeStatement unsafeStatement)
{
throw new NotImplementedException();
}
public virtual object VisitUnsafeStatement(UnsafeStatement unsafeStatement, object data) {
Debug.Assert((unsafeStatement != null));
Debug.Assert((unsafeStatement.Block != null));
return unsafeStatement.Block.AcceptVisitor(this, data);
}
public StringBuilder VisitUnsafeStatement(UnsafeStatement unsafeStatement)
{
throw new NotImplementedException();
}
public Node VisitUnsafeStatement(UnsafeStatement unsafeStatement)
{
return(CreateDummy(unsafeStatement));
}
public JNode VisitUnsafeStatement(UnsafeStatement node)
{
throw new NotImplementedException();
}
public virtual void Enter(UnsafeStatement unsafeStatement)
{
}
public override void VisitUnsafeStatement(UnsafeStatement unsafeStatement)
{
throw NotSupportedToConsistency();
}
public virtual void Exit(UnsafeStatement unsafeStatement)
{
}
public StringBuilder VisitUnsafeStatement(UnsafeStatement unsafeStatement, int data)
{
throw new SLSharpException("SL# does not allow unsafe code.");
}
public UnifiedElement VisitUnsafeStatement(UnsafeStatement unsafeStatement, object data)
{
throw new NotImplementedException("UnsafeStatement");
}
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
{
UnsafeStatement o = other as UnsafeStatement;
return(o != null && this.Body.DoMatch(o.Body, match));
}
void EmbeddedStatement(
#line 1528 "cs.ATG"
out Statement statement) {
#line 1530 "cs.ATG"
TypeReference type = null;
Expression expr = null;
Statement embeddedStatement = null;
statement = null;
#line 1536 "cs.ATG"
Location startLocation = la.Location;
if (la.kind == 16) {
Block(
#line 1538 "cs.ATG"
out statement);
} else if (la.kind == 11) {
lexer.NextToken();
#line 1541 "cs.ATG"
statement = new EmptyStatement();
} else if (
#line 1544 "cs.ATG"
UnCheckedAndLBrace()) {
#line 1544 "cs.ATG"
Statement block; bool isChecked = true;
if (la.kind == 58) {
lexer.NextToken();
} else if (la.kind == 118) {
lexer.NextToken();
#line 1545 "cs.ATG"
isChecked = false;
} else SynErr(197);
Block(
#line 1546 "cs.ATG"
out block);
#line 1546 "cs.ATG"
statement = isChecked ? (Statement)new CheckedStatement(block) : (Statement)new UncheckedStatement(block);
} else if (la.kind == 79) {
IfStatement(
#line 1549 "cs.ATG"
out statement);
} else if (la.kind == 110) {
lexer.NextToken();
#line 1551 "cs.ATG"
List<SwitchSection> switchSections = new List<SwitchSection>();
Expect(20);
Expr(
#line 1552 "cs.ATG"
out expr);
Expect(21);
Expect(16);
SwitchSections(
#line 1553 "cs.ATG"
switchSections);
Expect(17);
#line 1555 "cs.ATG"
statement = new SwitchStatement(expr, switchSections);
} else if (la.kind == 125) {
lexer.NextToken();
Expect(20);
Expr(
#line 1558 "cs.ATG"
out expr);
Expect(21);
EmbeddedStatement(
#line 1559 "cs.ATG"
out embeddedStatement);
#line 1560 "cs.ATG"
statement = new DoLoopStatement(expr, embeddedStatement, ConditionType.While, ConditionPosition.Start);
} else if (la.kind == 65) {
lexer.NextToken();
EmbeddedStatement(
#line 1562 "cs.ATG"
out embeddedStatement);
Expect(125);
Expect(20);
Expr(
#line 1563 "cs.ATG"
out expr);
Expect(21);
Expect(11);
#line 1564 "cs.ATG"
statement = new DoLoopStatement(expr, embeddedStatement, ConditionType.While, ConditionPosition.End);
} else if (la.kind == 76) {
lexer.NextToken();
#line 1566 "cs.ATG"
List<Statement> initializer = null; List<Statement> iterator = null;
Expect(20);
if (StartOf(6)) {
ForInitializer(
#line 1567 "cs.ATG"
out initializer);
}
Expect(11);
if (StartOf(6)) {
Expr(
#line 1568 "cs.ATG"
out expr);
}
Expect(11);
if (StartOf(6)) {
ForIterator(
#line 1569 "cs.ATG"
out iterator);
}
Expect(21);
EmbeddedStatement(
#line 1570 "cs.ATG"
out embeddedStatement);
#line 1571 "cs.ATG"
statement = new ForStatement(initializer, expr, iterator, embeddedStatement);
} else if (la.kind == 77) {
lexer.NextToken();
Expect(20);
Type(
#line 1573 "cs.ATG"
out type);
Identifier();
#line 1573 "cs.ATG"
string varName = t.val;
Expect(81);
Expr(
#line 1574 "cs.ATG"
out expr);
Expect(21);
EmbeddedStatement(
#line 1575 "cs.ATG"
out embeddedStatement);
#line 1576 "cs.ATG"
statement = new ForeachStatement(type, varName , expr, embeddedStatement);
} else if (la.kind == 53) {
lexer.NextToken();
Expect(11);
#line 1579 "cs.ATG"
statement = new BreakStatement();
} else if (la.kind == 61) {
lexer.NextToken();
Expect(11);
#line 1580 "cs.ATG"
statement = new ContinueStatement();
} else if (la.kind == 78) {
GotoStatement(
#line 1581 "cs.ATG"
out statement);
} else if (
#line 1583 "cs.ATG"
IsYieldStatement()) {
Expect(132);
if (la.kind == 101) {
lexer.NextToken();
Expr(
#line 1584 "cs.ATG"
out expr);
#line 1584 "cs.ATG"
statement = new YieldStatement(new ReturnStatement(expr));
} else if (la.kind == 53) {
lexer.NextToken();
#line 1585 "cs.ATG"
statement = new YieldStatement(new BreakStatement());
} else SynErr(198);
Expect(11);
} else if (la.kind == 101) {
lexer.NextToken();
if (StartOf(6)) {
Expr(
#line 1588 "cs.ATG"
out expr);
}
Expect(11);
#line 1588 "cs.ATG"
statement = new ReturnStatement(expr);
} else if (la.kind == 112) {
lexer.NextToken();
if (StartOf(6)) {
Expr(
#line 1589 "cs.ATG"
out expr);
}
Expect(11);
#line 1589 "cs.ATG"
statement = new ThrowStatement(expr);
} else if (StartOf(6)) {
StatementExpr(
#line 1592 "cs.ATG"
out statement);
while (!(la.kind == 0 || la.kind == 11)) {SynErr(199); lexer.NextToken(); }
Expect(11);
} else if (la.kind == 114) {
TryStatement(
#line 1595 "cs.ATG"
out statement);
} else if (la.kind == 86) {
lexer.NextToken();
Expect(20);
Expr(
#line 1598 "cs.ATG"
out expr);
Expect(21);
EmbeddedStatement(
#line 1599 "cs.ATG"
out embeddedStatement);
#line 1599 "cs.ATG"
statement = new LockStatement(expr, embeddedStatement);
} else if (la.kind == 121) {
#line 1602 "cs.ATG"
Statement resourceAcquisitionStmt = null;
lexer.NextToken();
Expect(20);
ResourceAcquisition(
#line 1604 "cs.ATG"
out resourceAcquisitionStmt);
Expect(21);
EmbeddedStatement(
#line 1605 "cs.ATG"
out embeddedStatement);
#line 1605 "cs.ATG"
statement = new UsingStatement(resourceAcquisitionStmt, embeddedStatement);
} else if (la.kind == 119) {
lexer.NextToken();
Block(
#line 1608 "cs.ATG"
out embeddedStatement);
#line 1608 "cs.ATG"
statement = new UnsafeStatement(embeddedStatement);
} else if (la.kind == 74) {
#line 1610 "cs.ATG"
Statement pointerDeclarationStmt = null;
lexer.NextToken();
Expect(20);
ResourceAcquisition(
#line 1612 "cs.ATG"
out pointerDeclarationStmt);
Expect(21);
EmbeddedStatement(
#line 1613 "cs.ATG"
out embeddedStatement);
#line 1613 "cs.ATG"
statement = new FixedStatement(pointerDeclarationStmt, embeddedStatement);
} else SynErr(200);
#line 1615 "cs.ATG"
if (statement != null) {
statement.StartLocation = startLocation;
statement.EndLocation = t.EndLocation;
}
}
public virtual object VisitUnsafeStatement(UnsafeStatement unsafeStatement, object data)
{
throw new global::System.NotImplementedException("UnsafeStatement");
}
public virtual void VisitUnsafeStatement(UnsafeStatement unsafeStatement)
{
DebugExpression(unsafeStatement);
StartNode(unsafeStatement);
WriteKeyword(UnsafeStatement.UnsafeKeywordRole);
unsafeStatement.Body.AcceptVisitor(this);
EndNode(unsafeStatement);
}
public override void VisitUnsafeStatement(UnsafeStatement unsafeStatement)
{
FixEmbeddedStatment(policy.StatementBraceStyle, BraceForcement.DoNotChange, unsafeStatement.Body);
}
public object VisitUnsafeStatement(UnsafeStatement unsafeStatement, object data)
{
AddError(unsafeStatement, "UnsafeStatement is not supported.");
return(null);
}
// Yield statements use the default logic
public override DefiniteAssignmentStatus VisitUnsafeStatement(UnsafeStatement unsafeStatement, DefiniteAssignmentStatus data)
{
return(data);
}
private void Process_Unsafe_Statement(StringBuilder sb, UnsafeStatement statement)
{
sb.Append("unsafe");
sb.Append(ProcessStatement(statement.Statement));
}
public override ControlFlowNode VisitUnsafeStatement(UnsafeStatement unsafeStatement, ControlFlowNode data)
{
ControlFlowNode bodyEnd = HandleEmbeddedStatement(unsafeStatement.Body, data);
return(CreateConnectedEndNode(unsafeStatement, bodyEnd));
}
public override object VisitUnsafeStatement(UnsafeStatement unsafeStatement, object data)
{
return(base.VisitUnsafeStatement(unsafeStatement, data));
}
public virtual void VisitUnsafeStatement (UnsafeStatement unsafeStatement)
{
VisitChildren (unsafeStatement);
}
public virtual T Visit(UnsafeStatement unsafeStatement)
{
return(VisitChildren(unsafeStatement));
}
public void VisitUnsafeStatement(UnsafeStatement unsafeStatement)
{
StartNode(unsafeStatement);
WriteKeyword(UnsafeStatement.UnsafeKeywordRole);
unsafeStatement.Body.AcceptVisitor(this);
EndNode(unsafeStatement);
}
public virtual object TrackedVisitUnsafeStatement(UnsafeStatement unsafeStatement, object data) {
return base.VisitUnsafeStatement(unsafeStatement, data);
}