public static Type GetTypeFromTypeStringWithErrors(this TypeResolverGroup typeResolverGroup, string typeString)
{
var type = typeResolverGroup.GetTypeFromTypeString(typeString);
if (type == null)
{
Debug.LogError($"Unable to find type {typeString} in type resolver group");
}
return(type);
}
public static void AddTypeInterfaces(this Type type, HashSet <string> interfaces,
TypeResolverGroup typeResolverGroup)
{
if (type == null)
{
return;
}
foreach (var Interface in type.GetInterfaces())
{
if (typeResolverGroup.GetTypeFromTypeString(UdonTypeExporter.GenerateUdonName(Interface)) != null)
{
interfaces.Add(UdonTypeExporter.GetTypeFullName(Interface));
Interface.AddTypeInterfaces(interfaces, typeResolverGroup);
}
}
}
private void HandlePushEnumInstruction(string rawLine, string[] instructionArgs, Stack <object> stack,
TypeResolverGroup typeResolver)
{
if (instructionArgs.Length != 3)
{
throw new InvalidOperationException(
$"PUSHENUM requires 2 arguments(EnumType, EnumValueName). EX: 'PUSHENUM UnityEngineFFTWindow Rectangular'");
}
var enumName = instructionArgs[1];
var enumValueName = instructionArgs[2];
var enumType = typeResolver.GetTypeFromTypeString(enumName);
if (enumType == null)
{
throw new InvalidOperationException(
$"Unable to find type '{enumName}'.");
}
object output = Enum.Parse(enumType, enumValueName);
stack.Push(output);
}
private void HandleConstructInstruction(string rawLine, string[] instructionArgs, Stack <object> stack,
TypeResolverGroup typeResolver)
{
if (instructionArgs.Length != 3)
{
throw new InvalidOperationException(
$"CONSTRUCT instruction requires 2 arguments(TypeName, ArgumentCount). EX: 'CONSTRUCT UnityEngineVector2 2'");
}
var typeName = instructionArgs[1];
var constructorArgumentcount = int.Parse(instructionArgs[2]);
Stack <object> flipped = new Stack <object>();
for (int i = 0; i < constructorArgumentcount; i++)
{
flipped.Push(stack.Pop());
}
object obj = Activator.CreateInstance(typeResolver.GetTypeFromTypeString(typeName), flipped.ToArray());
stack.Push(obj);
}
private static string RecurseInheritedType(Type originalType, Type type, TypeResolverGroup typeResolverGroup)
{
if (type == null || type == typeof(object))
{
return("");
}
if (originalType == type)
{
return(RecurseInheritedType(originalType, type.BaseType, typeResolverGroup));
}
if (typeResolverGroup.GetTypeFromTypeString(UdonTypeExporter.GenerateUdonName(type)) != null)
{
return(UdonTypeExporter.GetTypeFullName(type));
}
if (type.BaseType != null)
{
return(RecurseInheritedType(originalType, type.BaseType, typeResolverGroup));
}
return("");
}
public static TDType GetOrCreateTDType(TDType rootType, string fullName, TypeResolverGroup typeResolverGroup)
{
bool containsGenericArguments = fullName.Contains("<");
Queue <string> namespaces;
string genericArguments = null;
if (containsGenericArguments) //Generic types
{
var match = GenericsRegex.Match(fullName);
var groups = match.Groups;
var baseType = groups["GenericBaseType"].ToString();
genericArguments = groups["GenericArguments"].ToString();
namespaces = new Queue <string>(baseType.Split('.'));
}
else
{
namespaces = new Queue <string>(fullName.Split('.'));
}
var current = rootType;
while (namespaces.Count > 0)
{
var name = namespaces.Dequeue();
//Only the full string is "generic", so it must be the last thing in the queue.
//IE. System.Collections.Generic isn't generic itself, but System.Collections.Generic.List is generic
bool isGeneric = containsGenericArguments && namespaces.Count == 0;
var child = current.Children.Find(x =>
x.TypeName == name && x.IsGeneric == isGeneric && genericArguments == x.InputGenericArguments);
if (child != null)
{
//Go down tree
current = child;
}
else
{
//Create an go down tree
var type = new TDType
{
NamespaceName = current.FullName,
FullName = (current.FullName != null ? current.FullName + "." : "") + name,
TypeName = name,
InputGenericArguments = genericArguments
};
string attemptedUdonName =
GenerateUdonName(type.FullName, true); //Try to generate udon name and set it if it's correct.
if (typeResolverGroup.GetTypeFromTypeString(attemptedUdonName) != null)
{
type.UdonName = attemptedUdonName;
}
current.Children.Add(type);
current = type;
current.IsGeneric = isGeneric;
}
}
if (current.IsGeneric)
{
current.IsGeneric = true;
if (!genericArguments.Contains("<"))
{
current.AddGenericArguments(rootType, typeResolverGroup, genericArguments.Replace(" ", "").Split(','));
}
else
{
//Only one thing contains a nested generic argument in Udon currently
//and luckily it looks like "thing<other<something, else>>"
//which means it's a single layer of nesting
//So for now we can just pass "other<something, else>" to GetOrCreateTDType
//In the future this might change?
current.AddGenericArguments(rootType, typeResolverGroup, genericArguments);
}
}
if (fullName.Contains("[]"))
{
//Add base type for arrays
GetOrCreateTDType(rootType, fullName.Replace("[]", ""), typeResolverGroup);
}
return(current);
}
private void HandlePushInstruction(string rawLine, string[] instructionArgs, Stack <object> stack,
TypeResolverGroup typeResolver)
{
if (instructionArgs.Length < 3)
{
throw new InvalidOperationException(
$"PUSH instruction requires 2 arguments(TypeName, literal). EX: 'PUSH SystemSingle 5'");
}
var typeName = instructionArgs[1];
var literal = rawLine.Substring(rawLine.IndexOf(typeName) + typeName.Length + 1);
object output = null;
switch (typeName)
{
case "SystemSingle":
output = Single.Parse(literal);
break;
case "SystemDouble":
output = Double.Parse(literal);
break;
case "SystemInt64":
output = Int64.Parse(literal);
break;
case "SystemInt32":
output = Int32.Parse(literal);
break;
case "SystemInt16":
output = Int16.Parse(literal);
break;
case "SystemUInt64":
output = UInt64.Parse(literal);
break;
case "SystemUInt32":
output = UInt32.Parse(literal);
break;
case "SystemUInt16":
output = UInt16.Parse(literal);
break;
case "SystemString":
output = literal.Trim('"');
break;
case "SystemBoolean":
output = Boolean.Parse(literal);
break;
case "SystemChar":
output = char.Parse(literal);
break;
case "SystemByte":
output = byte.Parse(literal);
break;
case "SystemSByte":
output = sbyte.Parse(literal);
break;
case "SystemType":
output = typeResolver.GetTypeFromTypeString(literal);
if (output == null)
{
throw new InvalidOperationException(
$"Unable to find type '{literal}'.");
}
break;
default:
throw new InvalidOperationException($"PUSH literal unsupported for type {typeName}");
}
stack.Push(output);
}
