public override void WriteTo(CCodeWriterBase c)
{
c.TextSpanNewLine("inline static GC_descr __get_type_descriptor()");
c.OpenBlock();
c.TextSpan("typedef");
c.WhiteSpace();
c.WriteType(this.Type, true, true, true);
c.WhiteSpace();
c.TextSpanNewLine("__type;");
c.TextSpanNewLine("GC_word bitmap[GC_BITMAP_SIZE(__type)] = {0};");
// set fields
foreach (var field in this.Type.EnumPossibleReferenceFields())
{
c.TextSpan("GC_set_bit(bitmap, GC_WORD_OFFSET(__type,");
c.WhiteSpace();
// TODO: fix it, replace with "base" type as generic types causing issues
////c.WriteFieldAccessAsStaticField(field);
c.WriteName(field);
c.TextSpanNewLine("));");
}
c.TextSpanNewLine("return GC_make_descriptor(bitmap, GC_WORD_LEN(__type));");
c.EndBlock();
c.Separate();
}
internal override void WriteTo(CCodeWriterBase c)
{
c.WriteWrappedExpressionIfNeeded(this.Operand);
c.TextSpan("[");
this.Index.WriteTo(c);
c.TextSpan("]");
}
internal override void WriteTo(CCodeWriterBase c)
{
c.TextSpan("if");
c.WhiteSpace();
c.TextSpan("(");
if (!this.JumpIfTrue)
{
c.TextSpan("!");
c.WriteWrappedExpressionIfNeeded(this.Condition);
}
else
{
this.Condition.WriteTo(c);
}
c.TextSpan(")");
c.NewLine();
c.OpenBlock();
new GotoStatement {
Label = this.Label
}.WriteTo(c);
c.EndBlock();
c.Separate();
}
internal override void WriteTo(CCodeWriterBase c)
{
c.TextSpan("__reftype");
c.TextSpan("(");
this.Operand.WriteTo(c);
c.TextSpan(")");
}
internal override void WriteTo(CCodeWriterBase c)
{
c.TextSpan("typedef");
c.WhiteSpace();
if (this.TypeExpressionOpt != null)
{
this.TypeExpressionOpt.WriteTo(c);
c.WhiteSpace();
this.Identifier.WriteTo(c);
}
else if (this.PointerToMemberOpt != null)
{
c.WriteType(this.PointerToMemberOpt.ReturnType, containingNamespace: MethodOwner?.ContainingNamespace);
c.WhiteSpace();
c.TextSpan("(");
if (!this.PointerToMemberOpt.IsStatic)
{
c.WriteType(this.PointerToMemberOpt.ContainingType, true, true, true, containingNamespace: MethodOwner?.ContainingNamespace);
c.TextSpan("::");
}
c.TextSpan("*");
c.WhiteSpace();
this.Identifier.WriteTo(c);
c.TextSpan(")");
c.WriteMethodParameters(this.PointerToMemberOpt, true, false, containingNamespace: MethodOwner?.ContainingNamespace);
}
base.WriteTo(c);
}
internal override void WriteTo(CCodeWriterBase c)
{
c.TextSpan("for");
c.WhiteSpace();
c.TextSpan("(");
PrintStatementAsExpression(c, this.InitializationOpt);
c.TextSpan(";");
c.WhiteSpace();
if (this.ConditionOpt != null)
{
this.ConditionOpt.WriteTo(c);
}
c.TextSpan(";");
c.WhiteSpace();
PrintStatementAsExpression(c, this.IncrementingOpt);
c.TextSpan(")");
c.NewLine();
base.WriteTo(c);
}
internal override void WriteTo(CCodeWriterBase c)
{
if (!this.Method.IsStatic)
{
var receiverOpt = this.ReceiverOpt;
if (receiverOpt is BaseReference)
{
receiverOpt = new ThisReference();
}
c.WriteWrappedExpressionIfNeeded(receiverOpt);
c.TextSpan(",");
c.WhiteSpace();
}
new Parenthesis {
Operand = new MethodPointer {
Method = this.Method
}
}.WriteTo(c);
c.TextSpan("&");
c.WriteTypeFullName(this.Method.ContainingType);
c.TextSpan("::");
c.WriteMethodNameNoTemplate(this.Method);
if (this.TypeArgumentsOpt != null && this.TypeArgumentsOpt.Any())
{
c.WriteTypeArguments(this.TypeArgumentsOpt);
}
}
internal override void WriteTo(CCodeWriterBase c)
{
c.TextSpan("[&]");
c.TextSpan("(");
var any = false;
foreach (var local in this.Locals)
{
if (any)
{
c.TextSpan(",");
c.WhiteSpace();
}
c.TextSpan("auto");
c.WhiteSpace();
c.WriteName(local);
any = true;
}
c.TextSpan(")");
c.WriteBlockOrStatementsAsBlock(this.Statements, true);
}
public override void WriteTo(CCodeWriterBase c)
{
c.TextSpan("class");
c.WhiteSpace();
this.Name(c);
c.WhiteSpace();
c.TextSpan(":");
c.WhiteSpace();
c.TextSpan("public");
c.WhiteSpace();
c.TextSpan("__methods_table");
c.NewLine();
c.OpenBlock();
c.DecrementIndent();
c.TextSpanNewLine("public:");
c.IncrementIndent();
foreach (var declaration in Declarations)
{
declaration.WriteTo(c);
}
c.EndBlockWithoutNewLine();
}
internal override void WriteTo(CCodeWriterBase c)
{
c.TextSpan("[&]()");
c.NewLine();
c.OpenBlock();
foreach (var statement in this.Locals)
{
statement.WriteTo(c);
}
foreach (var expression in this.SideEffects)
{
expression.WriteTo(c);
c.EndStatement();
}
c.TextSpan("return");
c.WhiteSpace();
this.Value.WriteTo(c);
c.EndStatement();
c.EndBlockWithoutNewLine();
c.TextSpan("()");
}
internal override void WriteTo(CCodeWriterBase c)
{
this.Expression.WriteTo(c);
c.TextSpan("->operator[](");
if (this._indices.Count > 1)
{
c.TextSpan("{");
}
var any = false;
foreach (var index in this._indices)
{
if (any)
{
c.TextSpan(",");
c.WhiteSpace();
}
index.WriteTo(c);
any = true;
}
if (this._indices.Count > 1)
{
c.TextSpan("}");
}
c.TextSpan(")");
}
internal override void WriteTo(CCodeWriterBase c)
{
switch (this.OperatorKind & UnaryOperatorKind.OpMask)
{
case UnaryOperatorKind.UnaryPlus:
c.TextSpan("+");
break;
case UnaryOperatorKind.UnaryMinus:
c.TextSpan("-");
break;
case UnaryOperatorKind.LogicalNegation:
c.TextSpan("!");
break;
case UnaryOperatorKind.BitwiseComplement:
c.TextSpan("~");
break;
default:
throw new NotImplementedException();
}
c.WriteExpressionInParenthesesIfNeeded(this.Operand);
}
internal static void WriteCheckedOperator(CCodeWriterBase c, BinaryOperatorKind operatorKind)
{
switch (GetOperatorKind(operatorKind))
{
case BinaryOperatorKind.Multiplication:
c.TextSpan("__mul_ovf");
break;
case BinaryOperatorKind.Addition:
c.TextSpan("__add_ovf");
break;
case BinaryOperatorKind.Subtraction:
c.TextSpan("__sub_ovf");
break;
default:
throw new NotImplementedException();
}
switch (operatorKind & BinaryOperatorKind.TypeMask)
{
case BinaryOperatorKind.UInt:
case BinaryOperatorKind.ULong:
c.TextSpan("_un");
break;
}
}
internal static void WriteCallArguments(IEnumerable <Expression> arguments, IEnumerable <IParameterSymbol> parameterSymbols, CCodeWriterBase c)
{
c.TextSpan("(");
var anyArgs = false;
var paramEnum = parameterSymbols != null?parameterSymbols.GetEnumerator() : null;
foreach (var expression in arguments)
{
var hasParameter = false;
if (paramEnum != null)
{
hasParameter = paramEnum.MoveNext();
}
if (anyArgs)
{
c.TextSpan(",");
c.WhiteSpace();
}
PreprocessParameter(expression, hasParameter ? paramEnum.Current : null).WriteTo(c);
anyArgs = true;
}
c.TextSpan(")");
}
public override void WriteTo(CCodeWriterBase c)
{
c.TextSpan("virtual operator");
c.WhiteSpace();
c.WriteType(this.interfaceSymbol);
c.TextSpan("()");
MethodBodyOpt.WriteTo(c);
}
internal override void WriteTo(CCodeWriterBase c)
{
c.TextSpan("reinterpret_cast<");
c.WriteType(Type);
c.TextSpan(">(alloca");
c.TextSpan("(");
this.Count.WriteTo(c);
c.TextSpan("))");
}
internal override void WriteTo(CCodeWriterBase c)
{
if (!this.Method.ReturnsVoid && (this.Method.IsVirtualGenericMethod() || this.CallGenericMethodFromInterfaceMethod))
{
c.TextSpan("((");
c.WriteType(this.Method.ReturnType, callGenericMethodFromInterfaceMethod: this.CallGenericMethodFromInterfaceMethod, containingNamespace: MethodOwner?.ContainingNamespace);
c.TextSpan(")");
}
if (this.Method.IsStatic)
{
if (!this.Method.IsExternDeclaration())
{
c.WriteTypeFullName(this.Method.ContainingType, containingNamespace: MethodOwner?.ContainingNamespace);
c.TextSpan("::");
}
else
{
c.WriteNamespace(this.Method.ContainingType, containingNamespace: MethodOwner?.ContainingNamespace);
}
c.WriteMethodName(this.Method, addTemplate: true, containingNamespace: MethodOwner?.ContainingNamespace);
}
else
{
IMethodSymbol receiverIsNotInterfacesButAccessingExplicitInterfaceMethod = null;
var receiverOpt = this.ReceiverOpt;
if (receiverOpt != null)
{
receiverOpt = this.PrepareMethodReceiver(receiverOpt, this.Method);
// if method name is empty then receiverOpt returns function pointer
if (!string.IsNullOrWhiteSpace(this.Method.Name))
{
c.WriteAccess(receiverOpt);
}
else
{
c.WriteWrappedExpressionIfNeeded(receiverOpt);
}
if (receiverOpt.Type.TypeKind != TypeKind.Interface && this.Method.ReceiverType != null && this.Method.ReceiverType.TypeKind == TypeKind.Interface)
{
receiverIsNotInterfacesButAccessingExplicitInterfaceMethod = receiverOpt.Type.GetMembers().OfType <IMethodSymbol>().FirstOrDefault(m => m.ExplicitInterfaceImplementations.Any() && m.ExplicitInterfaceImplementations.First().CompareTo(this.Method) == 0);
}
}
c.WriteMethodName(receiverIsNotInterfacesButAccessingExplicitInterfaceMethod ?? this.Method, addTemplate: true, callGenericMethodFromInterfaceMethod: this.CallGenericMethodFromInterfaceMethod, containingNamespace: MethodOwner?.ContainingNamespace);
}
WriteCallArguments(c, this.Method != null ? this.Method.Parameters : (IEnumerable <IParameterSymbol>)null, this._arguments, this.Method, methodOwner: MethodOwner, specialCaseInterfaceWrapperCall: this.SpecialCaseInterfaceWrapperCall, specialCaseCreateInstanceNewObjectReplacement: this.SpecialCaseCreateInstanceNewObjectReplacement);
if (!this.Method.ReturnsVoid && (this.Method.IsVirtualGenericMethod() || this.CallGenericMethodFromInterfaceMethod))
{
c.TextSpan(")");
}
}
internal override void WriteTo(CCodeWriterBase c)
{
c.TextSpan("__refvalue");
c.TextSpan("<");
c.WriteType(Type);
c.TextSpan(">");
c.TextSpan("(");
this.Operand.WriteTo(c);
c.TextSpan(")");
}
internal override void WriteTo(CCodeWriterBase c)
{
c.TextSpan("is<");
this.TargetType.IsReference = true;
this.TargetType.WriteTo(c);
c.TextSpan(">");
c.TextSpan("(");
c.WriteWrappedExpressionIfNeeded(this.Operand);
c.TextSpan(")");
}
internal override void WriteTo(CCodeWriterBase c)
{
c.TextSpan("as<");
this.TargetType.IsReference = true;
this.TargetType.WriteTo(c);
c.TextSpan(">");
c.TextSpan("(");
this.Operand.WriteTo(c);
c.TextSpan(")");
}
internal override void WriteTo(CCodeWriterBase c)
{
c.TextSpan("__refvalue");
c.TextSpan("<");
c.WriteType(Type, containingNamespace: MethodOwner?.ContainingNamespace);
c.TextSpan(">");
c.TextSpan("(");
this.Operand.WriteTo(c);
c.TextSpan(")");
}
internal override void WriteTo(CCodeWriterBase c)
{
c.DecrementIndent();
foreach (var label in this.Labels)
{
if (label.Value != null)
{
var skipCaseForNullableWhenNull = this.SwitchType.IsValueType && label.Value.IsNull;
if (!skipCaseForNullableWhenNull)
{
c.TextSpan("case");
c.WhiteSpace();
if (label.Value != null)
{
new Literal {
Value = label.Value, Type = label.Type
}.WriteTo(c);
}
else
{
label.WriteTo(c);
}
c.TextSpan(":");
}
else
{
label.GenerateLabel = this.IsNullableType;
}
}
else
{
c.TextSpan("default:");
if (this.IsNullableType)
{
label.GenerateLabel = true;
}
}
c.NewLine();
if (label.GenerateLabel)
{
label.WriteTo(c);
c.TextSpan(":");
c.NewLine();
}
}
c.IncrementIndent();
NoParenthesis = true;
base.WriteTo(c);
}
internal override void WriteTo(CCodeWriterBase c)
{
c.TextSpan("reinterpret_cast<");
c.WriteType(Type, containingNamespace: MethodOwner?.ContainingNamespace);
c.TextSpan(">(std::memset(alloca");
c.TextSpan("(");
this.Count.WriteTo(c);
c.TextSpan("), 0, ");
this.Count.WriteTo(c);
c.TextSpan("))");
}
internal override void WriteTo(CCodeWriterBase c)
{
c.TextSpan("__makeref");
////c.TextSpan("<");
////c.WriteType(this.Operand.Type);
////c.TextSpan(">");
c.TextSpan("(");
new AddressOfOperator {
Operand = this.Operand
}.WriteTo(c);
c.TextSpan(")");
}
private static int ConstructorInitializer(CCodeWriterBase c, IList <Statement> statements)
{
var skip = 0;
// call constructors
var constructorsOrAssignments =
statements.TakeWhile(IsConstructorCallOrAssignment).Select(GetCallOrAssignment).ToArray();
if (constructorsOrAssignments.Length > 0)
{
c.WhiteSpace();
c.TextSpan(":");
c.WhiteSpace();
var any = false;
foreach (var constructorAsAssignment in constructorsOrAssignments)
{
skip++;
if (any)
{
c.TextSpan(",");
c.WhiteSpace();
}
if (constructorAsAssignment.Kind == Kinds.Call)
{
constructorAsAssignment.WriteTo(c);
break;
}
else if (constructorAsAssignment.Kind == Kinds.AssignmentOperator)
{
// convert
var assignmentOperator = constructorAsAssignment as AssignmentOperator;
var fieldAccess = assignmentOperator.Left as FieldAccess;
if (fieldAccess != null && fieldAccess.ReceiverOpt.Kind == Kinds.ThisReference)
{
c.WriteName(fieldAccess.Field);
c.TextSpan("(");
assignmentOperator.Right.WriteTo(c);
c.TextSpan(")");
}
}
else
{
Debug.Assert(false);
}
any = true;
}
}
return(skip);
}
internal override void WriteTo(CCodeWriterBase c)
{
c.TextSpan("while");
c.WhiteSpace();
c.TextSpan("(");
this.Condition.WriteTo(c);
c.TextSpan(")");
c.NewLine();
base.WriteTo(c);
}
public override void WriteTo(CCodeWriterBase c)
{
// write boxing function
c.TextSpan("inline");
c.WhiteSpace();
c.WriteType(this.type, valueTypeAsClass: true);
c.WhiteSpace();
c.TextSpan("__box(");
c.WriteType(this.type);
c.WhiteSpace();
c.TextSpan("value)");
MethodBodyOpt.WriteTo(c);
}
internal override void WriteTo(CCodeWriterBase c)
{
if (this.Field.IsStatic)
{
if (this.Field.ContainingType == null && this.Field.ContainingSymbol is ITypeSymbol)
{
c.WriteTypeFullName((ITypeSymbol)this.Field.ContainingSymbol);
}
else
{
c.WriteTypeFullName(this.Field.ContainingType);
}
c.TextSpan("::");
c.WriteName(this.Field);
}
else
{
if (this.PointerAccess)
{
var pointerIndirect = this.ReceiverOpt as PointerIndirectionOperator;
if (pointerIndirect != null)
{
c.WriteWrappedExpressionIfNeeded(pointerIndirect.Operand);
c.TextSpan("->");
c.WriteName(this.Field);
return;
}
}
if (this.ReceiverOpt != null && this.ReceiverOpt.Kind != Kinds.ConditionalReceiver)
{
var primitiveValueAccess = this.Field.ContainingType != null &&
this.Field.ContainingType.IsPrimitiveValueType() &&
this.Field.Name == "m_value" && this.ReceiverOpt is Conversion &&
((Conversion)this.ReceiverOpt).ConversionKind == ConversionKind.Unboxing;
if (primitiveValueAccess)
{
c.WriteWrappedExpressionIfNeeded(this.ReceiverOpt);
return;
}
else
{
var effectiveReceiverOpt = PrepareFieldReceiver(this.ReceiverOpt, this.Field);
c.WriteAccess(effectiveReceiverOpt);
}
}
c.WriteName(this.Field);
}
}
internal override void WriteTo(CCodeWriterBase c)
{
if (!this.Method.ReturnsVoid && this.Method.IsVirtualGenericMethod())
{
c.TextSpan("((");
c.WriteType(this.Method.ReturnType, containingNamespace: MethodOwner?.ContainingNamespace);
c.TextSpan(")");
}
if (this.Method.IsStaticMethod())
{
if (!this.Method.IsExternDeclaration())
{
c.WriteTypeFullName(this.Method.ContainingType, containingNamespace: MethodOwner?.ContainingNamespace);
c.TextSpan("::");
}
else
{
c.WriteNamespace(this.Method.ContainingType, containingNamespace: MethodOwner?.ContainingNamespace);
c.TextSpan("::");
}
c.WriteMethodName(this.Method, addTemplate: true, containingNamespace: MethodOwner?.ContainingNamespace);
}
else
{
var receiverOpt = this.ReceiverOpt;
if (receiverOpt != null)
{
receiverOpt = this.PrepareMethodReceiver(receiverOpt, this.Method);
// if method name is empty then receiverOpt returns function pointer
if (!string.IsNullOrWhiteSpace(this.Method.Name))
{
c.WriteAccess(receiverOpt);
}
else
{
c.WriteWrappedExpressionIfNeeded(receiverOpt);
}
}
c.WriteMethodName(this.Method, addTemplate: true /*, methodSymbolForName: explicitMethod*/, interfaceWrapperMethodSpecialCase: InterfaceWrapperSpecialCall, containingNamespace: MethodOwner?.ContainingNamespace);
}
WriteCallArguments(c, this.Method != null ? this.Method.Parameters : (IEnumerable <IParameterSymbol>)null, this._arguments, this.Method, methodOwner: MethodOwner);
if (!this.Method.ReturnsVoid && this.Method.IsVirtualGenericMethod())
{
c.TextSpan(")");
}
}
internal override void WriteTo(CCodeWriterBase c)
{
if (!this.MethodsTable)
{
c.TextSpan(RuntimeType ? "_runtime_typeof<" : "_typeof<");
}
else
{
c.TextSpan("_typeMT<");
}
this.SourceType.WriteTo(c);
c.TextSpan(">()");
}
