private static void UnaryDecrement(UnionOperatorDefinition def, StringBuilder builder)
{
var unionName = def.UnionDefinition.Name;
var members = def.UnionDefinition.Members;
var pre_ = def.UnionDefinition.GetMemberPrefix();
builder.Append($@"
public static {unionName} operator --(in {unionName} operand)
{{");
builder.Append($@"
switch (operand.{pre_}ValueType)
{{");
foreach (var member in members)
{
var cast = BuiltInTypeHelper.GetPrimitiveCast(member.Type);
builder.Append($@"
case Type.{member.Name}: return new {unionName}({cast}(operand.{pre_}{member.Name} - 1));");
}
builder.Append($@"
}}
return operand;
}}
");
}
private static void UnaryBitwiseComplement(UnionOperatorDefinition def, StringBuilder builder)
{
var unionName = def.UnionDefinition.Name;
var members = def.UnionDefinition.Members;
var pre_ = def.UnionDefinition.GetMemberPrefix();
builder.Append($@"
public static {unionName} operator ~(in {unionName} operand)
{{");
builder.Append($@"
switch (operand.{pre_}ValueType)
{{");
foreach (var member in members)
{
if (BuiltInTypeHelper.IsFloat(member.Type) ||
BuiltInTypeHelper.IsDouble(member.Type))
{
continue;
}
var cast = BuiltInTypeHelper.GetPrimitiveCast(member.Type);
builder.Append($@"
case Type.{member.Name}: return new {unionName}({cast}~operand.{pre_}{member.Name});");
}
builder.Append($@"
}}
return operand;
}}
");
}
// Do lexical parse in constructor
public Lex(string signature)
{
lexSignature = string.Empty;
identifiers = new List <string>();
string[] segments = signature.Split(new char[] { ' ', '\t', '\n' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string segment in segments)
{
string temp = segment;
while (temp != string.Empty)
{
string symbol = null;
if (ParseLexSymbol(separatorPattern, ref temp, out symbol))
{
lexSignature += symbol;
continue;
}
if (ParseLexSymbol(staticPattern, ref temp, out symbol))
{
lexSignature += '!';
continue;
}
if (ParseLexSymbol(refPattern, ref temp, out symbol))
{
lexSignature += '&';
continue;
}
if (ParseLexSymbol(paramsPattern, ref temp, out symbol))
{
lexSignature += '%';
continue;
}
if (ParseLexSymbol(identifierPattern, ref temp, out symbol))
{
if (BuiltInTypeHelper.AliasToFullName(symbol) != null)
{
lexSignature += symbol;
}
else
{
int i = identifiers.IndexOf(symbol);
if (i == -1)
{
identifiers.Add(symbol);
i = identifiers.Count - 1;
}
lexSignature += string.Format(CultureInfo.InvariantCulture, "#{0}#", i);
}
continue;
}
throw new FaultInjectionException();
}
}
}
public PlainTypeName(string plainType)
{
builtInTypeFullName = BuiltInTypeHelper.AliasToFullName(plainType);
if (builtInTypeFullName == null)
{
string[] temp = SplitAtTopLevel(plainType, '.');
names = Array.ConvertAll <string, Name>(temp, delegate(string name) { return(new Name(name)); });
className = names[names.Length - 1].identifier;
}
else
{
string[] temp = builtInTypeFullName.Split('.');
className = temp[temp.Length - 1];
}
}
private static void BinaryOperatorReturnBool(UnionOperatorDefinition def, string op, StringBuilder builder)
{
var unionName = def.UnionDefinition.Name;
var members = def.UnionDefinition.Members;
var pre_ = def.UnionDefinition.GetMemberPrefix();
builder.Append($@"
public static bool operator {op}(in {unionName} lhs, in {unionName} rhs)
{{");
builder.Append($@"
switch (lhs.{pre_}ValueType)
{{");
for (var i = 0; i < members.Count; i++)
{
var lhs = members[i];
builder.Append($@"
case Type.{lhs.Name}:
{{
switch (rhs.{pre_}ValueType)
{{");
for (var k = 0; k < members.Count; k++)
{
var rhs = members[k];
BuiltInTypeHelper.GetPrimitiveCast(lhs.Type, rhs.Type, out var lhsCast, out var rhsCast);
builder.Append($@"
case Type.{rhs.Name}: return {lhsCast}lhs.{pre_}{lhs.Name} {op} {rhsCast}rhs.{pre_}{rhs.Name};");
}
builder.Append(@"
}
return false;
}");
}
builder.Append(@"
}
return false;
}
");
}
private static void BinaryOperatorStrict(UnionOperatorDefinition def, string op, StringBuilder builder)
{
var unionName = def.UnionDefinition.Name;
var throwException = def.UnionDefinition.InvalidValueAccess == InvalidValueAccess.ThrowException;
var members = def.UnionDefinition.Members;
var pre_ = def.UnionDefinition.GetMemberPrefix();
builder.Append($@"
public static {unionName} operator {op}(in {unionName} lhs, in {unionName} rhs)
{{");
if (throwException)
{
builder.Append($@"
if (lhs.{pre_}ValueType != rhs.{pre_}ValueType)
throw new InvalidCastException($""Cannot cast right operand from '{{rhs.GetUnderlyingType().GetNiceFullName()}}' to '{{lhs.GetUnderlyingType().GetNiceFullName()}}'"");
");
}
else
{
builder.Append($@"
if (lhs.{pre_}ValueType != rhs.{pre_}ValueType)
return new {unionName}(lhs.{pre_}ValueType);
");
}
builder.Append($@"
switch (lhs.{pre_}ValueType)
{{");
foreach (var member in members)
{
var cast = BuiltInTypeHelper.GetPrimitiveCast(member.Type);
builder.Append($@"
case Type.{member.Name}: return new {unionName}({cast}(lhs.{pre_}{member.Name} {op} rhs.{pre_}{member.Name}));");
}
builder.Append($@"
}}
return new {unionName}(lhs.{pre_}ValueType);
}}
");
}
/// <summary>
/// Get type from current appDomain or specific assembly, supporting nested class names
/// </summary>
/// <param name="typeName">type name</param>
/// <param name="assemblyName">assembly file path</param>
/// <param name="alternativeAssemblyName">alternative assembly name</param>
/// <returns>return type</returns>
private static Type GetType(string typeName, string assemblyName, string alternativeAssemblyName)
{
//get assemblies
List <Assembly> assemblyList = new List <Assembly>();
if (!string.IsNullOrEmpty(assemblyName))
{
assemblyList.Add(LoadAssembly(assemblyName));
}
else
{
if (!string.IsNullOrEmpty(alternativeAssemblyName))
{
assemblyList.Add(LoadAssembly(alternativeAssemblyName));
}
//get type from current appDomain
assemblyList.AddRange(AppDomain.CurrentDomain.GetAssemblies());
}
Assembly[] assemblies = assemblyList.ToArray();
//Trim white spaces
typeName = typeName.Trim();
//Change known buitin type with full name
string fullName = BuiltInTypeHelper.AliasToFullName(typeName);
if (fullName == null)
{
fullName = typeName;
}
Type type = null;
foreach (Assembly assembly in assemblies)
{
string reflectionTypeName = fullName;
do
{
type = assembly.GetType(reflectionTypeName);
if (type != null)
{
break;
}
int lastPeriod = reflectionTypeName.LastIndexOf('.');
if (lastPeriod < 0)
{
break;
}
reflectionTypeName = reflectionTypeName.Substring(0, lastPeriod) + '+' + reflectionTypeName.Substring(lastPeriod + 1, reflectionTypeName.Length - lastPeriod - 1);
} while (true);
if (type != null)
{
break;
}
}
if (type == null)
{
if (typeName.StartsWith(EngineInfo.NameSpace, StringComparison.Ordinal))
{
typeName = typeName.Substring(EngineInfo.NameSpace.Length + ".".Length, typeName.Length - EngineInfo.NameSpace.Length - ".".Length);
}
throw new FaultInjectionException(string.Format(CultureInfo.CurrentCulture, XmlErrorMessages.TargetTypeNotFound, typeName));
}
return(type);
}
