private static void HandleAssign(StringBuilder sb, LocalOperation operation, MidRepresentationVariables vars)
{
var assignment = (Assignment)operation.Value;
if (assignment.Right is NewConstructedObject)
{
HandleNewObject(operation, sb, vars);
return;
}
var assignedTo = assignment.AssignedTo;
var localVariable = assignment.Right as LocalVariable;
if (localVariable != null)
{
var leftVarType = assignment.AssignedTo.ComputedType();
var rightVarType = assignment.Right.ComputedType();
if (leftVarType != rightVarType)
{
if (rightVarType.ClrType.IsPointer)
{
sb.AppendFormat("{0} = *{1};", assignedTo, localVariable.Name);
return;
}
}
var assignedToData = vars.GetVariableData(assignedTo);
var localVariableData = vars.GetVariableData(localVariable);
var rightVar = localVariable;
if (assignedToData.Escaping == localVariableData.Escaping ||
assignedTo.ComputedType().ClrTypeCode != TypeCode.Object)
{
sb.AppendFormat("{0} = {1};", assignedTo.Name, rightVar.Name);
return;
}
switch (assignedToData.Escaping)
{
case EscapingMode.Pointer:
switch (localVariableData.Escaping)
{
case EscapingMode.Stack:
sb.AppendFormat("{0} = &{1};", assignedTo.Name, rightVar.Name);
return;
case EscapingMode.Smart:
sb.AppendFormat("{0} = ({1}).get();", assignedTo.Name, rightVar.Name);
return;
}
break;
case EscapingMode.Smart:
throw new InvalidDataException("Case not possible!");
}
throw new InvalidDataException("Case not handled");
}
else
{
sb.AppendFormat("{0} = {1};", assignedTo.Name, assignment.Right.ComputedValue());
}
}
private static void AddVariableContent(StringBuilder variablesSb, string format, LocalVariable localVariable, MidRepresentationVariables vars)
{
var localVariableData = vars.GetVariableData(localVariable);
if (localVariableData.Escaping == EscapingMode.Stack)
{
return;
}
if (localVariable.ComputedType().ClrType.IsSubclassOf(typeof(MethodInfo)))
{
variablesSb
.AppendFormat("void (*{0})({1});",
localVariable.Name,
ComputeCommaSeparatedParameterTypes(localVariable))
.AppendLine();
return;
}
if (localVariableData.Escaping == EscapingMode.Pointer)
{
var cppName = localVariable.ComputedType()
.ClrType.ToDeclaredVariableType(true, isSmartPtr: localVariableData.Escaping);
variablesSb
.AppendFormat(format, cppName, localVariable.Id)
.AppendLine();
return;
}
variablesSb
.AppendFormat(format, localVariable.ComputedType()
.ClrType.ToDeclaredVariableType(true, isSmartPtr: localVariableData.Escaping), localVariable.Id)
.AppendLine();
}
private static void HandleNewObject(LocalOperation operation, StringBuilder bodySb, MidRepresentationVariables vars)
{
var value = (Assignment)operation.Value;
var rightValue = (NewConstructedObject)value.Right;
var localValue = rightValue.Info;
var declaringType = localValue.DeclaringType;
var cppName = declaringType.ToDeclaredVariableType(true, EscapingMode.Stack);
var assignedData = vars.GetVariableData(value.AssignedTo);
switch (assignedData.Escaping)
{
case EscapingMode.Stack:
bodySb
.AppendFormat("{1} {0};", value.AssignedTo.Name, cppName)
.AppendLine();
break;
default:
bodySb
.AppendFormat("{0} = std::make_shared<{1}>();", value.AssignedTo.Name, cppName)
.AppendLine();;
break;
}
}
private static void HandleNewArray(LocalOperation operation, StringBuilder bodySb,
MidRepresentationVariables vars)
{
var assignment = (Assignment)operation.Value;
var arrayData = (NewArrayObject)assignment.Right;
var assignedData = vars.GetVariableData(assignment.AssignedTo);
switch (assignedData.Escaping)
{
case EscapingMode.Stack:
bodySb.AppendFormat("Array <{1}> {0} ({2}); ",
assignment.AssignedTo.Name,
arrayData.TypeArray.ToCppName(),
arrayData.ArrayLength.Name);
break;
default:
bodySb.AppendFormat("{0} = std::make_shared< Array <{1}> >({2}); ",
assignment.AssignedTo.Name,
arrayData.TypeArray.ToCppName(),
arrayData.ArrayLength.Name);
break;
}
}
private static void HandleReadArrayItem(LocalOperation operation, StringBuilder bodySb, MidRepresentationVariables vars)
{
var value = (Assignment)operation.Value;
var valueSrc = (ArrayVariable)value.Right;
var parentType = valueSrc.Parent.ComputedType();
var variableData = vars.GetVariableData(value.AssignedTo);
switch (variableData.Escaping)
{
case EscapingMode.Smart:
bodySb.AppendFormat(parentType.ClrType.IsClass
? "{0} = (*{1})[{2}];"
: "{0} = {1}[{2}];",
value.AssignedTo.Name, valueSrc.Parent.Name, valueSrc.Index.Name);
return;
case EscapingMode.Pointer:
bodySb.AppendFormat(parentType.ClrType.IsClass
? "{0} = ((*{1})[{2}]).get();"
: "{0} = ({1}[{2}]).get();",
value.AssignedTo.Name, valueSrc.Parent.Name, valueSrc.Index.Name);
return;
}
}
private static void HandleLoadField(LocalOperation operation, StringBuilder bodySb, MidRepresentationVariables vars)
{
var fieldGetterInfo = (FieldGetter)operation.Value;
var assignedFrom = fieldGetterInfo.Instance;
var assignedFromData = vars.GetVariableData(assignedFrom);
var isOnStack = assignedFromData.Escaping == EscapingMode.Stack;
var fieldText = String.Format(isOnStack ? "{0}.{1}" : "{0}->{1}", fieldGetterInfo.Instance.Name,
fieldGetterInfo.FieldName.ValidName());
var assignedTo = fieldGetterInfo.AssignedTo;
var assignedToData = vars.GetVariableData(assignedTo);
switch (assignedToData.Escaping)
{
case EscapingMode.Smart:
bodySb.AppendFormat("{0} = {1};", assignedTo.Name, fieldText);
break;
case EscapingMode.Pointer:
bodySb.AppendFormat("{0} = {1}.get();", assignedTo.Name, fieldText);
break;
}
}
public static void HandleCall(LocalOperation operation, StringBuilder sbCode, MidRepresentationVariables vars)
{
var operationData = (MethodData)operation.Value;
var sb = new StringBuilder();
var methodInfo = operationData.Info.GetReversedMethod();
#region Write method name
var isVoidMethod = methodInfo.GetReturnType().IsVoid();
if (isVoidMethod)
{
sb.AppendFormat("{0}", methodInfo.ClangMethodSignature());
}
else
{
if (operationData.Result == null)
{
sb.AppendFormat("{0}", methodInfo.ClangMethodSignature());
}
else
{
sb.AppendFormat("{1} = {0}", methodInfo.ClangMethodSignature(),
operationData.Result.Name);
}
}
var identifierValues = operationData.Parameters;
var escapingData = CppFullFileMethodWriter.BuildEscapingBools(methodInfo);
if (escapingData == null)
{
var argumentsCall = String.Join(", ", identifierValues.Select(p =>
{
var computeValue = p.ComputedValue();
return(computeValue);
}));
sb.AppendFormat("({0});", argumentsCall);
return;
}
#endregion
sb.Append("(");
#region Parameters
var pos = 0;
var isFirst = true;
var argumentTypes = operationData.Info.GetMethodArgumentTypes();
foreach (var value in identifierValues)
{
if (isFirst)
{
isFirst = false;
}
else
{
sb.Append(", ");
}
var localValue = value as LocalVariable;
var argumentData = argumentTypes[pos];
var isEscaping = escapingData[pos];
pos++;
if (localValue == null)
{
sb.Append(value.ComputedValue());
continue;
}
if (localValue.Kind == VariableKind.Argument)
{
}
if (localValue.ComputedType().ClrType == typeof(IntPtr))
{
var argumentTypeCast = argumentData.ToCppMangling();
sb.AppendFormat("({0}){1}", argumentTypeCast, localValue.Name);
continue;
}
var localValueData = vars.GetVariableData(localValue);
switch (localValueData.Escaping)
{
case EscapingMode.Smart:
if (!isEscaping && localValue.ComputedType().ClrType.IsClass)
{
sb.AppendFormat("{0}.get()", localValue.Name);
}
else
{
sb.AppendFormat("{0}", localValue.Name);
}
continue;
case EscapingMode.Stack:
sb.AppendFormat("&{0}", localValue.Name);
continue;
case EscapingMode.Pointer:
sb.AppendFormat(!isEscaping ? "{0}" : "{0}.get()", localValue.Name);
continue;
}
}
sb.Append(");");
#endregion
sbCode.Append(sb);
}
