home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
OS/2 Shareware BBS: 10 Tools
/
10-Tools.zip
/
tolkit45.zip
/
os2tk45
/
som
/
include
/
somcls.h
< prev
next >
Wrap
C/C++ Source or Header
|
1999-02-22
|
66KB
|
1,711 lines
/*
* This file was generated by the SOM Compiler.
* FileName: somcls.h.
* Generated using:
* SOM Precompiler somipc: 2.29.1.17
* SOM Emitter emith: 2.47
*/
#ifndef SOM_SOMClass_h
#define SOM_SOMClass_h
#include <som.h>
/*
* -- This emitter treats Method Tokens as Thunks by default.
* -- Use the sc modifier "nothunks" to change this default
*/
#undef somresolve_
#define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
/*
* Define the class name as an object type
*/
#ifndef SOMClass
#define SOMClass SOMObject
#endif
/*
* This is the SOM metaclass. That is, the instances of this class
* are class objects. When the SOM environment is created an instance
* of SOMClass is created and a pointer to it is placed in the external
* data location (SOMClassClassData.classObject). Bindings provide the
* macro _SOMClass for this expression. _SOMClass is unique in that it
* is its own class object. I.e., _SOMClass == _somGetClass(_SOMClass).
* SOMClass can be subclassed just like any SOM class. The subclasses
* of SOMClass are new metaclasses and can generate class objects with
* different implementations than those produced by _SOMClass.
*
* An important rule for metaclass programming is that no methods
* introduced by SOMClass should ever be overridden. While this
* limits the utility of metaclass programming in SOM, it guarantees
* that SOM will operate correctly. Special class frameworks may be
* available from IBM to alleviate this restriction. Also, the
* restriction may be lifted in the future.
*
*/
#include <somobj.h>
/*
* Start of bindings for IDL types
*/
#ifndef SOMClass
#define SOMClass SOMObject
#endif /* SOMClass */
#ifndef _IDL_SEQUENCE_somToken_defined
#define _IDL_SEQUENCE_somToken_defined
typedef struct {
unsigned long _maximum;
unsigned long _length;
somToken *_buffer;
} _IDL_SEQUENCE_somToken;
#endif /* _IDL_SEQUENCE_somToken_defined */
typedef
_IDL_SEQUENCE_somToken SOMClass_somTokenSequence;
/*
* a (generic) sequence of somTokens
*/
#ifndef _IDL_SEQUENCE_SOMClass_defined
#define _IDL_SEQUENCE_SOMClass_defined
typedef struct {
unsigned long _maximum;
unsigned long _length;
SOMClass **_buffer;
} _IDL_SEQUENCE_SOMClass;
#endif /* _IDL_SEQUENCE_SOMClass_defined */
typedef
_IDL_SEQUENCE_SOMClass SOMClass_SOMClassSequence;
/*
* a sequence of classes
*/
typedef
struct SOMClass_somOffsetInfo {
SOMClass* cls;
long offset;
} SOMClass_somOffsetInfo;
/*
* a structure to describe a class-related offset
*/
struct SOMClass_somOffsetInfo;
#ifndef _IDL_SEQUENCE_SOMClass_somOffsetInfo_defined
#define _IDL_SEQUENCE_SOMClass_somOffsetInfo_defined
typedef struct {
unsigned long _maximum;
unsigned long _length;
struct SOMClass_somOffsetInfo *_buffer;
} _IDL_SEQUENCE_SOMClass_somOffsetInfo;
#endif /* _IDL_SEQUENCE_SOMClass_somOffsetInfo_defined */
typedef
_IDL_SEQUENCE_SOMClass_somOffsetInfo SOMClass_somOffsets;
/*
* a sequence of class-related offsets
*/
#ifndef _IDL_SEQUENCE_somId_defined
#define _IDL_SEQUENCE_somId_defined
typedef struct {
unsigned long _maximum;
unsigned long _length;
somId *_buffer;
} _IDL_SEQUENCE_somId;
#endif /* _IDL_SEQUENCE_somId_defined */
typedef
_IDL_SEQUENCE_somId SOMClass_somIdSequence;
/*
* a sequence of somIds
*/
#ifndef SOM_DONT_USE_SHORT_NAMES
#ifndef SOM_DONT_USE_SHORT_NAMES
#ifndef SOMTGD_somTokenSequence
#ifdef somTokenSequence
#undef somTokenSequence
#define SOMTGD_somTokenSequence 1
#else
#define somTokenSequence SOMClass_somTokenSequence
#endif /* somTokenSequence */
#endif /* SOMTGD_somTokenSequence */
#endif /* SOM_DONT_USE_SHORT_NAMES */
#ifndef SOM_DONT_USE_SHORT_NAMES
#ifndef SOMTGD_SOMClassSequence
#ifdef SOMClassSequence
#undef SOMClassSequence
#define SOMTGD_SOMClassSequence 1
#else
#define SOMClassSequence SOMClass_SOMClassSequence
#endif /* SOMClassSequence */
#endif /* SOMTGD_SOMClassSequence */
#endif /* SOM_DONT_USE_SHORT_NAMES */
#ifndef SOMTGD_somOffsetInfo
#ifdef somOffsetInfo
#undef somOffsetInfo
#define SOMTGD_somOffsetInfo 1
#else
#define somOffsetInfo SOMClass_somOffsetInfo
#endif /* somOffsetInfo */
#endif /* SOMTGD_somOffsetInfo */
#ifndef SOMTGD__IDL_SEQUENCE_somOffsetInfo
#ifdef _IDL_SEQUENCE_somOffsetInfo
#undef _IDL_SEQUENCE_somOffsetInfo
#define SOMTGD__IDL_SEQUENCE_somOffsetInfo 1
#else
#define _IDL_SEQUENCE_somOffsetInfo _IDL_SEQUENCE_SOMClass_somOffsetInfo
#endif /* _IDL_SEQUENCE_somOffsetInfo */
#endif /* SOMTGD__IDL_SEQUENCE_somOffsetInfo */
#ifndef SOM_DONT_USE_SHORT_NAMES
#ifndef SOMTGD_somOffsets
#ifdef somOffsets
#undef somOffsets
#define SOMTGD_somOffsets 1
#else
#define somOffsets SOMClass_somOffsets
#endif /* somOffsets */
#endif /* SOMTGD_somOffsets */
#endif /* SOM_DONT_USE_SHORT_NAMES */
#ifndef SOM_DONT_USE_SHORT_NAMES
#ifndef SOMTGD_somIdSequence
#ifdef somIdSequence
#undef somIdSequence
#define SOMTGD_somIdSequence 1
#else
#define somIdSequence SOMClass_somIdSequence
#endif /* somIdSequence */
#endif /* SOMTGD_somIdSequence */
#endif /* SOM_DONT_USE_SHORT_NAMES */
#endif /* SOM_DONT_USE_SHORT_NAMES */
/*
* End of bindings for IDL types.
*/
#define SOMClass_MajorVersion 1
#define SOMClass_MinorVersion 5
/*
* External name shortening if required
*/
#ifdef SOM_USE_SHORT_EXTERNAL_NAMES
#define SOMClassNewClass sommcc
#pragma linkage(sommcc, system)
#define SOMClassClassData sommcd
#define SOMClassCClassData sommcx
#endif /* SOM_USE_SHORT_EXTERNAL_NAMES */
/*--------------Migration------------*/
#define SOMClass_classObj SOMClassClassData.classObject
#define _SOMClass SOMClass_classObj
/*
* Declare the class creation procedure
*/
SOMEXTERN SOMClass * SOMLINK SOMClassNewClass(integer4 somtmajorVersion,
integer4 somtminorVersion);
#pragma linkage(SOMClassNewClass, system)
/*
* Declare the class data structure
*/
SOMEXTERN struct SOMClassClassDataStructure {
SOMClass *classObject;
somMToken somNew;
somMToken somRenew;
somMToken somInitClass;
somMToken somClassReady;
somMToken somGetName;
somMToken somGetParent;
somMToken somDescendedFrom;
somMToken somCheckVersion;
somMToken somFindMethod;
somMToken somFindMethodOk;
somMToken somSupportsMethod;
somMToken somGetNumMethods;
somMToken somGetInstanceSize;
somMToken somGetInstanceOffset;
somMToken somGetInstancePartSize;
somMToken somGetMethodIndex;
somMToken somGetNumStaticMethods;
somMToken somGetPClsMtab;
somMToken somGetClassMtab;
somMToken somAddStaticMethod;
somMToken somOverrideSMethod;
somMToken somAddDynamicMethod;
somMToken somcPrivate0;
somMToken somGetApplyStub;
somMToken somFindSMethod;
somMToken somFindSMethodOk;
somMToken somGetMethodDescriptor;
somMToken somGetNthMethodInfo;
somMToken somSetClassData;
somMToken somGetClassData;
somMToken somNewNoInit;
somMToken somRenewNoInit;
somMToken somGetInstanceToken;
somMToken somGetMemberToken;
somMToken somcPrivate1;
somMToken somGetMethodData;
somMToken somOverrideMtab;
somMToken somGetMethodToken;
somMToken somGetParents;
somMToken somGetPClsMtabs;
somMToken somInitMIClass;
somMToken somGetVersionNumbers;
somMToken somLookupMethod;
somMToken _get_somInstanceDataOffsets;
somMToken somRenewNoZero;
somMToken somRenewNoInitNoZero;
somMToken somAllocate;
somMToken somDeallocate;
somMToken somGetRdStub;
somMToken somGetNthMethodData;
somMToken somcPrivate2;
somMToken somcPrivate3;
somMToken _get_somDirectInitClasses;
somMToken somcPrivate5;
somMToken somcPrivate6;
somMToken somcPrivate7;
somMToken somcPrivate8;
somMToken somcPrivate9;
somMToken somcPrivate10;
somMToken somcPrivate11;
somMToken somcPrivate12;
somMToken somDefinedMethod;
somMToken somcPrivate13;
somMToken somcPrivate14;
somMToken somcPrivate15;
somMToken somcPrivate16;
somMToken somcPrivate17;
somMToken somcPrivate18;
somMToken somcPrivate19;
somMToken somcPrivate20;
somMToken _get_somDataAlignment;
somMToken somcPrivate21;
somMToken somcPrivate22;
somMToken somcPrivate23;
somMToken somcPrivate24;
somMToken somcPrivate25;
} SOMDLINK SOMClassClassData;
/*
* Declare the C specific class data structure
*/
SOMEXTERN struct SOMClassCClassDataStructure {
somMethodTabs parentMtab;
somDToken instanceDataToken;
} SOMDLINK SOMClassCClassData;
/*
* New and Renew macros for SOMClass
*/
#define SOMClassNew() \
( _SOMClass ? \
_somNew(_SOMClass) \
: ( SOMClassNewClass(\
SOMClass_MajorVersion, \
SOMClass_MinorVersion),\
_somNew(_SOMClass)))
#define SOMClassRenew(buf) \
( _SOMClass ? \
_somRenew(_SOMClass, buf) \
: ( SOMClassNewClass(\
SOMClass_MajorVersion, \
SOMClass_MinorVersion),\
_somRenew(_SOMClass, buf)))
/*
* New Method: _get_somDataAlignment
*/
typedef long SOMLINK somTP_SOMClass__get_somDataAlignment(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass__get_somDataAlignment, system)
typedef somTP_SOMClass__get_somDataAlignment *somTD_SOMClass__get_somDataAlignment;
/*
* The alignment required for the instance data structure
* introduced by the receiving class.
*/
#define somMD_SOMClass__get_somDataAlignment "::SOMClass::_get_somDataAlignment"
#define SOMClass__get_somDataAlignment(somSelf) \
(SOM_Resolve(somSelf, SOMClass, _get_somDataAlignment) \
(somSelf))
#ifndef SOMGD_get_somDataAlignment
#if (defined(_get_somDataAlignment) || defined(__get_somDataAlignment))
#undef _get_somDataAlignment
#undef __get_somDataAlignment
#define SOMGD_get_somDataAlignment 1
#else
#define __get_somDataAlignment SOMClass__get_somDataAlignment
#endif /* __get_somDataAlignment */
#endif /* SOMGD_get_somDataAlignment */
/*
* New Method: _get_somInstanceDataOffsets
*/
typedef SOMClass_somOffsets SOMLINK somTP_SOMClass__get_somInstanceDataOffsets(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass__get_somInstanceDataOffsets, system)
typedef somTP_SOMClass__get_somInstanceDataOffsets *somTD_SOMClass__get_somInstanceDataOffsets;
/*
* A sequence of the instance data offsets for all classes used in
* the derivation of the receiving class (including the receiver).
*/
#define somMD_SOMClass__get_somInstanceDataOffsets "::SOMClass::_get_somInstanceDataOffsets"
#define SOMClass__get_somInstanceDataOffsets(somSelf) \
(SOM_Resolve(somSelf, SOMClass, _get_somInstanceDataOffsets) \
(somSelf))
#ifndef SOMGD_get_somInstanceDataOffsets
#if (defined(_get_somInstanceDataOffsets) || defined(__get_somInstanceDataOffsets))
#undef _get_somInstanceDataOffsets
#undef __get_somInstanceDataOffsets
#define SOMGD_get_somInstanceDataOffsets 1
#else
#define __get_somInstanceDataOffsets SOMClass__get_somInstanceDataOffsets
#endif /* __get_somInstanceDataOffsets */
#endif /* SOMGD_get_somInstanceDataOffsets */
/*
* New Method: _get_somDirectInitClasses
*/
typedef SOMClass_SOMClassSequence SOMLINK somTP_SOMClass__get_somDirectInitClasses(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass__get_somDirectInitClasses, system)
typedef somTP_SOMClass__get_somDirectInitClasses *somTD_SOMClass__get_somDirectInitClasses;
/*
* The ancestors whose initializers the receiving
* class wants to directly invoke.
*/
#define somMD_SOMClass__get_somDirectInitClasses "::SOMClass::_get_somDirectInitClasses"
#define SOMClass__get_somDirectInitClasses(somSelf) \
(SOM_Resolve(somSelf, SOMClass, _get_somDirectInitClasses) \
(somSelf))
#ifndef SOMGD_get_somDirectInitClasses
#if (defined(_get_somDirectInitClasses) || defined(__get_somDirectInitClasses))
#undef _get_somDirectInitClasses
#undef __get_somDirectInitClasses
#define SOMGD_get_somDirectInitClasses 1
#else
#define __get_somDirectInitClasses SOMClass__get_somDirectInitClasses
#endif /* __get_somDirectInitClasses */
#endif /* SOMGD_get_somDirectInitClasses */
/*
* New Method: somNew
*/
typedef SOMObject* SOMLINK somTP_SOMClass_somNew(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somNew, system)
typedef somTP_SOMClass_somNew *somTD_SOMClass_somNew;
/*
* Uses SOMMalloc to allocate storage for a new instance of the
* receiving class, and then calls somRenewNoInitNoZero to load the
* new object's method table pointer. Then somDefaultInit is called to
* initialize the new object. Note: If the instance is a class object,
* somInitMIClass must then be invoked to declare parents and
* initialize the class's instance method table. Upon failure, NULL
* is returned.
*/
#define somMD_SOMClass_somNew "::SOMClass::somNew"
#define SOMClass_somNew(somSelf) \
(SOM_Resolve(somSelf, SOMClass, somNew) \
(somSelf))
#ifndef SOMGD_somNew
#if (defined(_somNew) || defined(__somNew))
#undef _somNew
#undef __somNew
#define SOMGD_somNew 1
#else
#define _somNew SOMClass_somNew
#endif /* _somNew */
#endif /* SOMGD_somNew */
/*
* New Method: somNewNoInit
*/
typedef SOMObject* SOMLINK somTP_SOMClass_somNewNoInit(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somNewNoInit, system)
typedef somTP_SOMClass_somNewNoInit *somTD_SOMClass_somNewNoInit;
/*
* Equivalent to somNew except that somDefaultInit is not called.
*/
#define somMD_SOMClass_somNewNoInit "::SOMClass::somNewNoInit"
#define SOMClass_somNewNoInit(somSelf) \
(SOM_Resolve(somSelf, SOMClass, somNewNoInit) \
(somSelf))
#ifndef SOMGD_somNewNoInit
#if (defined(_somNewNoInit) || defined(__somNewNoInit))
#undef _somNewNoInit
#undef __somNewNoInit
#define SOMGD_somNewNoInit 1
#else
#define _somNewNoInit SOMClass_somNewNoInit
#endif /* _somNewNoInit */
#endif /* SOMGD_somNewNoInit */
/*
* New Method: somRenew
*/
typedef SOMObject* SOMLINK somTP_SOMClass_somRenew(SOMClass *somSelf,
void* obj);
#pragma linkage(somTP_SOMClass_somRenew, system)
typedef somTP_SOMClass_somRenew *somTD_SOMClass_somRenew;
/*
* Equivalent to somNew except that storage is not allocated.
* <obj> is taken as the address of the new object.
*/
#define somMD_SOMClass_somRenew "::SOMClass::somRenew"
#define SOMClass_somRenew(somSelf,obj) \
(SOM_Resolve(somSelf, SOMClass, somRenew) \
(somSelf,obj))
#ifndef SOMGD_somRenew
#if (defined(_somRenew) || defined(__somRenew))
#undef _somRenew
#undef __somRenew
#define SOMGD_somRenew 1
#else
#define _somRenew SOMClass_somRenew
#endif /* _somRenew */
#endif /* SOMGD_somRenew */
/*
* New Method: somRenewNoInit
*/
typedef SOMObject* SOMLINK somTP_SOMClass_somRenewNoInit(SOMClass *somSelf,
void* obj);
#pragma linkage(somTP_SOMClass_somRenewNoInit, system)
typedef somTP_SOMClass_somRenewNoInit *somTD_SOMClass_somRenewNoInit;
/*
* Equivalent to somRenew except that somDefaultInit is not called.
*/
#define somMD_SOMClass_somRenewNoInit "::SOMClass::somRenewNoInit"
#define SOMClass_somRenewNoInit(somSelf,obj) \
(SOM_Resolve(somSelf, SOMClass, somRenewNoInit) \
(somSelf,obj))
#ifndef SOMGD_somRenewNoInit
#if (defined(_somRenewNoInit) || defined(__somRenewNoInit))
#undef _somRenewNoInit
#undef __somRenewNoInit
#define SOMGD_somRenewNoInit 1
#else
#define _somRenewNoInit SOMClass_somRenewNoInit
#endif /* _somRenewNoInit */
#endif /* SOMGD_somRenewNoInit */
/*
* New Method: somRenewNoZero
*/
typedef SOMObject* SOMLINK somTP_SOMClass_somRenewNoZero(SOMClass *somSelf,
void* obj);
#pragma linkage(somTP_SOMClass_somRenewNoZero, system)
typedef somTP_SOMClass_somRenewNoZero *somTD_SOMClass_somRenewNoZero;
/*
* Equivalent to somRenew except that memory is not zeroed out.
*/
#define somMD_SOMClass_somRenewNoZero "::SOMClass::somRenewNoZero"
#define SOMClass_somRenewNoZero(somSelf,obj) \
(SOM_Resolve(somSelf, SOMClass, somRenewNoZero) \
(somSelf,obj))
#ifndef SOMGD_somRenewNoZero
#if (defined(_somRenewNoZero) || defined(__somRenewNoZero))
#undef _somRenewNoZero
#undef __somRenewNoZero
#define SOMGD_somRenewNoZero 1
#else
#define _somRenewNoZero SOMClass_somRenewNoZero
#endif /* _somRenewNoZero */
#endif /* SOMGD_somRenewNoZero */
/*
* New Method: somRenewNoInitNoZero
*/
typedef SOMObject* SOMLINK somTP_SOMClass_somRenewNoInitNoZero(SOMClass *somSelf,
void* obj);
#pragma linkage(somTP_SOMClass_somRenewNoInitNoZero, system)
typedef somTP_SOMClass_somRenewNoInitNoZero *somTD_SOMClass_somRenewNoInitNoZero;
/*
* The purpose of this method is to load an object's method table.
* The SOM API requires that somRenewNoInitNoZero always be
* called when creating a new object whose metaclass is not SOMClass.
* This is because metaclasses must be guaranteed that they can use
* somRenewNoInitNoZero to track object creation if this is desired.
*/
#define somMD_SOMClass_somRenewNoInitNoZero "::SOMClass::somRenewNoInitNoZero"
#define SOMClass_somRenewNoInitNoZero(somSelf,obj) \
(SOM_Resolve(somSelf, SOMClass, somRenewNoInitNoZero) \
(somSelf,obj))
#ifndef SOMGD_somRenewNoInitNoZero
#if (defined(_somRenewNoInitNoZero) || defined(__somRenewNoInitNoZero))
#undef _somRenewNoInitNoZero
#undef __somRenewNoInitNoZero
#define SOMGD_somRenewNoInitNoZero 1
#else
#define _somRenewNoInitNoZero SOMClass_somRenewNoInitNoZero
#endif /* _somRenewNoInitNoZero */
#endif /* SOMGD_somRenewNoInitNoZero */
/*
* New Method: somAllocate
*/
typedef somToken SOMLINK somTP_SOMClass_somAllocate(SOMClass *somSelf,
long size);
#pragma linkage(somTP_SOMClass_somAllocate, system)
typedef somTP_SOMClass_somAllocate *somTD_SOMClass_somAllocate;
/*
* Allocates memory to hold an object and returns a pointer to this memory.
* This is a nonstatic method, and cannot be overridden. The default
* implementation calls SOMMalloc, but a class designer can specify a
* different implementation using the somallocate modifier in IDL. The
* allocator takes the same parameters as this method.
*/
#define somMD_SOMClass_somAllocate "::SOMClass::somAllocate"
#define SOMClass_somAllocate(somSelf,size) \
(SOM_Resolve(somSelf, SOMClass, somAllocate) \
(somSelf,size))
#ifndef SOMGD_somAllocate
#if (defined(_somAllocate) || defined(__somAllocate))
#undef _somAllocate
#undef __somAllocate
#define SOMGD_somAllocate 1
#else
#define _somAllocate SOMClass_somAllocate
#endif /* _somAllocate */
#endif /* SOMGD_somAllocate */
/*
* New Method: somDeallocate
*/
typedef void SOMLINK somTP_SOMClass_somDeallocate(SOMClass *somSelf,
somToken memptr);
#pragma linkage(somTP_SOMClass_somDeallocate, system)
typedef somTP_SOMClass_somDeallocate *somTD_SOMClass_somDeallocate;
/*
* Zeros out the method table pointer stored in the word pointed to by
* memptr, and then deallocates the block of memory pointed to by memptr.
* This is a nonstatic method and cannot be overridden. The default
* deallocator called is SOMFree, but a class designer can specify a
* different deallocator using the somdeallocate modifier in IDL. The
* deallocator takes a char* (memptr) and a long (size) as arguments.
*/
#define somMD_SOMClass_somDeallocate "::SOMClass::somDeallocate"
#define SOMClass_somDeallocate(somSelf,memptr) \
(SOM_Resolve(somSelf, SOMClass, somDeallocate) \
(somSelf,memptr))
#ifndef SOMGD_somDeallocate
#if (defined(_somDeallocate) || defined(__somDeallocate))
#undef _somDeallocate
#undef __somDeallocate
#define SOMGD_somDeallocate 1
#else
#define _somDeallocate SOMClass_somDeallocate
#endif /* _somDeallocate */
#endif /* SOMGD_somDeallocate */
/*
* New Method: somInitClass
*/
typedef void SOMLINK somTP_SOMClass_somInitClass(SOMClass *somSelf,
string className,
SOMClass* parentClass,
long dataSize,
long maxStaticMethods,
long majorVersion,
long minorVersion);
#pragma linkage(somTP_SOMClass_somInitClass, system)
typedef somTP_SOMClass_somInitClass *somTD_SOMClass_somInitClass;
/*
* somInitClass is obsolete, and should no longer be used. The SOM 2.0
* kernel provides special handling for redispatch stubs in the case
* of SOM 1.0 classes, and use of this method is what tells the kernel
* that old-style redispatch stubs will be registered.
*/
#define somMD_SOMClass_somInitClass "::SOMClass::somInitClass"
#define SOMClass_somInitClass(somSelf,className,parentClass,dataSize,maxStaticMethods,majorVersion,minorVersion) \
(SOM_Resolve(somSelf, SOMClass, somInitClass) \
(somSelf,className,parentClass,dataSize,maxStaticMethods,majorVersion,minorVersion))
#ifndef SOMGD_somInitClass
#if (defined(_somInitClass) || defined(__somInitClass))
#undef _somInitClass
#undef __somInitClass
#define SOMGD_somInitClass 1
#else
#define _somInitClass SOMClass_somInitClass
#endif /* _somInitClass */
#endif /* SOMGD_somInitClass */
/*
* New Method: somInitMIClass
*/
typedef void SOMLINK somTP_SOMClass_somInitMIClass(SOMClass *somSelf,
long inherit_vars,
string className,
SOMClass_SOMClassSequence* parentClasses,
long dataSize,
long dataAlignment,
long maxStaticMethods,
long majorVersion,
long minorVersion);
#pragma linkage(somTP_SOMClass_somInitMIClass, system)
typedef somTP_SOMClass_somInitMIClass *somTD_SOMClass_somInitMIClass;
/*
* somInitMIClass implements the second phase of dynamic class creation:
* inheritance of interface and possibly implementation (instance
* variables) by suitable initialization of <self> (a class object).
*
* For somInitMIClass, the inherit_vars argument controls whether abstract
* or implementation inheritance is used. Inherit_vars is a 32 bit
* bit-vector. Implementation is inherited from parent i iff the bit
* 1<<i is on, or i>=32.
* On a class-by-class basis, for each class ancestor, implementation
* inheritance always takes precidence over abstract inheritance. This is
* necessary to guarantee that procedures supporting parent method calls
* (available on non-abstract parents) are always supported by parent
* instance variables.
*
* <className> is a string containing the class name. A copy is made, so
* the string may be freed upon return to the caller if this is desired.
*
* <parentClasses> is a SOMClassSequence containing pointers to the
* parent classes. somInitMIClass makes a copy of this, so it may
* be freed upon return to the caller if this is desired.
*
* <dataSize> is the space needed for the instance variables
* introduced by this class.
*
* <dataAlignment> specifies the desired byte alignment for instance
* data introduced by this class. A value of 0 selects a system-wide default;
* any other argument is taken as the desired byte alignment multiple. Thus,
* for example, even if a byte multiple of 8 is needed for double precision
* values on a given system (so 8 is the default), a class whose instance data
* doesn't require this can indicate otherwise. If A is the next memory
* address available for holding instance data, the address that will be
* used is A + (A mod byte-alignment).
*
* <maxStaticMethods> is the maximum number of static methods that will be
* added to the initialized class using addStaticMethod.
*
* <majorVersion> indicates the major version number for this
* implementation of the class definition, and <minorVersion>
* indicates the minor version number.
*/
#define somMD_SOMClass_somInitMIClass "::SOMClass::somInitMIClass"
#define SOMClass_somInitMIClass(somSelf,inherit_vars,className,parentClasses,dataSize,dataAlignment,maxStaticMethods,majorVersion,minorVersion) \
(SOM_Resolve(somSelf, SOMClass, somInitMIClass) \
(somSelf,inherit_vars,className,parentClasses,dataSize,dataAlignment,maxStaticMethods,majorVersion,minorVersion))
#ifndef SOMGD_somInitMIClass
#if (defined(_somInitMIClass) || defined(__somInitMIClass))
#undef _somInitMIClass
#undef __somInitMIClass
#define SOMGD_somInitMIClass 1
#else
#define _somInitMIClass SOMClass_somInitMIClass
#endif /* _somInitMIClass */
#endif /* SOMGD_somInitMIClass */
/*
* New Method: somAddStaticMethod
*/
typedef somMToken SOMLINK somTP_SOMClass_somAddStaticMethod(SOMClass *somSelf,
somId methodId,
somId methodDescriptor,
somMethodPtr method,
somMethodPtr redispatchStub,
somMethodPtr applyStub);
#pragma linkage(somTP_SOMClass_somAddStaticMethod, system)
typedef somTP_SOMClass_somAddStaticMethod *somTD_SOMClass_somAddStaticMethod;
/*
* Adds the indicated method, creating and returning a new method token.
*
* <methodDescriptor> is the somId for an identifier that can be used
* to access signature information about the method from an interface
* repository.
*
* <method> is the actual method procedure for this method
*
* <redispatchStub> is a procedure with the same calling sequence as
* <method> that invokes somDispatch for the method.
*
* <applyStub> is a procedure used to support somApply.
*/
#define somMD_SOMClass_somAddStaticMethod "::SOMClass::somAddStaticMethod"
#define SOMClass_somAddStaticMethod(somSelf,methodId,methodDescriptor,method,redispatchStub,applyStub) \
(SOM_Resolve(somSelf, SOMClass, somAddStaticMethod) \
(somSelf,methodId,methodDescriptor,method,redispatchStub,applyStub))
#ifndef SOMGD_somAddStaticMethod
#if (defined(_somAddStaticMethod) || defined(__somAddStaticMethod))
#undef _somAddStaticMethod
#undef __somAddStaticMethod
#define SOMGD_somAddStaticMethod 1
#else
#define _somAddStaticMethod SOMClass_somAddStaticMethod
#endif /* _somAddStaticMethod */
#endif /* SOMGD_somAddStaticMethod */
/*
* New Method: somAddDynamicMethod
*/
typedef void SOMLINK somTP_SOMClass_somAddDynamicMethod(SOMClass *somSelf,
somId methodId,
somId methodDescriptor,
somMethodPtr method,
somMethodPtr applyStub);
#pragma linkage(somTP_SOMClass_somAddDynamicMethod, system)
typedef somTP_SOMClass_somAddDynamicMethod *somTD_SOMClass_somAddDynamicMethod;
/*
* Adds the indicated method to the class's name lookup list.
* If this happens to override a static method then this operation is
* equivalent to <somOverrideSMethod> and the <methodDescriptor> and
* <applyStub> arguments are ignored (the overridden method's values
* will be used).
*
* <methodDescriptor> is the somId for an identifier that can be used
* to access signature information about the method from an interface
* repository.
*
* <method> is the actual method procedure for this method
*
* <applyStub> is a procedure that takes a standard variable argument
* list data structure applies it to its target object by calling
* <method> with arguments derived from the data structure. Its
* calling sequence is the same as the calling sequence of the
* dispatch methods defined in SOMObject. This stub is used in the
* support of the dispatch methods used in some classes. In classes
* where the dispatch functions do not need such a function this
* parameter may be null.
*/
#define somMD_SOMClass_somAddDynamicMethod "::SOMClass::somAddDynamicMethod"
#define SOMClass_somAddDynamicMethod(somSelf,methodId,methodDescriptor,method,applyStub) \
(SOM_Resolve(somSelf, SOMClass, somAddDynamicMethod) \
(somSelf,methodId,methodDescriptor,method,applyStub))
#ifndef SOMGD_somAddDynamicMethod
#if (defined(_somAddDynamicMethod) || defined(__somAddDynamicMethod))
#undef _somAddDynamicMethod
#undef __somAddDynamicMethod
#define SOMGD_somAddDynamicMethod 1
#else
#define _somAddDynamicMethod SOMClass_somAddDynamicMethod
#endif /* _somAddDynamicMethod */
#endif /* SOMGD_somAddDynamicMethod */
/*
* New Method: somOverrideSMethod
*/
typedef void SOMLINK somTP_SOMClass_somOverrideSMethod(SOMClass *somSelf,
somId methodId,
somMethodPtr method);
#pragma linkage(somTP_SOMClass_somOverrideSMethod, system)
typedef somTP_SOMClass_somOverrideSMethod *somTD_SOMClass_somOverrideSMethod;
/*
* This method can be used instead of <somAddStaticMethod> or
* <somAddDynamicMethod> when it is known that the class' parent
* class already supports this method. This call does not require the
* method descriptor and stub methods that the others do.
*/
#define somMD_SOMClass_somOverrideSMethod "::SOMClass::somOverrideSMethod"
#define SOMClass_somOverrideSMethod(somSelf,methodId,method) \
(SOM_Resolve(somSelf, SOMClass, somOverrideSMethod) \
(somSelf,methodId,method))
#ifndef SOMGD_somOverrideSMethod
#if (defined(_somOverrideSMethod) || defined(__somOverrideSMethod))
#undef _somOverrideSMethod
#undef __somOverrideSMethod
#define SOMGD_somOverrideSMethod 1
#else
#define _somOverrideSMethod SOMClass_somOverrideSMethod
#endif /* _somOverrideSMethod */
#endif /* SOMGD_somOverrideSMethod */
/*
* New Method: somClassReady
*/
typedef void SOMLINK somTP_SOMClass_somClassReady(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somClassReady, system)
typedef somTP_SOMClass_somClassReady *somTD_SOMClass_somClassReady;
/*
* This method is invoked when all of the static initialization for
* the class has been finished. The default implementation simply
* registers the newly constructed class with the SOMClassMgr.
*/
#define somMD_SOMClass_somClassReady "::SOMClass::somClassReady"
#define SOMClass_somClassReady(somSelf) \
(SOM_Resolve(somSelf, SOMClass, somClassReady) \
(somSelf))
#ifndef SOMGD_somClassReady
#if (defined(_somClassReady) || defined(__somClassReady))
#undef _somClassReady
#undef __somClassReady
#define SOMGD_somClassReady 1
#else
#define _somClassReady SOMClass_somClassReady
#endif /* _somClassReady */
#endif /* SOMGD_somClassReady */
/*
* New Method: somGetApplyStub
*/
typedef somMethodPtr SOMLINK somTP_SOMClass_somGetApplyStub(SOMClass *somSelf,
somId methodId);
#pragma linkage(somTP_SOMClass_somGetApplyStub, system)
typedef somTP_SOMClass_somGetApplyStub *somTD_SOMClass_somGetApplyStub;
/*
* Returns the apply stub associated with the specified method,
* if one exists; otherwise NULL is returned. This method is obsolete,
* and retained for binary compatability. In SOMr2, users never access
* apply stubs directly; The function somApply is used to invoke apply
* stubs. See somApply documentation for further information on apply
* stubs, and see somAddStaticMethod documentation for information
* on how apply stubs are registered by class implementations.
*/
#define somMD_SOMClass_somGetApplyStub "::SOMClass::somGetApplyStub"
#define SOMClass_somGetApplyStub(somSelf,methodId) \
(SOM_Resolve(somSelf, SOMClass, somGetApplyStub) \
(somSelf,methodId))
#ifndef SOMGD_somGetApplyStub
#if (defined(_somGetApplyStub) || defined(__somGetApplyStub))
#undef _somGetApplyStub
#undef __somGetApplyStub
#define SOMGD_somGetApplyStub 1
#else
#define _somGetApplyStub SOMClass_somGetApplyStub
#endif /* _somGetApplyStub */
#endif /* SOMGD_somGetApplyStub */
/*
* New Method: somGetClassData
*/
typedef somClassDataStructure* SOMLINK somTP_SOMClass_somGetClassData(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somGetClassData, system)
typedef somTP_SOMClass_somGetClassData *somTD_SOMClass_somGetClassData;
#define somMD_SOMClass_somGetClassData "::SOMClass::somGetClassData"
#define SOMClass_somGetClassData(somSelf) \
(SOM_Resolve(somSelf, SOMClass, somGetClassData) \
(somSelf))
#ifndef SOMGD_somGetClassData
#if (defined(_somGetClassData) || defined(__somGetClassData))
#undef _somGetClassData
#undef __somGetClassData
#define SOMGD_somGetClassData 1
#else
#define _somGetClassData SOMClass_somGetClassData
#endif /* _somGetClassData */
#endif /* SOMGD_somGetClassData */
/*
* New Method: somSetClassData
*/
typedef void SOMLINK somTP_SOMClass_somSetClassData(SOMClass *somSelf,
somClassDataStructure* cds);
#pragma linkage(somTP_SOMClass_somSetClassData, system)
typedef somTP_SOMClass_somSetClassData *somTD_SOMClass_somSetClassData;
/*
* The class' pointer to the static <className>ClassData structure.
*/
#define somMD_SOMClass_somSetClassData "::SOMClass::somSetClassData"
#define SOMClass_somSetClassData(somSelf,cds) \
(SOM_Resolve(somSelf, SOMClass, somSetClassData) \
(somSelf,cds))
#ifndef SOMGD_somSetClassData
#if (defined(_somSetClassData) || defined(__somSetClassData))
#undef _somSetClassData
#undef __somSetClassData
#define SOMGD_somSetClassData 1
#else
#define _somSetClassData SOMClass_somSetClassData
#endif /* _somSetClassData */
#endif /* SOMGD_somSetClassData */
/*
* New Method: somGetClassMtab
*/
typedef somMethodTab* SOMLINK somTP_SOMClass_somGetClassMtab(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somGetClassMtab, system)
typedef somTP_SOMClass_somGetClassMtab *somTD_SOMClass_somGetClassMtab;
/*
* A pointer to the method table used by instances of this class. This
* method was misnamed; it should have been called somGetInstanceMtab.
*/
#define somMD_SOMClass_somGetClassMtab "::SOMClass::somGetClassMtab"
#define SOMClass_somGetClassMtab(somSelf) \
(SOM_Resolve(somSelf, SOMClass, somGetClassMtab) \
(somSelf))
#ifndef SOMGD_somGetClassMtab
#if (defined(_somGetClassMtab) || defined(__somGetClassMtab))
#undef _somGetClassMtab
#undef __somGetClassMtab
#define SOMGD_somGetClassMtab 1
#else
#define _somGetClassMtab SOMClass_somGetClassMtab
#endif /* _somGetClassMtab */
#endif /* SOMGD_somGetClassMtab */
/*
* New Method: somGetInstanceOffset
*/
typedef long SOMLINK somTP_SOMClass_somGetInstanceOffset(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somGetInstanceOffset, system)
typedef somTP_SOMClass_somGetInstanceOffset *somTD_SOMClass_somGetInstanceOffset;
/*
* Returns the offset of instance data introduced by the receiver in
* an instance of the receiver. This method is obsolete and not useful in
* multiple-inheritance situations. The attribute somInstanceDataOffsets
* replaces this method.
*/
#define somMD_SOMClass_somGetInstanceOffset "::SOMClass::somGetInstanceOffset"
#define SOMClass_somGetInstanceOffset(somSelf) \
(SOM_Resolve(somSelf, SOMClass, somGetInstanceOffset) \
(somSelf))
#ifndef SOMGD_somGetInstanceOffset
#if (defined(_somGetInstanceOffset) || defined(__somGetInstanceOffset))
#undef _somGetInstanceOffset
#undef __somGetInstanceOffset
#define SOMGD_somGetInstanceOffset 1
#else
#define _somGetInstanceOffset SOMClass_somGetInstanceOffset
#endif /* _somGetInstanceOffset */
#endif /* SOMGD_somGetInstanceOffset */
/*
* New Method: somGetInstancePartSize
*/
typedef long SOMLINK somTP_SOMClass_somGetInstancePartSize(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somGetInstancePartSize, system)
typedef somTP_SOMClass_somGetInstancePartSize *somTD_SOMClass_somGetInstancePartSize;
/*
* The size in bytes of the instance data introduced by the receiving
* class.
*/
#define somMD_SOMClass_somGetInstancePartSize "::SOMClass::somGetInstancePartSize"
#define SOMClass_somGetInstancePartSize(somSelf) \
(SOM_Resolve(somSelf, SOMClass, somGetInstancePartSize) \
(somSelf))
#ifndef SOMGD_somGetInstancePartSize
#if (defined(_somGetInstancePartSize) || defined(__somGetInstancePartSize))
#undef _somGetInstancePartSize
#undef __somGetInstancePartSize
#define SOMGD_somGetInstancePartSize 1
#else
#define _somGetInstancePartSize SOMClass_somGetInstancePartSize
#endif /* _somGetInstancePartSize */
#endif /* SOMGD_somGetInstancePartSize */
/*
* New Method: somGetInstanceSize
*/
typedef long SOMLINK somTP_SOMClass_somGetInstanceSize(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somGetInstanceSize, system)
typedef somTP_SOMClass_somGetInstanceSize *somTD_SOMClass_somGetInstanceSize;
/*
* The total size of an instance of the receiving class.
*/
#define somMD_SOMClass_somGetInstanceSize "::SOMClass::somGetInstanceSize"
#define SOMClass_somGetInstanceSize(somSelf) \
(SOM_Resolve(somSelf, SOMClass, somGetInstanceSize) \
(somSelf))
#ifndef SOMGD_somGetInstanceSize
#if (defined(_somGetInstanceSize) || defined(__somGetInstanceSize))
#undef _somGetInstanceSize
#undef __somGetInstanceSize
#define SOMGD_somGetInstanceSize 1
#else
#define _somGetInstanceSize SOMClass_somGetInstanceSize
#endif /* _somGetInstanceSize */
#endif /* SOMGD_somGetInstanceSize */
/*
* New Method: somGetInstanceToken
*/
typedef somDToken SOMLINK somTP_SOMClass_somGetInstanceToken(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somGetInstanceToken, system)
typedef somTP_SOMClass_somGetInstanceToken *somTD_SOMClass_somGetInstanceToken;
/*
* A data token that identifies the introduced portion of this class
* within itself or any derived class. This token can be subsequently
* passed to the run-time somDataResolve function to locate the instance
* data introduced by this class in any object derived from this class.
*/
#define somMD_SOMClass_somGetInstanceToken "::SOMClass::somGetInstanceToken"
#define SOMClass_somGetInstanceToken(somSelf) \
(SOM_Resolve(somSelf, SOMClass, somGetInstanceToken) \
(somSelf))
#ifndef SOMGD_somGetInstanceToken
#if (defined(_somGetInstanceToken) || defined(__somGetInstanceToken))
#undef _somGetInstanceToken
#undef __somGetInstanceToken
#define SOMGD_somGetInstanceToken 1
#else
#define _somGetInstanceToken SOMClass_somGetInstanceToken
#endif /* _somGetInstanceToken */
#endif /* SOMGD_somGetInstanceToken */
/*
* New Method: somGetMemberToken
*/
typedef somDToken SOMLINK somTP_SOMClass_somGetMemberToken(SOMClass *somSelf,
long memberOffset,
somDToken instanceToken);
#pragma linkage(somTP_SOMClass_somGetMemberToken, system)
typedef somTP_SOMClass_somGetMemberToken *somTD_SOMClass_somGetMemberToken;
/*
* Returns a data token that for the data member at offset
* "memberOffset" within the introduced portion of the class identified
* by instanceToken. The instance token must have been obtained from a
* previous invocation of somGetInstanceToken. The returned member
* token can be subsequently passed to the run-time somDataResolve
* function to locate the data member.
*/
#define somMD_SOMClass_somGetMemberToken "::SOMClass::somGetMemberToken"
#define SOMClass_somGetMemberToken(somSelf,memberOffset,instanceToken) \
(SOM_Resolve(somSelf, SOMClass, somGetMemberToken) \
(somSelf,memberOffset,instanceToken))
#ifndef SOMGD_somGetMemberToken
#if (defined(_somGetMemberToken) || defined(__somGetMemberToken))
#undef _somGetMemberToken
#undef __somGetMemberToken
#define SOMGD_somGetMemberToken 1
#else
#define _somGetMemberToken SOMClass_somGetMemberToken
#endif /* _somGetMemberToken */
#endif /* SOMGD_somGetMemberToken */
/*
* New Method: somGetMethodData
*/
typedef boolean SOMLINK somTP_SOMClass_somGetMethodData(SOMClass *somSelf,
somId methodId,
somMethodData* md);
#pragma linkage(somTP_SOMClass_somGetMethodData, system)
typedef somTP_SOMClass_somGetMethodData *somTD_SOMClass_somGetMethodData;
/*
* If a method with id <methodId> is supported by the target class,
* the structure pointed to by <md> is loaded with method information
* and the value 1 is returned. In this case, if the method is not
* dynamic, md->method is loaded with the result of somClassResolve on
* the target class for the method. If the method is not supported,
* md->id is loaded with 0, and the value 0 is returned.
*/
#define somMD_SOMClass_somGetMethodData "::SOMClass::somGetMethodData"
#define SOMClass_somGetMethodData(somSelf,methodId,md) \
(SOM_Resolve(somSelf, SOMClass, somGetMethodData) \
(somSelf,methodId,md))
#ifndef SOMGD_somGetMethodData
#if (defined(_somGetMethodData) || defined(__somGetMethodData))
#undef _somGetMethodData
#undef __somGetMethodData
#define SOMGD_somGetMethodData 1
#else
#define _somGetMethodData SOMClass_somGetMethodData
#endif /* _somGetMethodData */
#endif /* SOMGD_somGetMethodData */
/*
* New Method: somGetRdStub
*/
typedef somMethodProc* SOMLINK somTP_SOMClass_somGetRdStub(SOMClass *somSelf,
somId methodId);
#pragma linkage(somTP_SOMClass_somGetRdStub, system)
typedef somTP_SOMClass_somGetRdStub *somTD_SOMClass_somGetRdStub;
/*
* Returns a redispatch stub for the indicated method, if possible.
* If not possible (because a valid redispatch stub has not been
* registered, and there is insufficient information to dynamically
* construct one), then a NULL is returned.
*/
#define somMD_SOMClass_somGetRdStub "::SOMClass::somGetRdStub"
#define SOMClass_somGetRdStub(somSelf,methodId) \
(SOM_Resolve(somSelf, SOMClass, somGetRdStub) \
(somSelf,methodId))
#ifndef SOMGD_somGetRdStub
#if (defined(_somGetRdStub) || defined(__somGetRdStub))
#undef _somGetRdStub
#undef __somGetRdStub
#define SOMGD_somGetRdStub 1
#else
#define _somGetRdStub SOMClass_somGetRdStub
#endif /* _somGetRdStub */
#endif /* SOMGD_somGetRdStub */
/*
* New Method: somGetMethodDescriptor
*/
typedef somId SOMLINK somTP_SOMClass_somGetMethodDescriptor(SOMClass *somSelf,
somId methodId);
#pragma linkage(somTP_SOMClass_somGetMethodDescriptor, system)
typedef somTP_SOMClass_somGetMethodDescriptor *somTD_SOMClass_somGetMethodDescriptor;
/*
* Returns the method descriptor for the indicated method. If
* this object does not support the indicated method then NULL is
* returned.
*/
#define somMD_SOMClass_somGetMethodDescriptor "::SOMClass::somGetMethodDescriptor"
#define SOMClass_somGetMethodDescriptor(somSelf,methodId) \
(SOM_Resolve(somSelf, SOMClass, somGetMethodDescriptor) \
(somSelf,methodId))
#ifndef SOMGD_somGetMethodDescriptor
#if (defined(_somGetMethodDescriptor) || defined(__somGetMethodDescriptor))
#undef _somGetMethodDescriptor
#undef __somGetMethodDescriptor
#define SOMGD_somGetMethodDescriptor 1
#else
#define _somGetMethodDescriptor SOMClass_somGetMethodDescriptor
#endif /* _somGetMethodDescriptor */
#endif /* SOMGD_somGetMethodDescriptor */
/*
* New Method: somGetMethodIndex
*/
typedef long SOMLINK somTP_SOMClass_somGetMethodIndex(SOMClass *somSelf,
somId id);
#pragma linkage(somTP_SOMClass_somGetMethodIndex, system)
typedef somTP_SOMClass_somGetMethodIndex *somTD_SOMClass_somGetMethodIndex;
/*
* Returns the index for the specified method. (A number that may
* change if any methods are added or deleted to this class object or
* any of its ancestors). This number is the basis for other calls to
* get info about the method. Indexes start at 0. A -1 is returned if
* the method cannot be found.
*/
#define somMD_SOMClass_somGetMethodIndex "::SOMClass::somGetMethodIndex"
#define SOMClass_somGetMethodIndex(somSelf,id) \
(SOM_Resolve(somSelf, SOMClass, somGetMethodIndex) \
(somSelf,id))
#ifndef SOMGD_somGetMethodIndex
#if (defined(_somGetMethodIndex) || defined(__somGetMethodIndex))
#undef _somGetMethodIndex
#undef __somGetMethodIndex
#define SOMGD_somGetMethodIndex 1
#else
#define _somGetMethodIndex SOMClass_somGetMethodIndex
#endif /* _somGetMethodIndex */
#endif /* SOMGD_somGetMethodIndex */
/*
* New Method: somGetMethodToken
*/
typedef somMToken SOMLINK somTP_SOMClass_somGetMethodToken(SOMClass *somSelf,
somId methodId);
#pragma linkage(somTP_SOMClass_somGetMethodToken, system)
typedef somTP_SOMClass_somGetMethodToken *somTD_SOMClass_somGetMethodToken;
/*
* Returns the specified method's access token. This token can then
* be passed to method resolution routines, which use the token
* to select a method pointer from a method table.
*/
#define somMD_SOMClass_somGetMethodToken "::SOMClass::somGetMethodToken"
#define SOMClass_somGetMethodToken(somSelf,methodId) \
(SOM_Resolve(somSelf, SOMClass, somGetMethodToken) \
(somSelf,methodId))
#ifndef SOMGD_somGetMethodToken
#if (defined(_somGetMethodToken) || defined(__somGetMethodToken))
#undef _somGetMethodToken
#undef __somGetMethodToken
#define SOMGD_somGetMethodToken 1
#else
#define _somGetMethodToken SOMClass_somGetMethodToken
#endif /* _somGetMethodToken */
#endif /* SOMGD_somGetMethodToken */
/*
* New Method: somGetName
*/
typedef string SOMLINK somTP_SOMClass_somGetName(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somGetName, system)
typedef somTP_SOMClass_somGetName *somTD_SOMClass_somGetName;
/*
* This object's class name as a NULL terminated string.
*/
#define somMD_SOMClass_somGetName "::SOMClass::somGetName"
#define SOMClass_somGetName(somSelf) \
(SOM_Resolve(somSelf, SOMClass, somGetName) \
(somSelf))
#ifndef SOMGD_somGetName
#if (defined(_somGetName) || defined(__somGetName))
#undef _somGetName
#undef __somGetName
#define SOMGD_somGetName 1
#else
#define _somGetName SOMClass_somGetName
#endif /* _somGetName */
#endif /* SOMGD_somGetName */
/*
* New Method: somGetNthMethodData
*/
typedef boolean SOMLINK somTP_SOMClass_somGetNthMethodData(SOMClass *somSelf,
long n,
somMethodData* md);
#pragma linkage(somTP_SOMClass_somGetNthMethodData, system)
typedef somTP_SOMClass_somGetNthMethodData *somTD_SOMClass_somGetNthMethodData;
/*
* loads *md with the method data associated with the the nth method,
* or NULL if there is no such method. Returns true is successful;
* false otherwise.
*/
#define somMD_SOMClass_somGetNthMethodData "::SOMClass::somGetNthMethodData"
#define SOMClass_somGetNthMethodData(somSelf,n,md) \
(SOM_Resolve(somSelf, SOMClass, somGetNthMethodData) \
(somSelf,n,md))
#ifndef SOMGD_somGetNthMethodData
#if (defined(_somGetNthMethodData) || defined(__somGetNthMethodData))
#undef _somGetNthMethodData
#undef __somGetNthMethodData
#define SOMGD_somGetNthMethodData 1
#else
#define _somGetNthMethodData SOMClass_somGetNthMethodData
#endif /* _somGetNthMethodData */
#endif /* SOMGD_somGetNthMethodData */
/*
* New Method: somGetNthMethodInfo
*/
typedef somId SOMLINK somTP_SOMClass_somGetNthMethodInfo(SOMClass *somSelf,
long n,
somId* descriptor);
#pragma linkage(somTP_SOMClass_somGetNthMethodInfo, system)
typedef somTP_SOMClass_somGetNthMethodInfo *somTD_SOMClass_somGetNthMethodInfo;
/*
* Returns the id of the <n>th method if one exists and NULL
* otherwise.
*
* The ordering of the methods is unpredictable, but will not change
* unless some change is made to the class or one of its ancestor classes.
*
* See CORBA documentation for info on method descriptors.
*/
#define somMD_SOMClass_somGetNthMethodInfo "::SOMClass::somGetNthMethodInfo"
#define SOMClass_somGetNthMethodInfo(somSelf,n,descriptor) \
(SOM_Resolve(somSelf, SOMClass, somGetNthMethodInfo) \
(somSelf,n,descriptor))
#ifndef SOMGD_somGetNthMethodInfo
#if (defined(_somGetNthMethodInfo) || defined(__somGetNthMethodInfo))
#undef _somGetNthMethodInfo
#undef __somGetNthMethodInfo
#define SOMGD_somGetNthMethodInfo 1
#else
#define _somGetNthMethodInfo SOMClass_somGetNthMethodInfo
#endif /* _somGetNthMethodInfo */
#endif /* SOMGD_somGetNthMethodInfo */
/*
* New Method: somGetNumMethods
*/
typedef long SOMLINK somTP_SOMClass_somGetNumMethods(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somGetNumMethods, system)
typedef somTP_SOMClass_somGetNumMethods *somTD_SOMClass_somGetNumMethods;
/*
* The number of methods currently supported by this class,
* including inherited methods (both static and dynamic).
*/
#define somMD_SOMClass_somGetNumMethods "::SOMClass::somGetNumMethods"
#define SOMClass_somGetNumMethods(somSelf) \
(SOM_Resolve(somSelf, SOMClass, somGetNumMethods) \
(somSelf))
#ifndef SOMGD_somGetNumMethods
#if (defined(_somGetNumMethods) || defined(__somGetNumMethods))
#undef _somGetNumMethods
#undef __somGetNumMethods
#define SOMGD_somGetNumMethods 1
#else
#define _somGetNumMethods SOMClass_somGetNumMethods
#endif /* _somGetNumMethods */
#endif /* SOMGD_somGetNumMethods */
/*
* New Method: somGetNumStaticMethods
*/
typedef long SOMLINK somTP_SOMClass_somGetNumStaticMethods(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somGetNumStaticMethods, system)
typedef somTP_SOMClass_somGetNumStaticMethods *somTD_SOMClass_somGetNumStaticMethods;
/*
* The number of static methods that this class has. Can
* be used by a child class when initializing its method table.
*/
#define somMD_SOMClass_somGetNumStaticMethods "::SOMClass::somGetNumStaticMethods"
#define SOMClass_somGetNumStaticMethods(somSelf) \
(SOM_Resolve(somSelf, SOMClass, somGetNumStaticMethods) \
(somSelf))
#ifndef SOMGD_somGetNumStaticMethods
#if (defined(_somGetNumStaticMethods) || defined(__somGetNumStaticMethods))
#undef _somGetNumStaticMethods
#undef __somGetNumStaticMethods
#define SOMGD_somGetNumStaticMethods 1
#else
#define _somGetNumStaticMethods SOMClass_somGetNumStaticMethods
#endif /* _somGetNumStaticMethods */
#endif /* SOMGD_somGetNumStaticMethods */
/*
* New Method: somGetParent
*/
typedef SOMClass* SOMLINK somTP_SOMClass_somGetParent(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somGetParent, system)
typedef somTP_SOMClass_somGetParent *somTD_SOMClass_somGetParent;
/*
* Returns the parent class of self (along its "left-hand" derivation
* path), if one exists and NULL otherwise.
*/
#define somMD_SOMClass_somGetParent "::SOMClass::somGetParent"
#define SOMClass_somGetParent(somSelf) \
(SOM_Resolve(somSelf, SOMClass, somGetParent) \
(somSelf))
#ifndef SOMGD_somGetParent
#if (defined(_somGetParent) || defined(__somGetParent))
#undef _somGetParent
#undef __somGetParent
#define SOMGD_somGetParent 1
#else
#define _somGetParent SOMClass_somGetParent
#endif /* _somGetParent */
#endif /* SOMGD_somGetParent */
/*
* New Method: somGetParents
*/
typedef SOMClass_SOMClassSequence SOMLINK somTP_SOMClass_somGetParents(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somGetParents, system)
typedef somTP_SOMClass_somGetParents *somTD_SOMClass_somGetParents;
/*
* The parent classes of self.
*/
#define somMD_SOMClass_somGetParents "::SOMClass::somGetParents"
#define SOMClass_somGetParents(somSelf) \
(SOM_Resolve(somSelf, SOMClass, somGetParents) \
(somSelf))
#ifndef SOMGD_somGetParents
#if (defined(_somGetParents) || defined(__somGetParents))
#undef _somGetParents
#undef __somGetParents
#define SOMGD_somGetParents 1
#else
#define _somGetParents SOMClass_somGetParents
#endif /* _somGetParents */
#endif /* SOMGD_somGetParents */
/*
* New Method: somGetVersionNumbers
*/
typedef void SOMLINK somTP_SOMClass_somGetVersionNumbers(SOMClass *somSelf,
long* majorVersion,
long* minorVersion);
#pragma linkage(somTP_SOMClass_somGetVersionNumbers, system)
typedef somTP_SOMClass_somGetVersionNumbers *somTD_SOMClass_somGetVersionNumbers;
/*
* Returns the class' major and minor version numbers in the corresponding
* output parameters.
*/
#define somMD_SOMClass_somGetVersionNumbers "::SOMClass::somGetVersionNumbers"
#define SOMClass_somGetVersionNumbers(somSelf,majorVersion,minorVersion) \
(SOM_Resolve(somSelf, SOMClass, somGetVersionNumbers) \
(somSelf,majorVersion,minorVersion))
#ifndef SOMGD_somGetVersionNumbers
#if (defined(_somGetVersionNumbers) || defined(__somGetVersionNumbers))
#undef _somGetVersionNumbers
#undef __somGetVersionNumbers
#define SOMGD_somGetVersionNumbers 1
#else
#define _somGetVersionNumbers SOMClass_somGetVersionNumbers
#endif /* _somGetVersionNumbers */
#endif /* SOMGD_somGetVersionNumbers */
/*
* New Method: somFindMethod
*/
typedef boolean SOMLINK somTP_SOMClass_somFindMethod(SOMClass *somSelf,
somId methodId,
somMethodPtr* m);
#pragma linkage(somTP_SOMClass_somFindMethod, system)
typedef somTP_SOMClass_somFindMethod *somTD_SOMClass_somFindMethod;
/*
* Finds the method procedure associated with <methodId> for this
* class and sets <m> to it. 1 (true) is returned when the
* method procedure is a static method and 0 (false) is returned
* when the method procedure is dynamic method.
*
* If the class does not support the specified method then
* <m> is set to NULL and the return value is meaningless.
*
*/
#define somMD_SOMClass_somFindMethod "::SOMClass::somFindMethod"
#define SOMClass_somFindMethod(somSelf,methodId,m) \
(SOM_Resolve(somSelf, SOMClass, somFindMethod) \
(somSelf,methodId,m))
#ifndef SOMGD_somFindMethod
#if (defined(_somFindMethod) || defined(__somFindMethod))
#undef _somFindMethod
#undef __somFindMethod
#define SOMGD_somFindMethod 1
#else
#define _somFindMethod SOMClass_somFindMethod
#endif /* _somFindMethod */
#endif /* SOMGD_somFindMethod */
/*
* New Method: somFindMethodOk
*/
typedef boolean SOMLINK somTP_SOMClass_somFindMethodOk(SOMClass *somSelf,
somId methodId,
somMethodPtr* m);
#pragma linkage(somTP_SOMClass_somFindMethodOk, system)
typedef somTP_SOMClass_somFindMethodOk *somTD_SOMClass_somFindMethodOk;
/*
* Just like <somFindMethod> except that if the method is not
* supported then an error is raised and execution is halted.
*/
#define somMD_SOMClass_somFindMethodOk "::SOMClass::somFindMethodOk"
#define SOMClass_somFindMethodOk(somSelf,methodId,m) \
(SOM_Resolve(somSelf, SOMClass, somFindMethodOk) \
(somSelf,methodId,m))
#ifndef SOMGD_somFindMethodOk
#if (defined(_somFindMethodOk) || defined(__somFindMethodOk))
#undef _somFindMethodOk
#undef __somFindMethodOk
#define SOMGD_somFindMethodOk 1
#else
#define _somFindMethodOk SOMClass_somFindMethodOk
#endif /* _somFindMethodOk */
#endif /* SOMGD_somFindMethodOk */
/*
* New Method: somFindSMethod
*/
typedef somMethodPtr SOMLINK somTP_SOMClass_somFindSMethod(SOMClass *somSelf,
somId methodId);
#pragma linkage(somTP_SOMClass_somFindSMethod, system)
typedef somTP_SOMClass_somFindSMethod *somTD_SOMClass_somFindSMethod;
/*
* Finds the indicated method, which must be a static method supported
* by this class, and returns a pointer to its method procedure.
* If the method is not supported by the receiver (as a static method
* or at all) then a NULL pointer is returned.
*/
#define somMD_SOMClass_somFindSMethod "::SOMClass::somFindSMethod"
#define SOMClass_somFindSMethod(somSelf,methodId) \
(SOM_Resolve(somSelf, SOMClass, somFindSMethod) \
(somSelf,methodId))
#ifndef SOMGD_somFindSMethod
#if (defined(_somFindSMethod) || defined(__somFindSMethod))
#undef _somFindSMethod
#undef __somFindSMethod
#define SOMGD_somFindSMethod 1
#else
#define _somFindSMethod SOMClass_somFindSMethod
#endif /* _somFindSMethod */
#endif /* SOMGD_somFindSMethod */
/*
* New Method: somFindSMethodOk
*/
typedef somMethodPtr SOMLINK somTP_SOMClass_somFindSMethodOk(SOMClass *somSelf,
somId methodId);
#pragma linkage(somTP_SOMClass_somFindSMethodOk, system)
typedef somTP_SOMClass_somFindSMethodOk *somTD_SOMClass_somFindSMethodOk;
/*
* Uses <somFindSMethod>, and raises an error if the result is NULL.
*/
#define somMD_SOMClass_somFindSMethodOk "::SOMClass::somFindSMethodOk"
#define SOMClass_somFindSMethodOk(somSelf,methodId) \
(SOM_Resolve(somSelf, SOMClass, somFindSMethodOk) \
(somSelf,methodId))
#ifndef SOMGD_somFindSMethodOk
#if (defined(_somFindSMethodOk) || defined(__somFindSMethodOk))
#undef _somFindSMethodOk
#undef __somFindSMethodOk
#define SOMGD_somFindSMethodOk 1
#else
#define _somFindSMethodOk SOMClass_somFindSMethodOk
#endif /* _somFindSMethodOk */
#endif /* SOMGD_somFindSMethodOk */
/*
* New Method: somLookupMethod
*/
typedef somMethodPtr SOMLINK somTP_SOMClass_somLookupMethod(SOMClass *somSelf,
somId methodId);
#pragma linkage(somTP_SOMClass_somLookupMethod, system)
typedef somTP_SOMClass_somLookupMethod *somTD_SOMClass_somLookupMethod;
/*
* Like <somFindSMethodOK>, but without restriction to static methods.
*/
#define somMD_SOMClass_somLookupMethod "::SOMClass::somLookupMethod"
#define SOMClass_somLookupMethod(somSelf,methodId) \
(SOM_Resolve(somSelf, SOMClass, somLookupMethod) \
(somSelf,methodId))
#ifndef SOMGD_somLookupMethod
#if (defined(_somLookupMethod) || defined(__somLookupMethod))
#undef _somLookupMethod
#undef __somLookupMethod
#define SOMGD_somLookupMethod 1
#else
#define _somLookupMethod SOMClass_somLookupMethod
#endif /* _somLookupMethod */
#endif /* SOMGD_somLookupMethod */
/*
* New Method: somCheckVersion
*/
typedef boolean SOMLINK somTP_SOMClass_somCheckVersion(SOMClass *somSelf,
long majorVersion,
long minorVersion);
#pragma linkage(somTP_SOMClass_somCheckVersion, system)
typedef somTP_SOMClass_somCheckVersion *somTD_SOMClass_somCheckVersion;
/*
* Returns 1 (true) if the implementation of this class is
* compatible with the specified major and minor version number and
* false (0) otherwise. An implementation is compatible with the
* specified version numbers if it has the same major version number
* and a minor version number that is equal to or greater than
* <minorVersion>. The major, minor version number pair (0,0) is
* considered to match any version. This method is usually called
* immediately after creating the class object to verify that a
* dynamically loaded class definition is compatible with a using
* application.
*/
#define somMD_SOMClass_somCheckVersion "::SOMClass::somCheckVersion"
#define SOMClass_somCheckVersion(somSelf,majorVersion,minorVersion) \
(SOM_Resolve(somSelf, SOMClass, somCheckVersion) \
(somSelf,majorVersion,minorVersion))
#ifndef SOMGD_somCheckVersion
#if (defined(_somCheckVersion) || defined(__somCheckVersion))
#undef _somCheckVersion
#undef __somCheckVersion
#define SOMGD_somCheckVersion 1
#else
#define _somCheckVersion SOMClass_somCheckVersion
#endif /* _somCheckVersion */
#endif /* SOMGD_somCheckVersion */
/*
* New Method: somDescendedFrom
*/
typedef boolean SOMLINK somTP_SOMClass_somDescendedFrom(SOMClass *somSelf,
SOMClass* aClassObj);
#pragma linkage(somTP_SOMClass_somDescendedFrom, system)
typedef somTP_SOMClass_somDescendedFrom *somTD_SOMClass_somDescendedFrom;
/*
* Returns 1 (true) if <self> is a descendent class of <aClassObj> and
* 0 (false) otherwise. Note: a class object is considered to be
* descended itself for the purposes of this method.
*/
#define somMD_SOMClass_somDescendedFrom "::SOMClass::somDescendedFrom"
#define SOMClass_somDescendedFrom(somSelf,aClassObj) \
(SOM_Resolve(somSelf, SOMClass, somDescendedFrom) \
(somSelf,aClassObj))
#ifndef SOMGD_somDescendedFrom
#if (defined(_somDescendedFrom) || defined(__somDescendedFrom))
#undef _somDescendedFrom
#undef __somDescendedFrom
#define SOMGD_somDescendedFrom 1
#else
#define _somDescendedFrom SOMClass_somDescendedFrom
#endif /* _somDescendedFrom */
#endif /* SOMGD_somDescendedFrom */
/*
* New Method: somSupportsMethod
*/
typedef boolean SOMLINK somTP_SOMClass_somSupportsMethod(SOMClass *somSelf,
somId mId);
#pragma linkage(somTP_SOMClass_somSupportsMethod, system)
typedef somTP_SOMClass_somSupportsMethod *somTD_SOMClass_somSupportsMethod;
/*
* Returns 1 (true) if the indicated method is supported by this
* class and 0 (false) otherwise.
*/
#define somMD_SOMClass_somSupportsMethod "::SOMClass::somSupportsMethod"
#define SOMClass_somSupportsMethod(somSelf,mId) \
(SOM_Resolve(somSelf, SOMClass, somSupportsMethod) \
(somSelf,mId))
#ifndef SOMGD_somSupportsMethod
#if (defined(_somSupportsMethod) || defined(__somSupportsMethod))
#undef _somSupportsMethod
#undef __somSupportsMethod
#define SOMGD_somSupportsMethod 1
#else
#define _somSupportsMethod SOMClass_somSupportsMethod
#endif /* _somSupportsMethod */
#endif /* SOMGD_somSupportsMethod */
/*
* New Method: somDefinedMethod
*/
typedef somMethodPtr SOMLINK somTP_SOMClass_somDefinedMethod(SOMClass *somSelf,
somMToken method);
#pragma linkage(somTP_SOMClass_somDefinedMethod, system)
typedef somTP_SOMClass_somDefinedMethod *somTD_SOMClass_somDefinedMethod;
/*
* if the receiving class either introduces or overrides the
* indicated method, then its somMethodPtr is returned, otherwise
* NULL is returned.
*/
#define somMD_SOMClass_somDefinedMethod "::SOMClass::somDefinedMethod"
#define SOMClass_somDefinedMethod(somSelf,method) \
(SOM_Resolve(somSelf, SOMClass, somDefinedMethod) \
(somSelf,method))
#ifndef SOMGD_somDefinedMethod
#if (defined(_somDefinedMethod) || defined(__somDefinedMethod))
#undef _somDefinedMethod
#undef __somDefinedMethod
#define SOMGD_somDefinedMethod 1
#else
#define _somDefinedMethod SOMClass_somDefinedMethod
#endif /* _somDefinedMethod */
#endif /* SOMGD_somDefinedMethod */
/*
* New Method: somOverrideMtab
*/
typedef void SOMLINK somTP_SOMClass_somOverrideMtab(SOMClass *somSelf);
#pragma linkage(somTP_SOMClass_somOverrideMtab, system)
typedef somTP_SOMClass_somOverrideMtab *somTD_SOMClass_somOverrideMtab;
/*
* Overrides the method table pointers to point to the redispatch stubs.
* All the methods except somDispatch methods are overriden.
*/
#define somMD_SOMClass_somOverrideMtab "::SOMClass::somOverrideMtab"
#define SOMClass_somOverrideMtab(somSelf) \
(SOM_Resolve(somSelf, SOMClass, somOverrideMtab) \
(somSelf))
#ifndef SOMGD_somOverrideMtab
#if (defined(_somOverrideMtab) || defined(__somOverrideMtab))
#undef _somOverrideMtab
#undef __somOverrideMtab
#define SOMGD_somOverrideMtab 1
#else
#define _somOverrideMtab SOMClass_somOverrideMtab
#endif /* _somOverrideMtab */
#endif /* SOMGD_somOverrideMtab */
#ifndef SOM_DONT_USE_INHERITED_MACROS
#define SOMClass_somDefaultInit SOMObject_somDefaultInit
#define SOMClass_somDestruct SOMObject_somDestruct
#define SOMClass_somDefaultCopyInit SOMObject_somDefaultCopyInit
#define SOMClass_somDefaultAssign SOMObject_somDefaultAssign
#define SOMClass_somDefaultConstCopyInit SOMObject_somDefaultConstCopyInit
#define SOMClass_somDefaultVCopyInit SOMObject_somDefaultVCopyInit
#define SOMClass_somDefaultConstVCopyInit SOMObject_somDefaultConstVCopyInit
#define SOMClass_somDefaultConstAssign SOMObject_somDefaultConstAssign
#define SOMClass_somDefaultVAssign SOMObject_somDefaultVAssign
#define SOMClass_somDefaultConstVAssign SOMObject_somDefaultConstVAssign
#define SOMClass_somInit SOMObject_somInit
#define SOMClass_somFree SOMObject_somFree
#define SOMClass_somUninit SOMObject_somUninit
#define SOMClass_somGetClass SOMObject_somGetClass
#define SOMClass_somGetClassName SOMObject_somGetClassName
#define SOMClass_somGetSize SOMObject_somGetSize
#define SOMClass_somIsA SOMObject_somIsA
#define SOMClass_somIsInstanceOf SOMObject_somIsInstanceOf
#define SOMClass_somRespondsTo SOMObject_somRespondsTo
#define SOMClass_somDispatch SOMObject_somDispatch
#define SOMClass_somClassDispatch SOMObject_somClassDispatch
#define SOMClass_somCastObj SOMObject_somCastObj
#define SOMClass_somResetObj SOMObject_somResetObj
#define SOMClass_somDispatchV SOMObject_somDispatchV
#define SOMClass_somDispatchL SOMObject_somDispatchL
#define SOMClass_somDispatchA SOMObject_somDispatchA
#define SOMClass_somDispatchD SOMObject_somDispatchD
#define SOMClass_somPrintSelf SOMObject_somPrintSelf
#define SOMClass_somDumpSelf SOMObject_somDumpSelf
#define SOMClass_somDumpSelfInt SOMObject_somDumpSelfInt
#endif /* SOM_DONT_USE_INHERITED_MACROS */
#endif /* SOM_SOMClass_h */