@ -1,102 +1,102 @@
using System.Linq ; using System.Linq ;
using CppSharp.AST ; using CppSharp.AST ;
using CppSharp.AST.Extensions ; using CppSharp.AST.Extensions ;
using CppSharp.Generators ; using CppSharp.Generators ;
namespace CppSharp.Passes namespace CppSharp.Passes
{ {
/// <summary>
/// <summary>
/// Checks for missing operator overloads required by C#.
/// Checks for missing operator overloads required by C#.
/// </summary>
/// </summary>
class CheckOperatorsOverloadsPass : TranslationUnitPass class CheckOperatorsOverloadsPass : TranslationUnitPass
{ {
public CheckOperatorsOverloadsPass ( ) public CheckOperatorsOverloadsPass ( )
{ {
ClearVisitedDeclarations = false ; ClearVisitedDeclarations = false ;
} }
public override bool VisitClassDecl ( Class @class ) public override bool VisitClassDecl ( Class @class )
{ {
if ( @class . CompleteDeclaration ! = null ) if ( @class . CompleteDeclaration ! = null )
return VisitClassDecl ( @class . CompleteDeclaration as Class ) ; return VisitClassDecl ( @class . CompleteDeclaration as Class ) ;
if ( ! VisitDeclarationContext ( @class ) ) if ( ! VisitDeclarationContext ( @class ) )
return false ; return false ;
// Check for C++ operators that cannot be represented in C#.
// Check for C++ operators that cannot be represented in C#.
CheckInvalidOperators ( @class ) ; CheckInvalidOperators ( @class ) ;
if ( Driver . Options . IsCSharpGenerator ) if ( Driver . Options . IsCSharpGenerator )
{ {
// The comparison operators, if overloaded, must be overloaded in pairs;
// The comparison operators, if overloaded, must be overloaded in pairs;
// that is, if == is overloaded, != must also be overloaded. The reverse
// that is, if == is overloaded, != must also be overloaded. The reverse
// is also true, and similar for < and >, and for <= and >=.
// is also true, and similar for < and >, and for <= and >=.
HandleMissingOperatorOverloadPair ( @class , CXXOperatorKind . EqualEqual , HandleMissingOperatorOverloadPair ( @class , CXXOperatorKind . EqualEqual ,
CXXOperatorKind . ExclaimEqual ) ; CXXOperatorKind . ExclaimEqual ) ;
HandleMissingOperatorOverloadPair ( @class , CXXOperatorKind . Less , HandleMissingOperatorOverloadPair ( @class , CXXOperatorKind . Less ,
CXXOperatorKind . Greater ) ; CXXOperatorKind . Greater ) ;
HandleMissingOperatorOverloadPair ( @class , CXXOperatorKind . LessEqual , HandleMissingOperatorOverloadPair ( @class , CXXOperatorKind . LessEqual ,
CXXOperatorKind . GreaterEqual ) ; CXXOperatorKind . GreaterEqual ) ;
} }
return false ; return false ;
} }
private void CheckInvalidOperators ( Class @class ) private void CheckInvalidOperators ( Class @class )
{ {
foreach ( var @operator in @class . Operators . Where ( o = > o . IsGenerated ) ) foreach ( var @operator in @class . Operators . Where ( o = > o . IsGenerated ) )
{ {
if ( ! IsValidOperatorOverload ( @operator ) ) if ( ! IsValidOperatorOverload ( @operator ) )
{ {
Driver . Diagnostics . Debug ( DiagnosticId . InvalidOperatorOverload , Driver . Diagnostics . Debug ( DiagnosticId . InvalidOperatorOverload ,
"Invalid operator overload {0}::{1}" , "Invalid operator overload {0}::{1}" ,
@class . OriginalName , @operator . OperatorKind ) ; @class . OriginalName , @operator . OperatorKind ) ;
@operator . ExplicityIgnored = true ; @operator . ExplicitlyIgnore ( ) ;
continue ; continue ;
} }
if ( @operator . SynthKind = = FunctionSynthKind . NonMemberOperator ) if ( @operator . SynthKind = = FunctionSynthKind . NonMemberOperator )
continue ; continue ;
if ( @operator . OperatorKind = = CXXOperatorKind . Subscript ) if ( @operator . OperatorKind = = CXXOperatorKind . Subscript )
{ {
CreateIndexer ( @class , @operator ) ; CreateIndexer ( @class , @operator ) ;
} }
else else
{ {
// Handle missing operator parameters
// Handle missing operator parameters
if ( @operator . IsStatic ) if ( @operator . IsStatic )
@operator . Parameters = @operator . Parameters . Skip ( 1 ) . ToList ( ) ; @operator . Parameters = @operator . Parameters . Skip ( 1 ) . ToList ( ) ;
var type = new PointerType ( ) var type = new PointerType ( )
{ {
QualifiedPointee = new QualifiedType ( new TagType ( @class ) ) , QualifiedPointee = new QualifiedType ( new TagType ( @class ) ) ,
Modifier = PointerType . TypeModifier . LVReference Modifier = PointerType . TypeModifier . LVReference
} ; } ;
@operator . Parameters . Insert ( 0 , new Parameter @operator . Parameters . Insert ( 0 , new Parameter
{ {
Name = Generator . GeneratedIdentifier ( "op" ) , Name = Generator . GeneratedIdentifier ( "op" ) ,
QualifiedType = new QualifiedType ( type ) , QualifiedType = new QualifiedType ( type ) ,
Kind = ParameterKind . OperatorParameter Kind = ParameterKind . OperatorParameter
} ) ; } ) ;
} }
} }
} }
void CreateIndexer ( Class @class , Method @operator ) void CreateIndexer ( Class @class , Method @operator )
{ {
var property = new Property var property = new Property
{ {
Name = "Item" , Name = "Item" ,
QualifiedType = @operator . ReturnType , QualifiedType = @operator . ReturnType ,
Access = @operator . Access , Access = @operator . Access ,
Namespace = @class , Namespace = @class ,
GetMethod = @operator GetMethod = @operator
} ; } ;
if ( ! @operator . ReturnType . Qualifiers . IsConst & & @operator . ReturnType . Type . IsAddress ( ) ) if ( ! @operator . ReturnType . Qualifiers . IsConst & & @operator . ReturnType . Type . IsAddress ( ) )
property . SetMethod = @operator ; property . SetMethod = @operator ;
@ -114,148 +114,148 @@ namespace CppSharp.Passes
} }
property . Parameters . AddRange ( @operator . Parameters ) ; property . Parameters . AddRange ( @operator . Parameters ) ;
@class . Properties . Add ( property ) ; @class . Properties . Add ( property ) ;
@operator . GenerationKind = GenerationKind . Internal ; @operator . GenerationKind = GenerationKind . Internal ;
} }
static void HandleMissingOperatorOverloadPair ( Class @class , CXXOperatorKind op1 , static void HandleMissingOperatorOverloadPair ( Class @class , CXXOperatorKind op1 ,
CXXOperatorKind op2 ) CXXOperatorKind op2 )
{ {
foreach ( var op in @class . Operators . Where ( foreach ( var op in @class . Operators . Where (
o = > o . OperatorKind = = op1 | | o . OperatorKind = = op2 ) . ToList ( ) ) o = > o . OperatorKind = = op1 | | o . OperatorKind = = op2 ) . ToList ( ) )
{ {
int index ; int index ;
var missingKind = CheckMissingOperatorOverloadPair ( @class , out index , op1 , op2 , var missingKind = CheckMissingOperatorOverloadPair ( @class , out index , op1 , op2 ,
op . Parameters . Last ( ) . Type ) ; op . Parameters . Last ( ) . Type ) ;
if ( missingKind = = CXXOperatorKind . None | | ! op . IsGenerated ) if ( missingKind = = CXXOperatorKind . None | | ! op . IsGenerated )
continue ; continue ;
var method = new Method ( ) var method = new Method ( )
{ {
Name = Operators . GetOperatorIdentifier ( missingKind ) , Name = Operators . GetOperatorIdentifier ( missingKind ) ,
Namespace = @class , Namespace = @class ,
IsSynthetized = true , IsSynthetized = true ,
Kind = CXXMethodKind . Operator , Kind = CXXMethodKind . Operator ,
OperatorKind = missingKind , OperatorKind = missingKind ,
ReturnType = op . ReturnType , ReturnType = op . ReturnType ,
Parameters = op . Parameters Parameters = op . Parameters
} ; } ;
@class . Methods . Insert ( index , method ) ; @class . Methods . Insert ( index , method ) ;
} }
} }
static CXXOperatorKind CheckMissingOperatorOverloadPair ( Class @class , static CXXOperatorKind CheckMissingOperatorOverloadPair ( Class @class ,
out int index , CXXOperatorKind op1 , CXXOperatorKind op2 , Type type ) out int index , CXXOperatorKind op1 , CXXOperatorKind op2 , Type type )
{ {
var first = @class . Operators . FirstOrDefault ( o = > o . OperatorKind = = op1 & & var first = @class . Operators . FirstOrDefault ( o = > o . OperatorKind = = op1 & &
o . Parameters . Last ( ) . Type . Equals ( type ) ) ; o . Parameters . Last ( ) . Type . Equals ( type ) ) ;
var second = @class . Operators . FirstOrDefault ( o = > o . OperatorKind = = op2 & & var second = @class . Operators . FirstOrDefault ( o = > o . OperatorKind = = op2 & &
o . Parameters . Last ( ) . Type . Equals ( type ) ) ; o . Parameters . Last ( ) . Type . Equals ( type ) ) ;
var hasFirst = first ! = null ; var hasFirst = first ! = null ;
var hasSecond = second ! = null ; var hasSecond = second ! = null ;
if ( hasFirst & & ( ! hasSecond | | ! second . IsGenerated ) ) if ( hasFirst & & ( ! hasSecond | | ! second . IsGenerated ) )
{ {
index = @class . Methods . IndexOf ( first ) ; index = @class . Methods . IndexOf ( first ) ;
return op2 ; return op2 ;
} }
if ( hasSecond & & ( ! hasFirst | | ! first . IsGenerated ) ) if ( hasSecond & & ( ! hasFirst | | ! first . IsGenerated ) )
{ {
index = @class . Methods . IndexOf ( second ) ; index = @class . Methods . IndexOf ( second ) ;
return op1 ; return op1 ;
} }
index = 0 ; index = 0 ;
return CXXOperatorKind . None ; return CXXOperatorKind . None ;
} }
static bool IsValidOperatorOverload ( Method @operator ) static bool IsValidOperatorOverload ( Method @operator )
{ {
// These follow the order described in MSDN (Overloadable Operators).
// These follow the order described in MSDN (Overloadable Operators).
switch ( @operator . OperatorKind ) switch ( @operator . OperatorKind )
{ {
// These unary operators can be overloaded
// These unary operators can be overloaded
case CXXOperatorKind . Plus : case CXXOperatorKind . Plus :
case CXXOperatorKind . Minus : case CXXOperatorKind . Minus :
case CXXOperatorKind . Exclaim : case CXXOperatorKind . Exclaim :
case CXXOperatorKind . Tilde : case CXXOperatorKind . Tilde :
// These binary operators can be overloaded
// These binary operators can be overloaded
case CXXOperatorKind . Slash : case CXXOperatorKind . Slash :
case CXXOperatorKind . Percent : case CXXOperatorKind . Percent :
case CXXOperatorKind . Amp : case CXXOperatorKind . Amp :
case CXXOperatorKind . Pipe : case CXXOperatorKind . Pipe :
case CXXOperatorKind . Caret : case CXXOperatorKind . Caret :
// The array indexing operator can be overloaded
// The array indexing operator can be overloaded
case CXXOperatorKind . Subscript : case CXXOperatorKind . Subscript :
// The conversion operator can be overloaded
// The conversion operator can be overloaded
case CXXOperatorKind . Conversion : case CXXOperatorKind . Conversion :
return true ; return true ;
// The comparison operators can be overloaded if their return type is bool
// The comparison operators can be overloaded if their return type is bool
case CXXOperatorKind . EqualEqual : case CXXOperatorKind . EqualEqual :
case CXXOperatorKind . ExclaimEqual : case CXXOperatorKind . ExclaimEqual :
case CXXOperatorKind . Less : case CXXOperatorKind . Less :
case CXXOperatorKind . Greater : case CXXOperatorKind . Greater :
case CXXOperatorKind . LessEqual : case CXXOperatorKind . LessEqual :
case CXXOperatorKind . GreaterEqual : case CXXOperatorKind . GreaterEqual :
return @operator . ReturnType . Type . IsPrimitiveType ( PrimitiveType . Bool ) ; return @operator . ReturnType . Type . IsPrimitiveType ( PrimitiveType . Bool ) ;
// Only prefix operators can be overloaded
// Only prefix operators can be overloaded
case CXXOperatorKind . PlusPlus : case CXXOperatorKind . PlusPlus :
case CXXOperatorKind . MinusMinus : case CXXOperatorKind . MinusMinus :
return @operator . Parameters . Count = = 0 ; return @operator . Parameters . Count = = 0 ;
// Bitwise shift operators can only be overloaded if the second parameter is int
// Bitwise shift operators can only be overloaded if the second parameter is int
case CXXOperatorKind . LessLess : case CXXOperatorKind . LessLess :
case CXXOperatorKind . GreaterGreater : case CXXOperatorKind . GreaterGreater :
PrimitiveType primitiveType ; PrimitiveType primitiveType ;
return @operator . Parameters . Last ( ) . Type . IsPrimitiveType ( out primitiveType ) & & return @operator . Parameters . Last ( ) . Type . IsPrimitiveType ( out primitiveType ) & &
primitiveType = = PrimitiveType . Int32 ; primitiveType = = PrimitiveType . Int32 ;
// No parameters means the dereference operator - cannot be overloaded
// No parameters means the dereference operator - cannot be overloaded
case CXXOperatorKind . Star : case CXXOperatorKind . Star :
return @operator . Parameters . Count > 0 ; return @operator . Parameters . Count > 0 ;
// Assignment operators cannot be overloaded
// Assignment operators cannot be overloaded
case CXXOperatorKind . PlusEqual : case CXXOperatorKind . PlusEqual :
case CXXOperatorKind . MinusEqual : case CXXOperatorKind . MinusEqual :
case CXXOperatorKind . StarEqual : case CXXOperatorKind . StarEqual :
case CXXOperatorKind . SlashEqual : case CXXOperatorKind . SlashEqual :
case CXXOperatorKind . PercentEqual : case CXXOperatorKind . PercentEqual :
case CXXOperatorKind . AmpEqual : case CXXOperatorKind . AmpEqual :
case CXXOperatorKind . PipeEqual : case CXXOperatorKind . PipeEqual :
case CXXOperatorKind . CaretEqual : case CXXOperatorKind . CaretEqual :
case CXXOperatorKind . LessLessEqual : case CXXOperatorKind . LessLessEqual :
case CXXOperatorKind . GreaterGreaterEqual : case CXXOperatorKind . GreaterGreaterEqual :
// The conditional logical operators cannot be overloaded
// The conditional logical operators cannot be overloaded
case CXXOperatorKind . AmpAmp : case CXXOperatorKind . AmpAmp :
case CXXOperatorKind . PipePipe : case CXXOperatorKind . PipePipe :
// These operators cannot be overloaded.
// These operators cannot be overloaded.
case CXXOperatorKind . Equal : case CXXOperatorKind . Equal :
case CXXOperatorKind . Comma : case CXXOperatorKind . Comma :
case CXXOperatorKind . ArrowStar : case CXXOperatorKind . ArrowStar :
case CXXOperatorKind . Arrow : case CXXOperatorKind . Arrow :
case CXXOperatorKind . Call : case CXXOperatorKind . Call :
case CXXOperatorKind . Conditional : case CXXOperatorKind . Conditional :
case CXXOperatorKind . New : case CXXOperatorKind . New :
case CXXOperatorKind . Delete : case CXXOperatorKind . Delete :
case CXXOperatorKind . Array_New : case CXXOperatorKind . Array_New :
case CXXOperatorKind . Array_Delete : case CXXOperatorKind . Array_Delete :
default : default :
return false ; return false ;
} }
} }
} }
} }
marcos henrich
12 years ago
committed by
triton