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 virtual void VisitArrayRankSpecifier(ArrayRankSpecifierSyntax node)
{
DefaultVisit(node);
}
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);
}
