| #include <Foundation/Foundation.h> |
| #include <stdio.h> |
| |
| #define D(msg) printf("parameter-passing.m:%d -- %s\n\n", __LINE__, msg) |
| |
| typedef struct { |
| int first, second; |
| } IntPair; |
| |
| typedef struct { |
| float first, second; |
| } FloatPair; |
| |
| @interface A : NSObject { |
| int _i_ivar; |
| long long _ll_ivar; |
| float _f_ivar; |
| double _d_ivar; |
| _Complex int _i_complex_ivar; |
| _Complex float _f_complex_ivar; |
| IntPair _i_pair_ivar; |
| FloatPair _f_pair_ivar; |
| } |
| |
| // Synthesized property access |
| |
| @property (assign) int i_ivar; |
| @property (assign) long long ll_ivar; |
| @property (assign) float f_ivar; |
| @property (assign) double d_ivar; |
| @property (assign) _Complex int i_complex_ivar; |
| @property (assign) _Complex float f_complex_ivar; |
| @property (assign) IntPair i_pair_ivar; |
| @property (assign) FloatPair f_pair_ivar; |
| |
| // Method calls & return types |
| |
| -(void) nullary; |
| -(void) unary_i: (int) a0; |
| -(int) return_i; |
| -(void) unary_ll: (long long) a0; |
| -(long long) return_ll; |
| -(void) unary_f: (float) a0; |
| -(float) return_f; |
| -(void) unary_d: (double) a0; |
| -(double) return_d; |
| -(void) unary_i_complex: (_Complex int) a0; |
| -(_Complex int) return_i_complex; |
| -(void) unary_f_complex: (_Complex float) a0; |
| -(_Complex float) return_f_complex; |
| -(void) unary_i_pair: (IntPair) a0; |
| -(IntPair) return_i_pair; |
| -(void) unary_f_pair: (FloatPair) a0; |
| -(FloatPair) return_f_pair; |
| |
| @end |
| |
| @implementation A |
| @synthesize i_ivar = _i_ivar; |
| @synthesize ll_ivar = _ll_ivar; |
| @synthesize f_ivar = _f_ivar; |
| @synthesize d_ivar = _d_ivar; |
| @synthesize i_complex_ivar = _i_complex_ivar; |
| @synthesize f_complex_ivar = _f_complex_ivar; |
| @synthesize i_pair_ivar = _i_pair_ivar; |
| @synthesize f_pair_ivar = _f_pair_ivar; |
| |
| -(void) nullary { |
| D(__FUNCTION__); |
| } |
| |
| -(void) unary_i: (int) a0 { |
| D(__FUNCTION__); |
| printf("\ta0: %d\n", a0); |
| self.i_ivar = a0; |
| } |
| |
| -(int) return_i { |
| D(__FUNCTION__); |
| int rv = self.i_ivar; |
| printf("\t returning: %d\n", rv); |
| return rv; |
| } |
| |
| -(void) unary_ll: (long long) a0 { |
| D(__FUNCTION__); |
| printf("\ta0: %lld\n", a0); |
| self.ll_ivar = a0; |
| } |
| |
| -(long long) return_ll { |
| D(__FUNCTION__); |
| long long rv = self.ll_ivar; |
| printf("\t returning: %lld\n", rv); |
| return rv; |
| } |
| |
| -(void) unary_f: (float) a0 { |
| D(__FUNCTION__); |
| printf("\ta0: %f\n", a0); |
| self.f_ivar = a0; |
| } |
| |
| -(float) return_f { |
| D(__FUNCTION__); |
| float rv = self.f_ivar; |
| printf("\t returning: %f\n", rv); |
| return rv; |
| } |
| |
| -(void) unary_d: (double) a0 { |
| D(__FUNCTION__); |
| printf("\ta0: %f\n", a0); |
| self.d_ivar = a0; |
| } |
| |
| -(double) return_d { |
| D(__FUNCTION__); |
| double rv = self.d_ivar; |
| printf("\t returning: %f\n", rv); |
| return rv; |
| } |
| |
| -(void) unary_i_complex: (_Complex int) a0 { |
| D(__FUNCTION__); |
| printf("\ta0: %d + %dj\n", __real a0, __imag a0); |
| self.i_complex_ivar = a0; |
| } |
| |
| -(_Complex int) return_i_complex { |
| D(__FUNCTION__); |
| _Complex int rv = self.i_complex_ivar; |
| printf("\t returning: (%d, %d)\n", __real rv, __imag rv); |
| return rv; |
| } |
| |
| -(void) unary_f_complex: (_Complex float) a0 { |
| D(__FUNCTION__); |
| printf("\ta0: %f + %fj\n", __real a0, __imag a0); |
| self.f_complex_ivar = a0; |
| } |
| |
| -(_Complex float) return_f_complex { |
| D(__FUNCTION__); |
| _Complex float rv = self.f_complex_ivar; |
| printf("\t returning: (%f, %f)\n", __real rv, __imag rv); |
| return rv; |
| } |
| |
| -(void) unary_i_pair: (IntPair) a0 { |
| D(__FUNCTION__); |
| printf("\ta0: (%d, %d)\n", a0.first, a0.second); |
| self.i_pair_ivar = a0; |
| } |
| |
| -(IntPair) return_i_pair { |
| D(__FUNCTION__); |
| IntPair rv = self.i_pair_ivar; |
| printf("\t returning: (%d, %d)\n", rv.first, rv.second); |
| return rv; |
| } |
| |
| -(void) unary_f_pair: (FloatPair) a0 { |
| D(__FUNCTION__); |
| printf("\ta0: (%f, %f)\n", a0.first, a0.second); |
| self.f_pair_ivar = a0; |
| } |
| |
| -(FloatPair) return_f_pair { |
| D(__FUNCTION__); |
| FloatPair rv = self.f_pair_ivar; |
| printf("\t returning: (%f, %f)\n", rv.first, rv.second); |
| return rv; |
| } |
| |
| @end |
| |
| int main() { |
| NSAutoreleasePool *AP = [[NSAutoreleasePool alloc] init]; |
| |
| A *a = [[A alloc] init]; |
| |
| int i_test_var = 0xABCDABCD; |
| long long ll_test_var = 0xABCDABCDABCDABCDLL; |
| float f_test_var = 52.5; |
| double d_test_var = 25.2; |
| _Complex int i_complex_test_var = 123 + 456j; |
| _Complex float f_complex_test_var = 123.4 + 678.5j; |
| IntPair i_pair_test_var = { 0xABCDABCD, 0xDBCADBCA }; |
| FloatPair f_pair_test_var = { 25.2, 52.5 }; |
| |
| [a nullary]; |
| [a unary_i: i_test_var]; |
| [a unary_ll: ll_test_var]; |
| [a unary_f: f_test_var]; |
| [a unary_d: d_test_var]; |
| [a unary_i_complex: i_complex_test_var]; |
| [a unary_f_complex: f_complex_test_var]; |
| [a unary_i_pair: i_pair_test_var]; |
| [a unary_f_pair: f_pair_test_var]; |
| |
| { |
| int rv = [a return_i]; |
| printf("\tresult: %d\n\n", rv); |
| assert(rv == i_test_var); |
| } |
| { |
| long long rv = [a return_ll]; |
| printf("\tresult: %lld\n\n", rv); |
| assert(rv == ll_test_var); |
| } |
| { |
| float rv = [a return_f]; |
| printf("\tresult: %f\n\n", rv); |
| assert(rv == f_test_var); |
| } |
| { |
| double rv = [a return_d]; |
| printf("\tresult: %f\n\n", rv); |
| assert(rv == d_test_var); |
| } |
| { |
| _Complex int rv = [a return_i_complex]; |
| printf("\tresult: (%d, %d)\n\n", __real rv, __imag rv); |
| assert(rv == i_complex_test_var); |
| } |
| { |
| _Complex float rv = [a return_f_complex]; |
| printf("\tresult: (%f, %f)\n\n", __real rv, __imag rv); |
| assert(rv == f_complex_test_var); |
| } |
| { |
| IntPair rv = [a return_i_pair]; |
| printf("\tresult: (%d, %d)\n\n", rv.first, rv.second); |
| assert(memcmp(&rv, &i_pair_test_var, sizeof(rv)) == 0); |
| } |
| { |
| FloatPair rv = [a return_f_pair]; |
| printf("\tresult: (%f, %f)\n\n", rv.first, rv.second); |
| assert(memcmp(&rv, &f_pair_test_var, sizeof(rv)) == 0); |
| } |
| |
| [a release]; |
| |
| [AP release]; |
| return 0; |
| } |