1088 lines
39 KiB
C#
1088 lines
39 KiB
C#
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Xml.Linq;
|
|
using EpicGames.Core;
|
|
using EpicGames.UHT.Parsers;
|
|
using EpicGames.UHT.Types;
|
|
using EpicGames.UHT.Utils;
|
|
|
|
namespace EpicGames.UHT.Exporters.CodeGen
|
|
{
|
|
|
|
/// <summary>
|
|
/// Helper class for collection where types exist in different define scope blocks
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
public class UhtUsedDefineScopes<T> where T : UhtType
|
|
{
|
|
private bool _first = true;
|
|
private UhtDefineScope _soleScope = UhtDefineScope.Invalid;
|
|
private UhtDefineScope _allScopes = UhtDefineScope.None;
|
|
private uint _present = 0;
|
|
|
|
/// <summary>
|
|
/// Collection of instances
|
|
/// </summary>
|
|
public List<T> Instances { get; } = new();
|
|
|
|
/// <summary>
|
|
/// If true, there are no instances
|
|
/// </summary>
|
|
public bool IsEmpty => Instances.Count == 0;
|
|
|
|
/// <summary>
|
|
/// If true, at least one instance had no scope
|
|
/// </summary>
|
|
public bool HasNoneScope => HasScope(UhtDefineScope.None);
|
|
|
|
/// <summary>
|
|
/// If all types share the same scope, then the sole scope is that scope. The value will be Invalid if the
|
|
/// instances have different scopes.
|
|
/// </summary>
|
|
public UhtDefineScope SoleScope => _soleScope;
|
|
|
|
/// <summary>
|
|
/// Collection of all scopes found in the types. If
|
|
/// </summary>
|
|
public UhtDefineScope AllScopes => _allScopes;
|
|
|
|
/// <summary>
|
|
/// If any instance has no scope, then None is returned. Otherwise AllScopes is returned.
|
|
/// </summary>
|
|
public UhtDefineScope NoneAwareScopes => HasNoneScope ? UhtDefineScope.None : AllScopes;
|
|
|
|
/// <summary>
|
|
/// Constructor with no initial instances
|
|
/// </summary>
|
|
public UhtUsedDefineScopes()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Constructor with initial range of types
|
|
/// </summary>
|
|
/// <param name="instances">Instances to initially add</param>
|
|
public UhtUsedDefineScopes(IEnumerable<T> instances)
|
|
{
|
|
AddRange(instances);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add an instance to the collection
|
|
/// </summary>
|
|
/// <param name="instance">Instance to be added</param>
|
|
public void Add(T instance)
|
|
{
|
|
UhtDefineScope defineScope = instance.DefineScope;
|
|
if (_first)
|
|
{
|
|
_soleScope = defineScope;
|
|
_first = false;
|
|
}
|
|
else if (_soleScope != UhtDefineScope.Invalid && _soleScope != defineScope)
|
|
{
|
|
_soleScope = UhtDefineScope.Invalid;
|
|
}
|
|
_allScopes |= defineScope;
|
|
_present |= ScopeToMask(defineScope);
|
|
Instances.Add(instance);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add a range of instances to the collection
|
|
/// </summary>
|
|
/// <param name="instances">Collection of instances</param>
|
|
public void AddRange(IEnumerable<T> instances)
|
|
{
|
|
foreach (T instance in instances)
|
|
{
|
|
Add(instance);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check to see if the given scope has instances
|
|
/// </summary>
|
|
/// <param name="defineScope">Scope to test</param>
|
|
/// <returns>True if the scope has elements</returns>
|
|
public bool HasScope(UhtDefineScope defineScope)
|
|
{
|
|
return (_present & ScopeToMask(defineScope)) != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update the list to by ordered by the define scope
|
|
/// </summary>
|
|
public void OrderByDefineScope()
|
|
{
|
|
Instances.SortBy(x => x.DefineScope);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Enumerate all of the used defined scopes
|
|
/// </summary>
|
|
/// <returns>Enumeration</returns>
|
|
public IEnumerable<UhtDefineScope> EnumerateDefinedScopes()
|
|
{
|
|
ulong present = _present;
|
|
for (int index = 0; present != 0; ++index, present >>= 1)
|
|
{
|
|
if ((present & 1) != 0)
|
|
{
|
|
yield return (UhtDefineScope)index;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Enumerate all of the used defined scopes
|
|
/// </summary>
|
|
/// <returns>Enumeration</returns>
|
|
public IEnumerable<UhtDefineScope> EnumerateDefinedScopesNoneAtEnd()
|
|
{
|
|
ulong present = _present >> 1;
|
|
for (int index = 1; present != 0; ++index, present >>= 1)
|
|
{
|
|
if ((present & 1) != 0)
|
|
{
|
|
yield return (UhtDefineScope)index;
|
|
}
|
|
}
|
|
|
|
// At this time, we alway return None
|
|
yield return UhtDefineScope.None;
|
|
}
|
|
|
|
private static uint ScopeToMask(UhtDefineScope defineScope)
|
|
{
|
|
return (uint)1 << (int)defineScope;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Helper class to build linked lists of objects which are defined in different scopes.
|
|
/// e.g. properties of a class, where some properties are only present when WITH_EDITORONLY_DATA is defined
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
public class UhtDefineScopeListBuilder<T> : IDisposable
|
|
where T: UhtType
|
|
{
|
|
/// <summary>
|
|
/// Initialize the builder with an empty 'head' link.
|
|
/// </summary>
|
|
public UhtDefineScopeListBuilder(UhtDefineScope scope)
|
|
{
|
|
Head = new UhtDefineScopeLink<T>(scope);
|
|
_pending.Add(Head);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Link pointing to the first object in the list for each relevant define scope.
|
|
/// </summary>
|
|
public UhtDefineScopeLink<T> Head { get; }
|
|
|
|
/// <summary>
|
|
/// Add the given object as the next object after any preceding object which does not yet have a following object
|
|
/// in the scope(s) the new object is defined in.
|
|
/// </summary>
|
|
/// <param name="inNext">Object to append to the list</param>
|
|
public UhtDefineScopeLink<T> Add(T inNext)
|
|
{
|
|
foreach (UhtDefineScopeLink<T> link in _pending)
|
|
{
|
|
link.Add(inNext);
|
|
}
|
|
_pending.RemoveAll(x => x.IsComplete);
|
|
UhtDefineScopeLink<T> newLink = new(inNext.DefineScope);
|
|
_pending.Add(newLink);
|
|
return newLink;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public void Dispose()
|
|
{
|
|
Dispose(true);
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Explicitly terminate each pending link with null
|
|
/// </summary>
|
|
protected virtual void Dispose(bool disposing)
|
|
{
|
|
if (disposing)
|
|
{
|
|
foreach (UhtDefineScopeLink<T> link in _pending)
|
|
{
|
|
link.Terminate();
|
|
}
|
|
}
|
|
}
|
|
|
|
private readonly List<UhtDefineScopeLink<T>> _pending = [];
|
|
}
|
|
|
|
/// <summary>
|
|
/// This class can be used as a field in UhtTypes to perform as an intrusive linked list 'next' pointer to
|
|
/// another object of the same type, resolving to a different object depending on which preprocessor definitions
|
|
/// are set.
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
public class UhtDefineScopeLink<T> where T: UhtType
|
|
{
|
|
/// <summary>
|
|
/// Initialize this link with the declaration scope of the object holding the link.
|
|
/// </summary>
|
|
/// <param name="thisScope"></param>
|
|
public UhtDefineScopeLink(UhtDefineScope thisScope)
|
|
{
|
|
_thisScope = thisScope;
|
|
_completionMask = ToCompletionMask(thisScope);
|
|
// A next node in scope 'None' always completes this link regardless of _thisScope
|
|
_completionMask |= ToCompletionMask(UhtDefineScope.None);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Try to add a new element following this one in the linked list.
|
|
/// If there is already a next element for every combination of scopes for which this and the candidate are defined,
|
|
/// the new element will not be added.
|
|
/// If, after adding the new element, there is a next element for every combination of scopes in which this is defined,
|
|
/// this link will return true from IsComplete.
|
|
/// </summary>
|
|
/// <param name="inNext"></param>
|
|
public void Add(T inNext)
|
|
{
|
|
uint addedMask = ToAddedMask(inNext.DefineScope);
|
|
if ((addedMask & _addedScopes) == 0)
|
|
{
|
|
_addedScopes |= addedMask;
|
|
_next.Add(inNext);
|
|
|
|
uint completionCandidateMask = ToCompletionMask(inNext.DefineScope);
|
|
if ((completionCandidateMask & _completionMask) != 0)
|
|
{
|
|
IsComplete = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Must be called on an incomplete link. Terminates the link explicitly with nullptr to handle the case where there
|
|
/// is a next link for some scopes, but none for all scopes the link is defined in.
|
|
/// </summary>
|
|
public void Terminate()
|
|
{
|
|
if (IsComplete)
|
|
{
|
|
throw new InvalidOperationException("Attemping to terminate an already-complete link. Such links should be removed from the pending list by the builder.");
|
|
}
|
|
_next.Add(null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if there is a next element for every combination of scopes which this is defined.
|
|
/// </summary>
|
|
public bool IsComplete { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Returns the scope of the first object in the list, or UhtDefineScope.None.
|
|
/// </summary>
|
|
public UhtDefineScope InitialScope => _next.First()?.DefineScope ?? UhtDefineScope.None;
|
|
|
|
/// <summary>
|
|
/// Returns all objects which follow this object in some relevant scope.
|
|
/// Only the last element may be null.
|
|
/// </summary>
|
|
public IReadOnlyList<T?> Next => _next;
|
|
|
|
// Ordered list of next objects with differing scopes
|
|
private readonly List<T?> _next = [];
|
|
|
|
// The scope in which this link is defined
|
|
private readonly UhtDefineScope _thisScope;
|
|
|
|
// When any the bits in this are matched by the bits in the next added item, this link is complete
|
|
private readonly uint _completionMask;
|
|
|
|
// Tracks which scopes have been added with Add
|
|
private uint _addedScopes = 0;
|
|
|
|
// One of two masks used by this class, this is used for _completionMask to track when this link
|
|
// has a next node for every situation in which it is defined
|
|
private static uint ToCompletionMask(UhtDefineScope scope)
|
|
{
|
|
// Shift other scopes by 1 so that 'None' is assigned a bit as well
|
|
return scope == UhtDefineScope.None ? 1 : (uint)scope << 1;
|
|
}
|
|
|
|
// The second mask used by this class, this is used to track when a next node is already present for
|
|
// a given scope, so a candidate does not need to be added
|
|
private uint ToAddedMask(UhtDefineScope scope)
|
|
{
|
|
// Add the scope if this link to the mask because so that e.g.
|
|
// thisScope == UhtDefineScope.EditorOnly
|
|
// inNext.DefineScope = UhtDefineScope.VerseVM
|
|
// if the next link to be added is UhtDefineScope.EditorOnly|UhtDefineScope.VerseVM, we do not need to add it
|
|
// because under the preprocessor state UhtDefineScope.EditorOnly|UhtDefineScope.VerseVM, a next node is defined already.
|
|
return (uint)1 << (int)(scope | _thisScope);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Helper extensions when working with defined scope collections.
|
|
///
|
|
/// This class helps with producing consistent and correct code that works with the DefineScope element in UhtType.
|
|
///
|
|
/// In generated header files, it supports two flavors of macro definitions used to generate the body macro.
|
|
///
|
|
/// The multi macro style will generate one macro for each unique combination of DefineScope found. Only the instances
|
|
/// that match the DefineScope will be placed in that macro. The macros will be generated in such a way that they
|
|
/// will always be present and each much be included in the generated body macro. This style is used to generate
|
|
/// declarations as needed.
|
|
///
|
|
/// The single macro style will generate a single macro, but that macro will appear multiple times depending on
|
|
/// each combination of the DefineScope combinations required. Each macro will have a complete set of instances
|
|
/// filtered by the DefineScope. This style is used to populate such things as enum definitions needed by the engine.
|
|
///
|
|
/// In generated cpp files, there is support for enumerating through all the instances and emitting the appropriate
|
|
/// #if block to include instances based on their DefineScope.
|
|
/// </summary>
|
|
internal static class UhtUsedDefineScopesExtensions
|
|
{
|
|
|
|
/// <summary>
|
|
/// Append a macro scoped macro
|
|
/// </summary>
|
|
/// <param name="builder">Destination builder</param>
|
|
/// <param name="defineScopeNames">Which set of scope names will be used</param>
|
|
/// <param name="defineScope">Specified scope</param>
|
|
/// <param name="appendAction">Action to invoke to append an instance</param>
|
|
/// <returns>String builder</returns>
|
|
public static StringBuilder AppendScoped(this StringBuilder builder, UhtDefineScopeNames defineScopeNames, UhtDefineScope defineScope, Action<StringBuilder> appendAction)
|
|
{
|
|
using UhtMacroBlockEmitter blockEmitter = new(builder, defineScopeNames, defineScope);
|
|
appendAction(builder);
|
|
return builder;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Append multiple for the given collection of scopes
|
|
/// </summary>
|
|
/// <param name="builder">Destination builder</param>
|
|
/// <param name="instances">Defined scope instances</param>
|
|
/// <param name="defineScopeNames">Which set of scope names will be used</param>
|
|
/// <param name="appendAction">Action to invoke to append an instance</param>
|
|
/// <returns>String builder</returns>
|
|
public static StringBuilder AppendMultiScoped<T>(this StringBuilder builder, UhtUsedDefineScopes<T> instances, UhtDefineScopeNames defineScopeNames,
|
|
Action<StringBuilder, IEnumerable<T>> appendAction) where T : UhtType
|
|
{
|
|
foreach (UhtDefineScope defineScope in instances.EnumerateDefinedScopes())
|
|
{
|
|
AppendScoped(builder, defineScopeNames, defineScope, builder => appendAction(builder, instances.Instances.Where(x => x.DefineScope == defineScope)));
|
|
}
|
|
return builder;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Append a macro scoped macro
|
|
/// </summary>
|
|
/// <param name="builder">Destination builder</param>
|
|
/// <param name="defineScopeNames">Which set of scope names will be used</param>
|
|
/// <param name="defineScope">Specified scope</param>
|
|
/// <param name="generator">Header code generator</param>
|
|
/// <param name="outerType">Output type owning the instances</param>
|
|
/// <param name="macroSuffix">Macro being created</param>
|
|
/// <param name="includeSuffix">If true, include such things as _EOD onto the macro name</param>
|
|
/// <param name="appendAction">Action to invoke to append an instance</param>
|
|
/// <returns>String builder</returns>
|
|
public static StringBuilder AppendScopedMacro(this StringBuilder builder, UhtDefineScopeNames defineScopeNames, UhtDefineScope defineScope,
|
|
UhtHeaderCodeGenerator generator, UhtType outerType, string macroSuffix, bool includeSuffix, Action<StringBuilder> appendAction)
|
|
{
|
|
using (UhtMacroBlockEmitter blockEmitter = new(builder, defineScopeNames, defineScope))
|
|
{
|
|
using (UhtMacroCreator macro = new(builder, generator, outerType, macroSuffix, defineScope, includeSuffix))
|
|
{
|
|
appendAction(builder);
|
|
}
|
|
|
|
// We can skip writing the macros if there are no properties to declare, as the 'if' and 'else' would be the same
|
|
if (defineScope != UhtDefineScope.None)
|
|
{
|
|
// Trim the extra newlines added after the macro generator
|
|
if (builder.Length > 4 &&
|
|
builder[^4] == '\r' &&
|
|
builder[^3] == '\n' &&
|
|
builder[^2] == '\r' &&
|
|
builder[^1] == '\n')
|
|
{
|
|
builder.Length -= 4;
|
|
}
|
|
|
|
builder.AppendElsePreprocessor(defineScope, defineScopeNames);
|
|
using UhtMacroCreator macro = new(builder, generator, outerType, macroSuffix, defineScope, includeSuffix); // Empty macro
|
|
}
|
|
}
|
|
|
|
if (defineScope != UhtDefineScope.None)
|
|
{
|
|
builder.Append("\r\n\r\n");
|
|
}
|
|
return builder;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Append multi macros for the given collection of scopes
|
|
/// </summary>
|
|
/// <param name="builder">Destination builder</param>
|
|
/// <param name="instances">Defined scope instances</param>
|
|
/// <param name="defineScopeNames">Which set of scope names will be used</param>
|
|
/// <param name="generator">Header code generator</param>
|
|
/// <param name="outerType">Output type owning the instances</param>
|
|
/// <param name="macroSuffix">Macro being created</param>
|
|
/// <param name="appendAction">Action to invoke to append an instance</param>
|
|
/// <returns>String builder</returns>
|
|
public static StringBuilder AppendMultiScopedMacros<T>(this StringBuilder builder, UhtUsedDefineScopes<T> instances, UhtDefineScopeNames defineScopeNames,
|
|
UhtHeaderCodeGenerator generator, UhtType outerType, string macroSuffix, Action<StringBuilder, IEnumerable<T>> appendAction) where T : UhtType
|
|
{
|
|
foreach (UhtDefineScope defineScope in instances.EnumerateDefinedScopes())
|
|
{
|
|
AppendScopedMacro(builder, defineScopeNames, defineScope, generator, outerType, macroSuffix, true,
|
|
builder => appendAction(builder, instances.Instances.Where(x => x.DefineScope == defineScope)));
|
|
}
|
|
return builder;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Append the macro definitions requested
|
|
/// </summary>
|
|
/// <param name="builder">Destination builder</param>
|
|
/// <param name="instances">Defined scope instances</param>
|
|
/// <param name="generator">Header code generator</param>
|
|
/// <param name="outerType">Output type owning the instances</param>
|
|
/// <param name="macroSuffix">Macro being created</param>
|
|
/// <returns>String builder</returns>
|
|
public static StringBuilder AppendMultiMacroRefs<T>(this StringBuilder builder, UhtUsedDefineScopes<T> instances,
|
|
UhtHeaderCodeGenerator generator, UhtType outerType, string macroSuffix) where T : UhtType
|
|
{
|
|
foreach (UhtDefineScope defineScope in instances.EnumerateDefinedScopes())
|
|
{
|
|
builder.Append('\t').AppendMacroName(generator, outerType, macroSuffix, defineScope).Append(" \\\r\n");
|
|
}
|
|
return builder;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Append a single macro, where the macro -same- definition can exist inside of define scopes where
|
|
/// the instances contained are all instances that would be satisfied by a scope.
|
|
/// </summary>
|
|
/// <param name="builder">Destination builder</param>
|
|
/// <param name="instances">Defined scope instances</param>
|
|
/// <param name="defineScopeNames">Which set of scope names will be used</param>
|
|
/// <param name="generator">Header code generator</param>
|
|
/// <param name="outerType">Output type owning the instances</param>
|
|
/// <param name="macroSuffix">Macro being created</param>
|
|
/// <param name="appendAction">Action to invoke to append an instance</param>
|
|
/// <returns>String builder</returns>
|
|
public static StringBuilder AppendSingleMacro<T>(this StringBuilder builder, UhtUsedDefineScopes<T> instances, UhtDefineScopeNames defineScopeNames,
|
|
UhtHeaderCodeGenerator generator, UhtType outerType, string macroSuffix, Action<StringBuilder, IEnumerable<T>> appendAction) where T : UhtType
|
|
{
|
|
if (instances.SoleScope == UhtDefineScope.None)
|
|
{
|
|
using UhtMacroCreator macro = new(builder, generator, outerType, macroSuffix, UhtDefineScope.None);
|
|
appendAction(builder, instances.Instances);
|
|
}
|
|
else
|
|
{
|
|
bool first = true;
|
|
foreach (UhtDefineScope defineScope in instances.EnumerateDefinedScopesNoneAtEnd())
|
|
{
|
|
if (first)
|
|
{
|
|
builder.AppendIfPreprocessor(defineScope, defineScopeNames);
|
|
first = false;
|
|
}
|
|
else if (defineScope != UhtDefineScope.None)
|
|
{
|
|
builder.AppendElseIfPreprocessor(defineScope, defineScopeNames);
|
|
}
|
|
else
|
|
{
|
|
builder.Append("#else\r\n");
|
|
}
|
|
using (UhtMacroCreator macro = new(builder, generator, outerType, macroSuffix, UhtDefineScope.None))
|
|
{
|
|
appendAction(builder, instances.Instances.Where(x => (x.DefineScope & ~defineScope) == 0));
|
|
}
|
|
if (builder.Length > 4 &&
|
|
builder[^4] == '\r' &&
|
|
builder[^3] == '\n' &&
|
|
builder[^2] == '\r' &&
|
|
builder[^1] == '\n')
|
|
{
|
|
builder.Length -= 4;
|
|
}
|
|
}
|
|
builder.Append("#endif\r\n\r\n\r\n");
|
|
}
|
|
return builder;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Invoke the append action if any types are present. If all types are from the same define scope, then
|
|
/// it will be wrapped with and #if block.
|
|
/// </summary>
|
|
/// <param name="builder">Destination builder</param>
|
|
/// <param name="instances">Defined scope instances</param>
|
|
/// <param name="defineScopeNames">Names to use when outputting the scope</param>
|
|
/// <param name="appendAction">Action to invoke</param>
|
|
/// <returns>String builder</returns>
|
|
public static StringBuilder AppendIfInstances<T>(this StringBuilder builder, UhtUsedDefineScopes<T> instances, UhtDefineScopeNames defineScopeNames, Action<StringBuilder> appendAction) where T : UhtType
|
|
{
|
|
if (!instances.IsEmpty)
|
|
{
|
|
using UhtMacroBlockEmitter blockEmitter = new(builder, defineScopeNames, instances.NoneAwareScopes);
|
|
appendAction(builder);
|
|
}
|
|
return builder;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Append each instance to the builder
|
|
/// </summary>
|
|
/// <param name="builder">Destination builder</param>
|
|
/// <param name="instances">Defined scope instances</param>
|
|
/// <param name="defineScopeNames">Names to use when outputting the scope</param>
|
|
/// <param name="appendAction">Action to invoke</param>
|
|
/// <returns>String builder</returns>
|
|
public static StringBuilder AppendInstances<T>(this StringBuilder builder, UhtUsedDefineScopes<T> instances, UhtDefineScopeNames defineScopeNames, Action<StringBuilder, T> appendAction) where T : UhtType
|
|
{
|
|
return builder.AppendInstances(instances, defineScopeNames, null, appendAction, null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Append each instance to the builder
|
|
/// </summary>
|
|
/// <param name="builder">Destination builder</param>
|
|
/// <param name="instances">Defined scope instances</param>
|
|
/// <param name="defineScopeNames">Names to use when outputting the scope</param>
|
|
/// <param name="preambleAction">Action to invoke prior to first instance</param>
|
|
/// <param name="appendAction">Action to invoke</param>
|
|
/// <param name="postambleAction">Action to invoke following all instances</param>
|
|
/// <returns>String builder</returns>
|
|
public static StringBuilder AppendInstances<T>(this StringBuilder builder, UhtUsedDefineScopes<T> instances, UhtDefineScopeNames defineScopeNames,
|
|
Action<StringBuilder>? preambleAction, Action<StringBuilder, T> appendAction, Action<StringBuilder>? postambleAction) where T : UhtType
|
|
{
|
|
if (!instances.IsEmpty)
|
|
{
|
|
using UhtMacroBlockEmitter blockEmitter = new(builder, defineScopeNames, instances.SoleScope);
|
|
preambleAction?.Invoke(builder);
|
|
foreach (T instance in instances.Instances)
|
|
{
|
|
blockEmitter.Set(instance.DefineScope);
|
|
appendAction(builder, instance);
|
|
}
|
|
|
|
// Make sure the postable run with the proper initial scope
|
|
blockEmitter.Set(instances.SoleScope);
|
|
postambleAction?.Invoke(builder);
|
|
}
|
|
return builder;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Append an array view construction expression for the given instances
|
|
/// </summary>
|
|
/// <param name="builder">Destination builder</param>
|
|
/// <param name="instances">Collected instances</param>
|
|
/// <param name="defineScopeNames">Names to use when outputting the scope</param>
|
|
/// <param name="staticsName">Name of the statics section</param>
|
|
/// <param name="arrayName">The name of the arrray</param>
|
|
/// <param name="tabs">Number of tabs to start the line</param>
|
|
/// <param name="endl">Text to end the line</param>
|
|
/// <returns>Destination builder</returns>
|
|
public static StringBuilder AppendArrayView<T>(this StringBuilder builder, UhtUsedDefineScopes<T> instances, UhtDefineScopeNames defineScopeNames, string? staticsName, string arrayName, int tabs, string endl) where T : UhtType
|
|
{
|
|
UhtDefineScope noneAwareScopes = instances.NoneAwareScopes;
|
|
|
|
// We have no instances in the collection, the list will always be empty
|
|
if (instances.IsEmpty)
|
|
{
|
|
builder
|
|
.AppendTabs(tabs)
|
|
.Append("{}")
|
|
.Append(endl);
|
|
}
|
|
|
|
// If we have any instances that have no scope, then we can always just reference the array
|
|
else if (noneAwareScopes == UhtDefineScope.None)
|
|
{
|
|
builder
|
|
.AppendTabs(tabs)
|
|
.Append("MakeConstArrayView(")
|
|
.AppendCppName(staticsName, arrayName)
|
|
.Append(')')
|
|
.Append(endl);
|
|
}
|
|
|
|
// If the only scope we have is WITH_EDITORONLY_DATA, then we can use the existing macros
|
|
else if (noneAwareScopes == UhtDefineScope.EditorOnlyData)
|
|
{
|
|
switch (defineScopeNames)
|
|
{
|
|
case UhtDefineScopeNames.Standard:
|
|
builder
|
|
.AppendTabs(tabs)
|
|
.Append("IF_WITH_EDITORONLY_DATA(MakeConstArrayView(")
|
|
.AppendCppName(staticsName, arrayName)
|
|
.Append("), {})")
|
|
.Append(endl);
|
|
break;
|
|
case UhtDefineScopeNames.WithEditor:
|
|
builder
|
|
.AppendTabs(tabs)
|
|
.Append("IF_WITH_EDITOR(MakeConstArrayView(")
|
|
.AppendCppName(staticsName, arrayName)
|
|
.Append("), {})")
|
|
.Append(endl);
|
|
break;
|
|
default:
|
|
throw new UhtIceException("Unexpected define scope names value");
|
|
}
|
|
}
|
|
|
|
// Otherwise we have many different scopes but no none scope, must generate #if block
|
|
else
|
|
{
|
|
builder.Append("\r\n");
|
|
builder.AppendIfPreprocessor(instances.AllScopes, defineScopeNames);
|
|
builder
|
|
.AppendTabs(tabs)
|
|
.Append("MakeArrayView(")
|
|
.AppendCppName(staticsName, arrayName)
|
|
.Append(')')
|
|
.Append(endl);
|
|
builder.AppendElsePreprocessor(instances.AllScopes, defineScopeNames);
|
|
builder
|
|
.AppendTabs(tabs)
|
|
.Append("{}")
|
|
.Append(endl);
|
|
builder.AppendEndIfPreprocessor(instances.AllScopes, defineScopeNames);
|
|
}
|
|
return builder;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Append the given array list and count as arguments to a structure constructor
|
|
/// </summary>
|
|
/// <param name="builder">Destination builder</param>
|
|
/// <param name="instances">Collected instances</param>
|
|
/// <param name="defineScopeNames">Names to use when outputting the scope</param>
|
|
/// <param name="staticsName">Name of the statics section</param>
|
|
/// <param name="arrayName">The name of the arrray</param>
|
|
/// <param name="tabs">Number of tabs to start the line</param>
|
|
/// <param name="endl">Text to end the line</param>
|
|
/// <returns>Destination builder</returns>
|
|
public static StringBuilder AppendArrayPtrAndCountLine<T>(this StringBuilder builder, UhtUsedDefineScopes<T> instances, UhtDefineScopeNames defineScopeNames, string? staticsName, string arrayName, int tabs, string endl) where T : UhtType
|
|
{
|
|
UhtDefineScope noneAwareScopes = instances.NoneAwareScopes;
|
|
|
|
// We have no instances in the collection, the list will always be empty
|
|
if (instances.IsEmpty)
|
|
{
|
|
builder
|
|
.AppendTabs(tabs)
|
|
.Append("nullptr, 0")
|
|
.Append(endl);
|
|
}
|
|
|
|
// If we have any instances that have no scope, then we can always just reference the array
|
|
else if (noneAwareScopes == UhtDefineScope.None)
|
|
{
|
|
builder
|
|
.AppendTabs(tabs)
|
|
.AppendCppName(staticsName, arrayName)
|
|
.Append(", UE_ARRAY_COUNT(")
|
|
.AppendCppName(staticsName, arrayName)
|
|
.Append(')')
|
|
.Append(endl);
|
|
}
|
|
|
|
// If the only scope we have is WITH_EDITORONLY_DATA, then we can use the existing macros
|
|
else if (noneAwareScopes == UhtDefineScope.EditorOnlyData)
|
|
{
|
|
switch (defineScopeNames)
|
|
{
|
|
case UhtDefineScopeNames.Standard:
|
|
builder
|
|
.AppendTabs(tabs)
|
|
.Append("IF_WITH_EDITORONLY_DATA(")
|
|
.AppendCppName(staticsName, arrayName)
|
|
.Append(", nullptr), IF_WITH_EDITORONLY_DATA(UE_ARRAY_COUNT(")
|
|
.AppendCppName(staticsName, arrayName)
|
|
.Append("), 0)")
|
|
.Append(endl);
|
|
break;
|
|
case UhtDefineScopeNames.WithEditor:
|
|
builder
|
|
.AppendTabs(tabs)
|
|
.Append("IF_WITH_EDITOR(")
|
|
.AppendCppName(staticsName, arrayName)
|
|
.Append(", nullptr), IF_WITH_EDITOR(UE_ARRAY_COUNT(")
|
|
.AppendCppName(staticsName, arrayName)
|
|
.Append("), 0)")
|
|
.Append(endl);
|
|
break;
|
|
default:
|
|
throw new UhtIceException("Unexpected define scope names value");
|
|
}
|
|
}
|
|
|
|
// Otherwise we have many different scopes but no none scope, must generate #if block
|
|
else
|
|
{
|
|
builder.AppendIfPreprocessor(instances.AllScopes, defineScopeNames);
|
|
builder
|
|
.AppendTabs(tabs)
|
|
.AppendCppName(staticsName, arrayName)
|
|
.Append(", UE_ARRAY_COUNT(")
|
|
.AppendCppName(staticsName, arrayName)
|
|
.Append(')')
|
|
.Append(endl);
|
|
builder.AppendElsePreprocessor(instances.AllScopes, defineScopeNames);
|
|
builder
|
|
.AppendTabs(tabs)
|
|
.Append("nullptr, 0")
|
|
.Append(endl);
|
|
builder.AppendEndIfPreprocessor(instances.AllScopes, defineScopeNames);
|
|
}
|
|
return builder;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Append the given array list as arguments to a structure constructor
|
|
/// </summary>
|
|
/// <param name="builder">Destination builder</param>
|
|
/// <param name="instances">Collected instances</param>
|
|
/// <param name="defineScopeNames">Names to use when outputting the scope</param>
|
|
/// <param name="staticsName">Name of the statics section</param>
|
|
/// <param name="arrayName">The name of the arrray</param>
|
|
/// <param name="tabs">Number of tabs to start the line</param>
|
|
/// <param name="endl">Text to end the line</param>
|
|
/// <returns>Destination builder</returns>
|
|
public static StringBuilder AppendArrayPtrLine<T>(this StringBuilder builder, UhtUsedDefineScopes<T> instances, UhtDefineScopeNames defineScopeNames, string? staticsName, string arrayName, int tabs, string endl) where T : UhtType
|
|
{
|
|
UhtDefineScope noneAwareScopes = instances.NoneAwareScopes;
|
|
|
|
// We have no instances in the collection, the list will always be empty
|
|
if (instances.IsEmpty)
|
|
{
|
|
builder
|
|
.AppendTabs(tabs)
|
|
.Append("nullptr")
|
|
.Append(endl);
|
|
}
|
|
|
|
// If we have any instances that have no scope, then we can always just reference the array
|
|
else if (noneAwareScopes == UhtDefineScope.None)
|
|
{
|
|
builder
|
|
.AppendTabs(tabs)
|
|
.AppendCppName(staticsName, arrayName)
|
|
.Append(endl);
|
|
}
|
|
|
|
// If the only scope we have is WITH_EDITORONLY_DATA, then we can use the existing macros
|
|
else if (noneAwareScopes == UhtDefineScope.EditorOnlyData)
|
|
{
|
|
switch (defineScopeNames)
|
|
{
|
|
case UhtDefineScopeNames.Standard:
|
|
builder
|
|
.AppendTabs(tabs)
|
|
.Append("IF_WITH_EDITORONLY_DATA(")
|
|
.AppendCppName(staticsName, arrayName)
|
|
.Append(", nullptr)")
|
|
.Append(endl);
|
|
break;
|
|
case UhtDefineScopeNames.WithEditor:
|
|
builder
|
|
.AppendTabs(tabs)
|
|
.Append("IF_WITH_EDITOR(")
|
|
.AppendCppName(staticsName, arrayName)
|
|
.Append(", nullptr)")
|
|
.Append(endl);
|
|
break;
|
|
default:
|
|
throw new UhtIceException("Unexpected define scope names value");
|
|
}
|
|
}
|
|
|
|
// Otherwise we have many different scopes but no none scope, must generate #if block
|
|
else
|
|
{
|
|
builder.AppendIfPreprocessor(instances.AllScopes, defineScopeNames);
|
|
builder
|
|
.AppendTabs(tabs)
|
|
.AppendCppName(staticsName, arrayName)
|
|
.Append(endl);
|
|
builder.AppendElsePreprocessor(instances.AllScopes, defineScopeNames);
|
|
builder
|
|
.AppendTabs(tabs)
|
|
.Append("nullptr")
|
|
.Append(endl);
|
|
builder.AppendEndIfPreprocessor(instances.AllScopes, defineScopeNames);
|
|
}
|
|
return builder;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Append the given array count as arguments to a structure constructor
|
|
/// </summary>
|
|
/// <param name="builder">Destination builder</param>
|
|
/// <param name="instances">Collected instances</param>
|
|
/// <param name="defineScopeNames">Names to use when outputting the scope</param>
|
|
/// <param name="staticsName">Name of the statics section</param>
|
|
/// <param name="arrayName">The name of the arrray</param>
|
|
/// <param name="tabs">Number of tabs to start the line</param>
|
|
/// <param name="endl">Text to end the line</param>
|
|
/// <returns>Destination builder</returns>
|
|
public static StringBuilder AppendArrayCountLine<T>(this StringBuilder builder, UhtUsedDefineScopes<T> instances, UhtDefineScopeNames defineScopeNames, string? staticsName, string arrayName, int tabs, string endl) where T : UhtType
|
|
{
|
|
UhtDefineScope noneAwareScopes = instances.NoneAwareScopes;
|
|
|
|
// We have no instances in the collection, the list will always be empty
|
|
if (instances.IsEmpty)
|
|
{
|
|
builder
|
|
.AppendTabs(tabs)
|
|
.Append('0')
|
|
.Append(endl);
|
|
}
|
|
|
|
// If we have any instances that have no scope, then we can always just reference the array
|
|
else if (noneAwareScopes == UhtDefineScope.None)
|
|
{
|
|
builder
|
|
.AppendTabs(tabs)
|
|
.Append("UE_ARRAY_COUNT(")
|
|
.AppendCppName(staticsName, arrayName)
|
|
.Append(')')
|
|
.Append(endl);
|
|
}
|
|
|
|
// If the only scope we have is WITH_EDITORONLY_DATA, then we can use the existing macros
|
|
else if (noneAwareScopes == UhtDefineScope.EditorOnlyData)
|
|
{
|
|
switch (defineScopeNames)
|
|
{
|
|
case UhtDefineScopeNames.Standard:
|
|
builder
|
|
.AppendTabs(tabs)
|
|
.Append("IF_WITH_EDITORONLY_DATA(UE_ARRAY_COUNT(")
|
|
.AppendCppName(staticsName, arrayName)
|
|
.Append("), 0)")
|
|
.Append(endl);
|
|
break;
|
|
case UhtDefineScopeNames.WithEditor:
|
|
builder
|
|
.AppendTabs(tabs)
|
|
.Append("IF_WITH_EDITOR(UE_ARRAY_COUNT(")
|
|
.AppendCppName(staticsName, arrayName)
|
|
.Append("), 0)")
|
|
.Append(endl);
|
|
break;
|
|
default:
|
|
throw new UhtIceException("Unexpected define scope names value");
|
|
}
|
|
}
|
|
|
|
// Otherwise we have many different scopes but no none scope, must generate #if block
|
|
else
|
|
{
|
|
builder.AppendIfPreprocessor(instances.AllScopes, defineScopeNames);
|
|
builder
|
|
.AppendTabs(tabs)
|
|
.Append("UE_ARRAY_COUNT(")
|
|
.AppendCppName(staticsName, arrayName)
|
|
.Append(')')
|
|
.Append(endl);
|
|
builder.AppendElsePreprocessor(instances.AllScopes, defineScopeNames);
|
|
builder
|
|
.AppendTabs(tabs)
|
|
.Append('0')
|
|
.Append(endl);
|
|
builder.AppendEndIfPreprocessor(instances.AllScopes, defineScopeNames);
|
|
}
|
|
return builder;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Append a link which resolves to a different object under different preprocessor definitions
|
|
/// </summary>
|
|
/// <param name="builder"></param>
|
|
/// <param name="link"></param>
|
|
/// <param name="defineScopeNames"></param>
|
|
/// <param name="context"></param>
|
|
/// <param name="tabs"></param>
|
|
/// <param name="prefix"></param>
|
|
/// <param name="endl"></param>
|
|
/// <returns></returns>
|
|
public static StringBuilder AppendScopeLink(this StringBuilder builder, UhtDefineScopeLink<UhtProperty>? link, UhtDefineScopeNames defineScopeNames, IUhtPropertyMemberContext context, int tabs, string? prefix, string? endl)
|
|
{
|
|
// No link or link contains nothing
|
|
if (link is null)
|
|
{
|
|
return builder.AppendTabs(tabs).Append(prefix).Append("nullptr").Append(endl);
|
|
}
|
|
|
|
using (UhtMacroBlockEmitter blockEmitter = new(builder, defineScopeNames, link.InitialScope))
|
|
{
|
|
foreach (UhtProperty? next in link.Next)
|
|
{
|
|
blockEmitter.Set(next?.DefineScope ?? UhtDefineScope.None);
|
|
builder.AppendTabs(tabs).Append(prefix);
|
|
builder.AppendConstInitMemberPtr(next, context, next?.EngineName, "", 0, endl);
|
|
}
|
|
}
|
|
return builder;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Append a link which resolves to a different object under different preprocessor definitions
|
|
/// </summary>
|
|
/// <param name="builder"></param>
|
|
/// <param name="link"></param>
|
|
/// <param name="defineScopeNames"></param>
|
|
/// <param name="context"></param>
|
|
/// <param name="tabs"></param>
|
|
/// <param name="prefix"></param>
|
|
/// <param name="endl"></param>
|
|
/// <returns></returns>
|
|
public static StringBuilder AppendScopeLink(this StringBuilder builder, UhtDefineScopeLink<UhtFunction>? link, UhtDefineScopeNames defineScopeNames, IUhtPropertyMemberContext context, int tabs, string? prefix, string? endl)
|
|
{
|
|
// No link or link contains nothing
|
|
if (link is null)
|
|
{
|
|
return builder.AppendTabs(tabs).Append(prefix).Append("nullptr").Append(endl);
|
|
}
|
|
|
|
using (UhtMacroBlockEmitter blockEmitter = new(builder, defineScopeNames, link.InitialScope))
|
|
{
|
|
foreach (UhtFunction? next in link.Next)
|
|
{
|
|
blockEmitter.Set(next?.DefineScope ?? UhtDefineScope.None);
|
|
builder.AppendTabs(tabs).Append(prefix);
|
|
builder.AppendConstInitSingletonRef(context, next).Append(endl);
|
|
}
|
|
}
|
|
return builder;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Start an #if block with the given scope
|
|
/// </summary>
|
|
/// <param name="builder">String builder</param>
|
|
/// <param name="defineScope">Scope</param>
|
|
/// <param name="defineScopeNames">Which set of scope names will be used</param>
|
|
/// <returns>String builder</returns>
|
|
public static StringBuilder AppendIfPreprocessor(this StringBuilder builder, UhtDefineScope defineScope, UhtDefineScopeNames defineScopeNames = UhtDefineScopeNames.Standard)
|
|
{
|
|
if (defineScope != UhtDefineScope.None && defineScope != UhtDefineScope.Invalid)
|
|
{
|
|
builder.Append("#if ").AppendScopeExpression(defineScope, defineScopeNames).Append("\r\n");
|
|
}
|
|
return builder;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Start an #else block with the given scope
|
|
/// </summary>
|
|
/// <param name="builder">String builder</param>
|
|
/// <param name="defineScope">Scope</param>
|
|
/// <param name="defineScopeNames">Which set of scope names will be used</param>
|
|
/// <returns>String builder</returns>
|
|
public static StringBuilder AppendElsePreprocessor(this StringBuilder builder, UhtDefineScope defineScope, UhtDefineScopeNames defineScopeNames = UhtDefineScopeNames.Standard)
|
|
{
|
|
if (defineScope != UhtDefineScope.None && defineScope != UhtDefineScope.Invalid)
|
|
{
|
|
builder.Append("#else // ").AppendScopeExpression(defineScope, defineScopeNames).Append("\r\n");
|
|
}
|
|
return builder;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Start an #elif block with the given scope
|
|
/// </summary>
|
|
/// <param name="builder">String builder</param>
|
|
/// <param name="defineScope">Scope</param>
|
|
/// <param name="defineScopeNames">Which set of scope names will be used</param>
|
|
/// <returns>String builder</returns>
|
|
public static StringBuilder AppendElseIfPreprocessor(this StringBuilder builder, UhtDefineScope defineScope, UhtDefineScopeNames defineScopeNames = UhtDefineScopeNames.Standard)
|
|
{
|
|
if (defineScope != UhtDefineScope.None && defineScope != UhtDefineScope.Invalid)
|
|
{
|
|
builder.Append("#elif ").AppendScopeExpression(defineScope, defineScopeNames).Append("\r\n");
|
|
}
|
|
return builder;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Start an #endif block with the given scope
|
|
/// </summary>
|
|
/// <param name="builder">String builder</param>
|
|
/// <param name="defineScope">Scope</param>
|
|
/// <param name="defineScopeNames">Which set of scope names will be used</param>
|
|
/// <returns>String builder</returns>
|
|
public static StringBuilder AppendEndIfPreprocessor(this StringBuilder builder, UhtDefineScope defineScope, UhtDefineScopeNames defineScopeNames = UhtDefineScopeNames.Standard)
|
|
{
|
|
if (defineScope != UhtDefineScope.None && defineScope != UhtDefineScope.Invalid)
|
|
{
|
|
builder.Append("#endif // ").AppendScopeExpression(defineScope, defineScopeNames).Append("\r\n");
|
|
}
|
|
return builder;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Append scope expression (i.e. WITH_X && WITH_Y && ...)
|
|
/// </summary>
|
|
/// <param name="builder">String builder</param>
|
|
/// <param name="defineScope">Scope</param>
|
|
/// <param name="defineScopeNames">Which set of scope names will be used</param>
|
|
/// <returns>String builder</returns>
|
|
public static StringBuilder AppendScopeExpression(this StringBuilder builder, UhtDefineScope defineScope, UhtDefineScopeNames defineScopeNames)
|
|
{
|
|
if (defineScope != UhtDefineScope.None && defineScope != UhtDefineScope.Invalid)
|
|
{
|
|
int scopes = (int)defineScope;
|
|
bool needAnd = false;
|
|
for (int mask = 1; mask <= scopes; mask <<= 1)
|
|
{
|
|
if ((mask & scopes) != 0)
|
|
{
|
|
if (needAnd)
|
|
{
|
|
builder.Append(" && ");
|
|
}
|
|
builder.Append(((UhtDefineScope)(mask & scopes)).GetCompilerDirective(defineScopeNames).GetCompilerDirectiveText());
|
|
needAnd = true;
|
|
}
|
|
}
|
|
}
|
|
return builder;
|
|
}
|
|
|
|
private static StringBuilder AppendCppName(this StringBuilder builder, string? staticsName, string arrayName)
|
|
{
|
|
if (!String.IsNullOrEmpty(staticsName))
|
|
{
|
|
builder.Append(staticsName).Append("::");
|
|
}
|
|
return builder.Append(arrayName);
|
|
}
|
|
}
|
|
}
|