public static void Go(OutputWriter writer, SizeOfExpressionSyntax expression)
{
var type = TypeProcessor.GetTypeInfo(expression.Type);
//Use dTypes
writer.Write("(" + TypeProcessor.ConvertType(type.Type) + ").sizeof");
// writer.Write(SizeOf(type.Type).ToString());
}
public override LuaSyntaxNode VisitSizeOfExpression(SizeOfExpressionSyntax node)
{
var constExpression = GetConstExpression(node);
Contract.Assert(constExpression != null);
return(constExpression);
}
public static void Go(OutputWriter writer, SizeOfExpressionSyntax expression)
{
var type = TypeProcessor.GetTypeInfo(expression.Type);
//Use dTypes
writer.Write("" + TypeProcessor.ConvertType(type.Type) + ".sizeof");
// writer.Write(SizeOf(type.Type).ToString());
}
private Doc PrintSizeOfExpressionSyntax(SizeOfExpressionSyntax node)
{
return(Concat(
this.PrintSyntaxToken(node.Keyword),
this.PrintSyntaxToken(node.OpenParenToken),
this.Print(node.Type),
this.PrintSyntaxToken(node.CloseParenToken)
));
}
public static Doc Print(SizeOfExpressionSyntax node)
{
return(Doc.Concat(
Token.Print(node.Keyword),
Token.Print(node.OpenParenToken),
Node.Print(node.Type),
Token.Print(node.CloseParenToken)
));
}
public override void VisitSizeOfExpression(SizeOfExpressionSyntax node)
{
if (!PreVisit(node))
{
return;
}
node.Type?.Accept(this);
base.VisitSizeOfExpression(node);
PostVisit(node);
}
// sizeof表达式
public virtual void VisitSizeOfExpressionSyntax(SizeOfExpressionSyntax value)
{
DefaultVisit(value);
}
/// <inheritdoc />
public override Expression VisitSizeOfExpression(SizeOfExpressionSyntax node)
{
throw NotSupported(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitSizeOfExpression(SizeOfExpressionSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitSizeOfExpression(node);
}
public override void VisitSizeOfExpression(SizeOfExpressionSyntax node)
{
throw new NotSupportedException("SizeOf is not supported");
}
public override Evaluation VisitSizeOfExpression(SizeOfExpressionSyntax node)
{
node.Type?.Accept <Evaluation>(this);
return(base.VisitSizeOfExpression(node));
}
public override void VisitSizeOfExpression(SizeOfExpressionSyntax node)
{
//base.VisitSizeOfExpression(node);
}
public override void VisitSizeOfExpression(SizeOfExpressionSyntax node)
{
LogUnsupportedSyntax(node);
}
public static void Go(ScalaWriter writer, SizeOfExpressionSyntax expression)
{
var type = Program.GetModel(expression).GetTypeInfo(expression.Type);
writer.Write(SizeOf(type.Type).ToString());
}
public override SyntaxNode VisitSizeOfExpression(SizeOfExpressionSyntax node)
{
node = (SizeOfExpressionSyntax)base.VisitSizeOfExpression(node);
Classes.Add(node);
return(node);
}
public void VisitSizeOfExpression(SizeOfExpressionSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
ExpressionStart(node);
_writer.WriteKeyword(PrinterKeyword.SizeOf);
if (_writer.Configuration.Spaces.BeforeParentheses.SizeOfParentheses)
_writer.WriteSpace();
_writer.WriteSyntax(Syntax.OpenParen);
if (_writer.Configuration.Spaces.WithinParentheses.SizeOfParentheses)
_writer.WriteSpace();
node.Type.Accept(this);
if (_writer.Configuration.Spaces.WithinParentheses.SizeOfParentheses)
_writer.WriteSpace();
_writer.WriteSyntax(Syntax.CloseParen);
ExpressionEnd(node);
}
public TameSizeOfExpressionSyntax(SizeOfExpressionSyntax node)
{
Node = node;
AddChildren();
}
public override void VisitSizeOfExpression(SizeOfExpressionSyntax node)
{
node.Type?.Accept(this);
base.VisitSizeOfExpression(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitSizeOfExpression(SizeOfExpressionSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitSizeOfExpression(node);
}
public SizeOfExpressionTranslation(SizeOfExpressionSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Type = syntax.Type.Get <TypeTranslation>(this);
}
/// <inheritdoc/>
public override SyntaxNode?VisitSizeOfExpression(SizeOfExpressionSyntax node)
{
Diagnostics.Add(SizeOfExpression, node);
return(base.VisitSizeOfExpression(node));
}
public override void VisitSizeOfExpression(SizeOfExpressionSyntax node)
{
this.VisitExpression(node);
}
public override void VisitSizeOfExpression(SizeOfExpressionSyntax node)
{
throw new NotImplementedException();
}
public override void VisitSizeOfExpression(SizeOfExpressionSyntax node)
{
base.VisitSizeOfExpression(node);
MarkUnsafe();
}
public override SyntaxNode VisitSizeOfExpression(SizeOfExpressionSyntax node)
{
this.AppendCompileIssue(node, IssueType.Error, IssueId.SizeOfNotSupport);
return node;
}
public override void VisitSizeOfExpression(SizeOfExpressionSyntax node)
{
base.VisitSizeOfExpression(node);
MarkUnsafe();
}
public override SyntaxNode VisitSizeOfExpression(SizeOfExpressionSyntax node)
{
this.AppendCompileIssue(node, IssueType.Error, IssueId.SizeOfNotSupport);
return(node);
}
public override void VisitSizeOfExpression(SizeOfExpressionSyntax node)
{
}
// // Summary: // Called when the visitor visits a SizeOfExpressionSyntax node. public virtual void VisitSizeOfExpression(SizeOfExpressionSyntax node);
/// <inheritdoc/>
public override SyntaxNode?VisitSizeOfExpression(SizeOfExpressionSyntax node)
{
Context.ReportDiagnostic(SizeOfExpression, node);
return(base.VisitSizeOfExpression(node));
}
public override void VisitSizeOfExpression(SizeOfExpressionSyntax node)
{
VisitType(node.Type);
//base.VisitSizeOfExpression(node);
}
public override Ust VisitSizeOfExpression(SizeOfExpressionSyntax node)
{
var result = new IntLiteral(0, node.GetTextSpan());
return(result);
}
public override Expression VisitSizeOfExpression(SizeOfExpressionSyntax node)
{
// TODO really safe to strip the arguments? The arguments should only be Types.
return(new GenericLiteralExpression());
}
public SizeOfExpressionTranslation(SizeOfExpressionSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Type = syntax.Type.Get<TypeTranslation>(this);
}