pimhwang
/
CppSharp
mirror of https://github.com/mono/CppSharp.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Cleaned up operator overload helpers.

pull/47/merge
triton 12 years ago
parent
14dbe76e9d
commit
c8abdeb192
3 changed files with 122 additions and 110 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 114
      src/Generator/AST/Utils.cs
  2. 115
      src/Generator/Generators/CSharp/CSharpTextTemplate.cs
  3. 3
      src/Generator/Passes/CheckOperatorsOverloads.cs

114
src/Generator/AST/Utils.cs
Unescape View File

@ -1,4 +1,6 @@
 
using System;
namespace CppSharp.AST namespace CppSharp.AST
{ {
public static class ASTUtils public static class ASTUtils
@ -49,4 +51,116 @@ namespace CppSharp.AST
return field.Ignore; return field.Ignore;
} }
} }
public static class Operators
{
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 bool IsBuiltinOperator(CXXOperatorKind kind)
{
bool isBuiltin;
GetOperatorIdentifier(kind, out isBuiltin);
return isBuiltin;
}
public static string GetOperatorIdentifier(CXXOperatorKind kind)
{
bool isBuiltin;
return GetOperatorIdentifier(kind, out isBuiltin);
}
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();
}
throw new NotSupportedException();
}
}
} }

115
src/Generator/Generators/CSharp/CSharpTextTemplate.cs
Unescape View File

@ -1456,14 +1456,13 @@ namespace CppSharp.Generators.CSharp
Write("public "); Write("public ");
var isBuiltinOperator = false;
if (method.IsOperator)
GetOperatorIdentifier(method.OperatorKind, out isBuiltinOperator);
if (method.IsVirtual && !method.IsOverride) if (method.IsVirtual && !method.IsOverride)
Write("virtual "); Write("virtual ");
if (method.IsStatic || (method.IsOperator && isBuiltinOperator)) var isBuiltinOperator = method.IsOperator &&
Operators.IsBuiltinOperator(method.OperatorKind);
if (method.IsStatic || isBuiltinOperator)
Write("static "); Write("static ");
if (method.IsOverride) if (method.IsOverride)
@ -1525,35 +1524,11 @@ namespace CppSharp.Generators.CSharp
PopBlock(NewLineKind.BeforeNextBlock); PopBlock(NewLineKind.BeforeNextBlock);
} }
private 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 void GenerateOperator(Method method, Class @class) private void GenerateOperator(Method method, Class @class)
{ {
if (method.IsSynthetized) if (method.IsSynthetized)
{ {
var @operator = GetOperatorOverloadPair(method.OperatorKind); var @operator = Operators.GetOperatorOverloadPair(method.OperatorKind);
WriteLine("return !({0} {1} {2});", method.Parameters[0].Name, WriteLine("return !({0} {1} {2});", method.Parameters[0].Name,
@operator, method.Parameters[1].Name); @operator, method.Parameters[1].Name);
@ -1614,11 +1589,7 @@ namespace CppSharp.Generators.CSharp
needsInstance = !method.IsStatic; needsInstance = !method.IsStatic;
if (method.IsOperator) if (method.IsOperator)
{ needsInstance &= !Operators.IsBuiltinOperator(method.OperatorKind);
bool isBuiltin;
GetOperatorIdentifier(method.OperatorKind, out isBuiltin);
needsInstance &= !isBuiltin;
}
} }
var needsFixedThis = needsInstance && isValueType; var needsFixedThis = needsInstance && isValueType;
@ -1945,77 +1916,6 @@ namespace CppSharp.Generators.CSharp
PopBlock(NewLineKind.BeforeNextBlock); PopBlock(NewLineKind.BeforeNextBlock);
} }
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();
}
throw new NotSupportedException();
}
public static string GetFunctionIdentifier(Function function) public static string GetFunctionIdentifier(Function function)
{ {
var identifier = SafeIdentifier(function.Name); var identifier = SafeIdentifier(function.Name);
@ -2024,8 +1924,7 @@ namespace CppSharp.Generators.CSharp
if (method == null || !method.IsOperator) if (method == null || !method.IsOperator)
return identifier; return identifier;
bool isBuiltin; identifier = Operators.GetOperatorIdentifier(method.OperatorKind);
identifier = GetOperatorIdentifier(method.OperatorKind, out isBuiltin);
return identifier; return identifier;
} }

3
src/Generator/Passes/CheckOperatorsOverloads.cs
Unescape View File

@ -87,10 +87,9 @@ namespace CppSharp.Passes
if (op.Ignore) continue; if (op.Ignore) continue;
bool isBuiltin;
var method = new Method() var method = new Method()
{ {
Name = CSharpTextTemplate.GetOperatorIdentifier(missingKind, out isBuiltin), Name = Operators.GetOperatorIdentifier(missingKind),
Namespace = @class, Namespace = @class,
IsSynthetized = true, IsSynthetized = true,
Kind = CXXMethodKind.Operator, Kind = CXXMethodKind.Operator,

Write Preview
Loading…
Cancel
Save