From d402edc15d4b829e03d9f0a904e813bb24627a02 Mon Sep 17 00:00:00 2001 From: Nicola Pero Date: Mon, 29 Nov 2010 20:43:35 +0000 Subject: [PATCH] In gcc/objc/: 2010-11-29 Nicola Pero In gcc/objc/: 2010-11-29 Nicola Pero * objc-act.c (objc_maybe_build_component_ref): Removed TODO. In gcc/testsuite/: 2010-11-29 Nicola Pero * objc.dg/property/dotsyntax-21.m * obj-c++.dg/property/dotsyntax-21.mm From-SVN: r167269 --- gcc/objc/ChangeLog | 4 + gcc/objc/objc-act.c | 7 +- gcc/testsuite/ChangeLog | 5 + .../obj-c++.dg/property/dotsyntax-21.mm | 113 ++++++++++++++++++ gcc/testsuite/objc.dg/property/dotsyntax-21.m | 113 ++++++++++++++++++ 5 files changed, 237 insertions(+), 5 deletions(-) create mode 100644 gcc/testsuite/obj-c++.dg/property/dotsyntax-21.mm create mode 100644 gcc/testsuite/objc.dg/property/dotsyntax-21.m diff --git a/gcc/objc/ChangeLog b/gcc/objc/ChangeLog index 644129bbc163..636bf85de1bf 100644 --- a/gcc/objc/ChangeLog +++ b/gcc/objc/ChangeLog @@ -1,3 +1,7 @@ +2010-11-29 Nicola Pero + + * objc-act.c (objc_maybe_build_component_ref): Removed TODO. + 2010-11-29 Nicola Pero * objc-act.c (objc_eh_runtime_type): Avoid ICE if error_mark_node diff --git a/gcc/objc/objc-act.c b/gcc/objc/objc-act.c index 810a53af9532..2382da4fd4d4 100644 --- a/gcc/objc/objc-act.c +++ b/gcc/objc/objc-act.c @@ -1539,11 +1539,8 @@ objc_maybe_build_component_ref (tree object, tree property_ident) || TREE_CODE (t) == COMPONENT_REF) t = TREE_OPERAND (t, 0); - if (t == UOBJC_SUPER_decl) - { - /* TODO: Check if this is correct also for 'super' in categories. */ - interface_type = lookup_interface (CLASS_SUPER_NAME (implementation_template)); - } + if (t == UOBJC_SUPER_decl) + interface_type = lookup_interface (CLASS_SUPER_NAME (implementation_template)); else if (t == self_decl) interface_type = lookup_interface (CLASS_NAME (implementation_template)); diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index cfa16d3e2e6b..0a154e003a53 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,8 @@ +2010-11-29 Nicola Pero + + * objc.dg/property/dotsyntax-21.m + * obj-c++.dg/property/dotsyntax-21.mm + 2010-11-29 Alexandre Oliva PR debug/46338 diff --git a/gcc/testsuite/obj-c++.dg/property/dotsyntax-21.mm b/gcc/testsuite/obj-c++.dg/property/dotsyntax-21.mm new file mode 100644 index 000000000000..4b8945ed644e --- /dev/null +++ b/gcc/testsuite/obj-c++.dg/property/dotsyntax-21.mm @@ -0,0 +1,113 @@ +/* Contributed by Nicola Pero , November 2010. */ +/* { dg-do run } */ +/* { dg-xfail-run-if "Needs OBJC2 ABI" { *-*-darwin* && { lp64 && { ! objc2 } } } { "-fnext-runtime" } { "" } } */ + +/* Test dot-syntax with super in a category. */ + +#include +#include +#include + +@interface MyRootClass +{ + Class isa; + int a; +} ++ (id) initialize; ++ (id) alloc; +- (id) init; +- (int) count; +- (void) setCount: (int)count; +@end + +@implementation MyRootClass ++ (id) initialize { return self; } ++ (id) alloc { return class_createInstance (self, 0); } +- (id) init { return self; } +- (int) count +{ + return a; +} +- (void) setCount: (int)count +{ + a = count; +} +@end + +/* First, test 'super' in the main implementation of a subclass. */ +@interface MySubClass : MyRootClass +- (int) superCount; +- (void) setSuperCount: (int)count; +@end + +@implementation MySubClass +- (int) superCount +{ + return super.count; +} +- (void) setSuperCount: (int)count +{ + super.count = count; +} +@end + +/* Now, test 'super' in a category of a subclass. */ +@interface MySubClass (Category) +- (int) superCount2; +- (void) setSuperCount2: (int)count; +- (int) test: (int)x; +@end + +@implementation MySubClass (Category) +- (int) superCount2 +{ + return super.count; +} +- (void) setSuperCount2: (int)count +{ + super.count = count; +} +- (int) test: (int)x +{ + /* For positive x, the following will leave super.count + unchanged. */ + super.count++; + --super.count; + + super.count = (x < 0 ? x : super.count); + + if ((x = super.count)) + super.count += 1; + + if ((x = super.count)) + super.count -= 1; + + /* Finally, also put a bit of self.count in the mix. */ + self.count++; + super.count--; + + return super.count; +} +@end + +int main (void) +{ + MySubClass *object = [[MySubClass alloc] init]; + + object.count = 10; + if (object.count != 10) + abort (); + + object.superCount = 11; + if (object.superCount != 11) + abort (); + + object.superCount2 = 12; + if (object.superCount2 != 12) + abort (); + + if ([object test: 45] != 12) + abort (); + + return 0; +} diff --git a/gcc/testsuite/objc.dg/property/dotsyntax-21.m b/gcc/testsuite/objc.dg/property/dotsyntax-21.m new file mode 100644 index 000000000000..4b8945ed644e --- /dev/null +++ b/gcc/testsuite/objc.dg/property/dotsyntax-21.m @@ -0,0 +1,113 @@ +/* Contributed by Nicola Pero , November 2010. */ +/* { dg-do run } */ +/* { dg-xfail-run-if "Needs OBJC2 ABI" { *-*-darwin* && { lp64 && { ! objc2 } } } { "-fnext-runtime" } { "" } } */ + +/* Test dot-syntax with super in a category. */ + +#include +#include +#include + +@interface MyRootClass +{ + Class isa; + int a; +} ++ (id) initialize; ++ (id) alloc; +- (id) init; +- (int) count; +- (void) setCount: (int)count; +@end + +@implementation MyRootClass ++ (id) initialize { return self; } ++ (id) alloc { return class_createInstance (self, 0); } +- (id) init { return self; } +- (int) count +{ + return a; +} +- (void) setCount: (int)count +{ + a = count; +} +@end + +/* First, test 'super' in the main implementation of a subclass. */ +@interface MySubClass : MyRootClass +- (int) superCount; +- (void) setSuperCount: (int)count; +@end + +@implementation MySubClass +- (int) superCount +{ + return super.count; +} +- (void) setSuperCount: (int)count +{ + super.count = count; +} +@end + +/* Now, test 'super' in a category of a subclass. */ +@interface MySubClass (Category) +- (int) superCount2; +- (void) setSuperCount2: (int)count; +- (int) test: (int)x; +@end + +@implementation MySubClass (Category) +- (int) superCount2 +{ + return super.count; +} +- (void) setSuperCount2: (int)count +{ + super.count = count; +} +- (int) test: (int)x +{ + /* For positive x, the following will leave super.count + unchanged. */ + super.count++; + --super.count; + + super.count = (x < 0 ? x : super.count); + + if ((x = super.count)) + super.count += 1; + + if ((x = super.count)) + super.count -= 1; + + /* Finally, also put a bit of self.count in the mix. */ + self.count++; + super.count--; + + return super.count; +} +@end + +int main (void) +{ + MySubClass *object = [[MySubClass alloc] init]; + + object.count = 10; + if (object.count != 10) + abort (); + + object.superCount = 11; + if (object.superCount != 11) + abort (); + + object.superCount2 = 12; + if (object.superCount2 != 12) + abort (); + + if ([object test: 45] != 12) + abort (); + + return 0; +}