home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / warptlk3.zip / TOOLKIT / SOM / INCLUDE / SOMCLS.XH < prev    next >
Text File  |  1995-08-30  |  39KB  |  1,435 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: somcls.xh.
  5.  * Generated using:
  6.  *     SOM Precompiler somipc: 2.29.1.2
  7.  *     SOM Emitter emitxh: 2.41
  8.  */
  9.  
  10. /*
  11.  * 
  12.  *    COMPONENT_NAME: somk
  13.  * 
  14.  *    ORIGINS: 27
  15.  * 
  16.  * 
  17.  *    10H9767, 10H9769  (C) COPYRIGHT International Business Machines Corp. 1992,1994
  18.  *    All Rights Reserved
  19.  *    Licensed Materials - Property of IBM
  20.  *    US Government Users Restricted Rights - Use, duplication or
  21.  *    disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
  22.  * 
  23.  *   SOMObject: System Object Model root class
  24.  */
  25.  
  26.  
  27. #ifndef SOM_SOMClass_xh
  28. #define SOM_SOMClass_xh
  29.  
  30. class SOMClass;
  31.  
  32. /*
  33.  * 
  34.  *   This is the SOM metaclass.  That is, the instances of this class
  35.  *   are class objects.  When the SOM environment is created an instance
  36.  *   of SOMClass is created and a pointer to it is placed in the external
  37.  *   data location (SOMClassClassData.classObject). Bindings provide the
  38.  *   macro _SOMClass for this expression. _SOMClass is unique in that it
  39.  *   is its own class object. I.e., _SOMClass == _somGetClass(_SOMClass).
  40.  *   SOMClass can be subclassed just like any SOM class. The subclasses
  41.  *   of SOMClass are new metaclasses and can generate class objects with
  42.  *   different implementations than those produced by _SOMClass.
  43.  * 
  44.  *   An important rule for metaclass programming is that no methods
  45.  *   introduced by SOMClass should ever be overridden. While this
  46.  *   limits the utility of metaclass programming in SOM, it guarantees
  47.  *   that SOM will operate correctly. Special class frameworks may be
  48.  *   available from IBM to alleviate this restriction.
  49.  * 
  50.  */
  51.  
  52. #define SOMClass_MajorVersion 1
  53. #define SOMClass_MinorVersion 4
  54.  
  55. /* C++ SOM defs */
  56. #include <som.xh>
  57.  
  58. /* C++ parent defs */
  59. #ifndef SOM_SOMObject_xh
  60. #include <somobj.xh>
  61. #endif
  62.  
  63. #ifndef SOMClass_API
  64. #define SOMClass_API
  65. /*
  66.  * -- The Class API
  67.  */
  68.  
  69. /*
  70.  * Start of user-defined types:
  71.  */
  72. class SOMClass;
  73. class SOMObject;
  74. #ifndef _IDL_SEQUENCE_somToken_defined
  75. #define _IDL_SEQUENCE_somToken_defined
  76. typedef struct {
  77.     unsigned long _maximum;
  78.     unsigned long _length;
  79.     somToken *_buffer;
  80. } _IDL_SEQUENCE_somToken;
  81. #endif /* _IDL_SEQUENCE_somToken_defined */ 
  82. typedef
  83. _IDL_SEQUENCE_somToken SOMClass_somTokenSequence;
  84.  
  85. /*
  86.  *  a (generic) sequence of somTokens
  87.  */
  88. #ifndef _IDL_SEQUENCE_SOMClass_defined
  89. #define _IDL_SEQUENCE_SOMClass_defined
  90. typedef struct {
  91.     unsigned long _maximum;
  92.     unsigned long _length;
  93.     SOMClass **_buffer;
  94. } _IDL_SEQUENCE_SOMClass;
  95. #endif /* _IDL_SEQUENCE_SOMClass_defined */ 
  96. typedef
  97. _IDL_SEQUENCE_SOMClass SOMClass_SOMClassSequence;
  98.  
  99. /*
  100.  *  a sequence of classes
  101.  */
  102. typedef
  103. struct SOMClass_somOffsetInfo {
  104. SOMClass* cls;
  105. long  offset;
  106. } SOMClass_somOffsetInfo;
  107.  
  108. /*
  109.  *  a structure to describe a class-related offset
  110.  */
  111. struct SOMClass_somOffsetInfo;
  112. #ifndef _IDL_SEQUENCE_SOMClass_somOffsetInfo_defined
  113. #define _IDL_SEQUENCE_SOMClass_somOffsetInfo_defined
  114. typedef struct {
  115.     unsigned long _maximum;
  116.     unsigned long _length;
  117.     struct SOMClass_somOffsetInfo *_buffer;
  118. } _IDL_SEQUENCE_SOMClass_somOffsetInfo;
  119. #endif /* _IDL_SEQUENCE_SOMClass_somOffsetInfo_defined */ 
  120. typedef
  121. _IDL_SEQUENCE_SOMClass_somOffsetInfo SOMClass_somOffsets;
  122.  
  123. /*
  124.  *  a sequence of class-related offsets
  125.  */
  126. #ifndef _IDL_SEQUENCE_somId_defined
  127. #define _IDL_SEQUENCE_somId_defined
  128. typedef struct {
  129.     unsigned long _maximum;
  130.     unsigned long _length;
  131.     somId *_buffer;
  132. } _IDL_SEQUENCE_somId;
  133. #endif /* _IDL_SEQUENCE_somId_defined */ 
  134. typedef
  135. _IDL_SEQUENCE_somId SOMClass_somIdSequence;
  136.  
  137. /*
  138.  *  a sequence of somIds
  139.  */
  140.  
  141. #ifndef SOM_DONT_USE_SHORT_NAMES
  142.  
  143. #ifndef SOM_DONT_USE_SHORT_NAMES
  144. #ifndef SOMTGD_somTokenSequence
  145.     #ifdef somTokenSequence
  146.         #undef somTokenSequence
  147.         #define SOMTGD_somTokenSequence 1
  148.     #else
  149.         #define somTokenSequence SOMClass_somTokenSequence
  150.     #endif /* somTokenSequence */
  151. #endif /* SOMTGD_somTokenSequence */
  152. #endif /* SOM_DONT_USE_SHORT_NAMES */
  153.  
  154. #ifndef SOM_DONT_USE_SHORT_NAMES
  155. #ifndef SOMTGD_SOMClassSequence
  156.     #ifdef SOMClassSequence
  157.         #undef SOMClassSequence
  158.         #define SOMTGD_SOMClassSequence 1
  159.     #else
  160.         #define SOMClassSequence SOMClass_SOMClassSequence
  161.     #endif /* SOMClassSequence */
  162. #endif /* SOMTGD_SOMClassSequence */
  163. #endif /* SOM_DONT_USE_SHORT_NAMES */
  164. #ifndef SOMTGD_somOffsetInfo
  165.     #ifdef somOffsetInfo
  166.         #undef somOffsetInfo
  167.         #define SOMTGD_somOffsetInfo 1
  168.     #else
  169.         #define somOffsetInfo SOMClass_somOffsetInfo
  170.     #endif /* somOffsetInfo */
  171. #endif /* SOMTGD_somOffsetInfo */
  172. #ifndef SOMTGD__IDL_SEQUENCE_somOffsetInfo
  173.     #ifdef _IDL_SEQUENCE_somOffsetInfo
  174.         #undef _IDL_SEQUENCE_somOffsetInfo
  175.         #define SOMTGD__IDL_SEQUENCE_somOffsetInfo 1
  176.     #else
  177.         #define _IDL_SEQUENCE_somOffsetInfo _IDL_SEQUENCE_SOMClass_somOffsetInfo
  178.     #endif /* _IDL_SEQUENCE_somOffsetInfo */
  179. #endif /* SOMTGD__IDL_SEQUENCE_somOffsetInfo */
  180.  
  181. #ifndef SOM_DONT_USE_SHORT_NAMES
  182. #ifndef SOMTGD_somOffsets
  183.     #ifdef somOffsets
  184.         #undef somOffsets
  185.         #define SOMTGD_somOffsets 1
  186.     #else
  187.         #define somOffsets SOMClass_somOffsets
  188.     #endif /* somOffsets */
  189. #endif /* SOMTGD_somOffsets */
  190. #endif /* SOM_DONT_USE_SHORT_NAMES */
  191.  
  192. #ifndef SOM_DONT_USE_SHORT_NAMES
  193. #ifndef SOMTGD_somIdSequence
  194.     #ifdef somIdSequence
  195.         #undef somIdSequence
  196.         #define SOMTGD_somIdSequence 1
  197.     #else
  198.         #define somIdSequence SOMClass_somIdSequence
  199.     #endif /* somIdSequence */
  200. #endif /* SOMTGD_somIdSequence */
  201. #endif /* SOM_DONT_USE_SHORT_NAMES */
  202. #endif /* SOM_DONT_USE_SHORT_NAMES */
  203.  
  204. /*
  205.  * End of user-defined types.
  206.  */
  207.  
  208. /* A procedure to create the SOMClass Class */
  209. SOMEXTERN SOMClass * SOMLINK SOMClassNewClass(
  210.         integer4 majorVersion,
  211.         integer4 minorVersion);
  212.  
  213. /* The API to the SOMClass class object, and the methods it introduces. */
  214. SOMEXTERN struct SOMClassClassDataStructure {
  215.     SOMClass *classObject;
  216.     somMToken somNew;
  217.     somMToken somRenew;
  218.     somMToken somInitClass;
  219.     somMToken somClassReady;
  220.     somMToken somGetName;
  221.     somMToken somGetParent;
  222.     somMToken somDescendedFrom;
  223.     somMToken somCheckVersion;
  224.     somMToken somFindMethod;
  225.     somMToken somFindMethodOk;
  226.     somMToken somSupportsMethod;
  227.     somMToken somGetNumMethods;
  228.     somMToken somGetInstanceSize;
  229.     somMToken somGetInstanceOffset;
  230.     somMToken somGetInstancePartSize;
  231.     somMToken somGetMethodIndex;
  232.     somMToken somGetNumStaticMethods;
  233.     somMToken somGetPClsMtab;
  234.     somMToken somGetClassMtab;
  235.     somMToken somAddStaticMethod;
  236.     somMToken somOverrideSMethod;
  237.     somMToken somAddDynamicMethod;
  238.     somMToken somcPrivate0;
  239.     somMToken somGetApplyStub;
  240.     somMToken somFindSMethod;
  241.     somMToken somFindSMethodOk;
  242.     somMToken somGetMethodDescriptor;
  243.     somMToken somGetNthMethodInfo;
  244.     somMToken somSetClassData;
  245.     somMToken somGetClassData;
  246.     somMToken somNewNoInit;
  247.     somMToken somRenewNoInit;
  248.     somMToken somGetInstanceToken;
  249.     somMToken somGetMemberToken;
  250.     somMToken somSetMethodDescriptor;
  251.     somMToken somGetMethodData;
  252.     somMToken somOverrideMtab;
  253.     somMToken somGetMethodToken;
  254.     somMToken somGetParents;
  255.     somMToken somGetPClsMtabs;
  256.     somMToken somInitMIClass;
  257.     somMToken somGetVersionNumbers;
  258.     somMToken somLookupMethod;
  259.     somMToken _get_somInstanceDataOffsets;
  260.     somMToken somRenewNoZero;
  261.     somMToken somRenewNoInitNoZero;
  262.     somMToken somAllocate;
  263.     somMToken somDeallocate;
  264.     somMToken somGetRdStub;
  265.     somMToken somGetNthMethodData;
  266.     somMToken somcPrivate1;
  267.     somMToken somcPrivate2;
  268.     somMToken _get_somDirectInitClasses;
  269.     somMToken _set_somDirectInitClasses;
  270.     somMToken somGetInstanceInitMask;
  271.     somMToken somGetInstanceDestructionMask;
  272.     somMToken somcPrivate3;
  273.     somMToken somcPrivate4;
  274.     somMToken somcPrivate5;
  275.     somMToken somcPrivate6;
  276.     somMToken somcPrivate7;
  277.     somMToken somDefinedMethod;
  278.     somMToken somcPrivate8;
  279.     somMToken somcPrivate9;
  280.     somMToken somcPrivate10;
  281.     somMToken somcPrivate11;
  282.     somMToken somcPrivate12;
  283.     somMToken somcPrivate13;
  284.     somMToken somcPrivate14;
  285.     somMToken somcPrivate15;
  286.     somMToken _get_somDataAlignment;
  287.     somMToken somGetInstanceAssignmentMask;
  288.     somMToken somcPrivate16;
  289.     somMToken somcPrivate17;
  290.     somMToken _get_somClassAllocate;
  291.     somMToken _get_somClassDeallocate;
  292. } SOMDLINK SOMClassClassData;
  293. #define _SOMClass SOMClassClassData.classObject
  294.  
  295. /* The API to parentMtabs for SOMClass, and the instance data it introduces. */
  296. SOMEXTERN struct SOMClassCClassDataStructure {
  297.     somMethodTabs parentMtab;
  298.     somDToken              instanceDataToken;
  299. } SOMDLINK SOMClassCClassData;
  300.  
  301. /*
  302.  * -- Typedefs for SOMClass Method Procedures
  303.  */
  304. SOMEXTERN {
  305. typedef long   (SOMLINK * somTD_SOMClass__get_somDataAlignment)(SOMClass *somSelf);
  306. typedef SOMClass_somOffsets   (SOMLINK * somTD_SOMClass__get_somInstanceDataOffsets)(SOMClass *somSelf);
  307. typedef SOMClass_SOMClassSequence   (SOMLINK * somTD_SOMClass__get_somDirectInitClasses)(SOMClass *somSelf);
  308. typedef void   (SOMLINK * somTD_SOMClass__set_somDirectInitClasses)(SOMClass *somSelf,
  309.         SOMClass_SOMClassSequence* somDirectInitClasses);
  310. typedef SOMObject*   (SOMLINK * somTD_SOMClass_somNew)(SOMClass *somSelf);
  311. typedef SOMObject*   (SOMLINK * somTD_SOMClass_somNewNoInit)(SOMClass *somSelf);
  312. typedef SOMObject*   (SOMLINK * somTD_SOMClass_somRenew)(SOMClass *somSelf,
  313.         void* obj);
  314. typedef SOMObject*   (SOMLINK * somTD_SOMClass_somRenewNoInit)(SOMClass *somSelf,
  315.         void* obj);
  316. typedef SOMObject*   (SOMLINK * somTD_SOMClass_somRenewNoZero)(SOMClass *somSelf,
  317.         void* obj);
  318. typedef SOMObject*   (SOMLINK * somTD_SOMClass_somRenewNoInitNoZero)(SOMClass *somSelf,
  319.         void* obj);
  320. typedef string   (SOMLINK * somTD_SOMClass_somAllocate)(SOMClass *somSelf,
  321.         long size);
  322. typedef void   (SOMLINK * somTD_SOMClass_somDeallocate)(SOMClass *somSelf,
  323.         string memptr);
  324. typedef somMethodProc*   (SOMLINK * somTD_SOMClass__get_somClassAllocate)(SOMClass *somSelf);
  325. typedef somMethodProc*   (SOMLINK * somTD_SOMClass__get_somClassDeallocate)(SOMClass *somSelf);
  326. typedef somBooleanVector   (SOMLINK * somTD_SOMClass_somGetInstanceInitMask)(SOMClass *somSelf,
  327.         somInitCtrl* ctrl);
  328. typedef somBooleanVector   (SOMLINK * somTD_SOMClass_somGetInstanceDestructionMask)(SOMClass *somSelf,
  329.         somDestructCtrl* ctrl);
  330. typedef somBooleanVector   (SOMLINK * somTD_SOMClass_somGetInstanceAssignmentMask)(SOMClass *somSelf,
  331.         somAssignCtrl* ctrl);
  332. typedef void   (SOMLINK * somTD_SOMClass_somInitClass)(SOMClass *somSelf,
  333.         string className,
  334.         SOMClass* parentClass,
  335.         long dataSize,
  336.         long maxStaticMethods,
  337.         long majorVersion,
  338.         long minorVersion);
  339. typedef void   (SOMLINK * somTD_SOMClass_somInitMIClass)(SOMClass *somSelf,
  340.         long inherit_vars,
  341.         string className,
  342.         SOMClass_SOMClassSequence* parentClasses,
  343.         long dataSize,
  344.         long dataAlignment,
  345.         long maxStaticMethods,
  346.         long majorVersion,
  347.         long minorVersion);
  348. typedef somMToken   (SOMLINK * somTD_SOMClass_somAddStaticMethod)(SOMClass *somSelf,
  349.         somId methodId,
  350.         somId methodDescriptor,
  351.         somMethodPtr method,
  352.         somMethodPtr redispatchStub,
  353.         somMethodPtr applyStub);
  354. typedef void   (SOMLINK * somTD_SOMClass_somAddDynamicMethod)(SOMClass *somSelf,
  355.         somId methodId,
  356.         somId methodDescriptor,
  357.         somMethodPtr method,
  358.         somMethodPtr applyStub);
  359. typedef void   (SOMLINK * somTD_SOMClass_somOverrideSMethod)(SOMClass *somSelf,
  360.         somId methodId,
  361.         somMethodPtr method);
  362. typedef void   (SOMLINK * somTD_SOMClass_somClassReady)(SOMClass *somSelf);
  363. typedef somMethodPtr   (SOMLINK * somTD_SOMClass_somGetApplyStub)(SOMClass *somSelf,
  364.         somId methodId);
  365. typedef somClassDataStructure*   (SOMLINK * somTD_SOMClass_somGetClassData)(SOMClass *somSelf);
  366. typedef void   (SOMLINK * somTD_SOMClass_somSetClassData)(SOMClass *somSelf,
  367.         somClassDataStructure* cds);
  368. typedef somMethodTab*   (SOMLINK * somTD_SOMClass_somGetClassMtab)(SOMClass *somSelf);
  369. typedef long   (SOMLINK * somTD_SOMClass_somGetInstanceOffset)(SOMClass *somSelf);
  370. typedef long   (SOMLINK * somTD_SOMClass_somGetInstancePartSize)(SOMClass *somSelf);
  371. typedef long   (SOMLINK * somTD_SOMClass_somGetInstanceSize)(SOMClass *somSelf);
  372. typedef somDToken   (SOMLINK * somTD_SOMClass_somGetInstanceToken)(SOMClass *somSelf);
  373. typedef somDToken   (SOMLINK * somTD_SOMClass_somGetMemberToken)(SOMClass *somSelf,
  374.         long memberOffset,
  375.         somDToken instanceToken);
  376. typedef boolean   (SOMLINK * somTD_SOMClass_somGetMethodData)(SOMClass *somSelf,
  377.         somId methodId,
  378.         somMethodData* md);
  379. typedef somMethodProc*   (SOMLINK * somTD_SOMClass_somGetRdStub)(SOMClass *somSelf,
  380.         somId methodId);
  381. typedef somId   (SOMLINK * somTD_SOMClass_somGetMethodDescriptor)(SOMClass *somSelf,
  382.         somId methodId);
  383. typedef long   (SOMLINK * somTD_SOMClass_somGetMethodIndex)(SOMClass *somSelf,
  384.         somId id);
  385. typedef somMToken   (SOMLINK * somTD_SOMClass_somGetMethodToken)(SOMClass *somSelf,
  386.         somId methodId);
  387. typedef string   (SOMLINK * somTD_SOMClass_somGetName)(SOMClass *somSelf);
  388. typedef boolean   (SOMLINK * somTD_SOMClass_somGetNthMethodData)(SOMClass *somSelf,
  389.         long n,
  390.         somMethodData* md);
  391. typedef somId   (SOMLINK * somTD_SOMClass_somGetNthMethodInfo)(SOMClass *somSelf,
  392.         long n,
  393.         somId* descriptor);
  394. typedef long   (SOMLINK * somTD_SOMClass_somGetNumMethods)(SOMClass *somSelf);
  395. typedef long   (SOMLINK * somTD_SOMClass_somGetNumStaticMethods)(SOMClass *somSelf);
  396. typedef SOMClass*   (SOMLINK * somTD_SOMClass_somGetParent)(SOMClass *somSelf);
  397. typedef SOMClass_SOMClassSequence   (SOMLINK * somTD_SOMClass_somGetParents)(SOMClass *somSelf);
  398. typedef somMethodTabs   (SOMLINK * somTD_SOMClass_somGetPClsMtab)(SOMClass *somSelf);
  399. typedef somMethodTabs   (SOMLINK * somTD_SOMClass_somGetPClsMtabs)(SOMClass *somSelf);
  400. typedef void   (SOMLINK * somTD_SOMClass_somGetVersionNumbers)(SOMClass *somSelf,
  401.         long* majorVersion,
  402.         long* minorVersion);
  403. typedef boolean   (SOMLINK * somTD_SOMClass_somSetMethodDescriptor)(SOMClass *somSelf,
  404.         somId methodId,
  405.         somId descriptor);
  406. typedef boolean   (SOMLINK * somTD_SOMClass_somFindMethod)(SOMClass *somSelf,
  407.         somId methodId,
  408.         somMethodPtr* m);
  409. typedef boolean   (SOMLINK * somTD_SOMClass_somFindMethodOk)(SOMClass *somSelf,
  410.         somId methodId,
  411.         somMethodPtr* m);
  412. typedef somMethodPtr   (SOMLINK * somTD_SOMClass_somFindSMethod)(SOMClass *somSelf,
  413.         somId methodId);
  414. typedef somMethodPtr   (SOMLINK * somTD_SOMClass_somFindSMethodOk)(SOMClass *somSelf,
  415.         somId methodId);
  416. typedef somMethodPtr   (SOMLINK * somTD_SOMClass_somLookupMethod)(SOMClass *somSelf,
  417.         somId methodId);
  418. typedef boolean   (SOMLINK * somTD_SOMClass_somCheckVersion)(SOMClass *somSelf,
  419.         long majorVersion,
  420.         long minorVersion);
  421. typedef boolean   (SOMLINK * somTD_SOMClass_somDescendedFrom)(SOMClass *somSelf,
  422.         SOMClass* aClassObj);
  423. typedef boolean   (SOMLINK * somTD_SOMClass_somSupportsMethod)(SOMClass *somSelf,
  424.         somId mId);
  425. typedef somMethodPtr   (SOMLINK * somTD_SOMClass_somDefinedMethod)(SOMClass *somSelf,
  426.         somMToken method);
  427. typedef void   (SOMLINK * somTD_SOMClass_somOverrideMtab)(SOMClass *somSelf);
  428.  
  429. /*
  430.  * -- Typedefs for Reintroduced Wrapper Methods
  431.  */
  432. typedef void   (SOMLINK * somTD_SOMClass_somDefaultInit)(SOMClass *somSelf,
  433.         somInitCtrl* ctrl);
  434. typedef void   (SOMLINK * somTD_SOMClass_somDestruct)(SOMClass *somSelf,
  435.         octet doFree,
  436.         somDestructCtrl* ctrl);
  437. typedef void   (SOMLINK * somTD_SOMClass_somDefaultCopyInit)(SOMClass *somSelf,
  438.         somInitCtrl* ctrl,
  439.         SOMObject* fromObj);
  440. typedef SOMClass*   (SOMLINK * somTD_SOMClass_somDefaultAssign)(SOMClass *somSelf,
  441.         somAssignCtrl* ctrl,
  442.         SOMObject* fromObj);
  443. typedef void   (SOMLINK * somTD_SOMClass_somDefaultConstCopyInit)(SOMClass *somSelf,
  444.         somInitCtrl* ctrl,
  445.         SOMObject* fromObj);
  446. typedef void   (SOMLINK * somTD_SOMClass_somDefaultVCopyInit)(SOMClass *somSelf,
  447.         somInitCtrl* ctrl,
  448.         SOMObject* fromObj);
  449. typedef void   (SOMLINK * somTD_SOMClass_somDefaultConstVCopyInit)(SOMClass *somSelf,
  450.         somInitCtrl* ctrl,
  451.         SOMObject* fromObj);
  452. typedef SOMClass*   (SOMLINK * somTD_SOMClass_somDefaultConstAssign)(SOMClass *somSelf,
  453.         somAssignCtrl* ctrl,
  454.         SOMObject* fromObj);
  455. typedef SOMClass*   (SOMLINK * somTD_SOMClass_somDefaultVAssign)(SOMClass *somSelf,
  456.         somAssignCtrl* ctrl,
  457.         SOMObject* fromObj);
  458. typedef SOMClass*   (SOMLINK * somTD_SOMClass_somDefaultConstVAssign)(SOMClass *somSelf,
  459.         somAssignCtrl* ctrl,
  460.         SOMObject* fromObj);
  461. typedef void   (SOMLINK * somTD_SOMClass_somInit)(SOMClass *somSelf);
  462. typedef void   (SOMLINK * somTD_SOMClass_somFree)(SOMClass *somSelf);
  463. typedef void   (SOMLINK * somTD_SOMClass_somUninit)(SOMClass *somSelf);
  464. typedef SOMClass*   (SOMLINK * somTD_SOMClass_somGetClass)(SOMClass *somSelf);
  465. typedef string   (SOMLINK * somTD_SOMClass_somGetClassName)(SOMClass *somSelf);
  466. typedef long   (SOMLINK * somTD_SOMClass_somGetSize)(SOMClass *somSelf);
  467. typedef boolean   (SOMLINK * somTD_SOMClass_somIsA)(SOMClass *somSelf,
  468.         SOMClass* aClassObj);
  469. typedef boolean   (SOMLINK * somTD_SOMClass_somIsInstanceOf)(SOMClass *somSelf,
  470.         SOMClass* aClassObj);
  471. typedef boolean   (SOMLINK * somTD_SOMClass_somRespondsTo)(SOMClass *somSelf,
  472.         somId mId);
  473. typedef boolean   (SOMLINK * somTD_SOMClass_somDispatch)(SOMClass *somSelf,
  474.         somToken* retValue,
  475.         somId methodId,
  476.         va_list ap);
  477. typedef boolean   (SOMLINK * somTD_SOMClass_somClassDispatch)(SOMClass *somSelf,
  478.         SOMClass* clsObj,
  479.         somToken* retValue,
  480.         somId methodId,
  481.         va_list ap);
  482. typedef boolean   (SOMLINK * somTD_SOMClass_somCastObj)(SOMClass *somSelf,
  483.         SOMClass* cls);
  484. typedef boolean   (SOMLINK * somTD_SOMClass_somResetObj)(SOMClass *somSelf);
  485. typedef void   (SOMLINK * somTD_SOMClass_somDispatchV)(SOMClass *somSelf,
  486.         somId methodId,
  487.         somId descriptor,
  488.         va_list ap);
  489. typedef long   (SOMLINK * somTD_SOMClass_somDispatchL)(SOMClass *somSelf,
  490.         somId methodId,
  491.         somId descriptor,
  492.         va_list ap);
  493. typedef void*   (SOMLINK * somTD_SOMClass_somDispatchA)(SOMClass *somSelf,
  494.         somId methodId,
  495.         somId descriptor,
  496.         va_list ap);
  497. typedef double   (SOMLINK * somTD_SOMClass_somDispatchD)(SOMClass *somSelf,
  498.         somId methodId,
  499.         somId descriptor,
  500.         va_list ap);
  501. typedef SOMObject*   (SOMLINK * somTD_SOMClass_somPrintSelf)(SOMClass *somSelf);
  502. typedef void   (SOMLINK * somTD_SOMClass_somDumpSelf)(SOMClass *somSelf,
  503.         long level);
  504. typedef void   (SOMLINK * somTD_SOMClass_somDumpSelfInt)(SOMClass *somSelf,
  505.         long level);
  506. }
  507.  
  508. #endif /* SOMClass_API */
  509.  
  510.  
  511. /*
  512.  * -- This emitter treats Method Tokens as Thunks by default.
  513.  * -- Use the sc modifier "nothunks" to change this default
  514.  */
  515. #undef somresolve_
  516. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  517.  
  518. /*
  519.  * -- The C++ Wrapper Class for SOMClass
  520.  */
  521. class SOMClass : public SOMObject
  522. {
  523. public:
  524.  
  525. // SOMClass::new creates the class object if necessary, and then uses somNewNoInit
  526. // to allocate memory and create the object. Initialization is in ctors.
  527. void *operator new(size_t size)
  528. {
  529.    SOM_IgnoreWarning(size);
  530.    if (!_SOMClass) SOMClassNewClass(SOMClass_MajorVersion,SOMClass_MinorVersion);
  531.    return (void*)
  532.       SOM_Resolve(_SOMClass,SOMClass,somNewNoInit)
  533.          ((SOMClass *)((void*)_SOMClass));
  534. }
  535.  
  536. // SOMClass::delete uses the default deallocator for the object's class.
  537. void operator delete(void * obj)
  538. {
  539.    somToken objCls = obj ? *(void**)obj : (somToken) NULL;
  540.    if (somIsObj(objCls)) {
  541.       SOM_Resolve(objCls,SOMClass,somDeallocate)
  542.          ((SOMClass*)objCls, (string)obj);
  543.    }
  544. }
  545.  
  546. SOMClass()
  547. {
  548.    if (*(void**)this != 
  549.        ((somParentMtabStructPtr)
  550.         (SOMClassCClassData.parentMtab))->mtab)
  551.       return;
  552.    somDefaultInit(0);
  553. }
  554.  
  555. SOMClass(SOMClass* fromObj)
  556. {
  557.    if (*(void**)this != 
  558.        ((somParentMtabStructPtr)
  559.         (SOMClassCClassData.parentMtab))->mtab)
  560.       return;
  561.    somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  562. }
  563.  
  564. SOMClass(const SOMClass* fromObj)
  565. {
  566.    if (*(void**)this != 
  567.        ((somParentMtabStructPtr)
  568.         (SOMClassCClassData.parentMtab))->mtab)
  569.       return;
  570.    somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  571. }
  572.  
  573. ~SOMClass()
  574. {
  575.    if (!somIsObj(this)) return;
  576.    somDestruct(0,0);
  577.    *(void**)this = **(void***)this;
  578. }
  579.  
  580.  
  581. /* method: _get_somDataAlignment */
  582. long   _get_somDataAlignment()
  583. {
  584.    return SOM_ResolveD(this,SOMClass,SOMClass,_get_somDataAlignment)
  585.     (this);
  586. }
  587.  
  588.  
  589. /* nonstatic method: _get_somInstanceDataOffsets */
  590. SOMClass_somOffsets   _get_somInstanceDataOffsets()
  591. {
  592.    return SOM_ResolveD(this,SOMClass,SOMClass,_get_somInstanceDataOffsets)
  593.     (this);
  594. }
  595.  
  596.  
  597. /* nonstatic method: _get_somDirectInitClasses */
  598. SOMClass_SOMClassSequence   _get_somDirectInitClasses()
  599. {
  600.    return SOM_ResolveD(this,SOMClass,SOMClass,_get_somDirectInitClasses)
  601.     (this);
  602. }
  603.  
  604.  
  605. /* nonstatic method: _set_somDirectInitClasses */
  606. void   _set_somDirectInitClasses(SOMClass_SOMClassSequence* somDirectInitClasses)
  607. {
  608.    SOM_ResolveD(this,SOMClass,SOMClass,_set_somDirectInitClasses)
  609.     (this,somDirectInitClasses);
  610. }
  611.  
  612.  
  613. /* method: somNew */
  614. SOMObject*   somNew()
  615. {
  616.    return SOM_ResolveD(this,SOMClass,SOMClass,somNew)
  617.     (this);
  618. }
  619.  
  620.  
  621. /* method: somNewNoInit */
  622. SOMObject*   somNewNoInit()
  623. {
  624.    return SOM_ResolveD(this,SOMClass,SOMClass,somNewNoInit)
  625.     (this);
  626. }
  627.  
  628.  
  629. /* method: somRenew */
  630. SOMObject*   somRenew(void* obj)
  631. {
  632.    return SOM_ResolveD(this,SOMClass,SOMClass,somRenew)
  633.     (this,obj);
  634. }
  635.  
  636.  
  637. /* method: somRenewNoInit */
  638. SOMObject*   somRenewNoInit(void* obj)
  639. {
  640.    return SOM_ResolveD(this,SOMClass,SOMClass,somRenewNoInit)
  641.     (this,obj);
  642. }
  643.  
  644.  
  645. /* method: somRenewNoZero */
  646. SOMObject*   somRenewNoZero(void* obj)
  647. {
  648.    return SOM_ResolveD(this,SOMClass,SOMClass,somRenewNoZero)
  649.     (this,obj);
  650. }
  651.  
  652.  
  653. /* method: somRenewNoInitNoZero */
  654. SOMObject*   somRenewNoInitNoZero(void* obj)
  655. {
  656.    return SOM_ResolveD(this,SOMClass,SOMClass,somRenewNoInitNoZero)
  657.     (this,obj);
  658. }
  659.  
  660.  
  661. /* nonstatic method: somAllocate */
  662. string   somAllocate(long size)
  663. {
  664.    return SOM_ResolveD(this,SOMClass,SOMClass,somAllocate)
  665.     (this,size);
  666. }
  667.  
  668.  
  669. /* nonstatic method: somDeallocate */
  670. void   somDeallocate(string memptr)
  671. {
  672.    SOM_ResolveD(this,SOMClass,SOMClass,somDeallocate)
  673.     (this,memptr);
  674. }
  675.  
  676.  
  677. /* nonstatic method: _get_somClassAllocate */
  678. somMethodProc*   _get_somClassAllocate()
  679. {
  680.    return SOM_ResolveD(this,SOMClass,SOMClass,_get_somClassAllocate)
  681.     (this);
  682. }
  683.  
  684.  
  685. /* nonstatic method: _get_somClassDeallocate */
  686. somMethodProc*   _get_somClassDeallocate()
  687. {
  688.    return SOM_ResolveD(this,SOMClass,SOMClass,_get_somClassDeallocate)
  689.     (this);
  690. }
  691.  
  692.  
  693. /* method: somGetInstanceInitMask */
  694. somBooleanVector   somGetInstanceInitMask(somInitCtrl* ctrl)
  695. {
  696.    return SOM_ResolveD(this,SOMClass,SOMClass,somGetInstanceInitMask)
  697.     (this,ctrl);
  698. }
  699.  
  700.  
  701. /* method: somGetInstanceDestructionMask */
  702. somBooleanVector   somGetInstanceDestructionMask(somDestructCtrl* ctrl)
  703. {
  704.    return SOM_ResolveD(this,SOMClass,SOMClass,somGetInstanceDestructionMask)
  705.     (this,ctrl);
  706. }
  707.  
  708.  
  709. /* method: somGetInstanceAssignmentMask */
  710. somBooleanVector   somGetInstanceAssignmentMask(somAssignCtrl* ctrl)
  711. {
  712.    return SOM_ResolveD(this,SOMClass,SOMClass,somGetInstanceAssignmentMask)
  713.     (this,ctrl);
  714. }
  715.  
  716.  
  717. /* method: somInitClass */
  718. void   somInitClass(string className,
  719.         SOMClass* parentClass,
  720.         long dataSize,
  721.         long maxStaticMethods,
  722.         long majorVersion,
  723.         long minorVersion)
  724. {
  725.    SOM_ResolveD(this,SOMClass,SOMClass,somInitClass)
  726.     (this,className,parentClass,dataSize,maxStaticMethods,majorVersion,minorVersion);
  727. }
  728.  
  729.  
  730. /* method: somInitMIClass */
  731. void   somInitMIClass(long inherit_vars,
  732.         string className,
  733.         SOMClass_SOMClassSequence* parentClasses,
  734.         long dataSize,
  735.         long dataAlignment,
  736.         long maxStaticMethods,
  737.         long majorVersion,
  738.         long minorVersion)
  739. {
  740.    SOM_ResolveD(this,SOMClass,SOMClass,somInitMIClass)
  741.     (this,inherit_vars,className,parentClasses,dataSize,dataAlignment,maxStaticMethods,majorVersion,minorVersion);
  742. }
  743.  
  744.  
  745. /* method: somAddStaticMethod */
  746. somMToken   somAddStaticMethod(somId methodId,
  747.         somId methodDescriptor,
  748.         somMethodPtr method,
  749.         somMethodPtr redispatchStub,
  750.         somMethodPtr applyStub)
  751. {
  752.    return SOM_ResolveD(this,SOMClass,SOMClass,somAddStaticMethod)
  753.     (this,methodId,methodDescriptor,method,redispatchStub,applyStub);
  754. }
  755.  
  756.  
  757. /* method: somAddDynamicMethod */
  758. void   somAddDynamicMethod(somId methodId,
  759.         somId methodDescriptor,
  760.         somMethodPtr method,
  761.         somMethodPtr applyStub)
  762. {
  763.    SOM_ResolveD(this,SOMClass,SOMClass,somAddDynamicMethod)
  764.     (this,methodId,methodDescriptor,method,applyStub);
  765. }
  766.  
  767.  
  768. /* method: somOverrideSMethod */
  769. void   somOverrideSMethod(somId methodId,
  770.         somMethodPtr method)
  771. {
  772.    SOM_ResolveD(this,SOMClass,SOMClass,somOverrideSMethod)
  773.     (this,methodId,method);
  774. }
  775.  
  776.  
  777. /* method: somClassReady */
  778. void   somClassReady()
  779. {
  780.    SOM_ResolveD(this,SOMClass,SOMClass,somClassReady)
  781.     (this);
  782. }
  783.  
  784.  
  785. /* method: somGetApplyStub */
  786. somMethodPtr   somGetApplyStub(somId methodId)
  787. {
  788.    return SOM_ResolveD(this,SOMClass,SOMClass,somGetApplyStub)
  789.     (this,methodId);
  790. }
  791.  
  792.  
  793. /* method: somGetClassData */
  794. somClassDataStructure*   somGetClassData()
  795. {
  796.    return SOM_ResolveD(this,SOMClass,SOMClass,somGetClassData)
  797.     (this);
  798. }
  799.  
  800.  
  801. /* method: somSetClassData */
  802. void   somSetClassData(somClassDataStructure* cds)
  803. {
  804.    SOM_ResolveD(this,SOMClass,SOMClass,somSetClassData)
  805.     (this,cds);
  806. }
  807.  
  808.  
  809. /* method: somGetClassMtab */
  810. somMethodTab*   somGetClassMtab()
  811. {
  812.    return SOM_ResolveD(this,SOMClass,SOMClass,somGetClassMtab)
  813.     (this);
  814. }
  815.  
  816.  
  817. /* method: somGetInstanceOffset */
  818. long   somGetInstanceOffset()
  819. {
  820.    return SOM_ResolveD(this,SOMClass,SOMClass,somGetInstanceOffset)
  821.     (this);
  822. }
  823.  
  824.  
  825. /* method: somGetInstancePartSize */
  826. long   somGetInstancePartSize()
  827. {
  828.    return SOM_ResolveD(this,SOMClass,SOMClass,somGetInstancePartSize)
  829.     (this);
  830. }
  831.  
  832.  
  833. /* method: somGetInstanceSize */
  834. long   somGetInstanceSize()
  835. {
  836.    return SOM_ResolveD(this,SOMClass,SOMClass,somGetInstanceSize)
  837.     (this);
  838. }
  839.  
  840.  
  841. /* method: somGetInstanceToken */
  842. somDToken   somGetInstanceToken()
  843. {
  844.    return SOM_ResolveD(this,SOMClass,SOMClass,somGetInstanceToken)
  845.     (this);
  846. }
  847.  
  848.  
  849. /* method: somGetMemberToken */
  850. somDToken   somGetMemberToken(long memberOffset,
  851.         somDToken instanceToken)
  852. {
  853.    return SOM_ResolveD(this,SOMClass,SOMClass,somGetMemberToken)
  854.     (this,memberOffset,instanceToken);
  855. }
  856.  
  857.  
  858. /* method: somGetMethodData */
  859. boolean   somGetMethodData(somId methodId,
  860.         somMethodData* md)
  861. {
  862.    return SOM_ResolveD(this,SOMClass,SOMClass,somGetMethodData)
  863.     (this,methodId,md);
  864. }
  865.  
  866.  
  867. /* method: somGetRdStub */
  868. somMethodProc*   somGetRdStub(somId methodId)
  869. {
  870.    return SOM_ResolveD(this,SOMClass,SOMClass,somGetRdStub)
  871.     (this,methodId);
  872. }
  873.  
  874.  
  875. /* method: somGetMethodDescriptor */
  876. somId   somGetMethodDescriptor(somId methodId)
  877. {
  878.    return SOM_ResolveD(this,SOMClass,SOMClass,somGetMethodDescriptor)
  879.     (this,methodId);
  880. }
  881.  
  882.  
  883. /* method: somGetMethodIndex */
  884. long   somGetMethodIndex(somId id)
  885. {
  886.    return SOM_ResolveD(this,SOMClass,SOMClass,somGetMethodIndex)
  887.     (this,id);
  888. }
  889.  
  890.  
  891. /* method: somGetMethodToken */
  892. somMToken   somGetMethodToken(somId methodId)
  893. {
  894.    return SOM_ResolveD(this,SOMClass,SOMClass,somGetMethodToken)
  895.     (this,methodId);
  896. }
  897.  
  898.  
  899. /* method: somGetName */
  900. string   somGetName()
  901. {
  902.    return SOM_ResolveD(this,SOMClass,SOMClass,somGetName)
  903.     (this);
  904. }
  905.  
  906.  
  907. /* method: somGetNthMethodData */
  908. boolean   somGetNthMethodData(long n,
  909.         somMethodData* md)
  910. {
  911.    return SOM_ResolveD(this,SOMClass,SOMClass,somGetNthMethodData)
  912.     (this,n,md);
  913. }
  914.  
  915.  
  916. /* method: somGetNthMethodInfo */
  917. somId   somGetNthMethodInfo(long n,
  918.         somId* descriptor)
  919. {
  920.    return SOM_ResolveD(this,SOMClass,SOMClass,somGetNthMethodInfo)
  921.     (this,n,descriptor);
  922. }
  923.  
  924.  
  925. /* method: somGetNumMethods */
  926. long   somGetNumMethods()
  927. {
  928.    return SOM_ResolveD(this,SOMClass,SOMClass,somGetNumMethods)
  929.     (this);
  930. }
  931.  
  932.  
  933. /* method: somGetNumStaticMethods */
  934. long   somGetNumStaticMethods()
  935. {
  936.    return SOM_ResolveD(this,SOMClass,SOMClass,somGetNumStaticMethods)
  937.     (this);
  938. }
  939.  
  940.  
  941. /* method: somGetParent */
  942. SOMClass*   somGetParent()
  943. {
  944.    return SOM_ResolveD(this,SOMClass,SOMClass,somGetParent)
  945.     (this);
  946. }
  947.  
  948.  
  949. /* method: somGetParents */
  950. SOMClass_SOMClassSequence   somGetParents()
  951. {
  952.    return SOM_ResolveD(this,SOMClass,SOMClass,somGetParents)
  953.     (this);
  954. }
  955.  
  956.  
  957. /* method: somGetPClsMtab */
  958. somMethodTabs   somGetPClsMtab()
  959. {
  960.    return SOM_ResolveD(this,SOMClass,SOMClass,somGetPClsMtab)
  961.     (this);
  962. }
  963.  
  964.  
  965. /* method: somGetPClsMtabs */
  966. somMethodTabs   somGetPClsMtabs()
  967. {
  968.    return SOM_ResolveD(this,SOMClass,SOMClass,somGetPClsMtabs)
  969.     (this);
  970. }
  971.  
  972.  
  973. /* method: somGetVersionNumbers */
  974. void   somGetVersionNumbers(long* majorVersion,
  975.         long* minorVersion)
  976. {
  977.    SOM_ResolveD(this,SOMClass,SOMClass,somGetVersionNumbers)
  978.     (this,majorVersion,minorVersion);
  979. }
  980.  
  981.  
  982. /* method: somSetMethodDescriptor */
  983. boolean   somSetMethodDescriptor(somId methodId,
  984.         somId descriptor)
  985. {
  986.    return SOM_ResolveD(this,SOMClass,SOMClass,somSetMethodDescriptor)
  987.     (this,methodId,descriptor);
  988. }
  989.  
  990.  
  991. /* method: somFindMethod */
  992. boolean   somFindMethod(somId methodId,
  993.         somMethodPtr* m)
  994. {
  995.    return SOM_ResolveD(this,SOMClass,SOMClass,somFindMethod)
  996.     (this,methodId,m);
  997. }
  998.  
  999.  
  1000. /* method: somFindMethodOk */
  1001. boolean   somFindMethodOk(somId methodId,
  1002.         somMethodPtr* m)
  1003. {
  1004.    return SOM_ResolveD(this,SOMClass,SOMClass,somFindMethodOk)
  1005.     (this,methodId,m);
  1006. }
  1007.  
  1008.  
  1009. /* method: somFindSMethod */
  1010. somMethodPtr   somFindSMethod(somId methodId)
  1011. {
  1012.    return SOM_ResolveD(this,SOMClass,SOMClass,somFindSMethod)
  1013.     (this,methodId);
  1014. }
  1015.  
  1016.  
  1017. /* method: somFindSMethodOk */
  1018. somMethodPtr   somFindSMethodOk(somId methodId)
  1019. {
  1020.    return SOM_ResolveD(this,SOMClass,SOMClass,somFindSMethodOk)
  1021.     (this,methodId);
  1022. }
  1023.  
  1024.  
  1025. /* method: somLookupMethod */
  1026. somMethodPtr   somLookupMethod(somId methodId)
  1027. {
  1028.    return SOM_ResolveD(this,SOMClass,SOMClass,somLookupMethod)
  1029.     (this,methodId);
  1030. }
  1031.  
  1032.  
  1033. /* method: somCheckVersion */
  1034. boolean   somCheckVersion(long majorVersion,
  1035.         long minorVersion)
  1036. {
  1037.    return SOM_ResolveD(this,SOMClass,SOMClass,somCheckVersion)
  1038.     (this,majorVersion,minorVersion);
  1039. }
  1040.  
  1041.  
  1042. /* method: somDescendedFrom */
  1043. boolean   somDescendedFrom(SOMClass* aClassObj)
  1044. {
  1045.    return SOM_ResolveD(this,SOMClass,SOMClass,somDescendedFrom)
  1046.     (this,aClassObj);
  1047. }
  1048.  
  1049.  
  1050. /* method: somSupportsMethod */
  1051. boolean   somSupportsMethod(somId mId)
  1052. {
  1053.    return SOM_ResolveD(this,SOMClass,SOMClass,somSupportsMethod)
  1054.     (this,mId);
  1055. }
  1056.  
  1057.  
  1058. /* method: somDefinedMethod */
  1059. somMethodPtr   somDefinedMethod(somMToken method)
  1060. {
  1061.    return SOM_ResolveD(this,SOMClass,SOMClass,somDefinedMethod)
  1062.     (this,method);
  1063. }
  1064.  
  1065.  
  1066. /* method: somOverrideMtab */
  1067. void   somOverrideMtab()
  1068. {
  1069.    SOM_ResolveD(this,SOMClass,SOMClass,somOverrideMtab)
  1070.     (this);
  1071. }
  1072.  
  1073.  
  1074. /*
  1075.  * Reintroduce inherited methods
  1076.  */
  1077.  
  1078. /* initializer method: somDefaultInit */
  1079. void   somDefaultInit(somInitCtrl* ctrl)
  1080. {
  1081.    SOM_ResolveD(this,SOMClass,SOMObject,somDefaultInit)
  1082.     (this,ctrl);
  1083. }
  1084.  
  1085.  
  1086. /* method: somDestruct */
  1087. void   somDestruct(octet doFree,
  1088.         somDestructCtrl* ctrl)
  1089. {
  1090.    SOM_ResolveD(this,SOMClass,SOMObject,somDestruct)
  1091.     (this,doFree,ctrl);
  1092. }
  1093.  
  1094.  
  1095. /* method: somDefaultCopyInit */
  1096. void   somDefaultCopyInit(somInitCtrl* ctrl,
  1097.         SOMObject* fromObj)
  1098. {
  1099.    SOM_ResolveD(this,SOMClass,SOMObject,somDefaultCopyInit)
  1100.     (this,ctrl,fromObj);
  1101. }
  1102.  
  1103.  
  1104. /* method: somDefaultAssign */
  1105. SOMClass*  somDefaultAssign(somAssignCtrl* ctrl,
  1106.         SOMObject* fromObj)
  1107. {
  1108.    return SOM_ResolveD(this,SOMClass,SOMObject,somDefaultAssign)
  1109.     (this,ctrl,fromObj);
  1110. }
  1111.  
  1112.  
  1113. /* method: somDefaultConstCopyInit */
  1114. void   somDefaultConstCopyInit(somInitCtrl* ctrl,
  1115.         SOMObject* fromObj)
  1116. {
  1117.    SOM_ResolveD(this,SOMClass,SOMObject,somDefaultConstCopyInit)
  1118.     (this,ctrl,fromObj);
  1119. }
  1120.  
  1121.  
  1122. /* method: somDefaultVCopyInit */
  1123. void   somDefaultVCopyInit(somInitCtrl* ctrl,
  1124.         SOMObject* fromObj)
  1125. {
  1126.    SOM_ResolveD(this,SOMClass,SOMObject,somDefaultVCopyInit)
  1127.     (this,ctrl,fromObj);
  1128. }
  1129.  
  1130.  
  1131. /* method: somDefaultConstVCopyInit */
  1132. void   somDefaultConstVCopyInit(somInitCtrl* ctrl,
  1133.         SOMObject* fromObj)
  1134. {
  1135.    SOM_ResolveD(this,SOMClass,SOMObject,somDefaultConstVCopyInit)
  1136.     (this,ctrl,fromObj);
  1137. }
  1138.  
  1139.  
  1140. /* method: somDefaultConstAssign */
  1141. SOMClass*  somDefaultConstAssign(somAssignCtrl* ctrl,
  1142.         SOMObject* fromObj)
  1143. {
  1144.    return SOM_ResolveD(this,SOMClass,SOMObject,somDefaultConstAssign)
  1145.     (this,ctrl,fromObj);
  1146. }
  1147.  
  1148.  
  1149. /* method: somDefaultVAssign */
  1150. SOMClass*  somDefaultVAssign(somAssignCtrl* ctrl,
  1151.         SOMObject* fromObj)
  1152. {
  1153.    return SOM_ResolveD(this,SOMClass,SOMObject,somDefaultVAssign)
  1154.     (this,ctrl,fromObj);
  1155. }
  1156.  
  1157.  
  1158. /* method: somDefaultConstVAssign */
  1159. SOMClass*  somDefaultConstVAssign(somAssignCtrl* ctrl,
  1160.         SOMObject* fromObj)
  1161. {
  1162.    return SOM_ResolveD(this,SOMClass,SOMObject,somDefaultConstVAssign)
  1163.     (this,ctrl,fromObj);
  1164. }
  1165.  
  1166.  
  1167. /* method: somInit */
  1168. void   somInit()
  1169. {
  1170.    SOM_ResolveD(this,SOMClass,SOMObject,somInit)
  1171.     (this);
  1172. }
  1173.  
  1174.  
  1175. /* method: somFree */
  1176. void   somFree()
  1177. {
  1178.    SOM_ResolveD(this,SOMClass,SOMObject,somFree)
  1179.     (this);
  1180. }
  1181.  
  1182.  
  1183. /* method: somUninit */
  1184. void   somUninit()
  1185. {
  1186.    SOM_ResolveD(this,SOMClass,SOMObject,somUninit)
  1187.     (this);
  1188. }
  1189.  
  1190.  
  1191. /* method: somGetClass */
  1192. SOMClass*   somGetClass()
  1193. {
  1194.    return SOM_ResolveD(this,SOMClass,SOMObject,somGetClass)
  1195.     (this);
  1196. }
  1197.  
  1198.  
  1199. /* method: somGetClassName */
  1200. string   somGetClassName()
  1201. {
  1202.    return SOM_ResolveD(this,SOMClass,SOMObject,somGetClassName)
  1203.     (this);
  1204. }
  1205.  
  1206.  
  1207. /* method: somGetSize */
  1208. long   somGetSize()
  1209. {
  1210.    return SOM_ResolveD(this,SOMClass,SOMObject,somGetSize)
  1211.     (this);
  1212. }
  1213.  
  1214.  
  1215. /* method: somIsA */
  1216. boolean   somIsA(SOMClass* aClassObj)
  1217. {
  1218.    return SOM_ResolveD(this,SOMClass,SOMObject,somIsA)
  1219.     (this,aClassObj);
  1220. }
  1221.  
  1222.  
  1223. /* method: somIsInstanceOf */
  1224. boolean   somIsInstanceOf(SOMClass* aClassObj)
  1225. {
  1226.    return SOM_ResolveD(this,SOMClass,SOMObject,somIsInstanceOf)
  1227.     (this,aClassObj);
  1228. }
  1229.  
  1230.  
  1231. /* method: somRespondsTo */
  1232. boolean   somRespondsTo(somId mId)
  1233. {
  1234.    return SOM_ResolveD(this,SOMClass,SOMObject,somRespondsTo)
  1235.     (this,mId);
  1236. }
  1237.  
  1238.  
  1239. /* va_list method: somDispatch */
  1240. /* the va_list invocation form */
  1241. boolean   SOMClass_somDispatch(somToken* retValue,
  1242.         somId methodId,
  1243.         va_list ap)
  1244. {
  1245. return SOM_ResolveD(this,SOMClass,SOMObject,somDispatch)
  1246.     (this,retValue,methodId,ap);
  1247. }
  1248.  
  1249. /* the varargs invocation form */
  1250. boolean   somDispatch(somToken* retValue,
  1251.         somId methodId,
  1252.         ...)
  1253. {
  1254.    va_list ap;
  1255.    va_start(ap, methodId);
  1256.    boolean __somResult = 
  1257.       SOM_ResolveD(this,SOMClass,SOMObject,somDispatch)
  1258.     (this,retValue,methodId,ap);
  1259.    va_end(ap);
  1260.    return __somResult;
  1261. }
  1262.  
  1263.  
  1264. /* va_list method: somClassDispatch */
  1265. /* the va_list invocation form */
  1266. boolean   SOMClass_somClassDispatch(SOMClass* clsObj,
  1267.         somToken* retValue,
  1268.         somId methodId,
  1269.         va_list ap)
  1270. {
  1271. return SOM_ResolveD(this,SOMClass,SOMObject,somClassDispatch)
  1272.     (this,clsObj,retValue,methodId,ap);
  1273. }
  1274.  
  1275. /* the varargs invocation form */
  1276. boolean   somClassDispatch(SOMClass* clsObj,
  1277.         somToken* retValue,
  1278.         somId methodId,
  1279.         ...)
  1280. {
  1281.    va_list ap;
  1282.    va_start(ap, methodId);
  1283.    boolean __somResult = 
  1284.       SOM_ResolveD(this,SOMClass,SOMObject,somClassDispatch)
  1285.     (this,clsObj,retValue,methodId,ap);
  1286.    va_end(ap);
  1287.    return __somResult;
  1288. }
  1289.  
  1290.  
  1291. /* method: somCastObj */
  1292. boolean   somCastObj(SOMClass* cls)
  1293. {
  1294.    return SOM_ResolveD(this,SOMClass,SOMObject,somCastObj)
  1295.     (this,cls);
  1296. }
  1297.  
  1298.  
  1299. /* method: somResetObj */
  1300. boolean   somResetObj()
  1301. {
  1302.    return SOM_ResolveD(this,SOMClass,SOMObject,somResetObj)
  1303.     (this);
  1304. }
  1305.  
  1306.  
  1307. /* va_list method: somDispatchV */
  1308. /* the va_list invocation form */
  1309. void   SOMClass_somDispatchV(somId methodId,
  1310.         somId descriptor,
  1311.         va_list ap)
  1312. {
  1313.    SOM_ResolveD(this,SOMClass,SOMObject,somDispatchV)
  1314.     (this,methodId,descriptor,ap);
  1315. }
  1316.  
  1317. /* the varargs invocation form */
  1318. void   somDispatchV(somId methodId,
  1319.         somId descriptor,
  1320.         ...)
  1321. {
  1322.    va_list ap;
  1323.    va_start(ap, descriptor);
  1324.    SOM_ResolveD(this,SOMClass,SOMObject,somDispatchV)
  1325.     (this,methodId,descriptor,ap);
  1326.    va_end(ap);
  1327. }
  1328.  
  1329.  
  1330. /* va_list method: somDispatchL */
  1331. /* the va_list invocation form */
  1332. long   SOMClass_somDispatchL(somId methodId,
  1333.         somId descriptor,
  1334.         va_list ap)
  1335. {
  1336. return SOM_ResolveD(this,SOMClass,SOMObject,somDispatchL)
  1337.     (this,methodId,descriptor,ap);
  1338. }
  1339.  
  1340. /* the varargs invocation form */
  1341. long   somDispatchL(somId methodId,
  1342.         somId descriptor,
  1343.         ...)
  1344. {
  1345.    va_list ap;
  1346.    va_start(ap, descriptor);
  1347.    long __somResult = 
  1348.       SOM_ResolveD(this,SOMClass,SOMObject,somDispatchL)
  1349.     (this,methodId,descriptor,ap);
  1350.    va_end(ap);
  1351.    return __somResult;
  1352. }
  1353.  
  1354.  
  1355. /* va_list method: somDispatchA */
  1356. /* the va_list invocation form */
  1357. void*   SOMClass_somDispatchA(somId methodId,
  1358.         somId descriptor,
  1359.         va_list ap)
  1360. {
  1361. return SOM_ResolveD(this,SOMClass,SOMObject,somDispatchA)
  1362.     (this,methodId,descriptor,ap);
  1363. }
  1364.  
  1365. /* the varargs invocation form */
  1366. void*   somDispatchA(somId methodId,
  1367.         somId descriptor,
  1368.         ...)
  1369. {
  1370.    va_list ap;
  1371.    va_start(ap, descriptor);
  1372.    void* __somResult = 
  1373.       SOM_ResolveD(this,SOMClass,SOMObject,somDispatchA)
  1374.     (this,methodId,descriptor,ap);
  1375.    va_end(ap);
  1376.    return __somResult;
  1377. }
  1378.  
  1379.  
  1380. /* va_list method: somDispatchD */
  1381. /* the va_list invocation form */
  1382. double   SOMClass_somDispatchD(somId methodId,
  1383.         somId descriptor,
  1384.         va_list ap)
  1385. {
  1386. return SOM_ResolveD(this,SOMClass,SOMObject,somDispatchD)
  1387.     (this,methodId,descriptor,ap);
  1388. }
  1389.  
  1390. /* the varargs invocation form */
  1391. double   somDispatchD(somId methodId,
  1392.         somId descriptor,
  1393.         ...)
  1394. {
  1395.    va_list ap;
  1396.    va_start(ap, descriptor);
  1397.    double __somResult = 
  1398.       SOM_ResolveD(this,SOMClass,SOMObject,somDispatchD)
  1399.     (this,methodId,descriptor,ap);
  1400.    va_end(ap);
  1401.    return __somResult;
  1402. }
  1403.  
  1404.  
  1405. /* method: somPrintSelf */
  1406. SOMObject*   somPrintSelf()
  1407. {
  1408.    return SOM_ResolveD(this,SOMClass,SOMObject,somPrintSelf)
  1409.     (this);
  1410. }
  1411.  
  1412.  
  1413. /* method: somDumpSelf */
  1414. void   somDumpSelf(long level)
  1415. {
  1416.    SOM_ResolveD(this,SOMClass,SOMObject,somDumpSelf)
  1417.     (this,level);
  1418. }
  1419.  
  1420.  
  1421. /* method: somDumpSelfInt */
  1422. void   somDumpSelfInt(long level)
  1423. {
  1424.    SOM_ResolveD(this,SOMClass,SOMObject,somDumpSelfInt)
  1425.     (this,level);
  1426. }
  1427.  
  1428.  
  1429.  
  1430. };   /* SOMClass */
  1431.  
  1432.  
  1433.  
  1434. #endif       /* SOM_SOMClass_xh */
  1435.