home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / dtswps.zip / DTSFILES.ZIP / SOMCLS.IDL < prev    next >
Text File  |  1996-06-24  |  25KB  |  575 lines
  1. //
  2. //   COMPONENT_NAME: somk
  3. //
  4. //   ORIGINS: 27
  5. //
  6. //
  7. //    25H7912  (C)  COPYRIGHT International Business Machines Corp. 1992,1994,1996
  8. //   All Rights Reserved
  9. //   Licensed Materials - Property of IBM
  10. //   US Government Users Restricted Rights - Use, duplication or
  11. //   disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
  12. //
  13. //# @(#) somk/somcls.idl 2.39.2.18 4/9/96 16:45:25 [6/24/96 08:12:06]
  14.  
  15.  
  16. // SOMClass: System Object Model base metaclass
  17. // Multiple Inheritance Version
  18.  
  19. #ifndef somcls_idl
  20. #define somcls_idl
  21.  
  22. #include <somobj.idl>
  23.  
  24.  
  25. interface SOMClass : SOMObject
  26. //
  27. //  This is the SOM metaclass.  That is, the instances of this class
  28. //  are class objects.  When the SOM environment is created an instance
  29. //  of SOMClass is created and a pointer to it is placed in the external
  30. //  data location (SOMClassClassData.classObject). Bindings provide the
  31. //  macro _SOMClass for this expression. _SOMClass is unique in that it
  32. //  is its own class object. I.e., _SOMClass == _somGetClass(_SOMClass).
  33. //  SOMClass can be subclassed just like any SOM class. The subclasses
  34. //  of SOMClass are new metaclasses and can generate class objects with
  35. //  different implementations than those produced by _SOMClass.
  36. //
  37. //  An important rule for metaclass programming is that no methods
  38. //  introduced by SOMClass should ever be overridden. While this
  39. //  limits the utility of metaclass programming in SOM, it guarantees
  40. //  that SOM will operate correctly. Special class frameworks may be
  41. //  available from IBM to alleviate this restriction. Also, the
  42. //  restriction may be lifted in the future.
  43. //
  44. {
  45.  
  46.   //############  [Typedefs] ##############
  47.  
  48.   typedef sequence <somToken> somTokenSequence;
  49.   // a (generic) sequence of somTokens
  50.  
  51.   typedef sequence <SOMClass> SOMClassSequence;
  52.   // a sequence of classes
  53.  
  54.   struct somOffsetInfo {
  55.      SOMClass cls;
  56.      long     offset;
  57.   };
  58.   // a structure to describe a class-related offset
  59.  
  60.   typedef sequence <somOffsetInfo> somOffsets;
  61.   // a sequence of class-related offsets
  62.  
  63.   typedef sequence <somId> somIdSequence;
  64.   // a sequence of somIds
  65.  
  66.  
  67.   //############  [Attributes]  ############
  68.  
  69.   readonly attribute long somDataAlignment;
  70.   // The alignment required for the instance data structure
  71.   // introduced by the receiving class.
  72.  
  73.   readonly attribute somOffsets somInstanceDataOffsets;
  74.   // A sequence of the instance data offsets for all classes used in
  75.   // the derivation of the receiving class (including the receiver).
  76.  
  77.   readonly attribute SOMClassSequence somDirectInitClasses;
  78.   // The ancestors whose initializers the receiving
  79.   // class wants to directly invoke.
  80.  
  81.  
  82.  
  83.   //############   [Instance Creation/Deletion]   ############
  84.  
  85.   SOMObject somNew();
  86.   // Uses SOMMalloc to allocate storage for a new instance of the
  87.   // receiving class, and then calls somRenewNoInitNoZero to load the
  88.   // new object's method table pointer. Then somDefaultInit is called to
  89.   // initialize the new object.  Note: If the instance is a class object,
  90.   // somInitMIClass must then be invoked to declare parents and
  91.   // initialize the class's instance method table. Upon failure, NULL
  92.   // is returned.
  93.  
  94.   SOMObject somNewNoInit();
  95.   // Equivalent to somNew except that somDefaultInit is not called.
  96.  
  97.   SOMObject somRenew(in void *obj);
  98.   // Equivalent to somNew except that storage is not allocated.
  99.   // <obj> is taken as the address of the new object.
  100.  
  101.   SOMObject somRenewNoInit(in void *obj);
  102.   // Equivalent to somRenew except that somDefaultInit is not called.
  103.  
  104.   SOMObject somRenewNoZero(in void *obj);
  105.   // Equivalent to somRenew except that memory is not zeroed out.
  106.  
  107.   SOMObject somRenewNoInitNoZero(in void *obj);
  108.   // The purpose of this method is to load an object's method table.
  109.   // The SOM API requires that somRenewNoInitNoZero always be
  110.   // called when creating a new object whose metaclass is not SOMClass.
  111.   // This is because metaclasses must be guaranteed that they can use
  112.   // somRenewNoInitNoZero to track object creation if this is desired.
  113.  
  114.   somToken somAllocate(in long size);
  115.   // Allocates memory to hold an object and returns a pointer to this memory.
  116.   // This is a nonstatic method, and cannot be overridden. The default
  117.   // implementation calls SOMMalloc, but a class designer can specify a
  118.   // different implementation using the somallocate modifier in IDL. The
  119.   // allocator takes the same parameters as this method.
  120.  
  121.   void somDeallocate(in somToken memptr);
  122.   // Zeros out the method table pointer stored in the word pointed to by
  123.   // memptr, and then deallocates the block of memory pointed to by memptr.
  124.   // This is a nonstatic method and cannot be overridden. The default
  125.   // deallocator called is SOMFree, but a class designer can specify a
  126.   // different deallocator using the somdeallocate modifier in IDL. The
  127.   // deallocator takes a char* (memptr) and a long (size) as arguments.
  128.  
  129.  
  130.  
  131.  
  132.   //############### [Initialization/Termination] ###############
  133.  
  134.  
  135.   void somInitClass(in string className,
  136.                     in SOMClass parentClass,
  137.                     in long dataSize,
  138.                     in long maxStaticMethods,
  139.                     in long majorVersion,
  140.                     in long minorVersion);
  141. // somInitClass is obsolete, and should no longer be used. The SOM 2.0
  142. // kernel provides special handling for redispatch stubs in the case
  143. // of SOM 1.0 classes, and use of this method is what tells the kernel
  144. // that old-style redispatch stubs will be registered.
  145.  
  146.   void somInitMIClass(in long inherit_vars,
  147.                       in string className,
  148.                       in SOMClassSequence parentClasses,
  149.                       in long dataSize,
  150.                       in long dataAlignment,
  151.                       in long maxStaticMethods,
  152.                       in long majorVersion,
  153.                       in long minorVersion);
  154.   // somInitMIClass implements the second phase of dynamic class creation:
  155.   // inheritance of interface and possibly implementation (instance
  156.   // variables) by suitable initialization of <self> (a class object).
  157.   //
  158.   // For somInitMIClass, the inherit_vars argument controls whether abstract
  159.   // or implementation inheritance is used. Inherit_vars is a 32 bit
  160.   // bit-vector. Implementation is inherited from parent i iff the bit
  161.   // 1<<i is on, or i>=32.
  162.   // On a class-by-class basis, for each class ancestor, implementation
  163.   // inheritance always takes precidence over abstract inheritance. This is
  164.   // necessary to guarantee that procedures supporting parent method calls
  165.   // (available on non-abstract parents) are always supported by parent
  166.   // instance variables.
  167.   //
  168.   // <className> is a string containing the class name. A copy is made, so
  169.   // the string may be freed upon return to the caller if this is desired.
  170.   //
  171.   // <parentClasses> is a SOMClassSequence containing pointers to the
  172.   // parent classes. somInitMIClass makes a copy of this, so it may
  173.   // be freed upon return to the caller if this is desired.
  174.   //
  175.   // <dataSize> is the space needed for the instance variables
  176.   // introduced by this class.
  177.   //
  178.   // <dataAlignment> specifies the desired byte alignment for instance
  179.   // data introduced by this class. A value of 0 selects a system-wide default;
  180.   // any other argument is taken as the desired byte alignment multiple. Thus,
  181.   // for example, even if a byte multiple of 8 is needed for double precision
  182.   // values on a given system (so 8 is the default), a class whose instance data
  183.   // doesn't require this can indicate otherwise. If A is the next memory
  184.   // address available for holding instance data, the address that will be
  185.   // used is A + (A mod byte-alignment).
  186.   //
  187.   // <maxStaticMethods> is the maximum number of static methods that will be
  188.   // added to the initialized class using addStaticMethod.
  189.   //
  190.   // <majorVersion> indicates the major version number for this
  191.   // implementation of the class definition, and <minorVersion>
  192.   // indicates the minor version number.
  193.  
  194.   somMToken somAddStaticMethod(in somId methodId,
  195.                                in somId methodDescriptor,
  196.                                in somMethodPtr method,
  197.                                in somMethodPtr redispatchStub,
  198.                                in somMethodPtr applyStub);
  199.   // Adds the indicated method, creating and returning a new method token.
  200.   //
  201.   // <methodDescriptor> is the somId for an identifier that can be used
  202.   // to access signature information about the method from an interface
  203.   // repository.
  204.   //
  205.   // <method> is the actual method procedure for this method
  206.   //
  207.   // <redispatchStub> is a procedure with the same calling sequence as
  208.   // <method> that invokes somDispatch for the method.
  209.   //
  210.   // <applyStub> is a procedure used to support somApply.
  211.  
  212.   void somAddDynamicMethod(in somId methodId,
  213.                            in somId methodDescriptor,
  214.                            in somMethodPtr method,
  215.                            in somMethodPtr applyStub);
  216.   // Adds the indicated method to the class's name lookup list.
  217.   // If this happens to override a static method then this operation is
  218.   // equivalent to <somOverrideSMethod> and the <methodDescriptor> and
  219.   // <applyStub> arguments are ignored (the overridden method's values
  220.   // will be used).
  221.   //
  222.   // <methodDescriptor> is the somId for an identifier that can be used
  223.   // to access signature information about the method from an interface
  224.   // repository.
  225.   //
  226.   // <method> is the actual method procedure for this method
  227.   //
  228.   // <applyStub> is a procedure that takes a standard variable argument
  229.   // list data structure applies it to its target object by calling
  230.   // <method> with arguments derived from the data structure.  Its
  231.   // calling sequence is the same as the calling sequence of the
  232.   // dispatch methods defined in SOMObject.  This stub is used in the
  233.   // support of the dispatch methods used in some classes.  In classes
  234.   // where the dispatch functions do not need such a function this
  235.   // parameter may be null.
  236.  
  237.   void somOverrideSMethod(in somId methodId,
  238.                           in somMethodPtr method);
  239.  
  240.   // This method can be used instead of <somAddStaticMethod> or
  241.   // <somAddDynamicMethod> when it is known that the class' parent
  242.   // class already supports this method.  This call does not require the
  243.   // method descriptor and stub methods that the others do.
  244.  
  245.   void somClassReady();
  246.   // This method is invoked when all of the static initialization for
  247.   // the class has been finished.  The default implementation simply
  248.   // registers the newly constructed class with the SOMClassMgr.
  249.  
  250.  
  251.  
  252.  
  253.   //############ [Access -- also, see attributes]  ############
  254.  
  255.   somMethodPtr somGetApplyStub(in somId methodId);
  256.   // Returns the apply stub associated with the specified method,
  257.   // if one exists; otherwise NULL is returned. This method is obsolete,
  258.   // and retained for binary compatability. In SOMr2, users never access
  259.   // apply stubs directly; The function somApply is used to invoke apply
  260.   // stubs. See somApply documentation for further information on apply
  261.   // stubs, and see somAddStaticMethod documentation for information
  262.   // on how apply stubs are registered by class implementations.
  263.  
  264.   somClassDataStructure *somGetClassData();
  265.   void somSetClassData(in somClassDataStructure cds);
  266.   // The class' pointer to the static <className>ClassData structure.
  267.  
  268.   somMethodTab* somGetClassMtab();
  269.   // A pointer to the method table used by instances of this class. This
  270.   // method was misnamed; it should have been called somGetInstanceMtab.
  271.  
  272.   long somGetInstanceOffset();
  273.   // Returns the offset of instance data introduced by the receiver in
  274.   // an instance of the receiver. This method is obsolete and not useful in
  275.   // multiple-inheritance situations. The attribute somInstanceDataOffsets
  276.   // replaces this method.
  277.  
  278.   long somGetInstancePartSize();
  279.   // The size in bytes of the instance data introduced by the receiving
  280.   // class.
  281.  
  282.   long somGetInstanceSize();
  283.   // The total size of an instance of the receiving class.
  284.  
  285.   somDToken somGetInstanceToken();
  286.   // A data token that identifies the introduced portion of this class
  287.   // within itself or any derived class.  This token can be subsequently
  288.   // passed to the run-time somDataResolve function to locate the instance
  289.   // data introduced by this class in any object derived from this class.
  290.  
  291.   somDToken somGetMemberToken(in long memberOffset,
  292.                               in somDToken instanceToken);
  293.   // Returns a data token that for the data member at offset
  294.   // "memberOffset" within the introduced portion of the class identified
  295.   // by instanceToken.  The instance token must have been obtained from a
  296.   // previous invocation of somGetInstanceToken.  The returned member
  297.   // token can be subsequently passed to the run-time somDataResolve
  298.   // function to locate the data member.
  299.  
  300.   boolean somGetMethodData(in somId methodId,
  301.                        out somMethodData md);
  302.   // If a method with id <methodId> is supported by the target class,
  303.   // the structure pointed to by <md> is loaded with method information
  304.   // and the value 1 is returned. In this case, if the method is not
  305.   // dynamic, md->method is loaded with the result of somClassResolve on
  306.   // the target class for the method. If the method is not supported,
  307.   // md->id is loaded with 0, and the value 0 is returned.
  308.  
  309.   somMethodProc *somGetRdStub(in somId methodId);
  310.   // Returns a redispatch stub for the indicated method, if possible.
  311.   // If not possible (because a valid redispatch stub has not been
  312.   // registered, and there is insufficient information to dynamically
  313.   // construct one), then a NULL is returned.
  314.  
  315.   somId somGetMethodDescriptor(in somId methodId);
  316.   // Returns the method descriptor for the indicated method.    If
  317.   // this object does not support the indicated method then NULL is
  318.   // returned.
  319.  
  320.   long somGetMethodIndex(in somId id);
  321.   // Returns the index for the specified method. (A number that may
  322.   // change if any methods are added or deleted to this class object or
  323.   // any of its ancestors).  This number is the basis for other calls to
  324.   // get info about the method. Indexes start at 0. A -1 is returned if
  325.   // the method cannot be found.
  326.  
  327.   somMToken somGetMethodToken(in somId methodId);
  328.   // Returns the specified method's access token. This token can then
  329.   // be passed to method resolution routines, which use the token
  330.   // to select a method pointer from a method table.
  331.  
  332.   string somGetName();
  333.   // This object's class name as a NULL terminated string.
  334.  
  335.   boolean somGetNthMethodData(in long n, out somMethodData md);
  336.  
  337.   // loads *md with the method data associated with the the nth method,
  338.   // or NULL if there is no such method. Returns true is successful;
  339.   // false otherwise.
  340.  
  341.   somId somGetNthMethodInfo(in long n,
  342.                             out somId descriptor);
  343.   // Returns the id of the <n>th method if one exists and NULL
  344.   // otherwise.
  345.   //
  346.   // The ordering of the methods is unpredictable, but will not change
  347.   // unless some change is made to the class or one of its ancestor classes.
  348.   //
  349.   // See CORBA documentation for info on method descriptors.
  350.  
  351.   long somGetNumMethods();
  352.   // The number of methods currently supported by this class,
  353.   // including inherited methods (both static and dynamic).
  354.  
  355.   long somGetNumStaticMethods();
  356.   // The number of static methods that this class has.  Can
  357.   // be used by a child class when initializing its method table.
  358.  
  359.   SOMClass somGetParent();
  360.   // Returns the parent class of self (along its "left-hand" derivation
  361.   // path), if one exists and NULL otherwise.
  362.  
  363.   SOMClassSequence somGetParents();
  364.   // The parent classes of self.
  365.  
  366.  
  367.   void somGetVersionNumbers (out long majorVersion, out long minorVersion);
  368.   // Returns the class' major and minor version numbers in the corresponding
  369.   // output parameters.
  370.  
  371.  
  372.   boolean somFindMethod(in somId methodId,
  373.                         out somMethodPtr m);
  374.   // Finds the method procedure associated with <methodId> for this
  375.   // class and sets <m> to it.  1 (true) is returned when the
  376.   // method procedure is a static method and 0 (false) is returned
  377.   // when the method procedure is dynamic method.
  378.   //
  379.   // If the class does not support the specified method then
  380.   // <m> is set to NULL and the return value is meaningless.
  381.   //
  382.  
  383.   boolean somFindMethodOk(in somId methodId,
  384.                           out somMethodPtr m);
  385.   // Just like <somFindMethod> except that if the method is not
  386.   // supported then an error is raised and execution is halted.
  387.  
  388.   somMethodPtr somFindSMethod(in somId methodId);
  389.   // Finds the indicated method, which must be a static method supported
  390.   // by this class, and returns a pointer to its method procedure.
  391.   // If the method is not supported by the receiver (as a static method
  392.   // or at all) then a NULL pointer is returned.
  393.  
  394.  
  395.   somMethodPtr somFindSMethodOk(in somId methodId);
  396.   // Uses <somFindSMethod>, and raises an error if the result is NULL.
  397.  
  398.   somMethodPtr somLookupMethod(in somId methodId);
  399.   // Like <somFindSMethodOK>, but without restriction to static methods.
  400.  
  401.  
  402.  
  403.   //########### [Testing] #############
  404.  
  405.   boolean somCheckVersion(in long majorVersion,
  406.                           in long minorVersion);
  407.  
  408.   // Returns 1 (true) if the implementation of this class is
  409.   // compatible with the specified major and minor version number and
  410.   // false (0) otherwise.  An implementation is compatible with the
  411.   // specified version numbers if it has the same major version number
  412.   // and a minor version number that is equal to or greater than
  413.   // <minorVersion>.    The major, minor version number pair (0,0) is
  414.   // considered to match any version.  This method is usually called
  415.   // immediately after creating the class object to verify that a
  416.   // dynamically loaded class definition is compatible with a using
  417.   // application.
  418.  
  419.   boolean somDescendedFrom(in SOMClass aClassObj);
  420.  
  421.   // Returns 1 (true) if <self> is a descendent class of <aClassObj> and
  422.   // 0 (false) otherwise.  Note: a class object is considered to be
  423.   // descended itself for the purposes of this method.
  424.  
  425.   boolean somSupportsMethod(in somId mId);
  426.  
  427.   // Returns 1 (true) if the indicated method is supported by this
  428.   // class and 0 (false) otherwise.
  429.  
  430.   //############## [Dynamic] #################
  431.  
  432.   somMethodPtr somDefinedMethod(in somMToken method);
  433.   // if the receiving class either introduces or overrides the
  434.   // indicated method, then its somMethodPtr is returned, otherwise
  435.   // NULL is returned.
  436.  
  437.   void somOverrideMtab();
  438.   // Overrides the method table pointers to point to the redispatch stubs.
  439.   // All the methods except somDispatch methods are overriden.
  440.  
  441.  
  442.  
  443. #ifdef __SOMIDL__
  444.   implementation {
  445.     releaseorder:
  446.                 somNew,
  447.                 somRenew,
  448.                 somInitClass,
  449.                 somClassReady,
  450.                 somGetName,
  451.                 somGetParent,
  452.                 somDescendedFrom,
  453.                 somCheckVersion,
  454.                 somFindMethod,
  455.                 somFindMethodOk,
  456.                 somSupportsMethod,
  457.                 somGetNumMethods,
  458.                 somGetInstanceSize,
  459.                 somGetInstanceOffset,
  460.                 somGetInstancePartSize,
  461.                 somGetMethodIndex,
  462.                 somGetNumStaticMethods,
  463.                 somGetPClsMtab,
  464.                 somGetClassMtab,
  465.                 somAddStaticMethod,
  466.                 somOverrideSMethod,
  467.                 somAddDynamicMethod,
  468.                                                 somcPrivate0,
  469.                 somGetApplyStub,
  470.                 somFindSMethod,
  471.                 somFindSMethodOk,
  472.                 somGetMethodDescriptor,
  473.                 somGetNthMethodInfo,
  474.                 somSetClassData,
  475.                 somGetClassData,
  476.                 somNewNoInit,
  477.                 somRenewNoInit,
  478.                 somGetInstanceToken,
  479.                 somGetMemberToken,
  480.                                                 somcPrivate1,
  481.                 somGetMethodData,
  482.                 somOverrideMtab,
  483.                 somGetMethodToken,
  484.                 somGetParents,
  485.                 somGetPClsMtabs,
  486.                 somInitMIClass,
  487.                 somGetVersionNumbers,
  488.                 somLookupMethod,
  489.                 _get_somInstanceDataOffsets,
  490.                 somRenewNoZero,
  491.                 somRenewNoInitNoZero,
  492.                 somAllocate,
  493.                 somDeallocate,
  494.                 somGetRdStub,
  495.                 somGetNthMethodData,
  496.                                                 somcPrivate2,
  497.                                                 somcPrivate3,
  498.                 _get_somDirectInitClasses,
  499.                                                 somcPrivate5,
  500.                                                 somcPrivate6,
  501.                                                 somcPrivate7,
  502.                                                 somcPrivate8,
  503.                                                 somcPrivate9,
  504.                                                 somcPrivate10,
  505.                                                 somcPrivate11,
  506.                                                 somcPrivate12,
  507.                 somDefinedMethod,
  508.                                                 somcPrivate13,
  509.                                                 somcPrivate14,
  510.                                                 somcPrivate15,
  511.                                                 somcPrivate16,
  512.                                                 somcPrivate17,
  513.                                                 somcPrivate18,
  514.                                                 somcPrivate19,
  515.                                                 somcPrivate20,
  516.                 _get_somDataAlignment,
  517.                                                 somcPrivate21,
  518.                                                 somcPrivate22,
  519.                                                 somcPrivate23,
  520.                                                 somcPrivate24,
  521.                                                 somcPrivate25;
  522.  
  523.     // Class Modifiers
  524.     callstyle = oidl;
  525.     externalstem = sommc;
  526.     majorversion = 1;
  527.     minorversion = 5; // for som2.5 kernel
  528.     filestem = somcls;
  529.     dllname = "som.dll";
  530.  
  531.     // Attribute Modifiers
  532.     somInstanceDataOffsets: nodata, nonstatic;
  533.     somMethodOffsets: nodata, nonstatic;
  534.     somDirectAssignClasses: noget, nonstatic;
  535.     somDirectInitClasses: nonstatic;
  536.     somClassDataOrder: noset, nonstatic;
  537.  
  538.     // Method Modifiers
  539.     somClassOfNewClassWithParents: procedure, noself;
  540.     somAllocate: nonstatic;
  541.     somDeallocate: nonstatic;
  542.     _get_somClassAllocate: nonstatic;
  543.     _get_somClassDeallocate: nonstatic;
  544.     somLookupTerminal : nonstatic;
  545.  
  546.     somInitMIClass: caller_owns_parameters = "className, parentClasses";
  547.     somAddStaticMethod: caller_owns_parameters = "methodId";
  548.     somAddDynamicMethod: caller_owns_parameters = "methodId";
  549.     somOverrideSMethod: caller_owns_parameters = "methodId";
  550.     somGetApplyStub: caller_owns_parameters = "methodId";
  551.     somGetMemberToken: caller_owns_parameters = "instanceToken",
  552.                        caller_owns_result;
  553.     somGetMethodData: caller_owns_parameters = "methodId";
  554.     somGetRdStub: caller_owns_parameters = "methodId";
  555.     somGetMethodDescriptor: caller_owns_parameters = "methodId";
  556.     somGetMethodIndex: caller_owns_parameters = "id";
  557.     somGetMethodToken: caller_owns_parameters = "methodId";
  558.     somGetParents: caller_owns_result;
  559.     somSetMethodDescriptor: caller_owns_parameters = "methodId";
  560.     somFindMethod: caller_owns_parameters = "methodId";
  561.     somFindMethodOk: caller_owns_parameters = "methodId";
  562.     somFindSMethod: caller_owns_parameters = "methodId";
  563.     somFindSMethodOk: caller_owns_parameters = "methodId";
  564.     somLookupMethod: caller_owns_parameters = "methodId";
  565.     somSupportsMethod: caller_owns_parameters = "mId";
  566.     somDefinedMethod: caller_owns_parameters = "method";
  567.  
  568.  
  569.     };
  570. #endif /* __SOMIDL__ */
  571.  
  572. };
  573.  
  574. #endif  /* somcls_idl */
  575.