home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / som30tk.zip / som30os2.zip / include / somcls.idl < prev    next >
Text File  |  1996-12-24  |  25KB  |  597 lines
  1. //#  @(#) 1.53 src/somk/somcls.idl, somk.sc, som3.0 6/13/96 10:37:49 [12/24/96 07:40:21]
  2.  
  3. // 96F8647, 96F8648, 96F8850 (C) Copyright IBM Corp. 1992, 1994
  4. // All Rights Reserved
  5. // Licensed Materials - Property of IBM
  6.  
  7. // SOMClass: System Object Model base metaclass
  8. // Multiple Inheritance Version
  9.  
  10. #ifndef somcls_idl
  11. #define somcls_idl
  12.  
  13.  
  14. #include <somobj.idl>
  15.  
  16. typedef somToken somCClassDataStructurePtr;
  17. typedef somToken somClassDataStructurePtr;
  18. typedef somToken somMethodTabPtr;
  19. typedef somToken somEmbeddedObjStructPtr;
  20. typedef somToken somMethodDefnPtr;
  21. typedef somToken somClassMemPtr;
  22. typedef somToken somClassVars3Ptr;
  23. typedef somToken SOM_CIBPtr;
  24.  
  25.  
  26. interface SOMClass : SOMObject
  27. //
  28. //  SOMClass is the root SOM metaclass. Because it is a metaclass, its
  29. //  instances are classes. Because it is the root metaclass, all other
  30. //  metaclasses inherit its methods.
  31. //
  32. //  SOMClass defines the default behavior for SOM class objects
  33. //  accessed using methods available through the SOMClass interface.
  34. //  Other metaclasses are allowed to specialize the behavior of
  35. //  classes by introducing new methods and overriding SOMClass
  36. //  methods.
  37. //
  38. //  Generally, when SOMClass methods are overridden by user-defined
  39. //  metaclasses, a relative parent call should be made at some point to
  40. //  allow the default behavior implemented by SOMClass to execute
  41. //  (in addition to whatever additional behavior might be desired by the
  42. //  new metaclasses).
  43. //
  44. //# SOMLEGACY1 concerns obsolete but supported SOM 1.0 APIs.
  45. {
  46.  
  47.   //############  [Typedefs] ##############
  48.  
  49.   typedef sequence <somToken> somTokenSequence;
  50.   // a (generic) sequence of somTokens
  51.  
  52.   typedef sequence <SOMClass> SOMClassSequence;
  53.   // a sequence of classes
  54.  
  55.   struct somOffsetInfo {
  56.      SOMClass cls;
  57.      long     offset;
  58.   };
  59.   // a structure to describe a class-related offset
  60.  
  61.   typedef sequence <somOffsetInfo> somOffsets;
  62.   // a sequence of class-related offsets
  63.  
  64.   typedef sequence <somId> somIdSequence;
  65.   // a sequence of somIds
  66.  
  67.  
  68.  
  69.   //############   [Instance Creation/Renewal]   ############
  70.  
  71.   SOMObject somNew();
  72.   // Uses somAllocate to allocate storage for a new
  73.   // instance of the receiving class, calls somRenewNoInitNoZero
  74.   // to load the new object's method table pointer, and then
  75.   // calls somDefaultInit to initialize the new object.
  76.   // Overrides are not expected. NULL is returned on failure.
  77.  
  78.   SOMObject somNewNoInit();
  79.   // Equivalent to somNew except that somDefaultInit is not called.
  80.   // Overrides are not expected.
  81.  
  82.   SOMObject somRenew(in void *obj);
  83.   // Equivalent to somNew except that storage is not allocated.
  84.   // <obj> is taken as the address of the new object.
  85.   // Overrides are not expected.
  86.  
  87.   SOMObject somRenewNoInit(in void *obj);
  88.   // Equivalent to somRenew except that somDefaultInit is not called.
  89.   // Overrides are not expected.
  90.  
  91.   SOMObject somRenewNoZero(in void *obj);
  92.   // Equivalent to somRenew except that memory is not zeroed out.
  93.   // Overrides are not expected.
  94.  
  95.   SOMObject somRenewNoInitNoZero(in void *obj);
  96.   // This method loads an object's method table pointer, turning raw
  97.   // memory into an uninitialized SOM object. The other somNew and
  98.   // somRenew methods all call this method, so metaclasses can override
  99.   // this method to track object creation if this is desired. A relative
  100.   // parent call should be done from overrides.
  101.  
  102.   somToken somAllocate(in long size); // nonstatic
  103.   // Uses the memory allocation routine associated with the receiving
  104.   // class to allocate memory to hold an object of the indicated size.
  105.   // NULL is returned on failure. The default allocation routine uses
  106.   // SOMMalloc.
  107.  
  108.   void somDeallocate(in somToken memptr); // nonstatic
  109.   // Uses the memory deallocation routine associated with the receiving
  110.   // class to deallocate memory beginning at the address indicated by
  111.   // memptr. The first word of this memory (normally a method table
  112.   // pointer) is loaded with NULL. The deallocation routine receives
  113.   // a void* (memptr) and a size_t (size) as arguments.
  114.  
  115.  
  116.   SOMClass somJoin( in SOMClass secondParent, in string nameOfNewClass );
  117.   // Creates the multiple inheritance join of the target class and the 
  118.   // secondParent with the class name nameOfNewClass.
  119.  
  120.   SOMClass somEndow( in SOMClass parent, in string nameOfNewClass );
  121.   // Creates the a subclass of parent with the class name nameOfNewClass
  122.   // where the target class is an added metaclass constraint.
  123.   // NOTE: this means that the target class must be a metaclass.
  124.  
  125.  
  126.  
  127.   //############### [Class Initialization/Termination] ###############
  128.  
  129.   SOMClass somClassOfNewClassWithParents(in string newClassName,
  130.                                          in SOMClassSequence parents,
  131.                                          in SOMClass explicitMeta);
  132.   // procedure
  133.   // returns a metaclass appropriate for use as the class of a new
  134.   // class with the given parents and explicit metaclass.
  135.  
  136.  
  137.   void somInitMIClass(in unsigned long inherit_vars,
  138.                       in string className,
  139.                       in SOMClassSequence parentClasses,
  140.                       in long dataSize,
  141.                       in long dataAlignment,
  142.                       in long maxNDMethods,
  143.                       in long majorVersion,
  144.                       in long minorVersion);
  145.   // Perform inheritance into a class object from the specified parent
  146.   // classes, determine the layout of instances for the receiving class, and
  147.   // determine the layout of the instance method table for the receiving class.
  148.   // Overrides should perform relative parent calls.
  149.  
  150.   somMToken somAddStaticMethod(in somId methodId,
  151.                                in somId methodDescriptor,
  152.                                in somMethodPtr method,
  153.                                in somMethodPtr redispatchStub,
  154.                                in somMethodPtr applyStub);
  155.  
  156.   // Introduce a new static method with the indicated methodId into
  157.   // the receiving class. Overrides should perform relative parent calls.
  158.  
  159.   void somOverrideSMethod(in somId methodId,
  160.                           in somMethodPtr method);
  161.   // Replace the implementation for the indicated method in the instances
  162.   // of the receiving class. Overrides should perform relative parent calls.
  163.  
  164.  
  165.   void somClassReady();
  166.   // This method is invoked when all of the static initialization for
  167.   // the class has been finished (i.e., its instance method table has
  168.   // been loaded) and allows final setup for the class to be done. When
  169.   // overriding this method, all setup should be done before doing a
  170.   // relative pcall, since SOMClass's implementation will register the
  171.   // class with the class manager.
  172.  
  173.   void somAddDynamicMethod(in somId methodId,
  174.                            in somId methodDescriptor,
  175.                            in somMethodPtr methodImpl,
  176.                            in somMethodPtr applyStub);
  177.   // If the receiving class supports a static method with the indicated
  178.   // methodId, then override the method with the indicated implementation.
  179.   // Otherwise, a dynamic method with the indicated methodId is added to
  180.   // the receiving class.
  181.  
  182.  
  183.  
  184. #ifdef SOMLEGACY1
  185. #endif
  186.  
  187.  
  188.   //############ [Class Information]  ############
  189.  
  190.   string somGetName();
  191.   // This object's class name as a NULL terminated string.
  192.   // Overrides are not expected.
  193.  
  194.   void somGetVersionNumbers (out long majorVersion, out long minorVersion);
  195.   // Returns the class' major and minor version numbers in the corresponding
  196.   // output parameters.
  197.   // Overrides are not expected.
  198.  
  199.   long somGetNumMethods();
  200.   // The number of methods currently supported by this class,
  201.   // including inherited methods (static, nonstatic, and dynamic).
  202.   // Overrides are not expected.
  203.  
  204.   long somGetNumStaticMethods();
  205.   // The number of nondynamic methods that this class has.  Can
  206.   // be used by a child class when initializing its method table.
  207.   // Overrides are not expected.
  208.  
  209.   SOMClassSequence somGetParents();
  210.   // Returns a sequence containing pointers to the receiver's parent classes.
  211.   // Caller is responsible for using SOMFree on the returned sequence buffer.
  212.   // Overrides are not expected.
  213.  
  214.   long somGetInstanceSize();
  215.   // The total size of an instance of the receiving class.
  216.   // Overrides are not expected.
  217.  
  218.   long somGetInstancePartSize();
  219.   // The size in bytes of the instance data introduced by the receiving
  220.   // class.
  221.   // Overrides are not expected.
  222.  
  223.   somDToken somGetInstanceToken();
  224.   // A data token that identifies the introduced portion of this class
  225.   // within itself or any derived class.  This token can be subsequently
  226.   // passed to the run-time somDataResolve function to locate the instance
  227.   // data introduced by this class in any object derived from this class.
  228.   // Overrides are not expected.
  229.  
  230.   somDToken somGetMemberToken(in long memberOffset,
  231.                               in somDToken instanceToken);
  232.   // Returns a data token that for the data member at offset
  233.   // "memberOffset" within the introduced portion of the class identified
  234.   // by instanceToken.  The instance token must have been obtained from a
  235.   // previous invocation of somGetInstanceToken.  The returned member
  236.   // token can be subsequently passed to the run-time somDataResolve
  237.   // function to locate the data member.
  238.   // Overrides are not expected.
  239.  
  240.   somMethodTab* somGetClassMtab();
  241.   // A pointer to the method table used by instances of this class. This
  242.   // method was misnamed; it should have been called somGetInstanceMtab.
  243.   // Overrides are not expected.
  244.  
  245.   somClassDataStructurePtr somGetClassData();
  246.   void somSetClassData(in somClassDataStructurePtr cds);
  247.   // The pointer to the static <className>ClassData structure.
  248.   // Overrides are not expected.
  249.  
  250.   readonly attribute long somDataAlignment;
  251.   // The alignment required for the instance data structure
  252.   // introduced by the receiving class.
  253.   // Overrides are not expected.
  254.  
  255.   readonly attribute somOffsets somInstanceDataOffsets;
  256.   // A sequence of the instance data offsets for all classes used in
  257.   // the derivation of the receiving class (including the receiver).
  258.   // The caller is responsible for freeing the returned sequence buffer.
  259.   // Overrides are not expected.
  260.  
  261.   readonly attribute SOMClassSequence somDirectInitClasses;
  262.   // The ancestors whose initializers the receiving class wants to
  263.   // directly invoke. Caller is responsible for freeing the returned
  264.   // sequence buffer.
  265.   // Overrides are not expected.
  266.  
  267.  
  268.   //####### [Method Information] #########
  269.  
  270.   somId somGetMethodDescriptor(in somId methodId);
  271.   // Returns the method descriptor for the indicated method.    If
  272.   // this object does not support the indicated method then NULL is
  273.   // returned.
  274.   // Overrides are not expected.
  275.  
  276.   long somGetMethodIndex(in somId id);
  277.   // Returns the index for the specified method. (A number that may
  278.   // change if any methods are added or deleted to this class object or
  279.   // any of its ancestors).  This number is the basis for other calls to
  280.   // get info about the method. Indexes start at 0. A -1 is returned if
  281.   // the method cannot be found.
  282.   // Overrides are not expected.
  283.  
  284.   somMToken somGetMethodToken(in somId methodId);
  285.   // Returns the specified method's access token. This token can then
  286.   // be passed to method resolution routines, which use the token
  287.   // to select a method pointer from a method table.
  288.   // Overrides are not expected.
  289.  
  290.   somId somGetNthMethodInfo(in long n,
  291.                             out somId descriptor);
  292.   // Returns the id of the <n>th method if one exists and NULL
  293.   // otherwise.
  294.   //
  295.   // The ordering of the methods is unpredictable, but will not change
  296.   // unless some change is made to the class or one of its ancestor classes.
  297.   //
  298.   // See CORBA documentation for info on method descriptors.
  299.   // Overrides are not expected.
  300.  
  301.   somToken somGetMarshalPlan(in somId methodId);
  302.   // uses namelookup from the target class to locate a method that has the
  303.   // indicated methodId, and returns that method's marshal plan if there
  304.   // is one. Otherwise, null is returned.
  305.   // Overrides are not expected.
  306.  
  307.  
  308.   //########### Method Resolution ###############
  309.  
  310.   boolean somGetMethodData(in somId methodId,
  311.                        out somMethodData md);
  312.   // If the receiving class supports a method with the specified somId,
  313.   // then the method data pointed to by md is loaded with information
  314.   // for the method and 1 (TRUE) is returned. Otherwise md->id is set to
  315.   // NULL and 0 (FALSE) is returned. On success, the md->method field is
  316.   // loaded with a the address of a function that invokes the method
  317.   // implementation appropriate for instances of the receiving class.
  318.   // Successive calls for the same method are *not* guaranteed to load
  319.   // md->method with the same address. All somId-based method resolution
  320.   // routines use the md->method address computed by somGetMethodData
  321.   // as their resolution result.
  322.  
  323.  
  324.   boolean somGetNthMethodData(in long n, out somMethodData md);
  325.   // This method is similar to somGetMethodData. The method
  326.   // whose data is returned is the method for which the receiving
  327.   // class would return n from somGetMethodIndex.
  328.  
  329.   boolean somFindMethod(in somId methodId,
  330.                         out somMethodPtr m);
  331.   // If the receiving class supports a method with the specified
  332.   // methodId, m is set to the address of a function that
  333.   // will invoke the method implementation appropriate for instances
  334.   // of the receiving class and 1 (TRUE) is returned. Otherwise, m is
  335.   // set to NULL and 0 (FALSE) is returned. Successive calls on the
  336.   // same class with the same arguments are not guaranteed to return
  337.   // the same function address.
  338.   // Overrides are not expected.
  339.  
  340.   boolean somFindMethodOk(in somId methodId,
  341.                           out somMethodPtr m);
  342.   // Just like <somFindMethod> except that if the method is not
  343.   // supported then an error is raised and execution is halted.
  344.   // Overrides are not expected.
  345.  
  346.   somMethodPtr somFindSMethod(in somId methodId);
  347.   // Finds the indicated method, which must be a static method supported
  348.   // by this class, and returns a pointer to a function that will
  349.   // invoke the method implementation appropriate for instances of the
  350.   // receiving class. If the method is not supported by the receiver
  351.   // (as a static method or at all) then a NULL pointer is returned.
  352.   // Overrides are not expected.
  353.  
  354.   somMethodPtr somFindSMethodOk(in somId methodId);
  355.   // Uses <somFindSMethod>, and raises an error if the result is NULL.
  356.   // Overrides are not expected.
  357.  
  358.   somMethodPtr somLookupMethod(in somId methodId);
  359.   // Like <somFindSMethodOK>, but without restriction to static methods.
  360.   // Overrides are not expected.
  361.  
  362.  
  363. #ifdef SOMLEGACY1
  364.  
  365.   somMethodPtr somGetApplyStub(in somId methodId);
  366.   // Returns the apply stub associated with the specified method,
  367.   // if one exists; otherwise NULL is returned. This method is obsolete,
  368.   // and retained for binary compatability. In SOMr2, users never access
  369.   // apply stubs directly; The function somApply is used to invoke apply
  370.   // stubs. See somApply documentation for further information on apply
  371.   // stubs, and see somAddStaticMethod documentation for information
  372.   // on how apply stubs are registered by class implementations.
  373.   // Overrides are not expected.
  374.  
  375.   somMethodTabs somGetPClsMtab();
  376.   // Returns a list of the method tables of this class's parent classes in the
  377.   // specific format required by somParentNumResolve (for making parent method
  378.   // calls. The first entry on the list is actually the method table of the
  379.   // receiving class. Because the CClassData structure contains this list, the
  380.   // method table for any class with a CClassData structure is statically
  381.   // available. This method now returns a list because older SI emitters load
  382.   // CClassData.parentMtab with the result of this call, and the new runtime
  383.   // requires a list of classes in that position.
  384.   // Overrides are not expected.
  385. #endif
  386.  
  387.   //########### [Testing] #############
  388.  
  389.   boolean somCheckVersion(in long majorVersion,
  390.                           in long minorVersion);
  391.   // Returns 1 (true) if the implementation of this class is
  392.   // compatible with the specified major and minor version number and
  393.   // false (0) otherwise.  An implementation is compatible with the
  394.   // specified version numbers if it has the same major version number
  395.   // and a minor version number that is equal to or greater than
  396.   // <minorVersion>.    The major, minor version number pair (0,0) is
  397.   // considered to match any version.  This method is usually called
  398.   // immediately after creating the class object to verify that a
  399.   // dynamically loaded class definition is compatible with a using
  400.   // application.
  401.   // Overrides are not expected.
  402.  
  403.   boolean somDescendedFrom(in SOMClass aClassObj);
  404.   // Returns 1 (true) if <self> is a descendent class of <aClassObj> and
  405.   // 0 (false) otherwise.  Note: a class object is considered to be
  406.   // descended itself for the purposes of this method.
  407.   // Overrides are not expected.
  408.  
  409.   boolean somSupportsMethod(in somId mId);
  410.   // Returns 1 (true) if the indicated method is supported by this
  411.   // class and 0 (false) otherwise.
  412.   // Overrides are not expected.
  413.  
  414.   somMethodPtr somDefinedMethod(in somMToken method);
  415.   // If the receiving class explicitly defines an implementation for
  416.   // the indicated method, then the address of a function that will invoke
  417.   // this implementation is returned. Otherwise NULL is returned.
  418.   // Overrides are not expected.
  419.  
  420.   SOMClass somMethodImplOwner(inout somMethodData md);
  421.   // Returns the owner of the implementation of the method indicated by md
  422.   // for instances of the receiving class, and loads md->method with a
  423.   // pointer to the method implementation. If the receiving class doesn't
  424.   // support the method, md->method is not changed, and null is returned.
  425.   // Implementations that are automatically installed by SOM (such as for
  426.   // SOMObject's initializers and for legacy support of somInit) are
  427.   // reported as being owned by SOMObject.
  428.   // Overrides are not expected.
  429.  
  430.  
  431. //############## [Dynamic] #################
  432.  
  433.   somMethodProc *somGetRdStub(in somId methodId);
  434.   // Returns a redispatch stub for the indicated method if possible.
  435.   // If not possible (because a valid redispatch stub has not been
  436.   // registered, and there is insufficient information to dynamically
  437.   // construct one), then a pointer to a function that prints an
  438.   // informative message and terminates execution is returned.
  439.  
  440.   void somOverrideMtab();
  441.   // Overrides the method table pointers to point to the redispatch stubs.
  442.   // All the methods except somDispatch methods are overriden.
  443.  
  444.  
  445. #ifdef __SOMIDL__
  446.   implementation {
  447.     releaseorder:
  448.  
  449.                                 somNew,
  450.                                 somRenew,
  451.  
  452. #ifdef SOMLEGACY1
  453.                 somcPrivate1,
  454. #else
  455.                 somcReserved1,
  456. #endif
  457.                                 somClassReady,
  458.                                 somGetName,
  459.  
  460. #ifdef SOMLEGACY1
  461.                 somcPrivate2,
  462. #else
  463.                 somcReserved2,
  464. #endif
  465.                                 somDescendedFrom,
  466.                                 somCheckVersion,
  467.                                 somFindMethod,
  468.                                 somFindMethodOk,
  469.                                 somSupportsMethod,
  470.                                 somGetNumMethods,
  471.                                 somGetInstanceSize,
  472.                 somcPrivate3,
  473.                                 somGetInstancePartSize,
  474.                                 somGetMethodIndex,
  475.                                 somGetNumStaticMethods,
  476. #ifdef SOMLEGACY1
  477.                                 somGetPClsMtab,
  478. #else
  479.                 somcReserved3,
  480. #endif
  481.                                 somGetClassMtab,
  482.                                 somAddStaticMethod,
  483.                                 somOverrideSMethod,
  484.                                 somAddDynamicMethod,
  485.                                 somcUnused1,
  486. #ifdef SOMLEGACY1
  487.                                 somGetApplyStub,
  488. #else
  489.                 somcReserved4,
  490. #endif
  491.                                 somFindSMethod,
  492.                                 somFindSMethodOk,
  493.                                 somGetMethodDescriptor,
  494.                                 somGetNthMethodInfo,
  495.                                 somSetClassData,
  496.                                 somGetClassData,
  497.                                 somNewNoInit,
  498.                                 somRenewNoInit,
  499.                                 somGetInstanceToken,
  500.                                 somGetMemberToken,
  501.                                 somcUnused2, //# used to be somSetMethodDescriptor
  502.                                 somGetMethodData,
  503.                                 somOverrideMtab,
  504.                                 somGetMethodToken,
  505.                                 somGetParents,
  506.                                 somUnused3, //# used to be somGetPClsMtabs
  507.                                 somInitMIClass,
  508.                                 somGetVersionNumbers,
  509.                                 somLookupMethod,
  510.                                 _get_somInstanceDataOffsets,
  511.                                 somRenewNoZero,
  512.                                 somRenewNoInitNoZero,
  513.                                 somAllocate,
  514.                                 somDeallocate,
  515.                                 somGetRdStub,
  516.                                 somGetNthMethodData,
  517.  
  518.                 somcPrivate8,
  519.                 somcPrivate9,
  520.                                 _get_somDirectInitClasses,
  521.                 somcPrivate10,
  522.                 somcPrivate11,
  523.                 somcPrivate12,
  524.                 somcPrivate13,
  525.                 somcPrivate14,
  526.                                 somMethodImplOwner, //# replaces earlier private method
  527.                 somcPrivate15,
  528.                 somcPrivate16,
  529.                                 somDefinedMethod,
  530.                 somcPrivate17,
  531.                 somcPrivate18,
  532.                 somcPrivate19,
  533.                                 somClassOfNewClassWithParents,
  534.                 somcPrivate20,
  535.                                 somcUnused5,
  536.                                 somcUnused6,
  537.                                 somcUnused7,
  538.                                 _get_somDataAlignment,
  539.                 somcPrivate21,
  540.                                 somcUnused8,
  541.                 somcPrivate22,
  542.                                 somcUnused9,
  543.                                 somcUnused10,
  544.                                 somGetMarshalPlan,
  545.                                 somcUnused11,
  546.         somPrivate23,
  547.                 somJoin,
  548.                 somEndow;
  549.  
  550.  
  551.     // Class Modifiers
  552.     callstyle = oidl;
  553.     majorversion = 1;
  554.     minorversion = 6; // for som3.0 kernel
  555.     filestem = somcls;
  556.     dllname = "som.dll";
  557.  
  558.     // Attribute Modifiers
  559.     somDataAlignment: nodata;
  560.     somInstanceDataOffsets: nodata;
  561.     somDirectInitClasses: nodata;
  562.     somDirectAssignClasses: nodata;
  563.     somClassAllocate: nodata, nonstaticaccessors;
  564.     somClassDeallocate: nodata, nonstaticaccessors;
  565.  
  566.     //# Method Modifiers
  567.     somClassReady: pcall;
  568.     somInitMIClass: pcall;
  569.     somClassAssert: nonstatic;
  570.     somClassOfNewClassWithParents: procedure, noself;
  571.     somMakeUserRdStub: nonstatic;
  572.     somGetMethodProc: nonstatic;
  573.     somAllocate: nonstatic;
  574.     somDeallocate: nonstatic;
  575.     somMethodImplOwner: nonstatic;
  576.     somCloneClass: nonstatic;
  577.     somCastObjCls: nonstatic;
  578.     somResetObjCls: nonstatic;
  579.     somSetUserPCallDispatch: nonstatic;
  580.     somGetInstanceInitMask: nonstatic;
  581.     somGetInstanceAssignMask: nonstatic;
  582.     somGetInstanceDestructMask: nonstatic;
  583.     somFindSMethod: nonstatic; // so can execute in SP
  584.     somImportedClass: nonstatic;
  585.     somLookupTerminal: nonstatic;
  586.     _get_somInstanceDataOffsets: dual_owned_result;
  587.     somGetName: dual_owned_result;
  588.     somGetPClsMtab: dual_owned_result;
  589.  
  590.  
  591.     };
  592. #endif /* __SOMIDL__ */
  593.  
  594. };
  595.  
  596. #endif  /* somcls_idl */
  597.