You've already forked UnrealEngineUWP
mirror of
https://github.com/izzy2lost/UnrealEngineUWP.git
synced 2026-03-26 18:15:20 -07:00
1054 lines
37 KiB
C++
1054 lines
37 KiB
C++
// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "BlueprintCompilerCppBackendModulePrivatePCH.h"
|
|
#include "BlueprintCompilerCppBackend.h"
|
|
#include "BlueprintCompilerCppBackendUtils.h"
|
|
|
|
FString FBlueprintCompilerCppBackend::TermToText(const FBPTerminal* Term, const UProperty* CoerceProperty)
|
|
{
|
|
const FString PSC_Self(TEXT("self"));
|
|
if (Term->bIsLiteral)
|
|
{
|
|
//@TODO: Must have a coercion type if it's a literal, because the symbol table isn't plumbed in here and the literals don't carry type information either, yay!
|
|
ensure(CoerceProperty);
|
|
|
|
if (CoerceProperty->IsA(UStrProperty::StaticClass()))
|
|
{
|
|
return FString::Printf(TEXT("TEXT(\"%s\")"), *(Term->Name));
|
|
}
|
|
else if (CoerceProperty->IsA(UTextProperty::StaticClass()))
|
|
{
|
|
return FString::Printf(TEXT("FText::FromString(TEXT(\"%s\"))"), *(Term->Name));
|
|
}
|
|
else if (CoerceProperty->IsA(UFloatProperty::StaticClass()))
|
|
{
|
|
float Value = FCString::Atof(*(Term->Name));
|
|
return FString::Printf(TEXT("%f"), Value);
|
|
}
|
|
else if (CoerceProperty->IsA(UIntProperty::StaticClass()))
|
|
{
|
|
int32 Value = FCString::Atoi(*(Term->Name));
|
|
return FString::Printf(TEXT("%d"), Value);
|
|
}
|
|
else if (auto ByteProperty = Cast<const UByteProperty>(CoerceProperty))
|
|
{
|
|
// The PinSubCategoryObject check is to allow enum literals communicate with byte properties as literals
|
|
if (ByteProperty->Enum != NULL ||
|
|
(NULL != Cast<UEnum>(Term->Type.PinSubCategoryObject.Get())))
|
|
{
|
|
return Term->Name;
|
|
}
|
|
else
|
|
{
|
|
uint8 Value = FCString::Atoi(*(Term->Name));
|
|
return FString::Printf(TEXT("%u"), Value);
|
|
}
|
|
}
|
|
else if (auto BoolProperty = Cast<const UBoolProperty>(CoerceProperty))
|
|
{
|
|
bool bValue = Term->Name.ToBool();
|
|
return bValue ? TEXT("true") : TEXT("false");
|
|
}
|
|
else if (auto NameProperty = Cast<const UNameProperty>(CoerceProperty))
|
|
{
|
|
FName LiteralName(*(Term->Name));
|
|
return FString::Printf(TEXT("FName(TEXT(\"%s\"))"), *(LiteralName.ToString()));
|
|
}
|
|
else if (auto StructProperty = Cast<const UStructProperty>(CoerceProperty))
|
|
{
|
|
if (StructProperty->Struct == VectorStruct)
|
|
{
|
|
FVector Vect = FVector::ZeroVector;
|
|
FDefaultValueHelper::ParseVector(Term->Name, /*out*/ Vect);
|
|
|
|
return FString::Printf(TEXT("FVector(%f,%f,%f)"), Vect.X, Vect.Y, Vect.Z);
|
|
}
|
|
else if (StructProperty->Struct == RotatorStruct)
|
|
{
|
|
FRotator Rot = FRotator::ZeroRotator;
|
|
FDefaultValueHelper::ParseRotator(Term->Name, /*out*/ Rot);
|
|
|
|
return FString::Printf(TEXT("FRotator(%f,%f,%f)"), Rot.Pitch, Rot.Yaw, Rot.Roll);
|
|
}
|
|
else if (StructProperty->Struct == TransformStruct)
|
|
{
|
|
FTransform Trans = FTransform::Identity;
|
|
Trans.InitFromString(Term->Name);
|
|
|
|
const FQuat Rot = Trans.GetRotation();
|
|
const FVector Translation = Trans.GetTranslation();
|
|
const FVector Scale = Trans.GetScale3D();
|
|
|
|
return FString::Printf(TEXT("FTransform( FQuat(%f,%f,%f,%f), FVector(%f,%f,%f), FVector(%f,%f,%f) )"),
|
|
Rot.X, Rot.Y, Rot.Z, Rot.W, Translation.X, Translation.Y, Translation.Z, Scale.X, Scale.Y, Scale.Z);
|
|
}
|
|
else if (StructProperty->Struct == LinearColorStruct)
|
|
{
|
|
FLinearColor LinearColor;
|
|
LinearColor.InitFromString(Term->Name);
|
|
return FString::Printf(TEXT("FLinearColor(%f,%f,%f,%f)"), LinearColor.R, LinearColor.G, LinearColor.B, LinearColor.A);
|
|
}
|
|
else
|
|
{
|
|
//@todo: This needs to be more robust, since import text isn't really proper for struct construction.
|
|
return FString(TEXT("F")) + StructProperty->Struct->GetName() + Term->Name;
|
|
}
|
|
}
|
|
else if (auto ClassProperty = Cast<const UClassProperty>(CoerceProperty))
|
|
{
|
|
if (auto FoundClass = Cast<const UClass>(Term->ObjectLiteral))
|
|
{
|
|
return FString::Printf(TEXT("%s%s::StaticClass()"), FoundClass->GetPrefixCPP(), *FoundClass->GetName());
|
|
}
|
|
return FString(TEXT("NULL"));
|
|
}
|
|
else if (CoerceProperty->IsA(UDelegateProperty::StaticClass()))
|
|
{
|
|
//@TODO: K2 Delegate Support: Won't compile, there isn't an operator= that does what we want here, it should be a proper call to BindDynamic instead!
|
|
if (Term->Name == TEXT(""))
|
|
{
|
|
return TEXT("NULL");
|
|
}
|
|
else
|
|
{
|
|
return FString::Printf(TEXT("BindDynamic(this, &%s::%s)"), *CppClassName, *(Term->Name));
|
|
}
|
|
}
|
|
else if (CoerceProperty->IsA(UObjectPropertyBase::StaticClass()))
|
|
{
|
|
if (Term->Type.PinSubCategory == PSC_Self)
|
|
{
|
|
return TEXT("this");
|
|
}
|
|
else if (Term->ObjectLiteral)
|
|
{
|
|
if (auto LiteralClass = Cast<const UClass>(Term->ObjectLiteral))
|
|
{
|
|
return FString::Printf(TEXT("%s%s::StaticClass()"), LiteralClass->GetPrefixCPP(), *LiteralClass->GetName());
|
|
}
|
|
else
|
|
{
|
|
auto ObjectCoerceProperty = CastChecked<const UObjectPropertyBase>(CoerceProperty);
|
|
UClass* FoundClass = ObjectCoerceProperty ? ObjectCoerceProperty->PropertyClass : NULL;
|
|
FString ClassString = FoundClass ? (FString(FoundClass->GetPrefixCPP()) + FoundClass->GetName()) : TEXT("UObject");
|
|
return FString::Printf(TEXT("FindObject<%s>(ANY_PACKAGE, TEXT(\"%s\"))"), *ClassString, *(Term->ObjectLiteral->GetPathName()));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return FString(TEXT("NULL"));
|
|
}
|
|
}
|
|
else if (CoerceProperty->IsA(UInterfaceProperty::StaticClass()))
|
|
{
|
|
if (Term->Type.PinSubCategory == PSC_Self)
|
|
{
|
|
return TEXT("this");
|
|
}
|
|
else
|
|
{
|
|
ensureMsg(false, TEXT("It is not possible to express this interface property as a literal value!"));
|
|
return Term->Name;
|
|
}
|
|
}
|
|
else
|
|
// else if (CoerceProperty->IsA(UMulticastDelegateProperty::StaticClass()))
|
|
// Cannot assign a literal to a multicast delegate; it should be added instead of assigned
|
|
{
|
|
ensureMsg(false, TEXT("It is not possible to express this type as a literal value!"));
|
|
return Term->Name;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FString Prefix(TEXT(""));
|
|
if ((Term->Context != NULL) && (Term->Context->Name != PSC_Self))
|
|
{
|
|
Prefix = TermToText(Term->Context);
|
|
|
|
if (Term->Context->bIsStructContext)
|
|
{
|
|
Prefix += TEXT(".");
|
|
}
|
|
else
|
|
{
|
|
Prefix += TEXT("->");
|
|
}
|
|
}
|
|
|
|
Prefix += Term->Name;
|
|
return Prefix;
|
|
}
|
|
}
|
|
|
|
FString FBlueprintCompilerCppBackend::LatentFunctionInfoTermToText(FBPTerminal* Term, FBlueprintCompiledStatement* TargetLabel)
|
|
{
|
|
check(LatentInfoStruct);
|
|
|
|
// Find the term name we need to fixup
|
|
FString FixupTermName;
|
|
for (UProperty* Prop = LatentInfoStruct->PropertyLink; Prop; Prop = Prop->PropertyLinkNext)
|
|
{
|
|
static const FName NeedsLatentFixup(TEXT("NeedsLatentFixup"));
|
|
if (Prop->GetBoolMetaData(NeedsLatentFixup))
|
|
{
|
|
FixupTermName = Prop->GetName();
|
|
break;
|
|
}
|
|
}
|
|
|
|
check(!FixupTermName.IsEmpty());
|
|
|
|
FString StructValues = Term->Name;
|
|
|
|
// Index 0 is always the ubergraph
|
|
const int32 TargetStateIndex = StateMapPerFunction[0].StatementToStateIndex(TargetLabel);
|
|
const int32 LinkageTermStartIdx = StructValues.Find(FixupTermName);
|
|
check(LinkageTermStartIdx != INDEX_NONE);
|
|
StructValues = StructValues.Replace(TEXT("-1"), *FString::FromInt(TargetStateIndex));
|
|
|
|
return FString(TEXT("F")) + LatentInfoStruct->GetName() + StructValues;
|
|
}
|
|
|
|
void FBlueprintCompilerCppBackend::EmitClassProperties(FStringOutputDevice& Target, UClass* SourceClass)
|
|
{
|
|
// Emit class variables
|
|
for (TFieldIterator<UProperty> It(SourceClass, EFieldIteratorFlags::ExcludeSuper); It; ++It)
|
|
{
|
|
UProperty* Property = *It;
|
|
check(Property);
|
|
|
|
Emit(Header, TEXT("\n\tUPROPERTY("));
|
|
{
|
|
TArray<FString> Tags = FEmitHelper::ProperyFlagsToTags(Property->PropertyFlags);
|
|
Tags.Emplace(FEmitHelper::HandleRepNotifyFunc(Property));
|
|
Tags.Emplace(FEmitHelper::HandleMetaData(Property, false));
|
|
Tags.Remove(FString());
|
|
|
|
FString AllTags;
|
|
FEmitHelper::ArrayToString(Tags, AllTags, TEXT(", "));
|
|
Emit(Header, *AllTags);
|
|
}
|
|
Emit(Header, TEXT(")\n"));
|
|
Emit(Header, TEXT("\t"));
|
|
Property->ExportCppDeclaration(Target, EExportedDeclaration::Member, NULL, EPropertyExportCPPFlags::CPPF_CustomTypeName);
|
|
Emit(Header, TEXT(";\n"));
|
|
}
|
|
}
|
|
|
|
void FBlueprintCompilerCppBackend::GenerateCodeFromClass(UClass* SourceClass, FString NewClassName, TIndirectArray<FKismetFunctionContext>& Functions, bool bGenerateStubsOnly)
|
|
{
|
|
auto CleanCppClassName = NewClassName.IsEmpty() ? SourceClass->GetName() : NewClassName;
|
|
CppClassName = FString(SourceClass->GetPrefixCPP()) + CleanCppClassName;
|
|
|
|
UClass* SuperClass = SourceClass->GetSuperClass();
|
|
|
|
Emit(Header, TEXT("#pragma once\n\n"));
|
|
Emit(Header, *FString::Printf(TEXT("#include \"%s.generated.h\"\n\n"), *CleanCppClassName));
|
|
|
|
// MC DELEGATE DECLARATION
|
|
{
|
|
auto DelegateDeclarations = FEmitHelper::EmitMulticastDelegateDeclarations(SourceClass);
|
|
FString AllDeclarations;
|
|
FEmitHelper::ArrayToString(DelegateDeclarations, AllDeclarations, TEXT(";\n"));
|
|
if (DelegateDeclarations.Num())
|
|
{
|
|
Emit(Header, *AllDeclarations);
|
|
Emit(Header, TEXT(";\n"));
|
|
}
|
|
}
|
|
|
|
// GATHER ALL SC DELEGATES
|
|
{
|
|
TArray<UDelegateProperty*> Delegates;
|
|
for (TFieldIterator<UDelegateProperty> It(SourceClass, EFieldIteratorFlags::ExcludeSuper); It; ++It)
|
|
{
|
|
Delegates.Add(*It);
|
|
}
|
|
|
|
for (auto& FuncContext : Functions)
|
|
{
|
|
for (TFieldIterator<UDelegateProperty> It(FuncContext.Function, EFieldIteratorFlags::ExcludeSuper); It; ++It)
|
|
{
|
|
Delegates.Add(*It);
|
|
}
|
|
}
|
|
|
|
auto DelegateDeclarations = FEmitHelper::EmitSinglecastDelegateDeclarations(Delegates);
|
|
FString AllDeclarations;
|
|
FEmitHelper::ArrayToString(DelegateDeclarations, AllDeclarations, TEXT(";\n"));
|
|
if (DelegateDeclarations.Num())
|
|
{
|
|
Emit(Header, *AllDeclarations);
|
|
Emit(Header, TEXT(";\n"));
|
|
}
|
|
}
|
|
|
|
Emit(Header, TEXT("UCLASS(Blueprintable)\n"));
|
|
|
|
Emit(Header,
|
|
*FString::Printf(TEXT("class %s : public %s%s\n"), *CppClassName, SuperClass->GetPrefixCPP(), *SuperClass->GetName()));
|
|
Emit(Header,
|
|
TEXT("{\n")
|
|
TEXT("public:\n"));
|
|
Emit(Header, *FString::Printf(TEXT("\tGENERATED_UCLASS_BODY()\n")));
|
|
|
|
EmitClassProperties(Header, SourceClass);
|
|
|
|
// Create the state map
|
|
for (int32 i = 0; i < Functions.Num(); ++i)
|
|
{
|
|
StateMapPerFunction.Add(FFunctionLabelInfo());
|
|
FunctionIndexMap.Add(&Functions[i], i);
|
|
}
|
|
|
|
// Emit function declarations and definitions (writes to header and body simultaneously)
|
|
if (Functions.Num() > 0)
|
|
{
|
|
Emit(Header, TEXT("\n"));
|
|
}
|
|
|
|
TArray<FString> PersistentHeaders;
|
|
PersistentHeaders.Add(FString(FApp::GetGameName()) + TEXT(".h"));
|
|
PersistentHeaders.Add(CleanCppClassName + TEXT(".h"));
|
|
PersistentHeaders.Add(TEXT("GeneratedCodeHelpers.h"));
|
|
Emit(Body, *FEmitHelper::GatherHeadersToInclude(SourceClass, PersistentHeaders));
|
|
|
|
//constructor
|
|
Emit(Body, *FString::Printf(
|
|
TEXT("%s::%s(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer) {}\n\n"),
|
|
*CppClassName, *CppClassName));
|
|
|
|
for (int32 i = 0; i < Functions.Num(); ++i)
|
|
{
|
|
if (Functions[i].IsValid())
|
|
{
|
|
ConstructFunction(Functions[i], bGenerateStubsOnly);
|
|
}
|
|
}
|
|
|
|
Emit(Header, TEXT("};\n\n"));
|
|
|
|
Emit(Body, *FEmitHelper::EmitLifetimeReplicatedPropsImpl(SourceClass, CppClassName, TEXT("")));
|
|
}
|
|
|
|
void FBlueprintCompilerCppBackend::EmitCallDelegateStatment(FKismetFunctionContext& FunctionContext, FBlueprintCompiledStatement& Statement)
|
|
{
|
|
check(Statement.FunctionContext && Statement.FunctionContext->AssociatedVarProperty);
|
|
FSafeContextScopedEmmitter SafeContextScope(Body, Statement.FunctionContext->Context, *this, TEXT("\t\t\t"));
|
|
|
|
Emit(Body, TEXT("\t\t\t"));
|
|
Emit(Body, *SafeContextScope.GetAdditionalIndent());
|
|
Emit(Body, *FString::Printf(TEXT("%s.Broadcast("), *TermToText(Statement.FunctionContext)));
|
|
int32 NumParams = 0;
|
|
for (TFieldIterator<UProperty> PropIt(Statement.FunctionToCall); PropIt && (PropIt->PropertyFlags & CPF_Parm); ++PropIt)
|
|
{
|
|
UProperty* FuncParamProperty = *PropIt;
|
|
|
|
if (!FuncParamProperty->HasAnyPropertyFlags(CPF_ReturnParm))
|
|
{
|
|
if (NumParams > 0)
|
|
{
|
|
Emit(Body, TEXT(", "));
|
|
}
|
|
|
|
FString VarName;
|
|
|
|
FBPTerminal* Term = Statement.RHS[NumParams];
|
|
ensure(Term != NULL);
|
|
|
|
// See if this is a hidden array param term, which needs to be fixed up with the final generated UArrayProperty
|
|
if (FBPTerminal** ArrayParmTerm = Statement.ArrayCoersionTermMap.Find(Term))
|
|
{
|
|
Term->ObjectLiteral = (*ArrayParmTerm)->AssociatedVarProperty;
|
|
}
|
|
|
|
if ((Statement.TargetLabel != NULL) && (Statement.UbergraphCallIndex == NumParams))
|
|
{
|
|
// The target label will only ever be set on a call function when calling into the Ubergraph or
|
|
// on a latent function that will later call into the ubergraph, either of which requires a patchup
|
|
UStructProperty* StructProp = Cast<UStructProperty>(FuncParamProperty);
|
|
if (StructProp && StructProp->Struct == LatentInfoStruct)
|
|
{
|
|
// Latent function info case
|
|
VarName = LatentFunctionInfoTermToText(Term, Statement.TargetLabel);
|
|
}
|
|
else
|
|
{
|
|
// Ubergraph entry point case
|
|
VarName = FString::FromInt(StateMapPerFunction[0].StatementToStateIndex(Statement.TargetLabel));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Emit a normal parameter term
|
|
VarName = TermToText(Term, FuncParamProperty);
|
|
}
|
|
|
|
if (FuncParamProperty->HasAnyPropertyFlags(CPF_OutParm))
|
|
{
|
|
Emit(Body, TEXT("/*out*/ "));
|
|
}
|
|
Emit(Body, *VarName);
|
|
|
|
NumParams++;
|
|
}
|
|
}
|
|
Emit(Body, TEXT(");\n"));
|
|
}
|
|
|
|
void FBlueprintCompilerCppBackend::EmitCallStatment(FKismetFunctionContext& FunctionContext, FBlueprintCompiledStatement& Statement)
|
|
{
|
|
const bool bCallOnDifferentObject = (Statement.FunctionContext != NULL) && (Statement.FunctionContext->Name != TEXT("self"));
|
|
const bool bStaticCall = Statement.FunctionToCall->HasAnyFunctionFlags(FUNC_Static);
|
|
|
|
const bool bUseSafeContext = bCallOnDifferentObject && !bStaticCall;
|
|
FSafeContextScopedEmmitter SafeContextScope(Body, bUseSafeContext ? Statement.FunctionContext : NULL, *this, TEXT("\t\t\t"));
|
|
|
|
Emit(Body, TEXT("\t\t\t"));
|
|
Emit(Body, *SafeContextScope.GetAdditionalIndent());
|
|
|
|
// Handle the return value of the function being called
|
|
UProperty* FuncToCallReturnProperty = Statement.FunctionToCall->GetReturnProperty();
|
|
if (FuncToCallReturnProperty != NULL)
|
|
{
|
|
FBPTerminal* Term = Statement.LHS;
|
|
ensure(Term != NULL);
|
|
|
|
FString ReturnVarName = TermToText(Term);
|
|
Emit(Body, *FString::Printf(TEXT("%s = "), *ReturnVarName));
|
|
}
|
|
|
|
// Emit object to call the method on
|
|
if (bCallOnDifferentObject) //@TODO: Badness, could be a self reference wired to another instance!
|
|
{
|
|
if (bStaticCall)
|
|
{
|
|
const bool bIsCustomThunk = Statement.FunctionToCall->HasMetaData(TEXT("CustomStructureParam")) || Statement.FunctionToCall->HasMetaData(TEXT("ArrayParm"));
|
|
FString FullFunctionNamePrefix = bIsCustomThunk
|
|
? TEXT("FCustomThunkTemplates::")
|
|
: FString::Printf(TEXT("U%s::"), *Statement.FunctionToCall->GetOuter()->GetName());
|
|
Emit(Body, *FullFunctionNamePrefix); //@TODO: Assuming U prefix but could be A
|
|
}
|
|
else
|
|
{
|
|
Emit(Body, *FString::Printf(TEXT("%s->"), *TermToText(Statement.FunctionContext, (UProperty*)(GetDefault<UObjectProperty>()))));
|
|
}
|
|
}
|
|
|
|
// Emit method name
|
|
FString FunctionNameToCall;
|
|
Statement.FunctionToCall->GetName(FunctionNameToCall);
|
|
if (Statement.bIsParentContext)
|
|
{
|
|
FunctionNameToCall = TEXT("Super::") + FunctionNameToCall;
|
|
}
|
|
Emit(Body, *FString::Printf(TEXT("%s"), *FunctionNameToCall));
|
|
|
|
// Emit method parameter list
|
|
Emit(Body, TEXT("("));
|
|
{
|
|
int32 NumParams = 0;
|
|
|
|
for (TFieldIterator<UProperty> PropIt(Statement.FunctionToCall); PropIt && (PropIt->PropertyFlags & CPF_Parm); ++PropIt)
|
|
{
|
|
UProperty* FuncParamProperty = *PropIt;
|
|
|
|
if (!FuncParamProperty->HasAnyPropertyFlags(CPF_ReturnParm))
|
|
{
|
|
if (NumParams > 0)
|
|
{
|
|
Emit(Body, TEXT(", "));
|
|
}
|
|
|
|
FString VarName;
|
|
|
|
FBPTerminal* Term = Statement.RHS[NumParams];
|
|
ensure(Term != NULL);
|
|
|
|
// See if this is a hidden array param term, which needs to be fixed up with the final generated UArrayProperty
|
|
if (FBPTerminal** ArrayParmTerm = Statement.ArrayCoersionTermMap.Find(Term))
|
|
{
|
|
Term->ObjectLiteral = (*ArrayParmTerm)->AssociatedVarProperty;
|
|
}
|
|
|
|
if ((Statement.TargetLabel != NULL) && (Statement.UbergraphCallIndex == NumParams))
|
|
{
|
|
// The target label will only ever be set on a call function when calling into the Ubergraph or
|
|
// on a latent function that will later call into the ubergraph, either of which requires a patchup
|
|
UStructProperty* StructProp = Cast<UStructProperty>(FuncParamProperty);
|
|
if (StructProp && StructProp->Struct == LatentInfoStruct)
|
|
{
|
|
// Latent function info case
|
|
VarName = LatentFunctionInfoTermToText(Term, Statement.TargetLabel);
|
|
}
|
|
else
|
|
{
|
|
// Ubergraph entry point case
|
|
VarName = FString::FromInt(StateMapPerFunction[0].StatementToStateIndex(Statement.TargetLabel));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Emit a normal parameter term
|
|
VarName = TermToText(Term, FuncParamProperty);
|
|
}
|
|
|
|
if (FuncParamProperty->HasAnyPropertyFlags(CPF_OutParm))
|
|
{
|
|
Emit(Body, TEXT("/*out*/ "));
|
|
}
|
|
Emit(Body, *VarName);
|
|
|
|
NumParams++;
|
|
}
|
|
}
|
|
}
|
|
Emit(Body, TEXT(");\n"));
|
|
}
|
|
|
|
void FBlueprintCompilerCppBackend::EmitAssignmentStatment(FKismetFunctionContext& FunctionContext, FBlueprintCompiledStatement& Statement)
|
|
{
|
|
FString DestinationExpression = TermToText(Statement.LHS);
|
|
FString SourceExpression = TermToText(Statement.RHS[0], Statement.LHS->AssociatedVarProperty);
|
|
|
|
FSafeContextScopedEmmitter SafeContextScope(Body, Statement.LHS->Context, *this, TEXT("\t\t\t"));
|
|
// Emit the assignment statement
|
|
Emit(Body, TEXT("\t\t\t"));
|
|
Emit(Body, *SafeContextScope.GetAdditionalIndent());
|
|
Emit(Body, *FString::Printf(TEXT("%s = %s;\n"), *DestinationExpression, *SourceExpression));
|
|
}
|
|
|
|
void FBlueprintCompilerCppBackend::EmitCastObjToInterfaceStatement(FKismetFunctionContext& FunctionContext, FBlueprintCompiledStatement& Statement)
|
|
{
|
|
FString InterfaceClass = TermToText(Statement.RHS[0], (UProperty*)(GetDefault<UClassProperty>()));
|
|
FString ObjectValue = TermToText(Statement.RHS[1], (UProperty*)(GetDefault<UObjectProperty>()));
|
|
FString InterfaceValue = TermToText(Statement.LHS, (UProperty*)(GetDefault<UObjectProperty>()));
|
|
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\tif ( IsValid(%s) && %s->GetClass()->ImplementsInterface(%s) )\n"), *ObjectValue, *ObjectValue, *InterfaceClass));
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\t{\n")));
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\t\t%s.SetObject(%s);\n"), *InterfaceValue, *ObjectValue));
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\t\tvoid* IAddress = %s->GetInterfaceAddress(%s);\n"), *ObjectValue, *InterfaceClass));
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\t\t%s.SetInterface(IAddress);\n"), *InterfaceValue));
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\t}\n")));
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\telse\n")));
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\t{\n")));
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\t\t%s.SetObject(NULL);\n"), *InterfaceValue));
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\t}\n")));
|
|
}
|
|
|
|
void FBlueprintCompilerCppBackend::EmitCastBetweenInterfacesStatement(FKismetFunctionContext& FunctionContext, FBlueprintCompiledStatement& Statement)
|
|
{
|
|
FString ClassToCastTo = TermToText(Statement.RHS[0], (UProperty*)(GetDefault<UClassProperty>()));
|
|
FString InputInterface = TermToText(Statement.RHS[1], (UProperty*)(GetDefault<UInterfaceProperty>()));
|
|
FString ResultInterface = TermToText(Statement.LHS, (UProperty*)(GetDefault<UInterfaceProperty>()));
|
|
|
|
FString InputObject = FString::Printf(TEXT("%s.GetObjectRef()"), *InputInterface);
|
|
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\tif ( %s && %s->GetClass()->IsChildOf(%s) )\n"), *InputObject, *InputObject, *ClassToCastTo));
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\t{\n")));
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\t\t%s.SetObject(%s);\n"), *ResultInterface, *InputObject));
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\t\tvoid* IAddress = %s->GetInterfaceAddress(%s);\n"), *InputObject, *ClassToCastTo));
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\t\t%s.SetInterface(IAddress);\n"), *ResultInterface));
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\t}\n")));
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\telse\n")));
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\t{\n")));
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\t\t%s.SetObject(NULL);\n"), *ResultInterface));
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\t}\n")));
|
|
}
|
|
|
|
void FBlueprintCompilerCppBackend::EmitCastInterfaceToObjStatement(FKismetFunctionContext& FunctionContext, FBlueprintCompiledStatement& Statement)
|
|
{
|
|
FString ClassToCastTo = TermToText(Statement.RHS[0], (UProperty*)(GetDefault<UClassProperty>()));
|
|
FString InputInterface = TermToText(Statement.RHS[1], (UProperty*)(GetDefault<UInterfaceProperty>()));
|
|
FString ResultObject = TermToText(Statement.LHS, (UProperty*)(GetDefault<UInterfaceProperty>()));
|
|
|
|
FString InputObject = FString::Printf(TEXT("%s.GetObjectRef()"), *InputInterface);
|
|
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\t%s = Cast<%s>(%s);\n"),
|
|
*ResultObject, *ClassToCastTo, *InputObject));
|
|
}
|
|
|
|
void FBlueprintCompilerCppBackend::EmitDynamicCastStatement(FKismetFunctionContext& FunctionContext, FBlueprintCompiledStatement& Statement)
|
|
{
|
|
FString TargetClass = TermToText(Statement.RHS[0], (UProperty*)(GetDefault<UClassProperty>()));
|
|
FString ObjectValue = TermToText(Statement.RHS[1], (UProperty*)(GetDefault<UObjectProperty>()));
|
|
FString CastedValue = TermToText(Statement.LHS, (UProperty*)(GetDefault<UObjectProperty>()));
|
|
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\t%s = Cast<%s>(%s);\n"),
|
|
*CastedValue, *TargetClass, *ObjectValue));
|
|
}
|
|
|
|
void FBlueprintCompilerCppBackend::EmitMetaCastStatement(FKismetFunctionContext& FunctionContext, FBlueprintCompiledStatement& Statement)
|
|
{
|
|
FString DesiredClass = TermToText(Statement.RHS[0], (UProperty*)(GetDefault<UClassProperty>()));
|
|
FString SourceClass = TermToText(Statement.RHS[1], (UProperty*)(GetDefault<UClassProperty>()));
|
|
FString Destination = TermToText(Statement.LHS, (UProperty*)(GetDefault<UClassProperty>()));
|
|
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\t%s = DynamicMetaCast(%s, %s);\n"),
|
|
*Destination, *DesiredClass, *SourceClass));
|
|
}
|
|
|
|
void FBlueprintCompilerCppBackend::EmitObjectToBoolStatement(FKismetFunctionContext& FunctionContext, FBlueprintCompiledStatement& Statement)
|
|
{
|
|
FString ObjectTarget = TermToText(Statement.RHS[0]);
|
|
FString DestinationExpression = TermToText(Statement.LHS);
|
|
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\t%s = (%s != NULL);\n"), *DestinationExpression, *ObjectTarget));
|
|
}
|
|
|
|
void FBlueprintCompilerCppBackend::EmitAddMulticastDelegateStatement(FKismetFunctionContext& FunctionContext, FBlueprintCompiledStatement& Statement)
|
|
{
|
|
check(Statement.LHS && Statement.LHS->AssociatedVarProperty);
|
|
FSafeContextScopedEmmitter SafeContextScope(Body, Statement.LHS->Context, *this, TEXT("\t\t\t"));
|
|
|
|
Emit(Body, TEXT("\t\t\t"));
|
|
Emit(Body, *SafeContextScope.GetAdditionalIndent());
|
|
|
|
const FString Delegate = TermToText(Statement.LHS);
|
|
const FString DelegateToAdd = TermToText(Statement.RHS[0]);
|
|
|
|
Emit(Body, *FString::Printf(TEXT("%s.Add(%s);\n"), *Delegate, *DelegateToAdd));
|
|
}
|
|
|
|
void FBlueprintCompilerCppBackend::EmitRemoveMulticastDelegateStatement(FKismetFunctionContext& FunctionContext, FBlueprintCompiledStatement& Statement)
|
|
{
|
|
check(Statement.LHS && Statement.LHS->AssociatedVarProperty);
|
|
FSafeContextScopedEmmitter SafeContextScope(Body, Statement.LHS->Context, *this, TEXT("\t\t\t"));
|
|
|
|
Emit(Body, TEXT("\t\t\t"));
|
|
Emit(Body, *SafeContextScope.GetAdditionalIndent());
|
|
|
|
const FString Delegate = TermToText(Statement.LHS);
|
|
const FString DelegateToAdd = TermToText(Statement.RHS[0]);
|
|
|
|
Emit(Body, *FString::Printf(TEXT("%s.Remove(%s);\n"), *Delegate, *DelegateToAdd));
|
|
}
|
|
|
|
void FBlueprintCompilerCppBackend::EmitBindDelegateStatement(FKismetFunctionContext& FunctionContext, FBlueprintCompiledStatement& Statement)
|
|
{
|
|
check(2 == Statement.RHS.Num());
|
|
check(Statement.LHS);
|
|
FSafeContextScopedEmmitter SafeContextScope(Body, Statement.LHS->Context, *this, TEXT("\t\t\t"));
|
|
|
|
Emit(Body, TEXT("\t\t\t"));
|
|
Emit(Body, *SafeContextScope.GetAdditionalIndent());
|
|
|
|
|
|
const FString Delegate = TermToText(Statement.LHS);
|
|
const FString NameTerm = TermToText(Statement.RHS[0], GetDefault<UNameProperty>());
|
|
const FString ObjectTerm = TermToText(Statement.RHS[1], GetDefault<UObjectProperty>());
|
|
|
|
Emit(Body, *FString::Printf(TEXT("%s.BindUFunction(%s,%s);\n"), *Delegate, *ObjectTerm, *NameTerm));
|
|
}
|
|
|
|
void FBlueprintCompilerCppBackend::EmitClearMulticastDelegateStatement(FKismetFunctionContext& FunctionContext, FBlueprintCompiledStatement& Statement)
|
|
{
|
|
check(Statement.LHS);
|
|
FSafeContextScopedEmmitter SafeContextScope(Body, Statement.LHS->Context, *this, TEXT("\t\t\t"));
|
|
|
|
Emit(Body, TEXT("\t\t\t"));
|
|
Emit(Body, *SafeContextScope.GetAdditionalIndent());
|
|
|
|
const FString Delegate = TermToText(Statement.LHS);
|
|
|
|
Emit(Body, *FString::Printf(TEXT("%s.Clear();\n"), *Delegate));
|
|
}
|
|
|
|
void FBlueprintCompilerCppBackend::EmitCreateArrayStatement(FKismetFunctionContext& FunctionContext, FBlueprintCompiledStatement& Statement)
|
|
{
|
|
FBPTerminal* ArrayTerm = Statement.LHS;
|
|
const FString Array = TermToText(ArrayTerm);
|
|
|
|
UArrayProperty* ArrayProperty = CastChecked<UArrayProperty>(ArrayTerm->AssociatedVarProperty);
|
|
UProperty* InnerProperty = ArrayProperty->Inner;
|
|
|
|
for (int32 i = 0; i < Statement.RHS.Num(); ++i)
|
|
{
|
|
FBPTerminal* CurrentTerminal = Statement.RHS[i];
|
|
Emit(Body,
|
|
*FString::Printf(
|
|
TEXT("\t\t\t%s[%d] = %s;"),
|
|
*Array,
|
|
i,
|
|
*TermToText(CurrentTerminal, (CurrentTerminal->bIsLiteral ? InnerProperty : NULL))));
|
|
}
|
|
}
|
|
|
|
void FBlueprintCompilerCppBackend::EmitGotoStatement(FKismetFunctionContext& FunctionContext, FBlueprintCompiledStatement& Statement)
|
|
{
|
|
if (Statement.Type == KCST_ComputedGoto)
|
|
{
|
|
FString NextStateExpression;
|
|
NextStateExpression = TermToText(Statement.LHS, (UProperty*)(GetDefault<UIntProperty>()));
|
|
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\tCurrentState = %s;\n"), *NextStateExpression));
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\tbreak;\n")));
|
|
}
|
|
else if ((Statement.Type == KCST_GotoIfNot) || (Statement.Type == KCST_EndOfThreadIfNot) || (Statement.Type == KCST_GotoReturnIfNot))
|
|
{
|
|
FString ConditionExpression;
|
|
ConditionExpression = TermToText(Statement.LHS, (UProperty*)(GetDefault<UBoolProperty>()));
|
|
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\tif (!%s)\n"), *ConditionExpression));
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\t{\n")));
|
|
|
|
if (Statement.Type == KCST_EndOfThreadIfNot)
|
|
{
|
|
ensure(FunctionContext.bUseFlowStack);
|
|
Emit(Body, TEXT("\t\t\t\tCurrentState = (StateStack.Num() > 0) ? StateStack.Pop(/*bAllowShrinking=*/ false) : -1;\n"));
|
|
}
|
|
else if (Statement.Type == KCST_GotoReturnIfNot)
|
|
{
|
|
Emit(Body, TEXT("\t\t\t\tCurrentState = -1;\n"));
|
|
}
|
|
else
|
|
{
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\t\tCurrentState = %d;\n"), StatementToStateIndex(FunctionContext, Statement.TargetLabel)));
|
|
}
|
|
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\t\tbreak;\n")));
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\t}\n")));
|
|
}
|
|
else if (Statement.Type == KCST_GotoReturn)
|
|
{
|
|
Emit(Body, TEXT("\t\t\tCurrentState = -1;\n"));
|
|
}
|
|
else
|
|
{
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\tCurrentState = %d;\n"), StatementToStateIndex(FunctionContext, Statement.TargetLabel)));
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\tbreak;\n")));
|
|
}
|
|
}
|
|
|
|
void FBlueprintCompilerCppBackend::EmitPushStateStatement(FKismetFunctionContext& FunctionContext, FBlueprintCompiledStatement& Statement)
|
|
{
|
|
ensure(FunctionContext.bUseFlowStack);
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\tStateStack.Push(%d);\n"), StatementToStateIndex(FunctionContext, Statement.TargetLabel)));
|
|
}
|
|
|
|
void FBlueprintCompilerCppBackend::EmitEndOfThreadStatement(FKismetFunctionContext& FunctionContext, const FString& ReturnValueString)
|
|
{
|
|
ensure(FunctionContext.bUseFlowStack);
|
|
Emit(Body, TEXT("\t\t\tCurrentState = (StateStack.Num() > 0) ? StateStack.Pop(/*bAllowShrinking=*/ false) : -1;\n"));
|
|
Emit(Body, TEXT("\t\t\tbreak;\n"));
|
|
}
|
|
|
|
void FBlueprintCompilerCppBackend::EmitReturnStatement(FKismetFunctionContext& FunctionContext, const FString& ReturnValueString)
|
|
{
|
|
Emit(Body, *FString::Printf(TEXT("\treturn%s;\n"), *ReturnValueString));
|
|
}
|
|
|
|
void FBlueprintCompilerCppBackend::DeclareLocalVariables(FKismetFunctionContext& FunctionContext, TArray<UProperty*>& LocalVariables)
|
|
{
|
|
for (int32 i = 0; i < LocalVariables.Num(); ++i)
|
|
{
|
|
UProperty* LocalVariable = LocalVariables[i];
|
|
|
|
Emit(Body, TEXT("\t"));
|
|
LocalVariable->ExportCppDeclaration(Body, EExportedDeclaration::Local, NULL, EPropertyExportCPPFlags::CPPF_CustomTypeName);
|
|
Emit(Body, TEXT("{};\n"));
|
|
}
|
|
|
|
if (LocalVariables.Num() > 0)
|
|
{
|
|
Emit(Body, TEXT("\n"));
|
|
}
|
|
}
|
|
|
|
void FBlueprintCompilerCppBackend::DeclareStateSwitch(FKismetFunctionContext& FunctionContext)
|
|
{
|
|
if (FunctionContext.bUseFlowStack)
|
|
{
|
|
Emit(Body, TEXT("\tTArray< int32, TInlineAllocator<8> > StateStack;\n"));
|
|
}
|
|
Emit(Body, TEXT("\tint32 CurrentState = 0;\n"));
|
|
Emit(Body, TEXT("\tdo\n"));
|
|
Emit(Body, TEXT("\t{\n"));
|
|
Emit(Body, TEXT("\t\tswitch( CurrentState )\n"));
|
|
Emit(Body, TEXT("\t\t{\n"));
|
|
Emit(Body, TEXT("\t\tcase 0:\n"));
|
|
}
|
|
|
|
void FBlueprintCompilerCppBackend::CloseStateSwitch(FKismetFunctionContext& FunctionContext)
|
|
{
|
|
// Default error-catching case
|
|
Emit(Body, TEXT("\t\tdefault:\n"));
|
|
if (FunctionContext.bUseFlowStack)
|
|
{
|
|
Emit(Body, TEXT("\t\t\tcheck(false); // Invalid state\n"));
|
|
}
|
|
Emit(Body, TEXT("\t\t\tbreak;\n"));
|
|
|
|
// Close the switch block and do-while loop
|
|
Emit(Body, TEXT("\t\t}\n"));
|
|
Emit(Body, TEXT("\t} while( CurrentState != -1 );\n"));
|
|
}
|
|
|
|
void FBlueprintCompilerCppBackend::ConstructFunction(FKismetFunctionContext& FunctionContext, bool bGenerateStubOnly)
|
|
{
|
|
if (FunctionContext.IsDelegateSignature())
|
|
{
|
|
return;
|
|
}
|
|
|
|
UFunction* Function = FunctionContext.Function;
|
|
|
|
UProperty* ReturnValue = NULL;
|
|
TArray<UProperty*> LocalVariables;
|
|
|
|
{
|
|
FString FunctionName;
|
|
Function->GetName(FunctionName);
|
|
|
|
TArray<UProperty*> ArgumentList;
|
|
|
|
// Split the function property list into arguments, a return value (if any), and local variable declarations
|
|
for (TFieldIterator<UProperty> It(Function); It; ++It)
|
|
{
|
|
UProperty* Property = *It;
|
|
if (Property->HasAnyPropertyFlags(CPF_Parm))
|
|
{
|
|
if (Property->HasAnyPropertyFlags(CPF_ReturnParm))
|
|
{
|
|
if (ReturnValue == NULL)
|
|
{
|
|
ReturnValue = Property;
|
|
LocalVariables.Add(Property);
|
|
}
|
|
else
|
|
{
|
|
MessageLog.Error(*FString::Printf(TEXT("Function %s from graph @@ has more than one return value (named %s and %s)"),
|
|
*FunctionName, *ReturnValue->GetName(), *Property->GetName()), FunctionContext.SourceGraph);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ArgumentList.Add(Property);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LocalVariables.Add(Property);
|
|
}
|
|
}
|
|
|
|
// Emit the declaration
|
|
const FString ReturnType = ReturnValue ? ReturnValue->GetCPPType(NULL, EPropertyExportCPPFlags::CPPF_CustomTypeName) : TEXT("void");
|
|
|
|
//@TODO: Make the header+body export more uniform
|
|
{
|
|
const FString Start = FString::Printf(TEXT("%s %s%s%s("), *ReturnType, TEXT("%s"), TEXT("%s"), *FunctionName);
|
|
|
|
Emit(Header, *FString::Printf(TEXT("\t%s\n"), *FEmitHelper::EmitUFuntion(Function)));
|
|
Emit(Header, TEXT("\t"));
|
|
if (Function->HasAllFunctionFlags(FUNC_Static))
|
|
{
|
|
Emit(Header, TEXT("static "));
|
|
}
|
|
Emit(Header, *FString::Printf(*Start, TEXT(""), TEXT("")));
|
|
Emit(Body, *FString::Printf(*Start, *CppClassName, TEXT("::")));
|
|
|
|
for (int32 i = 0; i < ArgumentList.Num(); ++i)
|
|
{
|
|
UProperty* ArgProperty = ArgumentList[i];
|
|
|
|
if (i > 0)
|
|
{
|
|
Emit(Header, TEXT(", "));
|
|
Emit(Body, TEXT(", "));
|
|
}
|
|
|
|
if (ArgProperty->HasAnyPropertyFlags(CPF_OutParm))
|
|
{
|
|
Emit(Header, TEXT("/*out*/ "));
|
|
Emit(Body, TEXT("/*out*/ "));
|
|
}
|
|
|
|
ArgProperty->ExportCppDeclaration(Header, EExportedDeclaration::Parameter, NULL, EPropertyExportCPPFlags::CPPF_CustomTypeName);
|
|
ArgProperty->ExportCppDeclaration(Body, EExportedDeclaration::Parameter, NULL, EPropertyExportCPPFlags::CPPF_CustomTypeName);
|
|
}
|
|
|
|
Emit(Header, TEXT(")"));
|
|
Emit(Header, TEXT(";\n"));
|
|
Emit(Body, TEXT(")\n"));
|
|
}
|
|
|
|
// Start the body of the implementation
|
|
Emit(Body, TEXT("{\n"));
|
|
}
|
|
|
|
const FString ReturnValueString = ReturnValue ? (FString(TEXT(" ")) + ReturnValue->GetName()) : TEXT("");
|
|
|
|
if (!bGenerateStubOnly)
|
|
{
|
|
// Emit local variables
|
|
DeclareLocalVariables(FunctionContext, LocalVariables);
|
|
|
|
bool bUseSwitchState = false;
|
|
for (auto Node : FunctionContext.LinearExecutionList)
|
|
{
|
|
TArray<FBlueprintCompiledStatement*>* StatementList = FunctionContext.StatementsPerNode.Find(Node);
|
|
if (StatementList)
|
|
{
|
|
for (auto Statement : (*StatementList))
|
|
{
|
|
if (Statement && (
|
|
Statement->Type == KCST_UnconditionalGoto ||
|
|
Statement->Type == KCST_PushState ||
|
|
Statement->Type == KCST_GotoIfNot ||
|
|
Statement->Type == KCST_ComputedGoto ||
|
|
Statement->Type == KCST_EndOfThread ||
|
|
Statement->Type == KCST_EndOfThreadIfNot ||
|
|
Statement->Type == KCST_GotoReturn ||
|
|
Statement->Type == KCST_GotoReturnIfNot))
|
|
{
|
|
bUseSwitchState = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (bUseSwitchState)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (bUseSwitchState)
|
|
{
|
|
DeclareStateSwitch(FunctionContext);
|
|
}
|
|
|
|
|
|
// Run thru code looking only at things marked as jump targets, to make sure the jump targets are ordered in order of appearance in the linear execution list
|
|
// Emit code in the order specified by the linear execution list (the first node is always the entry point for the function)
|
|
for (int32 NodeIndex = 0; NodeIndex < FunctionContext.LinearExecutionList.Num(); ++NodeIndex)
|
|
{
|
|
UEdGraphNode* StatementNode = FunctionContext.LinearExecutionList[NodeIndex];
|
|
TArray<FBlueprintCompiledStatement*>* StatementList = FunctionContext.StatementsPerNode.Find(StatementNode);
|
|
|
|
if (StatementList != NULL)
|
|
{
|
|
for (int32 StatementIndex = 0; StatementIndex < StatementList->Num(); ++StatementIndex)
|
|
{
|
|
FBlueprintCompiledStatement& Statement = *((*StatementList)[StatementIndex]);
|
|
|
|
if (Statement.bIsJumpTarget)
|
|
{
|
|
// Just making sure we number them in order of appearance, so jump statements don't influence the order
|
|
const int32 StateNum = StatementToStateIndex(FunctionContext, &Statement);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Emit code in the order specified by the linear execution list (the first node is always the entry point for the function)
|
|
for (int32 NodeIndex = 0; NodeIndex < FunctionContext.LinearExecutionList.Num(); ++NodeIndex)
|
|
{
|
|
UEdGraphNode* StatementNode = FunctionContext.LinearExecutionList[NodeIndex];
|
|
TArray<FBlueprintCompiledStatement*>* StatementList = FunctionContext.StatementsPerNode.Find(StatementNode);
|
|
|
|
if (StatementList != NULL)
|
|
{
|
|
for (int32 StatementIndex = 0; StatementIndex < StatementList->Num(); ++StatementIndex)
|
|
{
|
|
FBlueprintCompiledStatement& Statement = *((*StatementList)[StatementIndex]);
|
|
|
|
if (Statement.bIsJumpTarget && bUseSwitchState)
|
|
{
|
|
const int32 StateNum = StatementToStateIndex(FunctionContext, &Statement);
|
|
Emit(Body, *FString::Printf(TEXT("\n\t\tcase %d:\n"), StateNum));
|
|
}
|
|
|
|
switch (Statement.Type)
|
|
{
|
|
case KCST_Nop:
|
|
Emit(Body, TEXT("\t\t\t//No operation.\n"));
|
|
break;
|
|
case KCST_WireTraceSite:
|
|
Emit(Body, TEXT("\t\t\t// Wire debug site.\n"));
|
|
break;
|
|
case KCST_DebugSite:
|
|
Emit(Body, TEXT("\t\t\t// Debug site.\n"));
|
|
break;
|
|
case KCST_CallFunction:
|
|
EmitCallStatment(FunctionContext, Statement);
|
|
break;
|
|
case KCST_CallDelegate:
|
|
EmitCallDelegateStatment(FunctionContext, Statement);
|
|
break;
|
|
case KCST_Assignment:
|
|
EmitAssignmentStatment(FunctionContext, Statement);
|
|
break;
|
|
case KCST_CastObjToInterface:
|
|
EmitCastObjToInterfaceStatement(FunctionContext, Statement);
|
|
break;
|
|
case KCST_CrossInterfaceCast:
|
|
EmitCastBetweenInterfacesStatement(FunctionContext, Statement);
|
|
break;
|
|
case KCST_CastInterfaceToObj:
|
|
EmitCastInterfaceToObjStatement(FunctionContext, Statement);
|
|
break;
|
|
case KCST_DynamicCast:
|
|
EmitDynamicCastStatement(FunctionContext, Statement);
|
|
break;
|
|
case KCST_ObjectToBool:
|
|
EmitObjectToBoolStatement(FunctionContext, Statement);
|
|
break;
|
|
case KCST_AddMulticastDelegate:
|
|
EmitAddMulticastDelegateStatement(FunctionContext, Statement);
|
|
break;
|
|
case KCST_RemoveMulticastDelegate:
|
|
EmitRemoveMulticastDelegateStatement(FunctionContext, Statement);
|
|
break;
|
|
case KCST_BindDelegate:
|
|
EmitBindDelegateStatement(FunctionContext, Statement);
|
|
break;
|
|
case KCST_ClearMulticastDelegate:
|
|
EmitClearMulticastDelegateStatement(FunctionContext, Statement);
|
|
break;
|
|
case KCST_CreateArray:
|
|
EmitCreateArrayStatement(FunctionContext, Statement);
|
|
break;
|
|
case KCST_ComputedGoto:
|
|
case KCST_UnconditionalGoto:
|
|
case KCST_GotoIfNot:
|
|
case KCST_EndOfThreadIfNot:
|
|
case KCST_GotoReturn:
|
|
case KCST_GotoReturnIfNot:
|
|
EmitGotoStatement(FunctionContext, Statement);
|
|
break;
|
|
case KCST_PushState:
|
|
EmitPushStateStatement(FunctionContext, Statement);
|
|
break;
|
|
case KCST_EndOfThread:
|
|
EmitEndOfThreadStatement(FunctionContext, ReturnValueString);
|
|
break;
|
|
case KCST_Comment:
|
|
Emit(Body, *FString::Printf(TEXT("\t\t\t// %s\n"), *Statement.Comment));
|
|
break;
|
|
case KCST_MetaCast:
|
|
EmitMetaCastStatement(FunctionContext, Statement);
|
|
break;
|
|
case KCST_Return:
|
|
Emit(Body, TEXT("\t\t\t// Return statement.\n"));
|
|
break;
|
|
default:
|
|
Emit(Body, TEXT("\t// Warning: Ignoring unsupported statement\n"));
|
|
UE_LOG(LogK2Compiler, Warning, TEXT("C++ backend encountered unsupported statement type %d"), (int32)Statement.Type);
|
|
break;
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bUseSwitchState)
|
|
{
|
|
CloseStateSwitch(FunctionContext);
|
|
}
|
|
}
|
|
|
|
EmitReturnStatement(FunctionContext, ReturnValueString);
|
|
|
|
Emit(Body, TEXT("}\n\n"));
|
|
} |