public override void VisitArrayRankSpecifier(ArrayRankSpecifierSyntax node) { foreach (ExpressionSyntax size in node.Sizes) { Visit(size); } }
public static Doc Print(ArrayRankSpecifierSyntax node) { if (node.Sizes.All(o => o is OmittedArraySizeExpressionSyntax)) { return(Doc.Concat( Token.Print(node.OpenBracketToken), SeparatedSyntaxList.Print(node.Sizes, Node.Print, Doc.Null), Token.Print(node.CloseBracketToken) )); } return(Doc.Group( Token.Print(node.OpenBracketToken), node.Sizes.Any() ? Doc.Concat( Doc.Indent( Doc.SoftLine, SeparatedSyntaxList.Print(node.Sizes, Node.Print, Doc.Null) ), Doc.SoftLine ) : Doc.Null, Token.Print(node.CloseBracketToken) )); }
private StatePropertySyntax ParseStateProperty() { var name = Match(SyntaxKind.IdentifierToken); ArrayRankSpecifierSyntax arrayRankSpecifier = null; if (Current.Kind == SyntaxKind.OpenBracketToken) { arrayRankSpecifier = ParseArrayRankSpecifier(true); } var equals = Match(SyntaxKind.EqualsToken); var lessThan = NextTokenIf(SyntaxKind.LessThanToken); _allowGreaterThanTokenAroundRhsExpression = true; _allowLinearAndPointAsIdentifiers = true; ExpressionSyntax value; try { value = ParseExpression(); } finally { _allowLinearAndPointAsIdentifiers = false; _allowGreaterThanTokenAroundRhsExpression = false; } var greaterThan = NextTokenIf(SyntaxKind.GreaterThanToken); var semicolon = Match(SyntaxKind.SemiToken); return(new StatePropertySyntax(name, arrayRankSpecifier, equals, lessThan, value, greaterThan, semicolon)); }
public override SyntaxNode VisitArrayRankSpecifier(ArrayRankSpecifierSyntax node) { if (node.Rank > 1) { this.AppendCompileIssue(node, IssueType.Error, IssueId.MultiDimensionArrayAccessNotSupport); } return(node); }
public bool Analyze(ArrayRankSpecifierSyntax syntax) { if (syntax.Rank != 1) { FireSyntaxErrorCallback(syntax, "Multi-rank arrays not supported supported"); return(false); } return(true); }
public override void VisitArrayRankSpecifier(ArrayRankSpecifierSyntax node) { foreach (ExpressionSyntax nodeSize in node.Sizes) { nodeSize.Accept(this); } base.VisitArrayRankSpecifier(node); }
public override IEnumerable <IModel> VisitArrayRankSpecifier(ArrayRankSpecifierSyntax node) { var model = Create <ArrayRankSpecifier>(node); TransformInto <ExpressionModel>(node.Sizes, model.Sizes); model.Rank = node.Rank; yield return(model); }
public override Evaluation VisitArrayRankSpecifier(ArrayRankSpecifierSyntax node) { foreach (ExpressionSyntax nodeSize in node.Sizes) { nodeSize.Accept <Evaluation>(this); } return(base.VisitArrayRankSpecifier(node)); }
public static Doc Print(ArrayRankSpecifierSyntax node) { return(Doc.Concat( Token.Print(node.OpenBracketToken), node.Sizes.Any() ? SeparatedSyntaxList.Print(node.Sizes, Node.Print, Doc.Null) : Doc.Null, Token.Print(node.CloseBracketToken) )); }
public StatePropertySyntax(SyntaxToken name, ArrayRankSpecifierSyntax arrayRankSpecifier, SyntaxToken equalsToken, SyntaxToken lessThanToken, ExpressionSyntax value, SyntaxToken greaterThanToken, SyntaxToken semicolonToken) : base(SyntaxKind.StateProperty) { RegisterChildNode(out Name, name); RegisterChildNode(out ArrayRankSpecifier, arrayRankSpecifier); RegisterChildNode(out EqualsToken, equalsToken); RegisterChildNode(out LessThanToken, lessThanToken); RegisterChildNode(out Value, value); RegisterChildNode(out GreaterThanToken, greaterThanToken); RegisterChildNode(out SemicolonToken, semicolonToken); }
public override LuaSyntaxNode VisitArrayRankSpecifier(ArrayRankSpecifierSyntax node) { LuaArrayRankSpecifierSyntax rankSpecifier = new LuaArrayRankSpecifierSyntax(node.Rank); foreach (var size in node.Sizes) { var expression = (LuaExpressionSyntax)size.Accept(this); rankSpecifier.Sizes.Add(expression); } return(rankSpecifier); }
private ArrayRankSpecifierSyntax BuildArrayRankSpecifier(int rank) { var result = new ArrayRankSpecifierSyntax(); for (int i = 0; i < rank; i++) { result.Sizes.Add(new OmittedArraySizeExpressionSyntax()); } return(result); }
private static ArrayTypeSyntax GetArrayType([NotNull] TypeSyntax elementType, int rank) { var arrayTypeSyntax = ArrayType(elementType); var ranks = new ArrayRankSpecifierSyntax[rank]; for (int i = 0; i < rank; ++i) { ranks[i] = CreateArrayRank(); } return(arrayTypeSyntax.WithRankSpecifiers(List(ranks))); }
public static void Write(this ArrayRankSpecifierSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context) { if (syntax.Sizes.Count == 1 && syntax.Sizes.Single() is OmittedArraySizeExpressionSyntax) { textWriter.Write("._C_0_0()"); } else { textWriter.Write("._C_0_2112("); syntax.Sizes.Write(ExpressionExtensions.Write, textWriter, context); textWriter.Write(")"); } }
private static int GetNumberOfNonOmittedArraySizes(ArrayRankSpecifierSyntax rankSpec) { int count = rankSpec.Sizes.Count; int result = 0; for (int i = 0; i < count; i++) { if (rankSpec.Sizes[i].Kind != SyntaxKind.OmittedArraySizeExpression) { result++; } } return(result); }
private Doc PrintArrayRankSpecifierSyntax(ArrayRankSpecifierSyntax node) { return(Concat( this.PrintSyntaxToken(node.OpenBracketToken), node.Sizes.Any() ? this.PrintSeparatedSyntaxList( node.Sizes, this.Print, Doc.Null ) : Doc.Null, this.PrintSyntaxToken(node.CloseBracketToken) )); }
public override void VisitArrayRankSpecifier(ArrayRankSpecifierSyntax node) { if (!PreVisit(node)) { return; } foreach (ExpressionSyntax nodeSize in node.Sizes) { nodeSize.Accept(this); } base.VisitArrayRankSpecifier(node); PostVisit(node); }
public override void VisitArrayRankSpecifier(ArrayRankSpecifierSyntax node) { emit("["); int num = 0; foreach (ExpressionSyntax exp in node.Sizes) { if (num >= 1) { emit(","); } Visit(exp); num++; } emit("]"); }
/// <summary> /// Generates an array creation expression /// </summary> /// <param name="node">The array creation expression</param> public override void Generate(ArrayCreationExpressionSyntax node) { IEnumerable <SyntaxNode> children = node.Type.ChildNodes(); SyntaxNode second = children.ElementAt(1); ArrayRankSpecifierSyntax rank = second as ArrayRankSpecifierSyntax; ExpressionSyntax sizeExpression = rank.Sizes.First(); // Malloc returns a pointer to the type // So that means this type has a pointer too much string type = m_context.ConvertTypeName(node.Type); type = type.Substring(0, type.Length - 1); /*m_context.Writer.Append(string.Format("malloc(sizeof({0}) * (", type)); * m_context.Generators.Expression.Generate(sizeExpression); * m_context.Writer.Append("))");*/ m_context.Writer.Append("calloc(("); m_context.Generators.Expression.Generate(sizeExpression); m_context.Writer.Append(string.Format("), sizeof({0}))", type)); }
public override SyntaxNode VisitArrayRankSpecifier(ArrayRankSpecifierSyntax node) { node = (ArrayRankSpecifierSyntax)base.VisitArrayRankSpecifier(node); Classes.Add(node); return(node); }
private static void CheckIfCommasAreAtTheSameLineAsThePreviousParameter(SyntaxNodeAnalysisContext context, List <SyntaxToken> commas, ArrayRankSpecifierSyntax arrayRankSpecifierSyntax) { for (int index = 0; index < commas.Count; index++) { var comma = commas[index]; if (arrayRankSpecifierSyntax.Sizes.Count <= index) { return; } var previousParameter = arrayRankSpecifierSyntax.Sizes[index]; var commaLocation = comma.GetLocation(); if (commaLocation.GetLineSpan().StartLinePosition.Line != previousParameter.GetLocation().GetLineSpan().EndLinePosition.Line) { context.ReportDiagnostic(Diagnostic.Create(Descriptor, commaLocation)); } } }
public virtual void PostWalkArrayRankSpecifier(ArrayRankSpecifierSyntax arrayRankSpecifierSyntax) { }
// ArrayRankSpecifierSyntax public virtual bool WalkArrayRankSpecifier(ArrayRankSpecifierSyntax arrayRankSpecifierSyntax) { return DefaultWalk(arrayRankSpecifierSyntax); }
public TameArrayRankSpecifierSyntax(ArrayRankSpecifierSyntax node) { Node = node; AddChildren(); }
public override Ust VisitArrayRankSpecifier(ArrayRankSpecifierSyntax node) { throw new InvalidOperationException(); }
public ArrayRankSpecifierTranslation(ArrayRankSpecifierSyntax syntax, SyntaxTranslation parent) : base(syntax, parent) { Sizes = syntax.Sizes.Get <ExpressionSyntax, ExpressionTranslation>(this); }
public override Expr VisitArrayRankSpecifier(ArrayRankSpecifierSyntax node) { return(base.VisitArrayRankSpecifier(node)); }
public void VisitArrayRankSpecifier(ArrayRankSpecifierSyntax node) { if (node == null) throw new ArgumentNullException("node"); node.Validate(); if (_writer.Configuration.Spaces.Other.BeforeArrayRankBrackets) _writer.WriteSpace(); _writer.WriteSyntax(Syntax.OpenBracket); if ( node.Sizes.Count == 0 || (node.Sizes.Count == 1 && node.Sizes[0].SyntaxKind == SyntaxKind.OmittedArraySizeExpression) ) { if (_writer.Configuration.Spaces.Other.WithinArrayRankEmptyBrackets) _writer.WriteSpace(); } else { if (_writer.Configuration.Spaces.Other.WithinArrayRankBrackets) _writer.WriteSpace(); bool hadOne = false; foreach (var size in node.Sizes) { if (hadOne) { if (size.SyntaxKind == SyntaxKind.OmittedArraySizeExpression) _writer.WriteSyntax(Syntax.Comma); else _writer.WriteListSeparator(); } else { hadOne = true; } size.Accept(this); } if (_writer.Configuration.Spaces.Other.WithinArrayRankBrackets) _writer.WriteSpace(); } _writer.WriteSyntax(Syntax.CloseBracket); }
public override void VisitArrayRankSpecifier(ArrayRankSpecifierSyntax node) => base.VisitArrayRankSpecifier(node);
public virtual void VisitArrayRankSpecifier(ArrayRankSpecifierSyntax node) { DefaultVisit(node); }
public override void VisitArrayRankSpecifier(ArrayRankSpecifierSyntax node) { throw new NotImplementedException(); }
public override void VisitArrayRankSpecifier(ArrayRankSpecifierSyntax node) { }
/// <summary>Called once at compilation start to register actions in the compilation context.</summary> /// <param name="context">The analysis context.</param> internal override void RegisterSyntaxNodeAction(CompilationStartAnalysisContext context) { context.RegisterSyntaxNodeAction(ctx => { // We can't replace array allocations in attributes, as they're persisted to metadata if (ctx.Node.Parent is AttributeArgumentSyntax) { return; } InitializerExpressionSyntax initializerExpr = null; bool isArrayCreationExpression = ctx.Node.CSharpKind() == SyntaxKind.ArrayCreationExpression; if (isArrayCreationExpression) { // This is an ArrayCreationExpression (e.g. "new byte[2]" or "new byte[] { 1, 2 }"). // If it has only a single rank, and if the input to it is a constant 0, report it. ArrayCreationExpressionSyntax arrayCreationExpr = (ArrayCreationExpressionSyntax)ctx.Node; var arrayType = arrayCreationExpr.Type; if (arrayType.ElementType is PointerTypeSyntax) // pointers can't be used as generic arguments { return; } if (arrayType.RankSpecifiers.Count >= 1) { // Make sure this is a single dimensional array. ArrayRankSpecifierSyntax rankSpecifier = arrayType.RankSpecifiers[0]; if (rankSpecifier.Rank != 1) { return; } // Parse out the numerical length from the rank specifier. It must be a constant zero. LiteralExpressionSyntax sizeSpecifier = rankSpecifier.ChildNodes().FirstOrDefault(child => child.CSharpKind() == SyntaxKind.NumericLiteralExpression) as LiteralExpressionSyntax; if (sizeSpecifier != null) { if (sizeSpecifier.Token.Value is int && ((int)sizeSpecifier.Token.Value) == 0) { Report(ctx, arrayCreationExpr); } return; } // We couldn't determine the length based on the rank specifier. // We'll try to do so based on any initializer expression the array has. initializerExpr = arrayCreationExpr.Initializer; } } else if (!(ctx.Node.Parent is ArrayCreationExpressionSyntax)) { // This is an ArrayInitializerExpression (e.g. { 1, 2 }). However, we only want to examine it // if it's not part of a larger ArrayCreationExpressionSyntax; otherwise, we'll end up // flagging it twice and recommending incorrect transforms. initializerExpr = ctx.Node as InitializerExpressionSyntax; } // If we needed to examine the initializer in order to get the size and if it's 0, // report it, but make sure to report the right syntax node. if (initializerExpr != null && initializerExpr.Expressions.Count == 0) { Report(ctx, isArrayCreationExpression ? ctx.Node : initializerExpr); } }, expressionKinds); }