Subversion Repositories openrisc

/gnu-src/gcc-4.5.1/gcc/testsuite/objc-obj-c++-shared/Object1-implementation.h

gnu-src/gcc-4.5.1/gcc/testsuite/objc-obj-c++-shared/Object1-implementation.h Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: gnu-src/gcc-4.5.1/gcc/testsuite/objc-obj-c++-shared/Protocol1.h =================================================================== --- gnu-src/gcc-4.5.1/gcc/testsuite/objc-obj-c++-shared/Protocol1.h (nonexistent) +++ gnu-src/gcc-4.5.1/gcc/testsuite/objc-obj-c++-shared/Protocol1.h (revision 310) @@ -0,0 +1,52 @@ +/* + * Temporary work-around to avoid the need for method attributes in + * the NeXT Runtime Protocol header. + */ +#ifndef _OBJC_PROTOCOL1_H_ +#define _OBJC_PROTOCOL1_H_ + +# ifndef __NEXT_RUNTIME__ +# include +# else +# include "next-abi.h" +# ifndef NEXT_OBJC_USE_NEW_INTERFACE +/* We are on a NeXT version without method __attributes__ */ +# import +# else +/* We make our own interface without the deprecation messages + * This is essentially without the OBJC2 + * flags. + * + */ +# ifndef _OBJC_PROTOCOL_H_ +# define _OBJC_PROTOCOL_H_ +# import "Object1.h" + +@interface Protocol : Object +{ +@private + char *protocol_name ; + struct objc_protocol_list *protocol_list ; + struct objc_method_description_list *instance_methods ; + struct objc_method_description_list *class_methods ; +} + +/* Obtaining attributes intrinsic to the protocol */ +#if (NEXT_OBJC_ABI_VERSION==0) +- (const char *)name ; /* Not avail in v2, deprecated in prior */ +/* Testing protocol conformance */ +- (BOOL) conformsTo: (Protocol *)aProtocolObject ; /* Not avail in v2 */ +#endif + +/* Looking up information specific to a protocol */ +/* Deprecated, but available */ + +- (struct objc_method_description *) descriptionForInstanceMethod:(SEL)aSel ; +- (struct objc_method_description *) descriptionForClassMethod:(SEL)aSel ; + +@end + +# endif /* __NEXT_RUNTIME__ */ +# endif /* _OBJC_PROTOCOL_H_ */ +# endif /* NEXT_OBJC_ABI_VERSION */ +#endif /* _OBJC_PROTOCOL1_H_ */

gnu-src/gcc-4.5.1/gcc/testsuite/objc-obj-c++-shared/Protocol1.h Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: gnu-src/gcc-4.5.1/gcc/testsuite/objc-obj-c++-shared/Object1.h =================================================================== --- gnu-src/gcc-4.5.1/gcc/testsuite/objc-obj-c++-shared/Object1.h (nonexistent) +++ gnu-src/gcc-4.5.1/gcc/testsuite/objc-obj-c++-shared/Object1.h (revision 310) @@ -0,0 +1,150 @@ +/* Object definition taken from + */ +#ifndef _OBJC_OBJECT1_H_ +#define _OBJC_OBJECT1_H_ + +#undef DO_NEXT_M64_OBJECT_IMPLEMENTATION + +#ifndef __NEXT_RUNTIME__ +# include +#else +# include "next-abi.h" +# ifndef NEXT_OBJC_USE_NEW_INTERFACE +/* We are on a next system, or version, that is happy to compile V0 ABI */ +# include +# else +# if (NEXT_OBJC_ABI_VERSION==0) +/* We are on a system that has V0 ABI implementation in libobjc.dylib. + * However, we need to use the new accessors and pretend that the + * structures are opaque to avoid 'deprecated' warnings + */ +# include +# else +/* We are on a system that includes a V2 ABI Object in libobjc.dylib. +*/ +# ifdef __OBJC2__ +/* ... and we have a V2 ABI compiler .. */ +# include +# else +/* We can't access the Object definition in libobjc.dylib because + * we can't yet generate OBJC2 code. + * + * So we'll roll our own Object - purely for the sake of compile + * checks - the code is unlikely to run... +*/ +# ifndef _OBJC_OBJECT_H_ +# define _OBJC_OBJECT_H_ + +#include +#import + +/* This is a cut-down Object with only the methods currently required + by the testsuite declared. + + For those executables that require an implementation (to link) this + can be provided in a given test by placing: + #include "path/to/objc-c++shared/Object1-implementation.h" + at the end of the source for the test. +*/ + +@interface Object +{ + Class isa; /* A pointer to the instance's class structure */ +} ++ initialize; +- init; + ++ new; ++ free; +- free; ++ alloc; +//- copy; +//+ allocFromZone:(void *)zone; +//- copyFromZone:(void *)zone; +//- (void *)zone; + ++ class; +//+ superclass; +//+ (const char *) name; +- class; +- superclass; +- (const char *) name; + +//- self; +//- (unsigned int) hash; +//-(BOOL) isEqual:anObject; + +/* Testing inheritance relationships */ + +//- (BOOL) isKindOf: aClassObject; +//- (BOOL) isMemberOf: aClassObject; +//- (BOOL) isKindOfClassNamed: (const char *)aClassName; +//- (BOOL) isMemberOfClassNamed: (const char *)aClassName; + +/* Testing class functionality */ + +//+ (BOOL) instancesRespondTo:(SEL)aSelector; +//- (BOOL) respondsTo:(SEL)aSelector; + +/* Testing protocol conformance */ + +- (BOOL) conformsTo: (Protocol *)aProtocolObject; +//+ (BOOL) conformsTo: (Protocol *)aProtocolObject; + +/* Obtaining method descriptors from protocols */ + +//- (struct objc_method_description *) descriptionForMethod:(SEL)aSel; +//+ (struct objc_method_description *) descriptionForInstanceMethod:(SEL)aSel; + +/* Obtaining method handles */ + +//- (IMP) methodFor:(SEL)aSelector; +//+ (IMP) instanceMethodFor:(SEL)aSelector; + +/* Sending messages determined at run time */ + +//- perform:(SEL)aSelector; +//- perform:(SEL)aSelector with:anObject; +//- perform:(SEL)aSelector with:object1 with:object2; + +/* Posing */ + +//+ poseAs: aClassObject; + +/* Enforcing intentions */ + +//- subclassResponsibility:(SEL)aSelector; +//- notImplemented:(SEL)aSelector; + +/* Error handling */ + +//- doesNotRecognize:(SEL)aSelector; +//- error:(const char *)aString, ...; + +/* Debugging */ + +//- (void) printForDebugger:(void *)stream; + +/* Archiving */ + +//- awake; +//- write:(void *)stream; +//- read:(void *)stream; +//+ (int) version; +//+ setVersion: (int) aVersion; + +/* Forwarding */ + +//- forward: (SEL)sel : (marg_list)args; +//- performv: (SEL)sel : (marg_list)args; + +@end + +#define DO_NEXT_M64_OBJECT_IMPLEMENTATION + +# endif /* _OBJC_OBJECT_H_ */ +# endif /* __OBJC2__ */ +# endif /* ABI=0 */ +# endif /* NEXT_OBJC_USE_NEW_INTERFACE */ +# endif /* __NEXT_RUNTIME__ */ +#endif /* _OBJC_OBJECT1_H_ */

gnu-src/gcc-4.5.1/gcc/testsuite/objc-obj-c++-shared/Object1.h Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: gnu-src/gcc-4.5.1/gcc/testsuite/objc-obj-c++-shared/next-abi.h =================================================================== --- gnu-src/gcc-4.5.1/gcc/testsuite/objc-obj-c++-shared/next-abi.h (nonexistent) +++ gnu-src/gcc-4.5.1/gcc/testsuite/objc-obj-c++-shared/next-abi.h (revision 310) @@ -0,0 +1,45 @@ + +#ifndef _OBJC_NEXT_ABI_H_ +#define _OBJC_NEXT_ABI_H_ +/* Produce a define that allows us to figure out what facilities are + available for this gcc and OS combination. +*/ + +/* By default we do nothing - therefore ifdef NEXT_OBJC_USE_NEW_INTERFACE + * is reliable for detecting + * (a) versions of the compiler that are transitional to the new next ABI + * (b) versions of the target that require the new ABI. + * + * This applies for versions of OSX >= 10.5 (darwin9). + * + * A compiler capable of producing ObjC V2 ABI should define __OBJC2__ +*/ + +#undef NEXT_OBJC_ABI_VERSION +#undef NEXT_OBJC_USE_NEW_INTERFACE + +#ifdef __NEXT_RUNTIME__ +# if (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1050 || __OBJC2__) + /* We have to use an updated interface for 32bit NeXT to avoid + * 'deprecated' warnings. + * For 64bit NeXT the ABI is different (and the interfaces 'deprecated' + * for 32bit have been removed). + */ +# define NEXT_OBJC_USE_NEW_INTERFACE 1 +# if __OBJC2__ || __LP64__ + /* We have OBJC v2 ABI compiler, + (or, at least, the available NeXT runtime requires one) */ +# define NEXT_OBJC_ABI_VERSION 2 +# else + /* We leave it open to define ABI 1 if and when we implement those + * extensions. + */ +# define NEXT_OBJC_ABI_VERSION 0 +# endif +# else + /* All before 10.5 is ABI 0 */ +# define NEXT_OBJC_ABI_VERSION 0 +# endif +#endif + +#endif /* _OBJC_NEXT_ABI_H_ */

gnu-src/gcc-4.5.1/gcc/testsuite/objc-obj-c++-shared/next-abi.h Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: gnu-src/gcc-4.5.1/gcc/testsuite/objc-obj-c++-shared/next-mapping.h =================================================================== --- gnu-src/gcc-4.5.1/gcc/testsuite/objc-obj-c++-shared/next-mapping.h (nonexistent) +++ gnu-src/gcc-4.5.1/gcc/testsuite/objc-obj-c++-shared/next-mapping.h (revision 310) @@ -0,0 +1,982 @@ +/* This file "renames" various ObjC GNU runtime entry points + (and fakes the existence of several others) + if the NeXT runtime is being used. */ +/* Authors: Ziemowit Laski */ +/* David Ayers */ +/* Darwin 64bit/OBJC2 modifications Iain Sandoe */ + +#ifndef __NEXT_RUNTIME__ + +#define CLASSPTRFIELD(x) (x)->class_pointer + +#else +/* Includes next-abi.h to set NEXT_OBJC_USE_NEW_INTERFACE etc.*/ +#ifndef _OBJC_OBJECT1_H_ +#include "Object1.h" +#endif +#include +#include +#include +#include + +#define objc_get_class(C) objc_getClass(C) +#define objc_get_meta_class(C) objc_getMetaClass(C) +#define class_get_class_method(C, S) class_getClassMethod(C, S) +#define class_get_instance_method(C, S) class_getInstanceMethod(C, S) +#define sel_get_name(S) sel_getName(S) +#define class_create_instance(C) class_createInstance(C, 0) +#define class_get_class_name(C) object_getClassName(C) + +#define CLASSPTRFIELD(x) (x)->isa + +#ifdef NEXT_OBJC_USE_NEW_INTERFACE +# define object_class_name(O) (object_getClassName(O)) +# define object_get_class(O) (object_getClass((id)O)) +# define object_get_super_class(O) class_get_super_class(object_get_class(O)) +# define object_is_class(O) class_is_meta_class(object_get_class(O)) +# define object_is_meta_class(O) (object_is_class(O) && class_is_meta_class(O) \ + && class_is_meta_class(object_get_class(O))) + +# define method_get_imp(M) (method_getImplementation((Method)M)) +# define method_get_types(M) (method_getTypeEncoding((Method)M)) + +# define class_get_super_class(C) (class_getSuperclass((Class)C)) +# define class_is_meta_class(C) (class_isMetaClass((Class)C) ? YES: NO) +# define class_is_class(C) (class_is_meta_class(C) == NO) + +#else +# define object_class_name(O) (O->name) +# define object_get_super_class(O) class_get_super_class(*(struct objc_class **)O) +# define object_get_class(O) (*(struct objc_class **)O) +# define object_is_class(O) class_is_meta_class(*(struct objc_class **)O) +# define object_is_meta_class(O) (class_is_meta_class(O) && class_is_meta_class(*(struct objc_class **)O)) + +# define method_get_imp(M) (((Method)M)->method_imp) +# define method_get_types(M) (((Method)M)->method_types) + +# define class_get_super_class(C) (((struct objc_class *)C)->super_class) +# define class_is_meta_class(C) (CLS_GETINFO((struct objc_class *)C, CLS_META)? YES: NO) +# define class_is_class(C) (CLS_GETINFO((struct objc_class *)C, CLS_CLASS)? YES: NO) +#endif + +#define objc_lookup_class(N) objc_lookUpClass(N) + +/* You need either an empty +initialize method or an empty -forward:: method. + The NeXT runtime unconditionally sends +initialize to classes when they are + first used, and unconditionally tries to forward methods that the class + doesn't understand (including +initialize). If you have neither +initialize + nor -forward::, the runtime complains. + + The simplest workaround is to add + + + initialize { return self; } + + to every root class @implementation. */ + +#ifndef NULL +#define NULL 0 +#endif + +/* The following is necessary to "cover" the bf*.m test cases on NeXT. */ + +#undef MAX +#undef MIN +#undef ROUND + +#ifdef __cplusplus +# define MAX(X, Y) ((X > Y) ? X : Y) +# define MIN(X, Y) ((X < Y) ? X : Y) +# define ROUND(V, A) (A * ((V + A - 1) / A)) +#else +# define MAX(X, Y) \ + ({ typeof (X) __x = (X), __y = (Y); \ + (__x > __y ? __x : __y); }) +# define MIN(X, Y) \ + ({ typeof (X) __x = (X), __y = (Y); \ + (__x < __y ? __x : __y); }) +# define ROUND(V, A) \ + ({ typeof (V) __v = (V); typeof (A) __a = (A); \ + __a * ((__v+__a - 1)/__a); }) +#endif + +#define BITS_PER_UNIT __CHAR_BIT__ +typedef struct{ char a; } __small_struct; +#define STRUCTURE_SIZE_BOUNDARY (BITS_PER_UNIT * sizeof (__small_struct)) + +/* Not sure why the following are missing from NeXT objc headers... */ + +#ifndef _C_LNG_LNG +#define _C_LNG_LNG 'q' +#endif +#ifndef _C_ULNG_LNG +#define _C_ULNG_LNG 'Q' +#endif +#ifndef _C_ATOM +#define _C_ATOM '%' +#endif +#ifndef _C_BOOL +#define _C_BOOL 'B' +#endif + +#define _C_CONST 'r' +#define _C_IN 'n' +#define _C_INOUT 'N' +#define _C_OUT 'o' +#define _C_BYCOPY 'O' +#define _C_BYREF 'R' +#define _C_ONEWAY 'V' +#define _C_GCINVISIBLE '!' + +#define _F_CONST 0x01 +#define _F_IN 0x01 +#define _F_OUT 0x02 +#define _F_INOUT 0x03 +#define _F_BYCOPY 0x04 +#define _F_BYREF 0x08 +#define _F_ONEWAY 0x10 +#define _F_GCINVISIBLE 0x20 + +struct objc_struct_layout +{ + const char *original_type; + const char *type; + const char *prev_type; + unsigned int record_size; + unsigned int record_align; +}; + +typedef union arglist { + char *arg_ptr; + char arg_regs[sizeof (char*)]; +} *arglist_t; /* argument frame */ + +const char *objc_skip_typespec (const char *type); +void objc_layout_structure_get_info (struct objc_struct_layout *layout, + unsigned int *offset, unsigned int *align, const char **type); +void objc_layout_structure (const char *type, + struct objc_struct_layout *layout); +BOOL objc_layout_structure_next_member (struct objc_struct_layout *layout); +void objc_layout_finish_structure (struct objc_struct_layout *layout, + unsigned int *size, unsigned int *align); +int objc_aligned_size (const char *type); + +/* + return the size of an object specified by type +*/ + +int +objc_sizeof_type (const char *type) +{ + /* Skip the variable name if any */ + if (*type == '"') + { + for (type++; *type++ != '"';) + /* do nothing */; + } + + switch (*type) { + case _C_ID: + return sizeof (id); + break; + + case _C_CLASS: + return sizeof (Class); + break; + + case _C_SEL: + return sizeof (SEL); + break; + + case _C_CHR: + return sizeof (char); + break; + + case _C_UCHR: + return sizeof (unsigned char); + break; + + case _C_SHT: + return sizeof (short); + break; + + case _C_USHT: + return sizeof (unsigned short); + break; + + case _C_INT: + return sizeof (int); + break; + + case _C_UINT: + return sizeof (unsigned int); + break; + + case _C_LNG: + return sizeof (long); + break; + + case _C_ULNG: + return sizeof (unsigned long); + break; + + case _C_LNG_LNG: + return sizeof (long long); + break; + + case _C_ULNG_LNG: + return sizeof (unsigned long long); + break; + + case _C_FLT: + return sizeof (float); + break; + + case _C_DBL: + return sizeof (double); + break; + + case _C_PTR: + case _C_ATOM: + case _C_CHARPTR: + return sizeof (char *); + break; + + case _C_ARY_B: + { + int len = atoi (type + 1); + while (isdigit ((unsigned char)*++type)) + ; + return len * objc_aligned_size (type); + } + break; + + case _C_BFLD: + { + /* The NeXT encoding of bitfields is _still_: b 'size' */ + int size = atoi (type + 1); + /* Return an upper bound on byte size */ + return (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT; + } + + case _C_STRUCT_B: + { + struct objc_struct_layout layout; + unsigned int size; + + objc_layout_structure (type, &layout); + while (objc_layout_structure_next_member (&layout)) + /* do nothing */ ; + objc_layout_finish_structure (&layout, &size, NULL); + + return size; + } + + case _C_UNION_B: + { + int max_size = 0; + while (*type != _C_UNION_E && *type++ != '=') + /* do nothing */; + while (*type != _C_UNION_E) + { + /* Skip the variable name if any */ + if (*type == '"') + { + for (type++; *type++ != '"';) + /* do nothing */; + } + max_size = MAX (max_size, objc_sizeof_type (type)); + type = objc_skip_typespec (type); + } + return max_size; + } + } + return 0; /* error */ +} + + +/* + Return the alignment of an object specified by type +*/ + +int +objc_alignof_type (const char *type) +{ + /* Skip the variable name if any */ + if (*type == '"') + { + for (type++; *type++ != '"';) + /* do nothing */; + } + switch (*type) { + case _C_ID: + return __alignof__ (id); + break; + + case _C_CLASS: + return __alignof__ (Class); + break; + + case _C_SEL: + return __alignof__ (SEL); + break; + + case _C_CHR: + return __alignof__ (char); + break; + + case _C_UCHR: + return __alignof__ (unsigned char); + break; + + case _C_SHT: + return __alignof__ (short); + break; + + case _C_USHT: + return __alignof__ (unsigned short); + break; + + case _C_INT: + case _C_BFLD: /* This is for the NeXT only */ + return __alignof__ (int); + break; + + case _C_UINT: + return __alignof__ (unsigned int); + break; + + case _C_LNG: + return __alignof__ (long); + break; + + case _C_ULNG: + return __alignof__ (unsigned long); + break; + + case _C_LNG_LNG: + return __alignof__ (long long); + break; + + case _C_ULNG_LNG: + return __alignof__ (unsigned long long); + break; + + case _C_FLT: + return __alignof__ (float); + break; + + case _C_DBL: + return __alignof__ (double); + break; + + case _C_PTR: + case _C_ATOM: + case _C_CHARPTR: + return __alignof__ (char *); + break; + + case _C_ARY_B: + while (isdigit ((unsigned char)*++type)) + /* do nothing */; + return objc_alignof_type (type); + + case _C_STRUCT_B: + { + struct objc_struct_layout layout; + unsigned int align; + + objc_layout_structure (type, &layout); + while (objc_layout_structure_next_member (&layout)) + /* do nothing */; + objc_layout_finish_structure (&layout, NULL, &align); + + return align; + } + + case _C_UNION_B: + { + int maxalign = 0; + while (*type != _C_UNION_E && *type++ != '=') + /* do nothing */; + while (*type != _C_UNION_E) + { + /* Skip the variable name if any */ + if (*type == '"') + { + for (type++; *type++ != '"';) + /* do nothing */; + } + maxalign = MAX (maxalign, objc_alignof_type (type)); + type = objc_skip_typespec (type); + } + return maxalign; + } + } + return 0; /* error */ +} + +/* + The aligned size if the size rounded up to the nearest alignment. +*/ + +int +objc_aligned_size (const char *type) +{ + int size, align; + + /* Skip the variable name */ + if (*type == '"') + { + for (type++; *type++ != '"';) + /* do nothing */; + } + + size = objc_sizeof_type (type); + align = objc_alignof_type (type); + + return ROUND (size, align); +} + +/* + The size rounded up to the nearest integral of the wordsize, taken + to be the size of a void *. +*/ + +int +objc_promoted_size (const char *type) +{ + int size, wordsize; + + /* Skip the variable name */ + if (*type == '"') + { + for (type++; *type++ != '"';) + /* do nothing */; + } + + size = objc_sizeof_type (type); + wordsize = sizeof (void *); + + return ROUND (size, wordsize); +} + +/* + Skip type qualifiers. These may eventually precede typespecs + occurring in method prototype encodings. +*/ + +inline const char * +objc_skip_type_qualifiers (const char *type) +{ + while (*type == _C_CONST + || *type == _C_IN + || *type == _C_INOUT + || *type == _C_OUT + || *type == _C_BYCOPY + || *type == _C_BYREF + || *type == _C_ONEWAY + || *type == _C_GCINVISIBLE) + { + type += 1; + } + return type; +} + + +/* + Skip one typespec element. If the typespec is prepended by type + qualifiers, these are skipped as well. +*/ + +const char * +objc_skip_typespec (const char *type) +{ + /* Skip the variable name if any */ + if (*type == '"') + { + for (type++; *type++ != '"';) + /* do nothing */; + } + + type = objc_skip_type_qualifiers (type); + + switch (*type) { + + case _C_ID: + /* An id may be annotated by the actual type if it is known + with the @"ClassName" syntax */ + + if (*++type != '"') + return type; + else + { + while (*++type != '"') + /* do nothing */; + return type + 1; + } + + /* The following are one character type codes */ + case _C_CLASS: + case _C_SEL: + case _C_CHR: + case _C_UCHR: + case _C_CHARPTR: + case _C_ATOM: + case _C_SHT: + case _C_USHT: + case _C_INT: + case _C_UINT: + case _C_LNG: + case _C_ULNG: + case _C_LNG_LNG: + case _C_ULNG_LNG: + case _C_FLT: + case _C_DBL: + case _C_VOID: + case _C_UNDEF: + return ++type; + break; + + case _C_ARY_B: + /* skip digits, typespec and closing ']' */ + + while (isdigit ((unsigned char)*++type)) + ; + type = objc_skip_typespec (type); + if (*type == _C_ARY_E) + return ++type; + else + break; /* error */ + + case _C_BFLD: + /* The NeXT encoding for bitfields is _still_: b 'size' */ + while (isdigit ((unsigned char)*++type)) + ; /* skip type and size */ + return type; + + case _C_STRUCT_B: + /* skip name, and elements until closing '}' */ + + while (*type != _C_STRUCT_E && *type++ != '=') + ; + while (*type != _C_STRUCT_E) + { + type = objc_skip_typespec (type); + } + return ++type; + + case _C_UNION_B: + /* skip name, and elements until closing ')' */ + + while (*type != _C_UNION_E && *type++ != '=') + ; + while (*type != _C_UNION_E) + { + type = objc_skip_typespec (type); + } + return ++type; + + case _C_PTR: + /* Just skip the following typespec */ + + return objc_skip_typespec (++type); + } + return 0; /* error */ +} + +/* + Skip an offset as part of a method encoding. This is prepended by a + '+' if the argument is passed in registers. +*/ +inline const char * +objc_skip_offset (const char *type) +{ + if (*type == '+') + type++; + while (isdigit ((unsigned char) *++type)) + ; + return type; +} + +/* + Skip an argument specification of a method encoding. +*/ +const char * +objc_skip_argspec (const char *type) +{ + type = objc_skip_typespec (type); + type = objc_skip_offset (type); + return type; +} + +#ifdef NEXT_OBJC_USE_NEW_INTERFACE +typedef void *PMETH; +#else +typedef struct objc_method *PMETH; +#endif + +/* + Return the number of arguments that the method MTH expects. + Note that all methods need two implicit arguments `self' and + `_cmd'. +*/ +int +method_get_number_of_arguments (PMETH mth) +{ + int i = 0; +#ifdef NEXT_OBJC_USE_NEW_INTERFACE + const char *type = method_getTypeEncoding((Method)mth); +#else + const char *type = mth->method_types; +#endif + while (*type) + { + type = objc_skip_argspec (type); + i += 1; + } + return i - 1; +} + +/* + Return the size of the argument block needed on the stack to invoke + the method MTH. This may be zero, if all arguments are passed in + registers. +*/ + +int +method_get_sizeof_arguments (PMETH mth) +{ +#ifdef NEXT_OBJC_USE_NEW_INTERFACE + const char *type = objc_skip_typespec (method_getTypeEncoding((Method)mth)); +#else + const char *type = objc_skip_typespec (mth->method_types); +#endif + return atoi (type); +} + +/* + Return a pointer to the next argument of ARGFRAME. type points to + the last argument. Typical use of this look like: + + { + char *datum, *type; + for (datum = method_get_first_argument (method, argframe, &type); + datum; datum = method_get_next_argument (argframe, &type)) + { + unsigned flags = objc_get_type_qualifiers (type); + type = objc_skip_type_qualifiers (type); + if (*type != _C_PTR) + [portal encodeData: datum ofType: type]; + else + { + if ((flags & _F_IN) == _F_IN) + [portal encodeData: *(char **) datum ofType: ++type]; + } + } + } +*/ + +char * +method_get_next_argument (arglist_t argframe, const char **type) +{ + const char *t = objc_skip_argspec (*type); + + if (*t == '\0') + return 0; + + *type = t; + t = objc_skip_typespec (t); + + if (*t == '+') + return argframe->arg_regs + atoi (++t); + else + return argframe->arg_ptr + atoi (t); +} + +/* + Return a pointer to the value of the first argument of the method + described in M with the given argumentframe ARGFRAME. The type + is returned in TYPE. type must be passed to successive calls of + method_get_next_argument. +*/ +char * +method_get_first_argument (PMETH m, + arglist_t argframe, + const char **type) +{ +#ifdef NEXT_OBJC_USE_NEW_INTERFACE + *type = method_getTypeEncoding((Method)m); +#else + *type = m->method_types; +#endif + + return method_get_next_argument (argframe, type); +} + +/* + Return a pointer to the ARGth argument of the method + M from the frame ARGFRAME. The type of the argument + is returned in the value-result argument TYPE +*/ + +char * +method_get_nth_argument (PMETH m, + arglist_t argframe, int arg, + const char **type) +{ +#ifdef NEXT_OBJC_USE_NEW_INTERFACE + const char *t = objc_skip_argspec (method_getTypeEncoding((Method)m)); +#else + const char *t = objc_skip_argspec (m->method_types); +#endif + + if (arg > method_get_number_of_arguments (m)) + return 0; + + while (arg--) + t = objc_skip_argspec (t); + + *type = t; + t = objc_skip_typespec (t); + + if (*t == '+') + return argframe->arg_regs + atoi (++t); + else + return argframe->arg_ptr + atoi (t); +} + +unsigned +objc_get_type_qualifiers (const char *type) +{ + unsigned res = 0; + BOOL flag = YES; + + while (flag) + switch (*type++) + { + case _C_CONST: res |= _F_CONST; break; + case _C_IN: res |= _F_IN; break; + case _C_INOUT: res |= _F_INOUT; break; + case _C_OUT: res |= _F_OUT; break; + case _C_BYCOPY: res |= _F_BYCOPY; break; + case _C_BYREF: res |= _F_BYREF; break; + case _C_ONEWAY: res |= _F_ONEWAY; break; + case _C_GCINVISIBLE: res |= _F_GCINVISIBLE; break; + default: flag = NO; + } + + return res; +} + + +/* The following three functions can be used to determine how a + structure is laid out by the compiler. For example: + + struct objc_struct_layout layout; + int i; + + objc_layout_structure (type, &layout); + while (objc_layout_structure_next_member (&layout)) + { + int position, align; + const char *type; + + objc_layout_structure_get_info (&layout, &position, &align, &type); + printf ("element %d has offset %d, alignment %d\n", + i++, position, align); + } + + These functions are used by objc_sizeof_type and objc_alignof_type + functions to compute the size and alignment of structures. The + previous method of computing the size and alignment of a structure + was not working on some architectures, particulary on AIX, and in + the presence of bitfields inside the structure. */ +void +objc_layout_structure (const char *type, + struct objc_struct_layout *layout) +{ + const char *ntype; + + layout->original_type = ++type; + + /* Skip "=" if any. Avoid embedded structures and unions. */ + ntype = type; + while (*ntype != _C_STRUCT_E && *ntype != _C_STRUCT_B && *ntype != _C_UNION_B + && *ntype++ != '=') + /* do nothing */; + + /* If there's a "=", ntype - 1 points to '='; skip the the name */ + if (*(ntype - 1) == '=') + type = ntype; + + layout->type = type; + layout->prev_type = NULL; + layout->record_size = 0; + layout->record_align = MAX (BITS_PER_UNIT, STRUCTURE_SIZE_BOUNDARY); +} + + +BOOL +objc_layout_structure_next_member (struct objc_struct_layout *layout) +{ + register int desired_align = 0; + + /* The current type without the type qualifiers */ + const char *type; + + /* Add the size of the previous field to the size of the record. */ + if (layout->prev_type) + { + type = objc_skip_type_qualifiers (layout->prev_type); + + if (*type != _C_BFLD) + layout->record_size += objc_sizeof_type (type) * BITS_PER_UNIT; + else + layout->record_size += atoi (++type); + } + + if (*layout->type == _C_STRUCT_E) + return NO; + + /* Skip the variable name if any */ + if (*layout->type == '"') + { + for (layout->type++; *layout->type++ != '"';) + /* do nothing */; + } + + type = objc_skip_type_qualifiers (layout->type); + + desired_align = objc_alignof_type (type) * BITS_PER_UNIT; + + /* Record must have at least as much alignment as any field. + Otherwise, the alignment of the field within the record + is meaningless. */ + layout->record_align = MAX (layout->record_align, desired_align); + + if (*type == _C_BFLD) + { + int bfld_size = atoi (++type); + int int_align = __alignof__ (int) * BITS_PER_UNIT; + /* If this bitfield would traverse a word alignment boundary, push it out + to that boundary instead. */ + if (layout->record_size % int_align + && (layout->record_size / int_align + < (layout->record_size + bfld_size - 1) / int_align)) + layout->record_size = ROUND (layout->record_size, int_align); + } + else if (layout->record_size % desired_align != 0) + { + /* We need to skip space before this field. + Bump the cumulative size to multiple of field alignment. */ + layout->record_size = ROUND (layout->record_size, desired_align); + } + + /* Jump to the next field in record. */ + + layout->prev_type = layout->type; + layout->type = objc_skip_typespec (layout->type); /* skip component */ + + return YES; +} + + +void objc_layout_finish_structure (struct objc_struct_layout *layout, + unsigned int *size, + unsigned int *align) +{ + if (layout->type && *layout->type == _C_STRUCT_E) + { + /* Round the size up to be a multiple of the required alignment */ + layout->record_size = ROUND (layout->record_size, layout->record_align); + layout->type = NULL; + } + if (size) + *size = layout->record_size / BITS_PER_UNIT; + if (align) + *align = layout->record_align / BITS_PER_UNIT; +} + + +void objc_layout_structure_get_info (struct objc_struct_layout *layout, + unsigned int *offset, + unsigned int *align, + const char **type) +{ + if (offset) + *offset = layout->record_size / BITS_PER_UNIT; + if (align) + *align = layout->record_align / BITS_PER_UNIT; + if (type) + *type = layout->prev_type; +} + +/* A small, portable NSConstantString implementation for use with the NeXT + runtime. + + On full-fledged Mac OS X systems, NSConstantString is provided + as part of the Foundation framework. However, on bare Darwin systems, + Foundation is not included, and hence there is no NSConstantString + implementation to link against. + + This code is derived from the GNU runtime's NXConstantString implementation. +*/ + +/* This definition cut out of with the OBJC2 deprecation + messages removed. +*/ +#ifdef NEXT_OBJC_USE_NEW_INTERFACE +struct fudge_objc_class { + Class isa; +#if NEXT_OBJC_ABI_VERSION < 2 + Class super_class ; + const char *name ; + long version ; + long info ; + long instance_size ; + struct anon *ivars ; /* objc_ivar_list */ + struct anon1 **methodLists ; /* objc_method_list */ + struct objc_cache *cache ; + struct objc_protocol_list *protocols ; +#endif +} _NSConstantStringClassReference ; +#else +struct objc_class _NSConstantStringClassReference ; +#endif + +@interface NSConstantString : Object +{ + char *c_string; + unsigned int len; +} + +-(const char *) cString; +-(unsigned int) length; + +@end + +@implementation NSConstantString + +-(const char *) cString +{ + return (c_string); +} + +-(unsigned int) length +{ + return (len); +} + +@end + +/* The NSConstantString metaclass will need to be initialized before we can + send messages to strings. */ + +void objc_constant_string_init (void) __attribute__((constructor)); +void objc_constant_string_init (void) { + memcpy (&_NSConstantStringClassReference, + objc_getClass ("NSConstantString"), + sizeof (_NSConstantStringClassReference)); +} + +#endif /* #ifdef __NEXT_RUNTIME__ */

gnu-src/gcc-4.5.1/gcc/testsuite/objc-obj-c++-shared/next-mapping.h Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property