public override void Emit(EmitContext context)
{
EmitContext.MethodLinkage methodLinkage = context.GetMethodLinkage(this, false);
if (RoslynSymbol.MethodKind == MethodKind.PropertySet)
{
UdonSharpBehaviourPropertySymbol owningProperty = context.GetSymbol(RoslynSymbol.AssociatedSymbol) as UdonSharpBehaviourPropertySymbol;
if (owningProperty != null &&
owningProperty.CallbackSymbol != null)
{
context.Module.AddFieldChangeExportTag(owningProperty.CallbackSymbol);
Value fieldValue = context.GetUserValue(owningProperty.CallbackSymbol);
Value oldValueVal = context.TopTable.CreateParameterValue($"_old_{fieldValue.UniqueID}", fieldValue.UserType);
Value methodValueParam = context.GetMethodLinkage(this, false).ParameterValues[0];
context.Module.AddCopy(fieldValue, methodValueParam);
context.Module.AddCopy(oldValueVal, fieldValue);
}
}
if (context.MethodNeedsExport(this))
{
ExportedMethodAddress.ResolveAddress(methodLinkage.MethodExportName);
context.Module.AddExportTag(this);
}
Value returnAddressConst = context.GetConstantValue(context.GetTypeSymbol(SpecialType.System_UInt32), 0xFFFFFFFF);
context.Module.AddPush(returnAddressConst);
base.Emit(context);
}
private Value GetParamValue(EmitContext context)
{
MethodSymbol containingMethod = AccessSymbol.ContainingSymbol;
EmitContext.MethodLinkage linkage = context.GetMethodLinkage(containingMethod, false);
int paramIdx = -1;
for (int i = 0; i < containingMethod.Parameters.Length; ++i)
{
if (containingMethod.Parameters[i] == AccessSymbol)
{
paramIdx = i;
break;
}
}
return(linkage.ParameterValues[paramIdx]);
}
public virtual void Emit(EmitContext context)
{
EmitContext.MethodLinkage linkage = context.GetMethodLinkage(this, false);
context.Module.AddCommentTag("");
context.Module.AddCommentTag(RoslynSymbol.ToDisplayString().Replace("\n", "").Replace("\r", ""));
context.Module.AddCommentTag("");
context.Module.LabelJump(linkage.MethodLabel);
using (context.OpenBlockScope())
{
if (MethodBody is BoundExpression bodyExpression)
{
context.EmitReturn(bodyExpression);
}
else
{
context.Emit(MethodBody);
context.EmitReturn();
}
context.FlattenTableCounters();
}
}
public override Value EmitValue(EmitContext context)
{
// Make base calls to UdonSharpBehaviour events a noop
if (IsBaseCall)
{
if (Method.ContainingType == context.GetTypeSymbol(typeof(UdonSharpBehaviour)))
{
if (Method.Name == "OnOwnershipRequest")
{
return(context.GetConstantValue(context.GetTypeSymbol(SpecialType.System_Boolean), true));
}
return(null);
}
}
if (SourceExpression == null || SourceExpression.IsThis)
{
return(base.EmitValue(context));
}
// Calls across UdonBehaviours
CompilationContext.MethodExportLayout layout =
context.CompileContext.GetUsbMethodLayout(Method, context);
Value.CowValue instanceCowValue = GetInstanceValue(context);
Value instanceValue = instanceCowValue.Value;
BoundAccessExpression instanceAccess = BoundAccessExpression.BindAccess(instanceValue);
TypeSymbol stringType = context.GetTypeSymbol(SpecialType.System_String);
Value[] recursiveValues = null;
Value stackSizeCheckVal = null;
bool isRecursiveCall = context.IsRecursiveMethodEmit;
if (isRecursiveCall)
{
stackSizeCheckVal = context.CreateGlobalInternalValue(context.GetTypeSymbol(SpecialType.System_Int32));
}
if (Method.Parameters.Length > 0)
{
MethodSymbol setProgramVariableMethod = context.GetTypeSymbol(typeof(UdonSharpBehaviour))
.GetMembers <MethodSymbol>("SetProgramVariable", context)
.First(e => e.Parameters.Length == 2 &&
e.Parameters[0].Type == stringType);
Value[] parameterValues = GetParameterValues(context);
instanceValue = instanceCowValue.Value;
instanceAccess = BoundAccessExpression.BindAccess(instanceValue); // Re-bind here since the parameters may have changed the cowvalue
if (isRecursiveCall)
{
EmitContext.MethodLinkage selfLinkage = context.GetMethodLinkage(context.CurrentEmitMethod, false);
recursiveValues = selfLinkage.ParameterValues;
CheckStackSize(stackSizeCheckVal, context);
PushRecursiveValues(recursiveValues, context);
for (int i = 0; i < parameterValues.Length; ++i)
{
Value paramIntermediate = context.CreateInternalValue(parameterValues[i].UserType);
context.Module.AddCopy(parameterValues[i], paramIntermediate);
parameterValues[i] = paramIntermediate;
}
}
else
{
instanceCowValue.Dispose();
}
context.TopTable.DirtyAllValues();
for (int i = 0; i < Method.Parameters.Length; ++i)
{
context.Emit(CreateBoundInvocation(context, SyntaxNode, setProgramVariableMethod, instanceAccess,
new BoundExpression[]
{
BoundAccessExpression.BindAccess(context.GetConstantValue(stringType, layout.ParameterExportNames[i])),
BoundAccessExpression.BindAccess(parameterValues[i])
}));
}
}
if (isRecursiveCall)
{
if (recursiveValues == null)
{
recursiveValues = Array.Empty <Value>();
}
Value[] scopeValues = context.CollectRecursiveValues();
PushRecursiveValues(scopeValues, context);
recursiveValues = recursiveValues.Concat(scopeValues).ToArray();
stackSizeCheckVal.DefaultValue = recursiveValues.Length;
context.UpdateRecursiveStackMaxSize(recursiveValues.Length);
}
MethodSymbol sendCustomEventMethod = context.GetTypeSymbol(typeof(UdonSharpBehaviour)).GetMember <MethodSymbol>("SendCustomEvent", context);
context.Emit(CreateBoundInvocation(context, SyntaxNode, sendCustomEventMethod, BoundAccessExpression.BindAccess(instanceValue),
new BoundExpression[]
{
BoundAccessExpression.BindAccess(context.GetConstantValue(stringType, layout.ExportMethodName))
}));
if (isRecursiveCall)
{
PopRecursiveValues(recursiveValues, context);
}
if (Method.Parameters.Length > 0 &&
Method.Parameters.Any(e => e.IsOut))
{
if (isRecursiveCall)
{
throw new CompilerException("U# does not yet support calling user methods with ref/out parameters from methods marked with RecursiveMethod");
}
MethodSymbol getProgramVariableMethod = context.GetTypeSymbol(typeof(UdonSharpBehaviour))
.GetMembers <MethodSymbol>("GetProgramVariable", context)
.First(e => e.Parameters.Length == 1 &&
e.Parameters[0].Type == stringType);
// Copy out/ref parameters back
for (int i = 0; i < Method.Parameters.Length; ++i)
{
ParameterSymbol parameterSymbol = Method.Parameters[i];
if (parameterSymbol.IsOut)
{
BoundAccessExpression currentAccessExpression = (BoundAccessExpression)ParameterExpressions[i];
currentAccessExpression.EmitSet(context, CreateBoundInvocation(context, SyntaxNode,
getProgramVariableMethod, instanceAccess, new[]
{
BoundAccessExpression.BindAccess(context.GetConstantValue(stringType,
layout.ParameterExportNames[i]))
}));
}
}
}
if (IsPropertySetter)
{
return(GetParameterValues(context).Last());
}
if (Method.ReturnType != null)
{
MethodSymbol getProgramVariableMethod = context.GetTypeSymbol(typeof(UdonSharpBehaviour))
.GetMembers <MethodSymbol>("GetProgramVariable", context)
.First(e => e.Parameters.Length == 1 &&
e.Parameters[0].Type == stringType);
Value returnVal = context.CreateInternalValue(Method.ReturnType);
BoundInvocationExpression boundGetReturn = CreateBoundInvocation(context, SyntaxNode,
getProgramVariableMethod, instanceAccess,
new BoundExpression[]
{
BoundAccessExpression.BindAccess(context.GetConstantValue(stringType,
layout.ReturnExportName))
});
context.EmitValueAssignment(returnVal, boundGetReturn);
return(returnVal);
}
return(null);
}
public override Value EmitValue(EmitContext context)
{
JumpLabel returnPoint = context.Module.CreateLabel();
Value returnPointVal =
context.CreateGlobalInternalValue(context.GetTypeSymbol(SpecialType.System_UInt32));
context.Module.AddPush(returnPointVal);
var linkage = context.GetMethodLinkage(Method, !IsBaseCall);
Value[] parameterValues = GetParameterValues(context);
Value[] recursiveValues = null;
bool isRecursiveCall = context.IsRecursiveMethodEmit;
Value stackSizeCheckVal = null;
if (isRecursiveCall)
{
EmitContext.MethodLinkage selfLinkage = context.GetMethodLinkage(context.CurrentEmitMethod, false);
recursiveValues = selfLinkage.ParameterValues;
stackSizeCheckVal = context.CreateGlobalInternalValue(context.GetTypeSymbol(SpecialType.System_Int32));
CheckStackSize(stackSizeCheckVal, context);
PushRecursiveValues(selfLinkage.ParameterValues, context);
}
ReleaseCowReferences(context);
if (isRecursiveCall)
{
Value.CowValue[] paramCows = parameterValues.Select(e => e.GetCowValue(context)).ToArray();
for (int i = 0; i < linkage.ParameterValues.Length; ++i)
{
context.EmitValueAssignment(linkage.ParameterValues[i], BoundAccessExpression.BindAccess(paramCows[i]));
}
foreach (var paramCow in paramCows)
{
paramCow.Dispose();
}
}
else
{
for (int i = 0; i < linkage.ParameterValues.Length; ++i)
{
context.Module.AddCopy(parameterValues[i], linkage.ParameterValues[i]);
}
}
context.TopTable.DirtyAllValues();
if (isRecursiveCall)
{
Value[] collectedValues = context.CollectRecursiveValues().Where(e => !recursiveValues.Contains(e)).ToArray();
PushRecursiveValues(collectedValues, context);
recursiveValues = recursiveValues.Concat(collectedValues).ToArray();
stackSizeCheckVal.DefaultValue = recursiveValues.Length;
context.UpdateRecursiveStackMaxSize(recursiveValues.Length);
}
context.Module.AddCommentTag($"Calling {Method}");
context.Module.AddJump(linkage.MethodLabel);
context.Module.LabelJump(returnPoint);
returnPointVal.DefaultValue = returnPoint.Address;
Value recursiveRet = null;
if (isRecursiveCall)
{
if (linkage.ReturnValue != null)
{
recursiveRet = context.CreateInternalValue(linkage.ReturnValue.UserType);
context.Module.AddCopy(linkage.ReturnValue, recursiveRet);
}
PopRecursiveValues(recursiveValues, context);
}
// Handle out/ref parameters
for (int i = 0; i < Method.Parameters.Length; ++i)
{
if (!Method.Parameters[i].IsOut)
{
continue;
}
if (isRecursiveCall)
{
throw new CompilerException("U# does not yet support calling user methods with ref/out parameters from methods marked with RecursiveMethod");
}
BoundAccessExpression paramAccess = (BoundAccessExpression)ParameterExpressions[i];
paramAccess.EmitSet(context, BoundAccessExpression.BindAccess(linkage.ParameterValues[i]));
}
// Properties need to return the value that they are set to for assignment expressions
if (IsPropertySetter)
{
return(parameterValues.Last());
}
if (Method.ReturnType != null)
{
if (isRecursiveCall)
{
return(recursiveRet);
}
return(linkage.ReturnValue);
}
return(null);
}
