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 >
C/C++ Source or Header  |  1999-02-22  |  66KB  |  1,711 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: somcls.h.
  5.  * Generated using:
  6.  *     SOM Precompiler somipc: 2.29.1.17
  7.  *     SOM Emitter emith: 2.47
  8.  */
  9.  
  10. #ifndef SOM_SOMClass_h
  11. #define SOM_SOMClass_h
  12.  
  13.  
  14. #include <som.h>
  15.  
  16. /*
  17.  * -- This emitter treats Method Tokens as Thunks by default.
  18.  * -- Use the sc modifier "nothunks" to change this default
  19.  */
  20. #undef somresolve_
  21. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  22.  
  23. /*
  24.  * Define the class name as an object type
  25.  */
  26. #ifndef SOMClass
  27. #define SOMClass SOMObject
  28. #endif
  29. /*
  30.  *   This is the SOM metaclass.  That is, the instances of this class
  31.  *   are class objects.  When the SOM environment is created an instance
  32.  *   of SOMClass is created and a pointer to it is placed in the external
  33.  *   data location (SOMClassClassData.classObject). Bindings provide the
  34.  *   macro _SOMClass for this expression. _SOMClass is unique in that it
  35.  *   is its own class object. I.e., _SOMClass == _somGetClass(_SOMClass).
  36.  *   SOMClass can be subclassed just like any SOM class. The subclasses
  37.  *   of SOMClass are new metaclasses and can generate class objects with
  38.  *   different implementations than those produced by _SOMClass.
  39.  * 
  40.  *   An important rule for metaclass programming is that no methods
  41.  *   introduced by SOMClass should ever be overridden. While this
  42.  *   limits the utility of metaclass programming in SOM, it guarantees
  43.  *   that SOM will operate correctly. Special class frameworks may be
  44.  *   available from IBM to alleviate this restriction. Also, the
  45.  *   restriction may be lifted in the future.
  46.  * 
  47.  */
  48. #include <somobj.h>
  49.  
  50. /*
  51.  * Start of bindings for IDL types
  52.  */
  53.  
  54. #ifndef SOMClass
  55.     #define SOMClass SOMObject
  56. #endif /* SOMClass */
  57. #ifndef _IDL_SEQUENCE_somToken_defined
  58. #define _IDL_SEQUENCE_somToken_defined
  59. typedef struct {
  60.     unsigned long _maximum;
  61.     unsigned long _length;
  62.     somToken *_buffer;
  63. } _IDL_SEQUENCE_somToken;
  64. #endif /* _IDL_SEQUENCE_somToken_defined */ 
  65. typedef
  66. _IDL_SEQUENCE_somToken SOMClass_somTokenSequence;
  67. /*
  68.  *  a (generic) sequence of somTokens
  69.  */
  70.  
  71. #ifndef _IDL_SEQUENCE_SOMClass_defined
  72. #define _IDL_SEQUENCE_SOMClass_defined
  73. typedef struct {
  74.     unsigned long _maximum;
  75.     unsigned long _length;
  76.     SOMClass **_buffer;
  77. } _IDL_SEQUENCE_SOMClass;
  78. #endif /* _IDL_SEQUENCE_SOMClass_defined */ 
  79. typedef
  80. _IDL_SEQUENCE_SOMClass SOMClass_SOMClassSequence;
  81. /*
  82.  *  a sequence of classes
  83.  */
  84.  
  85. typedef
  86. struct SOMClass_somOffsetInfo {
  87. SOMClass* cls;
  88. long  offset;
  89. } SOMClass_somOffsetInfo;
  90. /*
  91.  *  a structure to describe a class-related offset
  92.  */
  93.  
  94. struct SOMClass_somOffsetInfo;
  95. #ifndef _IDL_SEQUENCE_SOMClass_somOffsetInfo_defined
  96. #define _IDL_SEQUENCE_SOMClass_somOffsetInfo_defined
  97. typedef struct {
  98.     unsigned long _maximum;
  99.     unsigned long _length;
  100.     struct SOMClass_somOffsetInfo *_buffer;
  101. } _IDL_SEQUENCE_SOMClass_somOffsetInfo;
  102. #endif /* _IDL_SEQUENCE_SOMClass_somOffsetInfo_defined */ 
  103. typedef
  104. _IDL_SEQUENCE_SOMClass_somOffsetInfo SOMClass_somOffsets;
  105. /*
  106.  *  a sequence of class-related offsets
  107.  */
  108.  
  109. #ifndef _IDL_SEQUENCE_somId_defined
  110. #define _IDL_SEQUENCE_somId_defined
  111. typedef struct {
  112.     unsigned long _maximum;
  113.     unsigned long _length;
  114.     somId *_buffer;
  115. } _IDL_SEQUENCE_somId;
  116. #endif /* _IDL_SEQUENCE_somId_defined */ 
  117. typedef
  118. _IDL_SEQUENCE_somId SOMClass_somIdSequence;
  119. /*
  120.  *  a sequence of somIds
  121.  */
  122.  
  123.  
  124. #ifndef SOM_DONT_USE_SHORT_NAMES
  125.  
  126. #ifndef SOM_DONT_USE_SHORT_NAMES
  127. #ifndef SOMTGD_somTokenSequence
  128.     #ifdef somTokenSequence
  129.         #undef somTokenSequence
  130.         #define SOMTGD_somTokenSequence 1
  131.     #else
  132.         #define somTokenSequence SOMClass_somTokenSequence
  133.     #endif /* somTokenSequence */
  134. #endif /* SOMTGD_somTokenSequence */
  135. #endif /* SOM_DONT_USE_SHORT_NAMES */
  136.  
  137. #ifndef SOM_DONT_USE_SHORT_NAMES
  138. #ifndef SOMTGD_SOMClassSequence
  139.     #ifdef SOMClassSequence
  140.         #undef SOMClassSequence
  141.         #define SOMTGD_SOMClassSequence 1
  142.     #else
  143.         #define SOMClassSequence SOMClass_SOMClassSequence
  144.     #endif /* SOMClassSequence */
  145. #endif /* SOMTGD_SOMClassSequence */
  146. #endif /* SOM_DONT_USE_SHORT_NAMES */
  147. #ifndef SOMTGD_somOffsetInfo
  148.     #ifdef somOffsetInfo
  149.         #undef somOffsetInfo
  150.         #define SOMTGD_somOffsetInfo 1
  151.     #else
  152.         #define somOffsetInfo SOMClass_somOffsetInfo
  153.     #endif /* somOffsetInfo */
  154. #endif /* SOMTGD_somOffsetInfo */
  155. #ifndef SOMTGD__IDL_SEQUENCE_somOffsetInfo
  156.     #ifdef _IDL_SEQUENCE_somOffsetInfo
  157.         #undef _IDL_SEQUENCE_somOffsetInfo
  158.         #define SOMTGD__IDL_SEQUENCE_somOffsetInfo 1
  159.     #else
  160.         #define _IDL_SEQUENCE_somOffsetInfo _IDL_SEQUENCE_SOMClass_somOffsetInfo
  161.     #endif /* _IDL_SEQUENCE_somOffsetInfo */
  162. #endif /* SOMTGD__IDL_SEQUENCE_somOffsetInfo */
  163.  
  164. #ifndef SOM_DONT_USE_SHORT_NAMES
  165. #ifndef SOMTGD_somOffsets
  166.     #ifdef somOffsets
  167.         #undef somOffsets
  168.         #define SOMTGD_somOffsets 1
  169.     #else
  170.         #define somOffsets SOMClass_somOffsets
  171.     #endif /* somOffsets */
  172. #endif /* SOMTGD_somOffsets */
  173. #endif /* SOM_DONT_USE_SHORT_NAMES */
  174.  
  175. #ifndef SOM_DONT_USE_SHORT_NAMES
  176. #ifndef SOMTGD_somIdSequence
  177.     #ifdef somIdSequence
  178.         #undef somIdSequence
  179.         #define SOMTGD_somIdSequence 1
  180.     #else
  181.         #define somIdSequence SOMClass_somIdSequence
  182.     #endif /* somIdSequence */
  183. #endif /* SOMTGD_somIdSequence */
  184. #endif /* SOM_DONT_USE_SHORT_NAMES */
  185. #endif /* SOM_DONT_USE_SHORT_NAMES */
  186.  
  187. /*
  188.  * End of bindings for IDL types.
  189.  */
  190.  
  191. #define SOMClass_MajorVersion 1
  192. #define SOMClass_MinorVersion 5
  193.  
  194. /*
  195.  * External name shortening if required
  196.  */
  197. #ifdef SOM_USE_SHORT_EXTERNAL_NAMES
  198. #define SOMClassNewClass sommcc
  199. #pragma linkage(sommcc, system)
  200. #define SOMClassClassData sommcd
  201. #define SOMClassCClassData sommcx
  202. #endif /* SOM_USE_SHORT_EXTERNAL_NAMES */
  203. /*--------------Migration------------*/
  204. #define SOMClass_classObj SOMClassClassData.classObject
  205. #define _SOMClass SOMClass_classObj
  206.  
  207. /*
  208.  * Declare the class creation procedure
  209.  */
  210. SOMEXTERN SOMClass * SOMLINK SOMClassNewClass(integer4 somtmajorVersion,
  211.         integer4 somtminorVersion);
  212. #pragma linkage(SOMClassNewClass, system)
  213.  
  214. /*
  215.  * Declare the class data structure
  216.  */
  217. SOMEXTERN struct SOMClassClassDataStructure {
  218.     SOMClass *classObject;
  219.     somMToken somNew;
  220.     somMToken somRenew;
  221.     somMToken somInitClass;
  222.     somMToken somClassReady;
  223.     somMToken somGetName;
  224.     somMToken somGetParent;
  225.     somMToken somDescendedFrom;
  226.     somMToken somCheckVersion;
  227.     somMToken somFindMethod;
  228.     somMToken somFindMethodOk;
  229.     somMToken somSupportsMethod;
  230.     somMToken somGetNumMethods;
  231.     somMToken somGetInstanceSize;
  232.     somMToken somGetInstanceOffset;
  233.     somMToken somGetInstancePartSize;
  234.     somMToken somGetMethodIndex;
  235.     somMToken somGetNumStaticMethods;
  236.     somMToken somGetPClsMtab;
  237.     somMToken somGetClassMtab;
  238.     somMToken somAddStaticMethod;
  239.     somMToken somOverrideSMethod;
  240.     somMToken somAddDynamicMethod;
  241.     somMToken somcPrivate0;
  242.     somMToken somGetApplyStub;
  243.     somMToken somFindSMethod;
  244.     somMToken somFindSMethodOk;
  245.     somMToken somGetMethodDescriptor;
  246.     somMToken somGetNthMethodInfo;
  247.     somMToken somSetClassData;
  248.     somMToken somGetClassData;
  249.     somMToken somNewNoInit;
  250.     somMToken somRenewNoInit;
  251.     somMToken somGetInstanceToken;
  252.     somMToken somGetMemberToken;
  253.     somMToken somcPrivate1;
  254.     somMToken somGetMethodData;
  255.     somMToken somOverrideMtab;
  256.     somMToken somGetMethodToken;
  257.     somMToken somGetParents;
  258.     somMToken somGetPClsMtabs;
  259.     somMToken somInitMIClass;
  260.     somMToken somGetVersionNumbers;
  261.     somMToken somLookupMethod;
  262.     somMToken _get_somInstanceDataOffsets;
  263.     somMToken somRenewNoZero;
  264.     somMToken somRenewNoInitNoZero;
  265.     somMToken somAllocate;
  266.     somMToken somDeallocate;
  267.     somMToken somGetRdStub;
  268.     somMToken somGetNthMethodData;
  269.     somMToken somcPrivate2;
  270.     somMToken somcPrivate3;
  271.     somMToken _get_somDirectInitClasses;
  272.     somMToken somcPrivate5;
  273.     somMToken somcPrivate6;
  274.     somMToken somcPrivate7;
  275.     somMToken somcPrivate8;
  276.     somMToken somcPrivate9;
  277.     somMToken somcPrivate10;
  278.     somMToken somcPrivate11;
  279.     somMToken somcPrivate12;
  280.     somMToken somDefinedMethod;
  281.     somMToken somcPrivate13;
  282.     somMToken somcPrivate14;
  283.     somMToken somcPrivate15;
  284.     somMToken somcPrivate16;
  285.     somMToken somcPrivate17;
  286.     somMToken somcPrivate18;
  287.     somMToken somcPrivate19;
  288.     somMToken somcPrivate20;
  289.     somMToken _get_somDataAlignment;
  290.     somMToken somcPrivate21;
  291.     somMToken somcPrivate22;
  292.     somMToken somcPrivate23;
  293.     somMToken somcPrivate24;
  294.     somMToken somcPrivate25;
  295. } SOMDLINK SOMClassClassData;
  296.  
  297. /*
  298.  * Declare the C specific class data structure
  299.  */
  300. SOMEXTERN struct SOMClassCClassDataStructure {
  301.     somMethodTabs parentMtab;
  302.     somDToken instanceDataToken;
  303. } SOMDLINK SOMClassCClassData;
  304.  
  305. /*
  306.  * New and Renew macros for SOMClass
  307.  */
  308. #define SOMClassNew() \
  309.    ( _SOMClass ? \
  310.     _somNew(_SOMClass) \
  311.     : ( SOMClassNewClass(\
  312.         SOMClass_MajorVersion, \
  313.         SOMClass_MinorVersion),\
  314.        _somNew(_SOMClass)))
  315. #define SOMClassRenew(buf) \
  316.    ( _SOMClass ? \
  317.     _somRenew(_SOMClass, buf) \
  318.     : ( SOMClassNewClass(\
  319.         SOMClass_MajorVersion, \
  320.         SOMClass_MinorVersion),\
  321.        _somRenew(_SOMClass, buf)))
  322.  
  323. /*
  324.  * New Method: _get_somDataAlignment
  325.  */
  326. typedef long   SOMLINK somTP_SOMClass__get_somDataAlignment(SOMClass *somSelf);
  327. #pragma linkage(somTP_SOMClass__get_somDataAlignment, system)
  328. typedef somTP_SOMClass__get_somDataAlignment *somTD_SOMClass__get_somDataAlignment;
  329. /*
  330.  *  The alignment required for the instance data structure
  331.  *  introduced by the receiving class.
  332.  */
  333. #define somMD_SOMClass__get_somDataAlignment "::SOMClass::_get_somDataAlignment"
  334. #define SOMClass__get_somDataAlignment(somSelf) \
  335.     (SOM_Resolve(somSelf, SOMClass, _get_somDataAlignment) \
  336.     (somSelf))
  337. #ifndef SOMGD_get_somDataAlignment
  338.     #if (defined(_get_somDataAlignment) || defined(__get_somDataAlignment))
  339.         #undef _get_somDataAlignment
  340.         #undef __get_somDataAlignment
  341.         #define SOMGD_get_somDataAlignment 1
  342.     #else
  343.         #define __get_somDataAlignment SOMClass__get_somDataAlignment
  344.     #endif /* __get_somDataAlignment */
  345. #endif /* SOMGD_get_somDataAlignment */
  346.  
  347. /*
  348.  * New Method: _get_somInstanceDataOffsets
  349.  */
  350. typedef SOMClass_somOffsets   SOMLINK somTP_SOMClass__get_somInstanceDataOffsets(SOMClass *somSelf);
  351. #pragma linkage(somTP_SOMClass__get_somInstanceDataOffsets, system)
  352. typedef somTP_SOMClass__get_somInstanceDataOffsets *somTD_SOMClass__get_somInstanceDataOffsets;
  353. /*
  354.  *  A sequence of the instance data offsets for all classes used in
  355.  *  the derivation of the receiving class (including the receiver).
  356.  */
  357. #define somMD_SOMClass__get_somInstanceDataOffsets "::SOMClass::_get_somInstanceDataOffsets"
  358. #define SOMClass__get_somInstanceDataOffsets(somSelf) \
  359.     (SOM_Resolve(somSelf, SOMClass, _get_somInstanceDataOffsets) \
  360.     (somSelf))
  361. #ifndef SOMGD_get_somInstanceDataOffsets
  362.     #if (defined(_get_somInstanceDataOffsets) || defined(__get_somInstanceDataOffsets))
  363.         #undef _get_somInstanceDataOffsets
  364.         #undef __get_somInstanceDataOffsets
  365.         #define SOMGD_get_somInstanceDataOffsets 1
  366.     #else
  367.         #define __get_somInstanceDataOffsets SOMClass__get_somInstanceDataOffsets
  368.     #endif /* __get_somInstanceDataOffsets */
  369. #endif /* SOMGD_get_somInstanceDataOffsets */
  370.  
  371. /*
  372.  * New Method: _get_somDirectInitClasses
  373.  */
  374. typedef SOMClass_SOMClassSequence   SOMLINK somTP_SOMClass__get_somDirectInitClasses(SOMClass *somSelf);
  375. #pragma linkage(somTP_SOMClass__get_somDirectInitClasses, system)
  376. typedef somTP_SOMClass__get_somDirectInitClasses *somTD_SOMClass__get_somDirectInitClasses;
  377. /*
  378.  *  The ancestors whose initializers the receiving
  379.  *  class wants to directly invoke.
  380.  */
  381. #define somMD_SOMClass__get_somDirectInitClasses "::SOMClass::_get_somDirectInitClasses"
  382. #define SOMClass__get_somDirectInitClasses(somSelf) \
  383.     (SOM_Resolve(somSelf, SOMClass, _get_somDirectInitClasses) \
  384.     (somSelf))
  385. #ifndef SOMGD_get_somDirectInitClasses
  386.     #if (defined(_get_somDirectInitClasses) || defined(__get_somDirectInitClasses))
  387.         #undef _get_somDirectInitClasses
  388.         #undef __get_somDirectInitClasses
  389.         #define SOMGD_get_somDirectInitClasses 1
  390.     #else
  391.         #define __get_somDirectInitClasses SOMClass__get_somDirectInitClasses
  392.     #endif /* __get_somDirectInitClasses */
  393. #endif /* SOMGD_get_somDirectInitClasses */
  394.  
  395. /*
  396.  * New Method: somNew
  397.  */
  398. typedef SOMObject*   SOMLINK somTP_SOMClass_somNew(SOMClass *somSelf);
  399. #pragma linkage(somTP_SOMClass_somNew, system)
  400. typedef somTP_SOMClass_somNew *somTD_SOMClass_somNew;
  401. /*
  402.  *  Uses SOMMalloc to allocate storage for a new instance of the
  403.  *  receiving class, and then calls somRenewNoInitNoZero to load the
  404.  *  new object's method table pointer. Then somDefaultInit is called to
  405.  *  initialize the new object.  Note: If the instance is a class object,
  406.  *  somInitMIClass must then be invoked to declare parents and
  407.  *  initialize the class's instance method table. Upon failure, NULL
  408.  *  is returned.
  409.  */
  410. #define somMD_SOMClass_somNew "::SOMClass::somNew"
  411. #define SOMClass_somNew(somSelf) \
  412.     (SOM_Resolve(somSelf, SOMClass, somNew) \
  413.     (somSelf))
  414. #ifndef SOMGD_somNew
  415.     #if (defined(_somNew) || defined(__somNew))
  416.         #undef _somNew
  417.         #undef __somNew
  418.         #define SOMGD_somNew 1
  419.     #else
  420.         #define _somNew SOMClass_somNew
  421.     #endif /* _somNew */
  422. #endif /* SOMGD_somNew */
  423.  
  424. /*
  425.  * New Method: somNewNoInit
  426.  */
  427. typedef SOMObject*   SOMLINK somTP_SOMClass_somNewNoInit(SOMClass *somSelf);
  428. #pragma linkage(somTP_SOMClass_somNewNoInit, system)
  429. typedef somTP_SOMClass_somNewNoInit *somTD_SOMClass_somNewNoInit;
  430. /*
  431.  *  Equivalent to somNew except that somDefaultInit is not called.
  432.  */
  433. #define somMD_SOMClass_somNewNoInit "::SOMClass::somNewNoInit"
  434. #define SOMClass_somNewNoInit(somSelf) \
  435.     (SOM_Resolve(somSelf, SOMClass, somNewNoInit) \
  436.     (somSelf))
  437. #ifndef SOMGD_somNewNoInit
  438.     #if (defined(_somNewNoInit) || defined(__somNewNoInit))
  439.         #undef _somNewNoInit
  440.         #undef __somNewNoInit
  441.         #define SOMGD_somNewNoInit 1
  442.     #else
  443.         #define _somNewNoInit SOMClass_somNewNoInit
  444.     #endif /* _somNewNoInit */
  445. #endif /* SOMGD_somNewNoInit */
  446.  
  447. /*
  448.  * New Method: somRenew
  449.  */
  450. typedef SOMObject*   SOMLINK somTP_SOMClass_somRenew(SOMClass *somSelf, 
  451.         void* obj);
  452. #pragma linkage(somTP_SOMClass_somRenew, system)
  453. typedef somTP_SOMClass_somRenew *somTD_SOMClass_somRenew;
  454. /*
  455.  *  Equivalent to somNew except that storage is not allocated.
  456.  *  <obj> is taken as the address of the new object.
  457.  */
  458. #define somMD_SOMClass_somRenew "::SOMClass::somRenew"
  459. #define SOMClass_somRenew(somSelf,obj) \
  460.     (SOM_Resolve(somSelf, SOMClass, somRenew) \
  461.     (somSelf,obj))
  462. #ifndef SOMGD_somRenew
  463.     #if (defined(_somRenew) || defined(__somRenew))
  464.         #undef _somRenew
  465.         #undef __somRenew
  466.         #define SOMGD_somRenew 1
  467.     #else
  468.         #define _somRenew SOMClass_somRenew
  469.     #endif /* _somRenew */
  470. #endif /* SOMGD_somRenew */
  471.  
  472. /*
  473.  * New Method: somRenewNoInit
  474.  */
  475. typedef SOMObject*   SOMLINK somTP_SOMClass_somRenewNoInit(SOMClass *somSelf, 
  476.         void* obj);
  477. #pragma linkage(somTP_SOMClass_somRenewNoInit, system)
  478. typedef somTP_SOMClass_somRenewNoInit *somTD_SOMClass_somRenewNoInit;
  479. /*
  480.  *  Equivalent to somRenew except that somDefaultInit is not called.
  481.  */
  482. #define somMD_SOMClass_somRenewNoInit "::SOMClass::somRenewNoInit"
  483. #define SOMClass_somRenewNoInit(somSelf,obj) \
  484.     (SOM_Resolve(somSelf, SOMClass, somRenewNoInit) \
  485.     (somSelf,obj))
  486. #ifndef SOMGD_somRenewNoInit
  487.     #if (defined(_somRenewNoInit) || defined(__somRenewNoInit))
  488.         #undef _somRenewNoInit
  489.         #undef __somRenewNoInit
  490.         #define SOMGD_somRenewNoInit 1
  491.     #else
  492.         #define _somRenewNoInit SOMClass_somRenewNoInit
  493.     #endif /* _somRenewNoInit */
  494. #endif /* SOMGD_somRenewNoInit */
  495.  
  496. /*
  497.  * New Method: somRenewNoZero
  498.  */
  499. typedef SOMObject*   SOMLINK somTP_SOMClass_somRenewNoZero(SOMClass *somSelf, 
  500.         void* obj);
  501. #pragma linkage(somTP_SOMClass_somRenewNoZero, system)
  502. typedef somTP_SOMClass_somRenewNoZero *somTD_SOMClass_somRenewNoZero;
  503. /*
  504.  *  Equivalent to somRenew except that memory is not zeroed out.
  505.  */
  506. #define somMD_SOMClass_somRenewNoZero "::SOMClass::somRenewNoZero"
  507. #define SOMClass_somRenewNoZero(somSelf,obj) \
  508.     (SOM_Resolve(somSelf, SOMClass, somRenewNoZero) \
  509.     (somSelf,obj))
  510. #ifndef SOMGD_somRenewNoZero
  511.     #if (defined(_somRenewNoZero) || defined(__somRenewNoZero))
  512.         #undef _somRenewNoZero
  513.         #undef __somRenewNoZero
  514.         #define SOMGD_somRenewNoZero 1
  515.     #else
  516.         #define _somRenewNoZero SOMClass_somRenewNoZero
  517.     #endif /* _somRenewNoZero */
  518. #endif /* SOMGD_somRenewNoZero */
  519.  
  520. /*
  521.  * New Method: somRenewNoInitNoZero
  522.  */
  523. typedef SOMObject*   SOMLINK somTP_SOMClass_somRenewNoInitNoZero(SOMClass *somSelf, 
  524.         void* obj);
  525. #pragma linkage(somTP_SOMClass_somRenewNoInitNoZero, system)
  526. typedef somTP_SOMClass_somRenewNoInitNoZero *somTD_SOMClass_somRenewNoInitNoZero;
  527. /*
  528.  *  The purpose of this method is to load an object's method table.
  529.  *  The SOM API requires that somRenewNoInitNoZero always be
  530.  *  called when creating a new object whose metaclass is not SOMClass.
  531.  *  This is because metaclasses must be guaranteed that they can use
  532.  *  somRenewNoInitNoZero to track object creation if this is desired.
  533.  */
  534. #define somMD_SOMClass_somRenewNoInitNoZero "::SOMClass::somRenewNoInitNoZero"
  535. #define SOMClass_somRenewNoInitNoZero(somSelf,obj) \
  536.     (SOM_Resolve(somSelf, SOMClass, somRenewNoInitNoZero) \
  537.     (somSelf,obj))
  538. #ifndef SOMGD_somRenewNoInitNoZero
  539.     #if (defined(_somRenewNoInitNoZero) || defined(__somRenewNoInitNoZero))
  540.         #undef _somRenewNoInitNoZero
  541.         #undef __somRenewNoInitNoZero
  542.         #define SOMGD_somRenewNoInitNoZero 1
  543.     #else
  544.         #define _somRenewNoInitNoZero SOMClass_somRenewNoInitNoZero
  545.     #endif /* _somRenewNoInitNoZero */
  546. #endif /* SOMGD_somRenewNoInitNoZero */
  547.  
  548. /*
  549.  * New Method: somAllocate
  550.  */
  551. typedef somToken   SOMLINK somTP_SOMClass_somAllocate(SOMClass *somSelf, 
  552.         long size);
  553. #pragma linkage(somTP_SOMClass_somAllocate, system)
  554. typedef somTP_SOMClass_somAllocate *somTD_SOMClass_somAllocate;
  555. /*
  556.  *  Allocates memory to hold an object and returns a pointer to this memory.
  557.  *  This is a nonstatic method, and cannot be overridden. The default
  558.  *  implementation calls SOMMalloc, but a class designer can specify a
  559.  *  different implementation using the somallocate modifier in IDL. The
  560.  *  allocator takes the same parameters as this method.
  561.  */
  562. #define somMD_SOMClass_somAllocate "::SOMClass::somAllocate"
  563. #define SOMClass_somAllocate(somSelf,size) \
  564.     (SOM_Resolve(somSelf, SOMClass, somAllocate) \
  565.     (somSelf,size))
  566. #ifndef SOMGD_somAllocate
  567.     #if (defined(_somAllocate) || defined(__somAllocate))
  568.         #undef _somAllocate
  569.         #undef __somAllocate
  570.         #define SOMGD_somAllocate 1
  571.     #else
  572.         #define _somAllocate SOMClass_somAllocate
  573.     #endif /* _somAllocate */
  574. #endif /* SOMGD_somAllocate */
  575.  
  576. /*
  577.  * New Method: somDeallocate
  578.  */
  579. typedef void   SOMLINK somTP_SOMClass_somDeallocate(SOMClass *somSelf, 
  580.         somToken memptr);
  581. #pragma linkage(somTP_SOMClass_somDeallocate, system)
  582. typedef somTP_SOMClass_somDeallocate *somTD_SOMClass_somDeallocate;
  583. /*
  584.  *  Zeros out the method table pointer stored in the word pointed to by
  585.  *  memptr, and then deallocates the block of memory pointed to by memptr.
  586.  *  This is a nonstatic method and cannot be overridden. The default
  587.  *  deallocator called is SOMFree, but a class designer can specify a
  588.  *  different deallocator using the somdeallocate modifier in IDL. The
  589.  *  deallocator takes a char* (memptr) and a long (size) as arguments.
  590.  */
  591. #define somMD_SOMClass_somDeallocate "::SOMClass::somDeallocate"
  592. #define SOMClass_somDeallocate(somSelf,memptr) \
  593.     (SOM_Resolve(somSelf, SOMClass, somDeallocate) \
  594.     (somSelf,memptr))
  595. #ifndef SOMGD_somDeallocate
  596.     #if (defined(_somDeallocate) || defined(__somDeallocate))
  597.         #undef _somDeallocate
  598.         #undef __somDeallocate
  599.         #define SOMGD_somDeallocate 1
  600.     #else
  601.         #define _somDeallocate SOMClass_somDeallocate
  602.     #endif /* _somDeallocate */
  603. #endif /* SOMGD_somDeallocate */
  604.  
  605. /*
  606.  * New Method: somInitClass
  607.  */
  608. typedef void   SOMLINK somTP_SOMClass_somInitClass(SOMClass *somSelf, 
  609.         string className, 
  610.         SOMClass* parentClass, 
  611.         long dataSize, 
  612.         long maxStaticMethods, 
  613.         long majorVersion, 
  614.         long minorVersion);
  615. #pragma linkage(somTP_SOMClass_somInitClass, system)
  616. typedef somTP_SOMClass_somInitClass *somTD_SOMClass_somInitClass;
  617. /*
  618.  *  somInitClass is obsolete, and should no longer be used. The SOM 2.0
  619.  *  kernel provides special handling for redispatch stubs in the case
  620.  *  of SOM 1.0 classes, and use of this method is what tells the kernel
  621.  *  that old-style redispatch stubs will be registered.
  622.  */
  623. #define somMD_SOMClass_somInitClass "::SOMClass::somInitClass"
  624. #define SOMClass_somInitClass(somSelf,className,parentClass,dataSize,maxStaticMethods,majorVersion,minorVersion) \
  625.     (SOM_Resolve(somSelf, SOMClass, somInitClass) \
  626.     (somSelf,className,parentClass,dataSize,maxStaticMethods,majorVersion,minorVersion))
  627. #ifndef SOMGD_somInitClass
  628.     #if (defined(_somInitClass) || defined(__somInitClass))
  629.         #undef _somInitClass
  630.         #undef __somInitClass
  631.         #define SOMGD_somInitClass 1
  632.     #else
  633.         #define _somInitClass SOMClass_somInitClass
  634.     #endif /* _somInitClass */
  635. #endif /* SOMGD_somInitClass */
  636.  
  637. /*
  638.  * New Method: somInitMIClass
  639.  */
  640. typedef void   SOMLINK somTP_SOMClass_somInitMIClass(SOMClass *somSelf, 
  641.         long inherit_vars, 
  642.         string className, 
  643.         SOMClass_SOMClassSequence* parentClasses, 
  644.         long dataSize, 
  645.         long dataAlignment, 
  646.         long maxStaticMethods, 
  647.         long majorVersion, 
  648.         long minorVersion);
  649. #pragma linkage(somTP_SOMClass_somInitMIClass, system)
  650. typedef somTP_SOMClass_somInitMIClass *somTD_SOMClass_somInitMIClass;
  651. /*
  652.  *  somInitMIClass implements the second phase of dynamic class creation:
  653.  *  inheritance of interface and possibly implementation (instance
  654.  *  variables) by suitable initialization of <self> (a class object).
  655.  * 
  656.  *  For somInitMIClass, the inherit_vars argument controls whether abstract
  657.  *  or implementation inheritance is used. Inherit_vars is a 32 bit
  658.  *  bit-vector. Implementation is inherited from parent i iff the bit
  659.  *  1<<i is on, or i>=32.
  660.  *  On a class-by-class basis, for each class ancestor, implementation
  661.  *  inheritance always takes precidence over abstract inheritance. This is
  662.  *  necessary to guarantee that procedures supporting parent method calls
  663.  *  (available on non-abstract parents) are always supported by parent
  664.  *  instance variables.
  665.  * 
  666.  *  <className> is a string containing the class name. A copy is made, so
  667.  *  the string may be freed upon return to the caller if this is desired.
  668.  * 
  669.  *  <parentClasses> is a SOMClassSequence containing pointers to the
  670.  *  parent classes. somInitMIClass makes a copy of this, so it may
  671.  *  be freed upon return to the caller if this is desired.
  672.  * 
  673.  *  <dataSize> is the space needed for the instance variables
  674.  *  introduced by this class.
  675.  * 
  676.  *  <dataAlignment> specifies the desired byte alignment for instance
  677.  *  data introduced by this class. A value of 0 selects a system-wide default;
  678.  *  any other argument is taken as the desired byte alignment multiple. Thus,
  679.  *  for example, even if a byte multiple of 8 is needed for double precision
  680.  *  values on a given system (so 8 is the default), a class whose instance data
  681.  *  doesn't require this can indicate otherwise. If A is the next memory
  682.  *  address available for holding instance data, the address that will be
  683.  *  used is A + (A mod byte-alignment).
  684.  * 
  685.  *  <maxStaticMethods> is the maximum number of static methods that will be
  686.  *  added to the initialized class using addStaticMethod.
  687.  * 
  688.  *  <majorVersion> indicates the major version number for this
  689.  *  implementation of the class definition, and <minorVersion>
  690.  *  indicates the minor version number.
  691.  */
  692. #define somMD_SOMClass_somInitMIClass "::SOMClass::somInitMIClass"
  693. #define SOMClass_somInitMIClass(somSelf,inherit_vars,className,parentClasses,dataSize,dataAlignment,maxStaticMethods,majorVersion,minorVersion) \
  694.     (SOM_Resolve(somSelf, SOMClass, somInitMIClass) \
  695.     (somSelf,inherit_vars,className,parentClasses,dataSize,dataAlignment,maxStaticMethods,majorVersion,minorVersion))
  696. #ifndef SOMGD_somInitMIClass
  697.     #if (defined(_somInitMIClass) || defined(__somInitMIClass))
  698.         #undef _somInitMIClass
  699.         #undef __somInitMIClass
  700.         #define SOMGD_somInitMIClass 1
  701.     #else
  702.         #define _somInitMIClass SOMClass_somInitMIClass
  703.     #endif /* _somInitMIClass */
  704. #endif /* SOMGD_somInitMIClass */
  705.  
  706. /*
  707.  * New Method: somAddStaticMethod
  708.  */
  709. typedef somMToken   SOMLINK somTP_SOMClass_somAddStaticMethod(SOMClass *somSelf, 
  710.         somId methodId, 
  711.         somId methodDescriptor, 
  712.         somMethodPtr method, 
  713.         somMethodPtr redispatchStub, 
  714.         somMethodPtr applyStub);
  715. #pragma linkage(somTP_SOMClass_somAddStaticMethod, system)
  716. typedef somTP_SOMClass_somAddStaticMethod *somTD_SOMClass_somAddStaticMethod;
  717. /*
  718.  *  Adds the indicated method, creating and returning a new method token.
  719.  * 
  720.  *  <methodDescriptor> is the somId for an identifier that can be used
  721.  *  to access signature information about the method from an interface
  722.  *  repository.
  723.  * 
  724.  *  <method> is the actual method procedure for this method
  725.  * 
  726.  *  <redispatchStub> is a procedure with the same calling sequence as
  727.  *  <method> that invokes somDispatch for the method.
  728.  * 
  729.  *  <applyStub> is a procedure used to support somApply.
  730.  */
  731. #define somMD_SOMClass_somAddStaticMethod "::SOMClass::somAddStaticMethod"
  732. #define SOMClass_somAddStaticMethod(somSelf,methodId,methodDescriptor,method,redispatchStub,applyStub) \
  733.     (SOM_Resolve(somSelf, SOMClass, somAddStaticMethod) \
  734.     (somSelf,methodId,methodDescriptor,method,redispatchStub,applyStub))
  735. #ifndef SOMGD_somAddStaticMethod
  736.     #if (defined(_somAddStaticMethod) || defined(__somAddStaticMethod))
  737.         #undef _somAddStaticMethod
  738.         #undef __somAddStaticMethod
  739.         #define SOMGD_somAddStaticMethod 1
  740.     #else
  741.         #define _somAddStaticMethod SOMClass_somAddStaticMethod
  742.     #endif /* _somAddStaticMethod */
  743. #endif /* SOMGD_somAddStaticMethod */
  744.  
  745. /*
  746.  * New Method: somAddDynamicMethod
  747.  */
  748. typedef void   SOMLINK somTP_SOMClass_somAddDynamicMethod(SOMClass *somSelf, 
  749.         somId methodId, 
  750.         somId methodDescriptor, 
  751.         somMethodPtr method, 
  752.         somMethodPtr applyStub);
  753. #pragma linkage(somTP_SOMClass_somAddDynamicMethod, system)
  754. typedef somTP_SOMClass_somAddDynamicMethod *somTD_SOMClass_somAddDynamicMethod;
  755. /*
  756.  *  Adds the indicated method to the class's name lookup list.
  757.  *  If this happens to override a static method then this operation is
  758.  *  equivalent to <somOverrideSMethod> and the <methodDescriptor> and
  759.  *  <applyStub> arguments are ignored (the overridden method's values
  760.  *  will be used).
  761.  * 
  762.  *  <methodDescriptor> is the somId for an identifier that can be used
  763.  *  to access signature information about the method from an interface
  764.  *  repository.
  765.  * 
  766.  *  <method> is the actual method procedure for this method
  767.  * 
  768.  *  <applyStub> is a procedure that takes a standard variable argument
  769.  *  list data structure applies it to its target object by calling
  770.  *  <method> with arguments derived from the data structure.  Its
  771.  *  calling sequence is the same as the calling sequence of the
  772.  *  dispatch methods defined in SOMObject.  This stub is used in the
  773.  *  support of the dispatch methods used in some classes.  In classes
  774.  *  where the dispatch functions do not need such a function this
  775.  *  parameter may be null.
  776.  */
  777. #define somMD_SOMClass_somAddDynamicMethod "::SOMClass::somAddDynamicMethod"
  778. #define SOMClass_somAddDynamicMethod(somSelf,methodId,methodDescriptor,method,applyStub) \
  779.     (SOM_Resolve(somSelf, SOMClass, somAddDynamicMethod) \
  780.     (somSelf,methodId,methodDescriptor,method,applyStub))
  781. #ifndef SOMGD_somAddDynamicMethod
  782.     #if (defined(_somAddDynamicMethod) || defined(__somAddDynamicMethod))
  783.         #undef _somAddDynamicMethod
  784.         #undef __somAddDynamicMethod
  785.         #define SOMGD_somAddDynamicMethod 1
  786.     #else
  787.         #define _somAddDynamicMethod SOMClass_somAddDynamicMethod
  788.     #endif /* _somAddDynamicMethod */
  789. #endif /* SOMGD_somAddDynamicMethod */
  790.  
  791. /*
  792.  * New Method: somOverrideSMethod
  793.  */
  794. typedef void   SOMLINK somTP_SOMClass_somOverrideSMethod(SOMClass *somSelf, 
  795.         somId methodId, 
  796.         somMethodPtr method);
  797. #pragma linkage(somTP_SOMClass_somOverrideSMethod, system)
  798. typedef somTP_SOMClass_somOverrideSMethod *somTD_SOMClass_somOverrideSMethod;
  799. /*
  800.  *  This method can be used instead of <somAddStaticMethod> or
  801.  *  <somAddDynamicMethod> when it is known that the class' parent
  802.  *  class already supports this method.  This call does not require the
  803.  *  method descriptor and stub methods that the others do.
  804.  */
  805. #define somMD_SOMClass_somOverrideSMethod "::SOMClass::somOverrideSMethod"
  806. #define SOMClass_somOverrideSMethod(somSelf,methodId,method) \
  807.     (SOM_Resolve(somSelf, SOMClass, somOverrideSMethod) \
  808.     (somSelf,methodId,method))
  809. #ifndef SOMGD_somOverrideSMethod
  810.     #if (defined(_somOverrideSMethod) || defined(__somOverrideSMethod))
  811.         #undef _somOverrideSMethod
  812.         #undef __somOverrideSMethod
  813.         #define SOMGD_somOverrideSMethod 1
  814.     #else
  815.         #define _somOverrideSMethod SOMClass_somOverrideSMethod
  816.     #endif /* _somOverrideSMethod */
  817. #endif /* SOMGD_somOverrideSMethod */
  818.  
  819. /*
  820.  * New Method: somClassReady
  821.  */
  822. typedef void   SOMLINK somTP_SOMClass_somClassReady(SOMClass *somSelf);
  823. #pragma linkage(somTP_SOMClass_somClassReady, system)
  824. typedef somTP_SOMClass_somClassReady *somTD_SOMClass_somClassReady;
  825. /*
  826.  *  This method is invoked when all of the static initialization for
  827.  *  the class has been finished.  The default implementation simply
  828.  *  registers the newly constructed class with the SOMClassMgr.
  829.  */
  830. #define somMD_SOMClass_somClassReady "::SOMClass::somClassReady"
  831. #define SOMClass_somClassReady(somSelf) \
  832.     (SOM_Resolve(somSelf, SOMClass, somClassReady) \
  833.     (somSelf))
  834. #ifndef SOMGD_somClassReady
  835.     #if (defined(_somClassReady) || defined(__somClassReady))
  836.         #undef _somClassReady
  837.         #undef __somClassReady
  838.         #define SOMGD_somClassReady 1
  839.     #else
  840.         #define _somClassReady SOMClass_somClassReady
  841.     #endif /* _somClassReady */
  842. #endif /* SOMGD_somClassReady */
  843.  
  844. /*
  845.  * New Method: somGetApplyStub
  846.  */
  847. typedef somMethodPtr   SOMLINK somTP_SOMClass_somGetApplyStub(SOMClass *somSelf, 
  848.         somId methodId);
  849. #pragma linkage(somTP_SOMClass_somGetApplyStub, system)
  850. typedef somTP_SOMClass_somGetApplyStub *somTD_SOMClass_somGetApplyStub;
  851. /*
  852.  *  Returns the apply stub associated with the specified method,
  853.  *  if one exists; otherwise NULL is returned. This method is obsolete,
  854.  *  and retained for binary compatability. In SOMr2, users never access
  855.  *  apply stubs directly; The function somApply is used to invoke apply
  856.  *  stubs. See somApply documentation for further information on apply
  857.  *  stubs, and see somAddStaticMethod documentation for information
  858.  *  on how apply stubs are registered by class implementations.
  859.  */
  860. #define somMD_SOMClass_somGetApplyStub "::SOMClass::somGetApplyStub"
  861. #define SOMClass_somGetApplyStub(somSelf,methodId) \
  862.     (SOM_Resolve(somSelf, SOMClass, somGetApplyStub) \
  863.     (somSelf,methodId))
  864. #ifndef SOMGD_somGetApplyStub
  865.     #if (defined(_somGetApplyStub) || defined(__somGetApplyStub))
  866.         #undef _somGetApplyStub
  867.         #undef __somGetApplyStub
  868.         #define SOMGD_somGetApplyStub 1
  869.     #else
  870.         #define _somGetApplyStub SOMClass_somGetApplyStub
  871.     #endif /* _somGetApplyStub */
  872. #endif /* SOMGD_somGetApplyStub */
  873.  
  874. /*
  875.  * New Method: somGetClassData
  876.  */
  877. typedef somClassDataStructure*   SOMLINK somTP_SOMClass_somGetClassData(SOMClass *somSelf);
  878. #pragma linkage(somTP_SOMClass_somGetClassData, system)
  879. typedef somTP_SOMClass_somGetClassData *somTD_SOMClass_somGetClassData;
  880. #define somMD_SOMClass_somGetClassData "::SOMClass::somGetClassData"
  881. #define SOMClass_somGetClassData(somSelf) \
  882.     (SOM_Resolve(somSelf, SOMClass, somGetClassData) \
  883.     (somSelf))
  884. #ifndef SOMGD_somGetClassData
  885.     #if (defined(_somGetClassData) || defined(__somGetClassData))
  886.         #undef _somGetClassData
  887.         #undef __somGetClassData
  888.         #define SOMGD_somGetClassData 1
  889.     #else
  890.         #define _somGetClassData SOMClass_somGetClassData
  891.     #endif /* _somGetClassData */
  892. #endif /* SOMGD_somGetClassData */
  893.  
  894. /*
  895.  * New Method: somSetClassData
  896.  */
  897. typedef void   SOMLINK somTP_SOMClass_somSetClassData(SOMClass *somSelf, 
  898.         somClassDataStructure* cds);
  899. #pragma linkage(somTP_SOMClass_somSetClassData, system)
  900. typedef somTP_SOMClass_somSetClassData *somTD_SOMClass_somSetClassData;
  901. /*
  902.  *  The class' pointer to the static <className>ClassData structure.
  903.  */
  904. #define somMD_SOMClass_somSetClassData "::SOMClass::somSetClassData"
  905. #define SOMClass_somSetClassData(somSelf,cds) \
  906.     (SOM_Resolve(somSelf, SOMClass, somSetClassData) \
  907.     (somSelf,cds))
  908. #ifndef SOMGD_somSetClassData
  909.     #if (defined(_somSetClassData) || defined(__somSetClassData))
  910.         #undef _somSetClassData
  911.         #undef __somSetClassData
  912.         #define SOMGD_somSetClassData 1
  913.     #else
  914.         #define _somSetClassData SOMClass_somSetClassData
  915.     #endif /* _somSetClassData */
  916. #endif /* SOMGD_somSetClassData */
  917.  
  918. /*
  919.  * New Method: somGetClassMtab
  920.  */
  921. typedef somMethodTab*   SOMLINK somTP_SOMClass_somGetClassMtab(SOMClass *somSelf);
  922. #pragma linkage(somTP_SOMClass_somGetClassMtab, system)
  923. typedef somTP_SOMClass_somGetClassMtab *somTD_SOMClass_somGetClassMtab;
  924. /*
  925.  *  A pointer to the method table used by instances of this class. This
  926.  *  method was misnamed; it should have been called somGetInstanceMtab.
  927.  */
  928. #define somMD_SOMClass_somGetClassMtab "::SOMClass::somGetClassMtab"
  929. #define SOMClass_somGetClassMtab(somSelf) \
  930.     (SOM_Resolve(somSelf, SOMClass, somGetClassMtab) \
  931.     (somSelf))
  932. #ifndef SOMGD_somGetClassMtab
  933.     #if (defined(_somGetClassMtab) || defined(__somGetClassMtab))
  934.         #undef _somGetClassMtab
  935.         #undef __somGetClassMtab
  936.         #define SOMGD_somGetClassMtab 1
  937.     #else
  938.         #define _somGetClassMtab SOMClass_somGetClassMtab
  939.     #endif /* _somGetClassMtab */
  940. #endif /* SOMGD_somGetClassMtab */
  941.  
  942. /*
  943.  * New Method: somGetInstanceOffset
  944.  */
  945. typedef long   SOMLINK somTP_SOMClass_somGetInstanceOffset(SOMClass *somSelf);
  946. #pragma linkage(somTP_SOMClass_somGetInstanceOffset, system)
  947. typedef somTP_SOMClass_somGetInstanceOffset *somTD_SOMClass_somGetInstanceOffset;
  948. /*
  949.  *  Returns the offset of instance data introduced by the receiver in
  950.  *  an instance of the receiver. This method is obsolete and not useful in
  951.  *  multiple-inheritance situations. The attribute somInstanceDataOffsets
  952.  *  replaces this method.
  953.  */
  954. #define somMD_SOMClass_somGetInstanceOffset "::SOMClass::somGetInstanceOffset"
  955. #define SOMClass_somGetInstanceOffset(somSelf) \
  956.     (SOM_Resolve(somSelf, SOMClass, somGetInstanceOffset) \
  957.     (somSelf))
  958. #ifndef SOMGD_somGetInstanceOffset
  959.     #if (defined(_somGetInstanceOffset) || defined(__somGetInstanceOffset))
  960.         #undef _somGetInstanceOffset
  961.         #undef __somGetInstanceOffset
  962.         #define SOMGD_somGetInstanceOffset 1
  963.     #else
  964.         #define _somGetInstanceOffset SOMClass_somGetInstanceOffset
  965.     #endif /* _somGetInstanceOffset */
  966. #endif /* SOMGD_somGetInstanceOffset */
  967.  
  968. /*
  969.  * New Method: somGetInstancePartSize
  970.  */
  971. typedef long   SOMLINK somTP_SOMClass_somGetInstancePartSize(SOMClass *somSelf);
  972. #pragma linkage(somTP_SOMClass_somGetInstancePartSize, system)
  973. typedef somTP_SOMClass_somGetInstancePartSize *somTD_SOMClass_somGetInstancePartSize;
  974. /*
  975.  *  The size in bytes of the instance data introduced by the receiving
  976.  *  class.
  977.  */
  978. #define somMD_SOMClass_somGetInstancePartSize "::SOMClass::somGetInstancePartSize"
  979. #define SOMClass_somGetInstancePartSize(somSelf) \
  980.     (SOM_Resolve(somSelf, SOMClass, somGetInstancePartSize) \
  981.     (somSelf))
  982. #ifndef SOMGD_somGetInstancePartSize
  983.     #if (defined(_somGetInstancePartSize) || defined(__somGetInstancePartSize))
  984.         #undef _somGetInstancePartSize
  985.         #undef __somGetInstancePartSize
  986.         #define SOMGD_somGetInstancePartSize 1
  987.     #else
  988.         #define _somGetInstancePartSize SOMClass_somGetInstancePartSize
  989.     #endif /* _somGetInstancePartSize */
  990. #endif /* SOMGD_somGetInstancePartSize */
  991.  
  992. /*
  993.  * New Method: somGetInstanceSize
  994.  */
  995. typedef long   SOMLINK somTP_SOMClass_somGetInstanceSize(SOMClass *somSelf);
  996. #pragma linkage(somTP_SOMClass_somGetInstanceSize, system)
  997. typedef somTP_SOMClass_somGetInstanceSize *somTD_SOMClass_somGetInstanceSize;
  998. /*
  999.  *  The total size of an instance of the receiving class.
  1000.  */
  1001. #define somMD_SOMClass_somGetInstanceSize "::SOMClass::somGetInstanceSize"
  1002. #define SOMClass_somGetInstanceSize(somSelf) \
  1003.     (SOM_Resolve(somSelf, SOMClass, somGetInstanceSize) \
  1004.     (somSelf))
  1005. #ifndef SOMGD_somGetInstanceSize
  1006.     #if (defined(_somGetInstanceSize) || defined(__somGetInstanceSize))
  1007.         #undef _somGetInstanceSize
  1008.         #undef __somGetInstanceSize
  1009.         #define SOMGD_somGetInstanceSize 1
  1010.     #else
  1011.         #define _somGetInstanceSize SOMClass_somGetInstanceSize
  1012.     #endif /* _somGetInstanceSize */
  1013. #endif /* SOMGD_somGetInstanceSize */
  1014.  
  1015. /*
  1016.  * New Method: somGetInstanceToken
  1017.  */
  1018. typedef somDToken   SOMLINK somTP_SOMClass_somGetInstanceToken(SOMClass *somSelf);
  1019. #pragma linkage(somTP_SOMClass_somGetInstanceToken, system)
  1020. typedef somTP_SOMClass_somGetInstanceToken *somTD_SOMClass_somGetInstanceToken;
  1021. /*
  1022.  *  A data token that identifies the introduced portion of this class
  1023.  *  within itself or any derived class.  This token can be subsequently
  1024.  *  passed to the run-time somDataResolve function to locate the instance
  1025.  *  data introduced by this class in any object derived from this class.
  1026.  */
  1027. #define somMD_SOMClass_somGetInstanceToken "::SOMClass::somGetInstanceToken"
  1028. #define SOMClass_somGetInstanceToken(somSelf) \
  1029.     (SOM_Resolve(somSelf, SOMClass, somGetInstanceToken) \
  1030.     (somSelf))
  1031. #ifndef SOMGD_somGetInstanceToken
  1032.     #if (defined(_somGetInstanceToken) || defined(__somGetInstanceToken))
  1033.         #undef _somGetInstanceToken
  1034.         #undef __somGetInstanceToken
  1035.         #define SOMGD_somGetInstanceToken 1
  1036.     #else
  1037.         #define _somGetInstanceToken SOMClass_somGetInstanceToken
  1038.     #endif /* _somGetInstanceToken */
  1039. #endif /* SOMGD_somGetInstanceToken */
  1040.  
  1041. /*
  1042.  * New Method: somGetMemberToken
  1043.  */
  1044. typedef somDToken   SOMLINK somTP_SOMClass_somGetMemberToken(SOMClass *somSelf, 
  1045.         long memberOffset, 
  1046.         somDToken instanceToken);
  1047. #pragma linkage(somTP_SOMClass_somGetMemberToken, system)
  1048. typedef somTP_SOMClass_somGetMemberToken *somTD_SOMClass_somGetMemberToken;
  1049. /*
  1050.  *  Returns a data token that for the data member at offset
  1051.  *  "memberOffset" within the introduced portion of the class identified
  1052.  *  by instanceToken.  The instance token must have been obtained from a
  1053.  *  previous invocation of somGetInstanceToken.  The returned member
  1054.  *  token can be subsequently passed to the run-time somDataResolve
  1055.  *  function to locate the data member.
  1056.  */
  1057. #define somMD_SOMClass_somGetMemberToken "::SOMClass::somGetMemberToken"
  1058. #define SOMClass_somGetMemberToken(somSelf,memberOffset,instanceToken) \
  1059.     (SOM_Resolve(somSelf, SOMClass, somGetMemberToken) \
  1060.     (somSelf,memberOffset,instanceToken))
  1061. #ifndef SOMGD_somGetMemberToken
  1062.     #if (defined(_somGetMemberToken) || defined(__somGetMemberToken))
  1063.         #undef _somGetMemberToken
  1064.         #undef __somGetMemberToken
  1065.         #define SOMGD_somGetMemberToken 1
  1066.     #else
  1067.         #define _somGetMemberToken SOMClass_somGetMemberToken
  1068.     #endif /* _somGetMemberToken */
  1069. #endif /* SOMGD_somGetMemberToken */
  1070.  
  1071. /*
  1072.  * New Method: somGetMethodData
  1073.  */
  1074. typedef boolean   SOMLINK somTP_SOMClass_somGetMethodData(SOMClass *somSelf, 
  1075.         somId methodId, 
  1076.         somMethodData* md);
  1077. #pragma linkage(somTP_SOMClass_somGetMethodData, system)
  1078. typedef somTP_SOMClass_somGetMethodData *somTD_SOMClass_somGetMethodData;
  1079. /*
  1080.  *  If a method with id <methodId> is supported by the target class,
  1081.  *  the structure pointed to by <md> is loaded with method information
  1082.  *  and the value 1 is returned. In this case, if the method is not
  1083.  *  dynamic, md->method is loaded with the result of somClassResolve on
  1084.  *  the target class for the method. If the method is not supported,
  1085.  *  md->id is loaded with 0, and the value 0 is returned.
  1086.  */
  1087. #define somMD_SOMClass_somGetMethodData "::SOMClass::somGetMethodData"
  1088. #define SOMClass_somGetMethodData(somSelf,methodId,md) \
  1089.     (SOM_Resolve(somSelf, SOMClass, somGetMethodData) \
  1090.     (somSelf,methodId,md))
  1091. #ifndef SOMGD_somGetMethodData
  1092.     #if (defined(_somGetMethodData) || defined(__somGetMethodData))
  1093.         #undef _somGetMethodData
  1094.         #undef __somGetMethodData
  1095.         #define SOMGD_somGetMethodData 1
  1096.     #else
  1097.         #define _somGetMethodData SOMClass_somGetMethodData
  1098.     #endif /* _somGetMethodData */
  1099. #endif /* SOMGD_somGetMethodData */
  1100.  
  1101. /*
  1102.  * New Method: somGetRdStub
  1103.  */
  1104. typedef somMethodProc*   SOMLINK somTP_SOMClass_somGetRdStub(SOMClass *somSelf, 
  1105.         somId methodId);
  1106. #pragma linkage(somTP_SOMClass_somGetRdStub, system)
  1107. typedef somTP_SOMClass_somGetRdStub *somTD_SOMClass_somGetRdStub;
  1108. /*
  1109.  *  Returns a redispatch stub for the indicated method, if possible.
  1110.  *  If not possible (because a valid redispatch stub has not been
  1111.  *  registered, and there is insufficient information to dynamically
  1112.  *  construct one), then a NULL is returned.
  1113.  */
  1114. #define somMD_SOMClass_somGetRdStub "::SOMClass::somGetRdStub"
  1115. #define SOMClass_somGetRdStub(somSelf,methodId) \
  1116.     (SOM_Resolve(somSelf, SOMClass, somGetRdStub) \
  1117.     (somSelf,methodId))
  1118. #ifndef SOMGD_somGetRdStub
  1119.     #if (defined(_somGetRdStub) || defined(__somGetRdStub))
  1120.         #undef _somGetRdStub
  1121.         #undef __somGetRdStub
  1122.         #define SOMGD_somGetRdStub 1
  1123.     #else
  1124.         #define _somGetRdStub SOMClass_somGetRdStub
  1125.     #endif /* _somGetRdStub */
  1126. #endif /* SOMGD_somGetRdStub */
  1127.  
  1128. /*
  1129.  * New Method: somGetMethodDescriptor
  1130.  */
  1131. typedef somId   SOMLINK somTP_SOMClass_somGetMethodDescriptor(SOMClass *somSelf, 
  1132.         somId methodId);
  1133. #pragma linkage(somTP_SOMClass_somGetMethodDescriptor, system)
  1134. typedef somTP_SOMClass_somGetMethodDescriptor *somTD_SOMClass_somGetMethodDescriptor;
  1135. /*
  1136.  *  Returns the method descriptor for the indicated method.    If
  1137.  *  this object does not support the indicated method then NULL is
  1138.  *  returned.
  1139.  */
  1140. #define somMD_SOMClass_somGetMethodDescriptor "::SOMClass::somGetMethodDescriptor"
  1141. #define SOMClass_somGetMethodDescriptor(somSelf,methodId) \
  1142.     (SOM_Resolve(somSelf, SOMClass, somGetMethodDescriptor) \
  1143.     (somSelf,methodId))
  1144. #ifndef SOMGD_somGetMethodDescriptor
  1145.     #if (defined(_somGetMethodDescriptor) || defined(__somGetMethodDescriptor))
  1146.         #undef _somGetMethodDescriptor
  1147.         #undef __somGetMethodDescriptor
  1148.         #define SOMGD_somGetMethodDescriptor 1
  1149.     #else
  1150.         #define _somGetMethodDescriptor SOMClass_somGetMethodDescriptor
  1151.     #endif /* _somGetMethodDescriptor */
  1152. #endif /* SOMGD_somGetMethodDescriptor */
  1153.  
  1154. /*
  1155.  * New Method: somGetMethodIndex
  1156.  */
  1157. typedef long   SOMLINK somTP_SOMClass_somGetMethodIndex(SOMClass *somSelf, 
  1158.         somId id);
  1159. #pragma linkage(somTP_SOMClass_somGetMethodIndex, system)
  1160. typedef somTP_SOMClass_somGetMethodIndex *somTD_SOMClass_somGetMethodIndex;
  1161. /*
  1162.  *  Returns the index for the specified method. (A number that may
  1163.  *  change if any methods are added or deleted to this class object or
  1164.  *  any of its ancestors).  This number is the basis for other calls to
  1165.  *  get info about the method. Indexes start at 0. A -1 is returned if
  1166.  *  the method cannot be found.
  1167.  */
  1168. #define somMD_SOMClass_somGetMethodIndex "::SOMClass::somGetMethodIndex"
  1169. #define SOMClass_somGetMethodIndex(somSelf,id) \
  1170.     (SOM_Resolve(somSelf, SOMClass, somGetMethodIndex) \
  1171.     (somSelf,id))
  1172. #ifndef SOMGD_somGetMethodIndex
  1173.     #if (defined(_somGetMethodIndex) || defined(__somGetMethodIndex))
  1174.         #undef _somGetMethodIndex
  1175.         #undef __somGetMethodIndex
  1176.         #define SOMGD_somGetMethodIndex 1
  1177.     #else
  1178.         #define _somGetMethodIndex SOMClass_somGetMethodIndex
  1179.     #endif /* _somGetMethodIndex */
  1180. #endif /* SOMGD_somGetMethodIndex */
  1181.  
  1182. /*
  1183.  * New Method: somGetMethodToken
  1184.  */
  1185. typedef somMToken   SOMLINK somTP_SOMClass_somGetMethodToken(SOMClass *somSelf, 
  1186.         somId methodId);
  1187. #pragma linkage(somTP_SOMClass_somGetMethodToken, system)
  1188. typedef somTP_SOMClass_somGetMethodToken *somTD_SOMClass_somGetMethodToken;
  1189. /*
  1190.  *  Returns the specified method's access token. This token can then
  1191.  *  be passed to method resolution routines, which use the token
  1192.  *  to select a method pointer from a method table.
  1193.  */
  1194. #define somMD_SOMClass_somGetMethodToken "::SOMClass::somGetMethodToken"
  1195. #define SOMClass_somGetMethodToken(somSelf,methodId) \
  1196.     (SOM_Resolve(somSelf, SOMClass, somGetMethodToken) \
  1197.     (somSelf,methodId))
  1198. #ifndef SOMGD_somGetMethodToken
  1199.     #if (defined(_somGetMethodToken) || defined(__somGetMethodToken))
  1200.         #undef _somGetMethodToken
  1201.         #undef __somGetMethodToken
  1202.         #define SOMGD_somGetMethodToken 1
  1203.     #else
  1204.         #define _somGetMethodToken SOMClass_somGetMethodToken
  1205.     #endif /* _somGetMethodToken */
  1206. #endif /* SOMGD_somGetMethodToken */
  1207.  
  1208. /*
  1209.  * New Method: somGetName
  1210.  */
  1211. typedef string   SOMLINK somTP_SOMClass_somGetName(SOMClass *somSelf);
  1212. #pragma linkage(somTP_SOMClass_somGetName, system)
  1213. typedef somTP_SOMClass_somGetName *somTD_SOMClass_somGetName;
  1214. /*
  1215.  *  This object's class name as a NULL terminated string.
  1216.  */
  1217. #define somMD_SOMClass_somGetName "::SOMClass::somGetName"
  1218. #define SOMClass_somGetName(somSelf) \
  1219.     (SOM_Resolve(somSelf, SOMClass, somGetName) \
  1220.     (somSelf))
  1221. #ifndef SOMGD_somGetName
  1222.     #if (defined(_somGetName) || defined(__somGetName))
  1223.         #undef _somGetName
  1224.         #undef __somGetName
  1225.         #define SOMGD_somGetName 1
  1226.     #else
  1227.         #define _somGetName SOMClass_somGetName
  1228.     #endif /* _somGetName */
  1229. #endif /* SOMGD_somGetName */
  1230.  
  1231. /*
  1232.  * New Method: somGetNthMethodData
  1233.  */
  1234. typedef boolean   SOMLINK somTP_SOMClass_somGetNthMethodData(SOMClass *somSelf, 
  1235.         long n, 
  1236.         somMethodData* md);
  1237. #pragma linkage(somTP_SOMClass_somGetNthMethodData, system)
  1238. typedef somTP_SOMClass_somGetNthMethodData *somTD_SOMClass_somGetNthMethodData;
  1239. /*
  1240.  *  loads *md with the method data associated with the the nth method,
  1241.  *  or NULL if there is no such method. Returns true is successful;
  1242.  *  false otherwise.
  1243.  */
  1244. #define somMD_SOMClass_somGetNthMethodData "::SOMClass::somGetNthMethodData"
  1245. #define SOMClass_somGetNthMethodData(somSelf,n,md) \
  1246.     (SOM_Resolve(somSelf, SOMClass, somGetNthMethodData) \
  1247.     (somSelf,n,md))
  1248. #ifndef SOMGD_somGetNthMethodData
  1249.     #if (defined(_somGetNthMethodData) || defined(__somGetNthMethodData))
  1250.         #undef _somGetNthMethodData
  1251.         #undef __somGetNthMethodData
  1252.         #define SOMGD_somGetNthMethodData 1
  1253.     #else
  1254.         #define _somGetNthMethodData SOMClass_somGetNthMethodData
  1255.     #endif /* _somGetNthMethodData */
  1256. #endif /* SOMGD_somGetNthMethodData */
  1257.  
  1258. /*
  1259.  * New Method: somGetNthMethodInfo
  1260.  */
  1261. typedef somId   SOMLINK somTP_SOMClass_somGetNthMethodInfo(SOMClass *somSelf, 
  1262.         long n, 
  1263.         somId* descriptor);
  1264. #pragma linkage(somTP_SOMClass_somGetNthMethodInfo, system)
  1265. typedef somTP_SOMClass_somGetNthMethodInfo *somTD_SOMClass_somGetNthMethodInfo;
  1266. /*
  1267.  *  Returns the id of the <n>th method if one exists and NULL
  1268.  *  otherwise.
  1269.  * 
  1270.  *  The ordering of the methods is unpredictable, but will not change
  1271.  *  unless some change is made to the class or one of its ancestor classes.
  1272.  * 
  1273.  *  See CORBA documentation for info on method descriptors.
  1274.  */
  1275. #define somMD_SOMClass_somGetNthMethodInfo "::SOMClass::somGetNthMethodInfo"
  1276. #define SOMClass_somGetNthMethodInfo(somSelf,n,descriptor) \
  1277.     (SOM_Resolve(somSelf, SOMClass, somGetNthMethodInfo) \
  1278.     (somSelf,n,descriptor))
  1279. #ifndef SOMGD_somGetNthMethodInfo
  1280.     #if (defined(_somGetNthMethodInfo) || defined(__somGetNthMethodInfo))
  1281.         #undef _somGetNthMethodInfo
  1282.         #undef __somGetNthMethodInfo
  1283.         #define SOMGD_somGetNthMethodInfo 1
  1284.     #else
  1285.         #define _somGetNthMethodInfo SOMClass_somGetNthMethodInfo
  1286.     #endif /* _somGetNthMethodInfo */
  1287. #endif /* SOMGD_somGetNthMethodInfo */
  1288.  
  1289. /*
  1290.  * New Method: somGetNumMethods
  1291.  */
  1292. typedef long   SOMLINK somTP_SOMClass_somGetNumMethods(SOMClass *somSelf);
  1293. #pragma linkage(somTP_SOMClass_somGetNumMethods, system)
  1294. typedef somTP_SOMClass_somGetNumMethods *somTD_SOMClass_somGetNumMethods;
  1295. /*
  1296.  *  The number of methods currently supported by this class,
  1297.  *  including inherited methods (both static and dynamic).
  1298.  */
  1299. #define somMD_SOMClass_somGetNumMethods "::SOMClass::somGetNumMethods"
  1300. #define SOMClass_somGetNumMethods(somSelf) \
  1301.     (SOM_Resolve(somSelf, SOMClass, somGetNumMethods) \
  1302.     (somSelf))
  1303. #ifndef SOMGD_somGetNumMethods
  1304.     #if (defined(_somGetNumMethods) || defined(__somGetNumMethods))
  1305.         #undef _somGetNumMethods
  1306.         #undef __somGetNumMethods
  1307.         #define SOMGD_somGetNumMethods 1
  1308.     #else
  1309.         #define _somGetNumMethods SOMClass_somGetNumMethods
  1310.     #endif /* _somGetNumMethods */
  1311. #endif /* SOMGD_somGetNumMethods */
  1312.  
  1313. /*
  1314.  * New Method: somGetNumStaticMethods
  1315.  */
  1316. typedef long   SOMLINK somTP_SOMClass_somGetNumStaticMethods(SOMClass *somSelf);
  1317. #pragma linkage(somTP_SOMClass_somGetNumStaticMethods, system)
  1318. typedef somTP_SOMClass_somGetNumStaticMethods *somTD_SOMClass_somGetNumStaticMethods;
  1319. /*
  1320.  *  The number of static methods that this class has.  Can
  1321.  *  be used by a child class when initializing its method table.
  1322.  */
  1323. #define somMD_SOMClass_somGetNumStaticMethods "::SOMClass::somGetNumStaticMethods"
  1324. #define SOMClass_somGetNumStaticMethods(somSelf) \
  1325.     (SOM_Resolve(somSelf, SOMClass, somGetNumStaticMethods) \
  1326.     (somSelf))
  1327. #ifndef SOMGD_somGetNumStaticMethods
  1328.     #if (defined(_somGetNumStaticMethods) || defined(__somGetNumStaticMethods))
  1329.         #undef _somGetNumStaticMethods
  1330.         #undef __somGetNumStaticMethods
  1331.         #define SOMGD_somGetNumStaticMethods 1
  1332.     #else
  1333.         #define _somGetNumStaticMethods SOMClass_somGetNumStaticMethods
  1334.     #endif /* _somGetNumStaticMethods */
  1335. #endif /* SOMGD_somGetNumStaticMethods */
  1336.  
  1337. /*
  1338.  * New Method: somGetParent
  1339.  */
  1340. typedef SOMClass*   SOMLINK somTP_SOMClass_somGetParent(SOMClass *somSelf);
  1341. #pragma linkage(somTP_SOMClass_somGetParent, system)
  1342. typedef somTP_SOMClass_somGetParent *somTD_SOMClass_somGetParent;
  1343. /*
  1344.  *  Returns the parent class of self (along its "left-hand" derivation
  1345.  *  path), if one exists and NULL otherwise.
  1346.  */
  1347. #define somMD_SOMClass_somGetParent "::SOMClass::somGetParent"
  1348. #define SOMClass_somGetParent(somSelf) \
  1349.     (SOM_Resolve(somSelf, SOMClass, somGetParent) \
  1350.     (somSelf))
  1351. #ifndef SOMGD_somGetParent
  1352.     #if (defined(_somGetParent) || defined(__somGetParent))
  1353.         #undef _somGetParent
  1354.         #undef __somGetParent
  1355.         #define SOMGD_somGetParent 1
  1356.     #else
  1357.         #define _somGetParent SOMClass_somGetParent
  1358.     #endif /* _somGetParent */
  1359. #endif /* SOMGD_somGetParent */
  1360.  
  1361. /*
  1362.  * New Method: somGetParents
  1363.  */
  1364. typedef SOMClass_SOMClassSequence   SOMLINK somTP_SOMClass_somGetParents(SOMClass *somSelf);
  1365. #pragma linkage(somTP_SOMClass_somGetParents, system)
  1366. typedef somTP_SOMClass_somGetParents *somTD_SOMClass_somGetParents;
  1367. /*
  1368.  *  The parent classes of self.
  1369.  */
  1370. #define somMD_SOMClass_somGetParents "::SOMClass::somGetParents"
  1371. #define SOMClass_somGetParents(somSelf) \
  1372.     (SOM_Resolve(somSelf, SOMClass, somGetParents) \
  1373.     (somSelf))
  1374. #ifndef SOMGD_somGetParents
  1375.     #if (defined(_somGetParents) || defined(__somGetParents))
  1376.         #undef _somGetParents
  1377.         #undef __somGetParents
  1378.         #define SOMGD_somGetParents 1
  1379.     #else
  1380.         #define _somGetParents SOMClass_somGetParents
  1381.     #endif /* _somGetParents */
  1382. #endif /* SOMGD_somGetParents */
  1383.  
  1384. /*
  1385.  * New Method: somGetVersionNumbers
  1386.  */
  1387. typedef void   SOMLINK somTP_SOMClass_somGetVersionNumbers(SOMClass *somSelf, 
  1388.         long* majorVersion, 
  1389.         long* minorVersion);
  1390. #pragma linkage(somTP_SOMClass_somGetVersionNumbers, system)
  1391. typedef somTP_SOMClass_somGetVersionNumbers *somTD_SOMClass_somGetVersionNumbers;
  1392. /*
  1393.  *  Returns the class' major and minor version numbers in the corresponding
  1394.  *  output parameters.
  1395.  */
  1396. #define somMD_SOMClass_somGetVersionNumbers "::SOMClass::somGetVersionNumbers"
  1397. #define SOMClass_somGetVersionNumbers(somSelf,majorVersion,minorVersion) \
  1398.     (SOM_Resolve(somSelf, SOMClass, somGetVersionNumbers) \
  1399.     (somSelf,majorVersion,minorVersion))
  1400. #ifndef SOMGD_somGetVersionNumbers
  1401.     #if (defined(_somGetVersionNumbers) || defined(__somGetVersionNumbers))
  1402.         #undef _somGetVersionNumbers
  1403.         #undef __somGetVersionNumbers
  1404.         #define SOMGD_somGetVersionNumbers 1
  1405.     #else
  1406.         #define _somGetVersionNumbers SOMClass_somGetVersionNumbers
  1407.     #endif /* _somGetVersionNumbers */
  1408. #endif /* SOMGD_somGetVersionNumbers */
  1409.  
  1410. /*
  1411.  * New Method: somFindMethod
  1412.  */
  1413. typedef boolean   SOMLINK somTP_SOMClass_somFindMethod(SOMClass *somSelf, 
  1414.         somId methodId, 
  1415.         somMethodPtr* m);
  1416. #pragma linkage(somTP_SOMClass_somFindMethod, system)
  1417. typedef somTP_SOMClass_somFindMethod *somTD_SOMClass_somFindMethod;
  1418. /*
  1419.  *  Finds the method procedure associated with <methodId> for this
  1420.  *  class and sets <m> to it.  1 (true) is returned when the
  1421.  *  method procedure is a static method and 0 (false) is returned
  1422.  *  when the method procedure is dynamic method.
  1423.  * 
  1424.  *  If the class does not support the specified method then
  1425.  *  <m> is set to NULL and the return value is meaningless.
  1426.  * 
  1427.  */
  1428. #define somMD_SOMClass_somFindMethod "::SOMClass::somFindMethod"
  1429. #define SOMClass_somFindMethod(somSelf,methodId,m) \
  1430.     (SOM_Resolve(somSelf, SOMClass, somFindMethod) \
  1431.     (somSelf,methodId,m))
  1432. #ifndef SOMGD_somFindMethod
  1433.     #if (defined(_somFindMethod) || defined(__somFindMethod))
  1434.         #undef _somFindMethod
  1435.         #undef __somFindMethod
  1436.         #define SOMGD_somFindMethod 1
  1437.     #else
  1438.         #define _somFindMethod SOMClass_somFindMethod
  1439.     #endif /* _somFindMethod */
  1440. #endif /* SOMGD_somFindMethod */
  1441.  
  1442. /*
  1443.  * New Method: somFindMethodOk
  1444.  */
  1445. typedef boolean   SOMLINK somTP_SOMClass_somFindMethodOk(SOMClass *somSelf, 
  1446.         somId methodId, 
  1447.         somMethodPtr* m);
  1448. #pragma linkage(somTP_SOMClass_somFindMethodOk, system)
  1449. typedef somTP_SOMClass_somFindMethodOk *somTD_SOMClass_somFindMethodOk;
  1450. /*
  1451.  *  Just like <somFindMethod> except that if the method is not
  1452.  *  supported then an error is raised and execution is halted.
  1453.  */
  1454. #define somMD_SOMClass_somFindMethodOk "::SOMClass::somFindMethodOk"
  1455. #define SOMClass_somFindMethodOk(somSelf,methodId,m) \
  1456.     (SOM_Resolve(somSelf, SOMClass, somFindMethodOk) \
  1457.     (somSelf,methodId,m))
  1458. #ifndef SOMGD_somFindMethodOk
  1459.     #if (defined(_somFindMethodOk) || defined(__somFindMethodOk))
  1460.         #undef _somFindMethodOk
  1461.         #undef __somFindMethodOk
  1462.         #define SOMGD_somFindMethodOk 1
  1463.     #else
  1464.         #define _somFindMethodOk SOMClass_somFindMethodOk
  1465.     #endif /* _somFindMethodOk */
  1466. #endif /* SOMGD_somFindMethodOk */
  1467.  
  1468. /*
  1469.  * New Method: somFindSMethod
  1470.  */
  1471. typedef somMethodPtr   SOMLINK somTP_SOMClass_somFindSMethod(SOMClass *somSelf, 
  1472.         somId methodId);
  1473. #pragma linkage(somTP_SOMClass_somFindSMethod, system)
  1474. typedef somTP_SOMClass_somFindSMethod *somTD_SOMClass_somFindSMethod;
  1475. /*
  1476.  *  Finds the indicated method, which must be a static method supported
  1477.  *  by this class, and returns a pointer to its method procedure.
  1478.  *  If the method is not supported by the receiver (as a static method
  1479.  *  or at all) then a NULL pointer is returned.
  1480.  */
  1481. #define somMD_SOMClass_somFindSMethod "::SOMClass::somFindSMethod"
  1482. #define SOMClass_somFindSMethod(somSelf,methodId) \
  1483.     (SOM_Resolve(somSelf, SOMClass, somFindSMethod) \
  1484.     (somSelf,methodId))
  1485. #ifndef SOMGD_somFindSMethod
  1486.     #if (defined(_somFindSMethod) || defined(__somFindSMethod))
  1487.         #undef _somFindSMethod
  1488.         #undef __somFindSMethod
  1489.         #define SOMGD_somFindSMethod 1
  1490.     #else
  1491.         #define _somFindSMethod SOMClass_somFindSMethod
  1492.     #endif /* _somFindSMethod */
  1493. #endif /* SOMGD_somFindSMethod */
  1494.  
  1495. /*
  1496.  * New Method: somFindSMethodOk
  1497.  */
  1498. typedef somMethodPtr   SOMLINK somTP_SOMClass_somFindSMethodOk(SOMClass *somSelf, 
  1499.         somId methodId);
  1500. #pragma linkage(somTP_SOMClass_somFindSMethodOk, system)
  1501. typedef somTP_SOMClass_somFindSMethodOk *somTD_SOMClass_somFindSMethodOk;
  1502. /*
  1503.  *  Uses <somFindSMethod>, and raises an error if the result is NULL.
  1504.  */
  1505. #define somMD_SOMClass_somFindSMethodOk "::SOMClass::somFindSMethodOk"
  1506. #define SOMClass_somFindSMethodOk(somSelf,methodId) \
  1507.     (SOM_Resolve(somSelf, SOMClass, somFindSMethodOk) \
  1508.     (somSelf,methodId))
  1509. #ifndef SOMGD_somFindSMethodOk
  1510.     #if (defined(_somFindSMethodOk) || defined(__somFindSMethodOk))
  1511.         #undef _somFindSMethodOk
  1512.         #undef __somFindSMethodOk
  1513.         #define SOMGD_somFindSMethodOk 1
  1514.     #else
  1515.         #define _somFindSMethodOk SOMClass_somFindSMethodOk
  1516.     #endif /* _somFindSMethodOk */
  1517. #endif /* SOMGD_somFindSMethodOk */
  1518.  
  1519. /*
  1520.  * New Method: somLookupMethod
  1521.  */
  1522. typedef somMethodPtr   SOMLINK somTP_SOMClass_somLookupMethod(SOMClass *somSelf, 
  1523.         somId methodId);
  1524. #pragma linkage(somTP_SOMClass_somLookupMethod, system)
  1525. typedef somTP_SOMClass_somLookupMethod *somTD_SOMClass_somLookupMethod;
  1526. /*
  1527.  *  Like <somFindSMethodOK>, but without restriction to static methods.
  1528.  */
  1529. #define somMD_SOMClass_somLookupMethod "::SOMClass::somLookupMethod"
  1530. #define SOMClass_somLookupMethod(somSelf,methodId) \
  1531.     (SOM_Resolve(somSelf, SOMClass, somLookupMethod) \
  1532.     (somSelf,methodId))
  1533. #ifndef SOMGD_somLookupMethod
  1534.     #if (defined(_somLookupMethod) || defined(__somLookupMethod))
  1535.         #undef _somLookupMethod
  1536.         #undef __somLookupMethod
  1537.         #define SOMGD_somLookupMethod 1
  1538.     #else
  1539.         #define _somLookupMethod SOMClass_somLookupMethod
  1540.     #endif /* _somLookupMethod */
  1541. #endif /* SOMGD_somLookupMethod */
  1542.  
  1543. /*
  1544.  * New Method: somCheckVersion
  1545.  */
  1546. typedef boolean   SOMLINK somTP_SOMClass_somCheckVersion(SOMClass *somSelf, 
  1547.         long majorVersion, 
  1548.         long minorVersion);
  1549. #pragma linkage(somTP_SOMClass_somCheckVersion, system)
  1550. typedef somTP_SOMClass_somCheckVersion *somTD_SOMClass_somCheckVersion;
  1551. /*
  1552.  *  Returns 1 (true) if the implementation of this class is
  1553.  *  compatible with the specified major and minor version number and
  1554.  *  false (0) otherwise.  An implementation is compatible with the
  1555.  *  specified version numbers if it has the same major version number
  1556.  *  and a minor version number that is equal to or greater than
  1557.  *  <minorVersion>.    The major, minor version number pair (0,0) is
  1558.  *  considered to match any version.  This method is usually called
  1559.  *  immediately after creating the class object to verify that a
  1560.  *  dynamically loaded class definition is compatible with a using
  1561.  *  application.
  1562.  */
  1563. #define somMD_SOMClass_somCheckVersion "::SOMClass::somCheckVersion"
  1564. #define SOMClass_somCheckVersion(somSelf,majorVersion,minorVersion) \
  1565.     (SOM_Resolve(somSelf, SOMClass, somCheckVersion) \
  1566.     (somSelf,majorVersion,minorVersion))
  1567. #ifndef SOMGD_somCheckVersion
  1568.     #if (defined(_somCheckVersion) || defined(__somCheckVersion))
  1569.         #undef _somCheckVersion
  1570.         #undef __somCheckVersion
  1571.         #define SOMGD_somCheckVersion 1
  1572.     #else
  1573.         #define _somCheckVersion SOMClass_somCheckVersion
  1574.     #endif /* _somCheckVersion */
  1575. #endif /* SOMGD_somCheckVersion */
  1576.  
  1577. /*
  1578.  * New Method: somDescendedFrom
  1579.  */
  1580. typedef boolean   SOMLINK somTP_SOMClass_somDescendedFrom(SOMClass *somSelf, 
  1581.         SOMClass* aClassObj);
  1582. #pragma linkage(somTP_SOMClass_somDescendedFrom, system)
  1583. typedef somTP_SOMClass_somDescendedFrom *somTD_SOMClass_somDescendedFrom;
  1584. /*
  1585.  *  Returns 1 (true) if <self> is a descendent class of <aClassObj> and
  1586.  *  0 (false) otherwise.  Note: a class object is considered to be
  1587.  *  descended itself for the purposes of this method.
  1588.  */
  1589. #define somMD_SOMClass_somDescendedFrom "::SOMClass::somDescendedFrom"
  1590. #define SOMClass_somDescendedFrom(somSelf,aClassObj) \
  1591.     (SOM_Resolve(somSelf, SOMClass, somDescendedFrom) \
  1592.     (somSelf,aClassObj))
  1593. #ifndef SOMGD_somDescendedFrom
  1594.     #if (defined(_somDescendedFrom) || defined(__somDescendedFrom))
  1595.         #undef _somDescendedFrom
  1596.         #undef __somDescendedFrom
  1597.         #define SOMGD_somDescendedFrom 1
  1598.     #else
  1599.         #define _somDescendedFrom SOMClass_somDescendedFrom
  1600.     #endif /* _somDescendedFrom */
  1601. #endif /* SOMGD_somDescendedFrom */
  1602.  
  1603. /*
  1604.  * New Method: somSupportsMethod
  1605.  */
  1606. typedef boolean   SOMLINK somTP_SOMClass_somSupportsMethod(SOMClass *somSelf, 
  1607.         somId mId);
  1608. #pragma linkage(somTP_SOMClass_somSupportsMethod, system)
  1609. typedef somTP_SOMClass_somSupportsMethod *somTD_SOMClass_somSupportsMethod;
  1610. /*
  1611.  *  Returns 1 (true) if the indicated method is supported by this
  1612.  *  class and 0 (false) otherwise.
  1613.  */
  1614. #define somMD_SOMClass_somSupportsMethod "::SOMClass::somSupportsMethod"
  1615. #define SOMClass_somSupportsMethod(somSelf,mId) \
  1616.     (SOM_Resolve(somSelf, SOMClass, somSupportsMethod) \
  1617.     (somSelf,mId))
  1618. #ifndef SOMGD_somSupportsMethod
  1619.     #if (defined(_somSupportsMethod) || defined(__somSupportsMethod))
  1620.         #undef _somSupportsMethod
  1621.         #undef __somSupportsMethod
  1622.         #define SOMGD_somSupportsMethod 1
  1623.     #else
  1624.         #define _somSupportsMethod SOMClass_somSupportsMethod
  1625.     #endif /* _somSupportsMethod */
  1626. #endif /* SOMGD_somSupportsMethod */
  1627.  
  1628. /*
  1629.  * New Method: somDefinedMethod
  1630.  */
  1631. typedef somMethodPtr   SOMLINK somTP_SOMClass_somDefinedMethod(SOMClass *somSelf, 
  1632.         somMToken method);
  1633. #pragma linkage(somTP_SOMClass_somDefinedMethod, system)
  1634. typedef somTP_SOMClass_somDefinedMethod *somTD_SOMClass_somDefinedMethod;
  1635. /*
  1636.  *  if the receiving class either introduces or overrides the
  1637.  *  indicated method, then its somMethodPtr is returned, otherwise
  1638.  *  NULL is returned.
  1639.  */
  1640. #define somMD_SOMClass_somDefinedMethod "::SOMClass::somDefinedMethod"
  1641. #define SOMClass_somDefinedMethod(somSelf,method) \
  1642.     (SOM_Resolve(somSelf, SOMClass, somDefinedMethod) \
  1643.     (somSelf,method))
  1644. #ifndef SOMGD_somDefinedMethod
  1645.     #if (defined(_somDefinedMethod) || defined(__somDefinedMethod))
  1646.         #undef _somDefinedMethod
  1647.         #undef __somDefinedMethod
  1648.         #define SOMGD_somDefinedMethod 1
  1649.     #else
  1650.         #define _somDefinedMethod SOMClass_somDefinedMethod
  1651.     #endif /* _somDefinedMethod */
  1652. #endif /* SOMGD_somDefinedMethod */
  1653.  
  1654. /*
  1655.  * New Method: somOverrideMtab
  1656.  */
  1657. typedef void   SOMLINK somTP_SOMClass_somOverrideMtab(SOMClass *somSelf);
  1658. #pragma linkage(somTP_SOMClass_somOverrideMtab, system)
  1659. typedef somTP_SOMClass_somOverrideMtab *somTD_SOMClass_somOverrideMtab;
  1660. /*
  1661.  *  Overrides the method table pointers to point to the redispatch stubs.
  1662.  *  All the methods except somDispatch methods are overriden.
  1663.  */
  1664. #define somMD_SOMClass_somOverrideMtab "::SOMClass::somOverrideMtab"
  1665. #define SOMClass_somOverrideMtab(somSelf) \
  1666.     (SOM_Resolve(somSelf, SOMClass, somOverrideMtab) \
  1667.     (somSelf))
  1668. #ifndef SOMGD_somOverrideMtab
  1669.     #if (defined(_somOverrideMtab) || defined(__somOverrideMtab))
  1670.         #undef _somOverrideMtab
  1671.         #undef __somOverrideMtab
  1672.         #define SOMGD_somOverrideMtab 1
  1673.     #else
  1674.         #define _somOverrideMtab SOMClass_somOverrideMtab
  1675.     #endif /* _somOverrideMtab */
  1676. #endif /* SOMGD_somOverrideMtab */
  1677. #ifndef SOM_DONT_USE_INHERITED_MACROS
  1678. #define SOMClass_somDefaultInit SOMObject_somDefaultInit
  1679. #define SOMClass_somDestruct SOMObject_somDestruct
  1680. #define SOMClass_somDefaultCopyInit SOMObject_somDefaultCopyInit
  1681. #define SOMClass_somDefaultAssign SOMObject_somDefaultAssign
  1682. #define SOMClass_somDefaultConstCopyInit SOMObject_somDefaultConstCopyInit
  1683. #define SOMClass_somDefaultVCopyInit SOMObject_somDefaultVCopyInit
  1684. #define SOMClass_somDefaultConstVCopyInit SOMObject_somDefaultConstVCopyInit
  1685. #define SOMClass_somDefaultConstAssign SOMObject_somDefaultConstAssign
  1686. #define SOMClass_somDefaultVAssign SOMObject_somDefaultVAssign
  1687. #define SOMClass_somDefaultConstVAssign SOMObject_somDefaultConstVAssign
  1688. #define SOMClass_somInit SOMObject_somInit
  1689. #define SOMClass_somFree SOMObject_somFree
  1690. #define SOMClass_somUninit SOMObject_somUninit
  1691. #define SOMClass_somGetClass SOMObject_somGetClass
  1692. #define SOMClass_somGetClassName SOMObject_somGetClassName
  1693. #define SOMClass_somGetSize SOMObject_somGetSize
  1694. #define SOMClass_somIsA SOMObject_somIsA
  1695. #define SOMClass_somIsInstanceOf SOMObject_somIsInstanceOf
  1696. #define SOMClass_somRespondsTo SOMObject_somRespondsTo
  1697. #define SOMClass_somDispatch SOMObject_somDispatch
  1698. #define SOMClass_somClassDispatch SOMObject_somClassDispatch
  1699. #define SOMClass_somCastObj SOMObject_somCastObj
  1700. #define SOMClass_somResetObj SOMObject_somResetObj
  1701. #define SOMClass_somDispatchV SOMObject_somDispatchV
  1702. #define SOMClass_somDispatchL SOMObject_somDispatchL
  1703. #define SOMClass_somDispatchA SOMObject_somDispatchA
  1704. #define SOMClass_somDispatchD SOMObject_somDispatchD
  1705. #define SOMClass_somPrintSelf SOMObject_somPrintSelf
  1706. #define SOMClass_somDumpSelf SOMObject_somDumpSelf
  1707. #define SOMClass_somDumpSelfInt SOMObject_somDumpSelfInt
  1708. #endif /* SOM_DONT_USE_INHERITED_MACROS */
  1709.  
  1710. #endif       /* SOM_SOMClass_h */
  1711.