static CXXOperatorKind CheckMissingOperatorOverloadPair(Class @class, out int index,
CXXOperatorKind op1, CXXOperatorKind op2, Type typeLeft, Type typeRight)
{
var first = @class.Operators.FirstOrDefault(o => o.OperatorKind == op1 &&
o.Parameters.First().Type.Equals(typeLeft) && o.Parameters.Last().Type.Equals(typeRight));
var second = @class.Operators.FirstOrDefault(o => o.OperatorKind == op2 &&
o.Parameters.First().Type.Equals(typeLeft) && o.Parameters.Last().Type.Equals(typeRight));
var hasFirst = first != null;
var hasSecond = second != null;
if (hasFirst && (!hasSecond || !second.IsGenerated))
{
index = @class.Methods.IndexOf(first);
return op2;
}
if (hasSecond && (!hasFirst || !first.IsGenerated))
{
index = @class.Methods.IndexOf(second);
return op1;
}
index = 0;
return CXXOperatorKind.None;
}
static CXXOperatorKind CheckMissingOperatorOverloadPair(Class @class,
out int index, CXXOperatorKind op1, CXXOperatorKind op2, Type type)
{
var first = @class.Operators.FirstOrDefault(o => o.OperatorKind == op1 &&
o.Parameters.Last().Type.Equals(type));
var second = @class.Operators.FirstOrDefault(o => o.OperatorKind == op2 &&
o.Parameters.Last().Type.Equals(type));
var hasFirst = first != null;
var hasSecond = second != null;
if (hasFirst && (!hasSecond || !second.IsGenerated))
{
index = @class.Methods.IndexOf(first);
return(op2);
}
if (hasSecond && (!hasFirst || !first.IsGenerated))
{
index = @class.Methods.IndexOf(second);
return(op1);
}
index = 0;
return(CXXOperatorKind.None);
}
public static string GetOperatorOverloadPair(CXXOperatorKind kind)
{
switch (kind)
{
case CXXOperatorKind.EqualEqual:
return("!=");
case CXXOperatorKind.ExclaimEqual:
return("==");
case CXXOperatorKind.Less:
return(">");
case CXXOperatorKind.Greater:
return("<");
case CXXOperatorKind.LessEqual:
return(">=");
case CXXOperatorKind.GreaterEqual:
return("<=");
default:
throw new NotSupportedException();
}
}
private static void HandleMissingOperatorOverloadPair(Class @class, CXXOperatorKind op1,
CXXOperatorKind op2)
{
foreach (var op in @class.Operators.Where(
o => o.OperatorKind == op1 || o.OperatorKind == op2).ToList())
{
int index;
var missingKind = CheckMissingOperatorOverloadPair(@class, out index, op1, op2,
op.Parameters.First().Type, op.Parameters.Last().Type);
if (missingKind == CXXOperatorKind.None || !op.IsGenerated)
continue;
var method = new Method()
{
Name = Operators.GetOperatorIdentifier(missingKind),
Namespace = @class,
SynthKind = FunctionSynthKind.ComplementOperator,
Kind = CXXMethodKind.Operator,
OperatorKind = missingKind,
ReturnType = op.ReturnType,
Parameters = op.Parameters
};
@class.Methods.Insert(index, method);
}
}
static void HandleMissingOperatorOverloadPair(Class @class, CXXOperatorKind op1,
CXXOperatorKind op2)
{
foreach (var op in @class.Operators.Where(
o => o.OperatorKind == op1 || o.OperatorKind == op2).ToList())
{
int index;
var missingKind = CheckMissingOperatorOverloadPair(@class, out index, op1, op2,
op.Parameters.Last().Type);
if (missingKind == CXXOperatorKind.None || !op.IsGenerated)
{
continue;
}
var method = new Method()
{
Name = Operators.GetOperatorIdentifier(missingKind),
Namespace = @class,
SynthKind = FunctionSynthKind.ComplementOperator,
Kind = CXXMethodKind.Operator,
OperatorKind = missingKind,
ReturnType = op.ReturnType,
Parameters = op.Parameters
};
@class.Methods.Insert(index, method);
}
}
public static bool IsBuiltinOperator(CXXOperatorKind kind)
{
bool isBuiltin;
GetOperatorIdentifier(kind, out isBuiltin);
return(isBuiltin);
}
public override IEnumerable <Function> FindOperator(CXXOperatorKind kind)
{
return(Methods.Where(m => m.OperatorKind == kind));
}
AST.CXXOperatorKind VisitCXXOperatorKind(CXXOperatorKind operatorKind)
{
switch (operatorKind)
{
case CXXOperatorKind.None:
return(AST.CXXOperatorKind.None);
case CXXOperatorKind.New:
return(AST.CXXOperatorKind.New);
case CXXOperatorKind.Delete:
return(AST.CXXOperatorKind.Delete);
case CXXOperatorKind.Array_New:
return(AST.CXXOperatorKind.Array_New);
case CXXOperatorKind.Array_Delete:
return(AST.CXXOperatorKind.Array_Delete);
case CXXOperatorKind.Plus:
return(AST.CXXOperatorKind.Plus);
case CXXOperatorKind.Minus:
return(AST.CXXOperatorKind.Minus);
case CXXOperatorKind.Star:
return(AST.CXXOperatorKind.Star);
case CXXOperatorKind.Slash:
return(AST.CXXOperatorKind.Slash);
case CXXOperatorKind.Percent:
return(AST.CXXOperatorKind.Percent);
case CXXOperatorKind.Caret:
return(AST.CXXOperatorKind.Caret);
case CXXOperatorKind.Amp:
return(AST.CXXOperatorKind.Amp);
case CXXOperatorKind.Pipe:
return(AST.CXXOperatorKind.Pipe);
case CXXOperatorKind.Tilde:
return(AST.CXXOperatorKind.Tilde);
case CXXOperatorKind.Exclaim:
return(AST.CXXOperatorKind.Exclaim);
case CXXOperatorKind.Equal:
return(AST.CXXOperatorKind.Equal);
case CXXOperatorKind.Less:
return(AST.CXXOperatorKind.Less);
case CXXOperatorKind.Greater:
return(AST.CXXOperatorKind.Greater);
case CXXOperatorKind.PlusEqual:
return(AST.CXXOperatorKind.PlusEqual);
case CXXOperatorKind.MinusEqual:
return(AST.CXXOperatorKind.MinusEqual);
case CXXOperatorKind.StarEqual:
return(AST.CXXOperatorKind.StarEqual);
case CXXOperatorKind.SlashEqual:
return(AST.CXXOperatorKind.SlashEqual);
case CXXOperatorKind.PercentEqual:
return(AST.CXXOperatorKind.PercentEqual);
case CXXOperatorKind.CaretEqual:
return(AST.CXXOperatorKind.CaretEqual);
case CXXOperatorKind.AmpEqual:
return(AST.CXXOperatorKind.AmpEqual);
case CXXOperatorKind.PipeEqual:
return(AST.CXXOperatorKind.PipeEqual);
case CXXOperatorKind.LessLess:
return(AST.CXXOperatorKind.LessLess);
case CXXOperatorKind.GreaterGreater:
return(AST.CXXOperatorKind.GreaterGreater);
case CXXOperatorKind.LessLessEqual:
return(AST.CXXOperatorKind.LessLessEqual);
case CXXOperatorKind.GreaterGreaterEqual:
return(AST.CXXOperatorKind.GreaterGreaterEqual);
case CXXOperatorKind.EqualEqual:
return(AST.CXXOperatorKind.EqualEqual);
case CXXOperatorKind.ExclaimEqual:
return(AST.CXXOperatorKind.ExclaimEqual);
case CXXOperatorKind.LessEqual:
return(AST.CXXOperatorKind.LessEqual);
case CXXOperatorKind.GreaterEqual:
return(AST.CXXOperatorKind.GreaterEqual);
case CXXOperatorKind.AmpAmp:
return(AST.CXXOperatorKind.AmpAmp);
case CXXOperatorKind.PipePipe:
return(AST.CXXOperatorKind.PipePipe);
case CXXOperatorKind.PlusPlus:
return(AST.CXXOperatorKind.PlusPlus);
case CXXOperatorKind.MinusMinus:
return(AST.CXXOperatorKind.MinusMinus);
case CXXOperatorKind.Comma:
return(AST.CXXOperatorKind.Comma);
case CXXOperatorKind.ArrowStar:
return(AST.CXXOperatorKind.ArrowStar);
case CXXOperatorKind.Arrow:
return(AST.CXXOperatorKind.Arrow);
case CXXOperatorKind.Call:
return(AST.CXXOperatorKind.Call);
case CXXOperatorKind.Subscript:
return(AST.CXXOperatorKind.Subscript);
case CXXOperatorKind.Conditional:
return(AST.CXXOperatorKind.Conditional);
default:
throw new ArgumentOutOfRangeException("operatorKind");
}
}
public static string GetOperatorIdentifier(CXXOperatorKind kind,
out bool isBuiltin)
{
isBuiltin = true;
// These follow the order described in MSDN (Overloadable Operators).
switch (kind)
{
// These unary operators can be overloaded
case CXXOperatorKind.Plus: return("operator +");
case CXXOperatorKind.Minus: return("operator -");
case CXXOperatorKind.Exclaim: return("operator !");
case CXXOperatorKind.Tilde: return("operator ~");
case CXXOperatorKind.PlusPlus: return("operator ++");
case CXXOperatorKind.MinusMinus: return("operator --");
// These binary operators can be overloaded
case CXXOperatorKind.Star: return("operator *");
case CXXOperatorKind.Slash: return("operator /");
case CXXOperatorKind.Percent: return("operator %");
case CXXOperatorKind.Amp: return("operator &");
case CXXOperatorKind.Pipe: return("operator |");
case CXXOperatorKind.Caret: return("operator ^");
case CXXOperatorKind.LessLess: return("operator <<");
case CXXOperatorKind.GreaterGreater: return("operator >>");
// The comparison operators can be overloaded
case CXXOperatorKind.EqualEqual: return("operator ==");
case CXXOperatorKind.ExclaimEqual: return("operator !=");
case CXXOperatorKind.Less: return("operator <");
case CXXOperatorKind.Greater: return("operator >");
case CXXOperatorKind.LessEqual: return("operator <=");
case CXXOperatorKind.GreaterEqual: return("operator >=");
// Assignment operators cannot be overloaded
case CXXOperatorKind.PlusEqual:
case CXXOperatorKind.MinusEqual:
case CXXOperatorKind.StarEqual:
case CXXOperatorKind.SlashEqual:
case CXXOperatorKind.PercentEqual:
case CXXOperatorKind.AmpEqual:
case CXXOperatorKind.PipeEqual:
case CXXOperatorKind.CaretEqual:
case CXXOperatorKind.LessLessEqual:
case CXXOperatorKind.GreaterGreaterEqual:
// The array indexing operator cannot be overloaded
case CXXOperatorKind.Subscript:
// The conditional logical operators cannot be overloaded
case CXXOperatorKind.AmpAmp:
case CXXOperatorKind.PipePipe:
// These operators cannot be overloaded.
case CXXOperatorKind.Equal:
case CXXOperatorKind.Comma:
case CXXOperatorKind.ArrowStar:
case CXXOperatorKind.Arrow:
case CXXOperatorKind.Call:
case CXXOperatorKind.Conditional:
case CXXOperatorKind.Coawait:
case CXXOperatorKind.New:
case CXXOperatorKind.Delete:
case CXXOperatorKind.Array_New:
case CXXOperatorKind.Array_Delete:
isBuiltin = false;
return("Operator" + kind.ToString());
case CXXOperatorKind.Conversion:
return("implicit operator");
case CXXOperatorKind.ExplicitConversion:
return("explicit operator");
}
throw new NotSupportedException();
}
public static string GetOperatorIdentifier(CXXOperatorKind kind)
{
return(GetOperatorIdentifier(kind, out _));
}
public static bool IsBuiltinOperator(CXXOperatorKind kind)
{
bool isBuiltin;
GetOperatorIdentifier(kind, out isBuiltin);
return isBuiltin;
}
public static string GetOperatorOverloadPair(CXXOperatorKind kind)
{
switch (kind)
{
case CXXOperatorKind.EqualEqual:
return "!=";
case CXXOperatorKind.ExclaimEqual:
return "==";
case CXXOperatorKind.Less:
return ">";
case CXXOperatorKind.Greater:
return "<";
case CXXOperatorKind.LessEqual:
return ">=";
case CXXOperatorKind.GreaterEqual:
return "<=";
default:
throw new NotSupportedException();
}
}
public static string GetOperatorIdentifier(CXXOperatorKind kind,
out bool isBuiltin)
{
isBuiltin = true;
// These follow the order described in MSDN (Overloadable Operators).
switch (kind)
{
// These unary operators can be overloaded
case CXXOperatorKind.Plus: return "operator +";
case CXXOperatorKind.Minus: return "operator -";
case CXXOperatorKind.Exclaim: return "operator !";
case CXXOperatorKind.Tilde: return "operator ~";
case CXXOperatorKind.PlusPlus: return "operator ++";
case CXXOperatorKind.MinusMinus: return "operator --";
// These binary operators can be overloaded
case CXXOperatorKind.Star: return "operator *";
case CXXOperatorKind.Slash: return "operator /";
case CXXOperatorKind.Percent: return "operator +";
case CXXOperatorKind.Amp: return "operator &";
case CXXOperatorKind.Pipe: return "operator |";
case CXXOperatorKind.Caret: return "operator ^";
case CXXOperatorKind.LessLess: return "operator <<";
case CXXOperatorKind.GreaterGreater: return "operator >>";
// The comparison operators can be overloaded
case CXXOperatorKind.EqualEqual: return "operator ==";
case CXXOperatorKind.ExclaimEqual: return "operator !=";
case CXXOperatorKind.Less: return "operator <";
case CXXOperatorKind.Greater: return "operator >";
case CXXOperatorKind.LessEqual: return "operator <=";
case CXXOperatorKind.GreaterEqual: return "operator >=";
// Assignment operators cannot be overloaded
case CXXOperatorKind.PlusEqual:
case CXXOperatorKind.MinusEqual:
case CXXOperatorKind.StarEqual:
case CXXOperatorKind.SlashEqual:
case CXXOperatorKind.PercentEqual:
case CXXOperatorKind.AmpEqual:
case CXXOperatorKind.PipeEqual:
case CXXOperatorKind.CaretEqual:
case CXXOperatorKind.LessLessEqual:
case CXXOperatorKind.GreaterGreaterEqual:
// The array indexing operator cannot be overloaded
case CXXOperatorKind.Subscript:
// The conditional logical operators cannot be overloaded
case CXXOperatorKind.AmpAmp:
case CXXOperatorKind.PipePipe:
// These operators cannot be overloaded.
case CXXOperatorKind.Equal:
case CXXOperatorKind.Comma:
case CXXOperatorKind.ArrowStar:
case CXXOperatorKind.Arrow:
case CXXOperatorKind.Call:
case CXXOperatorKind.Conditional:
case CXXOperatorKind.New:
case CXXOperatorKind.Delete:
case CXXOperatorKind.Array_New:
case CXXOperatorKind.Array_Delete:
isBuiltin = false;
return "Operator" + kind.ToString();
case CXXOperatorKind.Conversion:
return "implicit operator";
case CXXOperatorKind.ExplicitConversion:
return "explicit operator";
}
throw new NotSupportedException();
}
public static string GetOperatorIdentifier(CXXOperatorKind kind)
{
bool isBuiltin;
return GetOperatorIdentifier(kind, out isBuiltin);
}
public static string GetOperatorIdentifier(CXXOperatorKind kind)
{
bool isBuiltin;
return(GetOperatorIdentifier(kind, out isBuiltin));
}
public virtual IEnumerable <Function> FindOperator(CXXOperatorKind kind)
{
return(Functions.Where(fn => fn.OperatorKind == kind));
}
public static IEnumerable <Method> FindOperator(this Class c, CXXOperatorKind kind)
{
return(c.Operators.Where(method => method.OperatorKind == kind));
}
public IEnumerable <Method> FindOperator(CXXOperatorKind kind)
{
return(Operators.Where(method => method.OperatorKind == kind));
}
