{ $Id$ Copyright (c) 1994-1996 by International Business Machines Corporation Copyright (c) 1997 Antony T Curtis. Copyright (c) 2002-2003 by Yuri Prokushev (prokushev@freemail.ru) System Object Model Run-time library API (SOM.DLL) This program is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License (LGPL) as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. **********************************************************************} Unit SOM; Interface {$mode objfpc} {$warning This units doesn't work because FPC/2 doesn't implements external vars} {$warning This code is alpha!} //uses // SOMTypes; var {$warning support of external vars required} SOM_MajorVersion, SOM_MinorVersion :Longint; (* SOM Version Numbers *) //³ 00070 ³ SOM_MajorVersion //³ 00071 ³ SOM_MinorVersion {$warning support of external vars required} SOM_MaxThreads :Longint; // ³ 00095 ³ SOM_MaxThreads (* SOM Thread Support *) type Flags =Longint; type SOMObjectType = Pointer; SOMClassType = Pointer; SOMMSingleInstanceType = Pointer; SOMClassMgrType = Pointer; SOMClassPtr = ^SOMClassType; SOMObjectPtr = ^SOMObjectType; CORBAObjectType = SOMObjectType; (* in SOM, a CORBA object is a SOM object *) somToken =Pointer; (* Uninterpretted value *) somId =^PChar; somIdPtr =^somId; somMToken =somToken; somDToken =somToken; somMTokenPtr =^somMToken; somDTokenPtr =^somDToken; type ImplId =^PChar; RepositoryId = PChar; AttributeDef_AttributeMode = Cardinal; OperationDef_OperationMode = Longint; ParameterDef_ParameterMode = Cardinal; somMethodPtr =Pointer; somBooleanVector =^Byte; somCtrlInfo =somToken; somSharedMethodData =somToken; somSharedMethodDataPtr=^somSharedMethodData; somClassInfoPtr =^somClassInfo; somClassInfo =somToken; Identifier =PChar; (* CORBA 7.5.1, p. 129 *) TypeCode = pointer; (* CORBA 5.7, p.89 *) any = record _type : TypeCode; _value : Pointer; end; NamedValue =record name : Identifier; argument : any; len : Longint; arg_modes : Flags; end; (* -- Method/Data Tokens -- For locating methods and data members. *) somRdAppType =LongInt; (* method signature code -- see def below *) somFloatMap =Array[0..13] of LongInt; (* float map -- see def below *) somFloatMapPtr =^somFloatMapPtr; somMethodInfoStruct =record callType :somRdAppType; va_listSize :Longint; float_map :somFloatMapPtr; end; somMethodInfo =somMethodInfoStruct; somMethodInfoPtr =^somMethodInfo; somMethodDataStruct =record id :somId; ctype :Longint; (* 0=static, 1=dynamic 2=nonstatic *) descriptor :somId; (* for use with IR interfaces *) mToken :somMToken; (* NULL for dynamic methods *) method :somMethodPtr; (* depends on resolution context *) shared :somSharedMethodDataPtr; end; somMethodData =somMethodDataStruct; somMethodDataPtr =^somMethodDataStruct; somMethodProc =Procedure(somSelf:SOMObjectType); somMethodProcPtr =^somMethodProc; (*--------------------------------------------------------------------- * C++-style constructors are called initializers in SOM. Initializers * are methods that receive a pointer to a somCtrlStruct as an argument. *) somInitInfo =record cls :SOMClassType;(* the class whose introduced data is to be initialized *) defaultInit :somMethodProc; defaultCopyInit :somMethodProc; defaultConstCopyInit:somMethodProc; defaultNCArgCopyInit:somMethodProc; dataOffset :Longint; legacyInit :somMethodProc; end; somDestructInfo =record cls :SOMClassType;(* the class whose introduced data is to be destroyed *) defaultDestruct :somMethodProc; dataOffset :Longint; legacyUninit :somMethodProc; end; somAssignInfo =record cls :SOMClassType;(* the class whose introduced data is to be assigned *) defaultAssign :somMethodProc; defaultConstAssign :somMethodProc; defaultNCArgAssign :somMethodProc; udaAssign :somMethodProc; udaConstAssign :somMethodProc; dataOffset :Longint; end; _IDL_SEQUENCE_octet = record _maximum : Cardinal; _length : Cardinal; _buffer : ^Byte; end; ReferenceData =_IDL_SEQUENCE_octet; (* * A special info access structure pointed to by * the parentMtab entry of somCClassDataStructure. *) somTD_somRenewNoInitNoZeroThunk =Procedure(var buf); cdecl; somInitInfoPtr =^somInitInfo; somInitCtrlStruct =record mask :somBooleanVector;(* an array of booleans to control ancestor calls *) info :somInitInfoPtr; (* an array of structs *) infoSize :Longint; (* increment for info access *) ctrlInfo :somCtrlInfo; end; somInitCtrl =somInitCtrlStruct; som3InitCtrl =somInitCtrlStruct; somDestructInfoPtr =^somDestructInfo; somDestructCtrlStruct =record mask :somBooleanVector;(* an array of booleans to control ancestor calls *) info :somDestructInfoPtr;(* an array of structs *) infoSize :Longint; (* increment for info access *) ctrlInfo :somCtrlInfo; end; somDestructCtrl =somDestructCtrlStruct; som3DestructCtrl =somDestructCtrlStruct; somAssignInfoPtr =^somAssignInfo; somAssignCtrlStruct =record mask :somBooleanVector;(* an array of booleans to control ancestor calls *) info :somAssignInfoPtr;(* an array of structs *) infoSize :Longint; (* increment for info access *) ctrlInfo :somCtrlInfo; end; somAssignCtrl =somAssignCtrlStruct; som3AssignCtrl =somAssignCtrlStruct; (*---------------------------------------------------------------------- * The Class Data Structures -- these are used to implement static * method and data interfaces to SOM objects. *) type (* -- (Generic) Class data Structure *) somClassDataStructure =record classObject :SOMClassType; (* changed by shadowing *) tokens :Array[0..0] of somToken; (* method tokens, etc. *) end; somClassDataStructurePtr=^somClassDataStructure; somInitCtrlPtr =^somInitCtrl; somDestructCtrlPtr =^somDestructCtrl; somAssignCtrlPtr =^somAssignCtrl; (* -- For building lists of method tables *) somMethodTabPtr =^somMethodTab; somMethodTabs =^somMethodTabList; somMethodTabList =record mtab :somMethodTabPtr; next :somMethodTabs; end; somParentMtabStruct =record mtab :somMethodTabPtr; (* this class' mtab -- changed by shadowing *) next :somMethodTabs; (* the parent mtabs -- unchanged by shadowing *) classObject :SOMClassType; (* unchanged by shadowing *) somRenewNoInitNoZeroThunk:somTD_somRenewNoInitNoZeroThunk; (* changed by shadowing *) instanceSize :Longint; (* changed by shadowing *) initializers :somMethodProcPtr; (* resolved initializer array in releaseorder *) resolvedMTokens :somMethodProcPtr; (* resolved methods *) initCtrl :somInitCtrl; (* these fields are filled in if somDTSClass&2 is on *) destructCtrl :somDestructCtrl; assignCtrl :somAssignCtrl; embeddedTotalCount :Longint; hierarchyTotalCount :Longint; unused :Longint; end; somParentMtabStructPtr=^somParentMtabStruct; (* * (Generic) Auxiliary Class Data Structure *) somCClassDataStructure=record parentMtab :somParentMtabStructPtr; instanceDataToken :somDToken; wrappers :Array[0..0] of somMethodProc; (* for valist methods *) end; somCClassDataStructurePtr=^somCClassDataStructure; (*---------------------------------------------------------------------- * The Method Table Structure *) (* -- to specify an embedded object (or array of objects). *) somEmbeddedObjStructPtr=^somEmbeddedObjStruct; somEmbeddedObjStruct =record copp :SOMClassType; (* address of class of object ptr *) cnt :Longint; (* object count *) offset :Longint; (* Offset to pointer (to embedded objs) *) end; somMethodTabStruct =record classObject :SOMClassType; classInfo :somClassInfoPtr; className :PChar; instanceSize :Longint; dataAlignment :Longint; mtabSize :Longint; protectedDataOffset :Longint; (* from class's introduced data *) protectedDataToken :somDToken; embeddedObjs :somEmbeddedObjStructPtr; (* remaining structure is opaque *) entries :Array[0..0] of somMethodProc; end; somMethodTab =somMethodTabStruct; (* -- For building lists of class objects *) somClasses =^somClassList; somClassList =record cls :SOMClassType; next :somClasses; end; (* -- For building lists of objects *) somObjects =^somObjectList; somObjectList =record obj :SOMObjectType; next :somObjects; end; (*---------------------------------------------------------------------- * Method Stubs -- Signature Support * * * This section defines the structures used to pass method signature * ingo to the runtime. This supports selection of generic apply stubs * and runtime generation of redispatchstubs when these are needed. The * information is registered with the runtime when methods are defined. * * When calling somAddStaticMethod, if the redispatchStub is -1, then a * pointer to a struct of type somApRdInfo is passed as the applyStub. * Otherwise, the passed redispatchstub and applystub are taken as given. * When calling somAddDynamicMethod, an actual apply stub must be passed. * Redispatch stubs for dynamic methods are not available, nor is * automated support for dynamic method apply stubs. The following * atructures only appropriate in relation to static methods. * * In SOMr2, somAddStaticMethod can be called with an actual redispatchstub * and applystub *ONLY* if the method doesn't return a structure. Recall * that no SOMr1 methods returned structures, so SOMr1 binaries obey this * restriction. The reason for this rule is that SOMr2 *may* use thunks, * and thunks need to know if a structure is returned. We therefore assume * that if no signature information is provided for a method through the * somAddStaticMethod interface, then the method returns a scalar. * * If a structure is returned, then a -1 *must* be passed to * somAddStaticMethod as a redispatchstub. In any case, if a -1 is passed, * then this means that the applystub actually points to a structure of type * somApRdInfo. This structure is used to hold and access signature * information encoded as follows. * * If the somApRdInfo pointer is NULL, then, if the runtime was built with * SOM_METHOD_STUBS defined, a default signature is assumed (no arguments, * and no structure returned); otherwise, the stubs are taken as * somDefaultMethod (which produces a runtime error when used) if dynamic * stubs are not available. * * If the somApRdInfo pointer is not NULL, then the structure it points to can * either include (non-null) redispatch and applystubs (the method is then * assumed to return a structure), or null stubs followed by information needed * to generate necessary stubs dynamically. *) somApRdInfoStruct =record rdStub :somMethodProc; apStub :somMethodProc; stubInfo :somMethodInfoPtr; end; somApRdInfo =somApRdInfoStruct; (* * Values for somRdAppType are generated by summing one from column A and one * from column B of the following constants: *) (* Column A: return type *) const SOMRdRetsimple = 0; (* Return type is a non-float fullword *) SOMRdRetfloat = 2; (* Return type is (single) float *) SOMRdRetdouble = 4; (* Return type is double *) SOMRdRetlongdouble = 6; (* Return type is long double *) SOMRdRetaggregate = 8; (* Return type is struct or union *) SOMRdRetbyte =10; (* Return type is a byte *) SOMRdRethalf =12; (* Return type is a (2 byte) halfword *) (* Column B: are there any floating point scalar arguments? *) SOMRdNoFloatArgs = 0; SOMRdFloatArgs = 1; (* A somFloatMap is only needed on RS/6000 *) (* * This is an array of offsets for up to the first 13 floating point arguments. * If there are fewer than 13 floating point arguments, then there will be * zero entries following the non-zero entries which represent the float args. * A non-zero entry signals either a single- or a double-precision floating point * argument. For a double-precision argument, the entry is the stack * frame offset. For a single-precision argument the entry is the stack * frame offset + 1. For the final floating point argument, add 2 to the * code that would otherwise be used. *) SOMFMSingle = 1; (* add to indicate single-precision *) SOMFMLast = 2; (* add to indicate last floating point arg *) const SOM_SCILEVEL = 4; (* The SCI includes the following information: * * The address of a class's ClassData structure is passed. * This structure should have the external name, * ClassData. The classObject field should be NULL * (if it is not NULL, then a new class will not be built). somBuildClass will * set this field to the address of the new class object when it is built. * * The address of the class's auxiliary ClassData structure is passed. * Thi structure should have the external name, * CClassData. The parentMtab field will be set by somBuildClass. * This field often allows method calls to a class object to be avoided. * * The other structures referenced by the static class information (SCI) * are used to: *) (* * to specify a static method. The methodId used here must be * a simple name (i.e., no colons). In all other cases, * where a somId is used to identify a registered method, * the somId can include explicit scoping. An explicitly-scoped * method name is called a method descriptor. For example, * the method introduced by SOMObjectType as somGetClass has the * method descriptor "SOMObjectType::somGetClass". When a * class is contained in an IDL module, the descriptor syntax * :::: can be used. Method * descriptors can be useful when a class supports different methods * that have the same name (note: IDL prevents this from occuring * statically, but SOM itself has no problems with this). *) type somStaticMethodStruct =record classData :somMTokenPtr; methodId :somIdPtr; (* this must be a simple name (no colons) *) methodDescriptor :somIdPtr; method :somMethodPtr;//somMethodProc; redispatchStub :somMethodPtr;//somMethodProc; applyStub :somMethodPtr;//somMethodProc; end; somStaticMethod_t =somStaticMethodStruct; somStaticMethod_p =^somStaticMethod_t; (* to specify an overridden method *) somOverideMethodStruct=record methodId :somIdPtr; (* this can be a method descriptor *) method :somMethodPtr;//somMethodProc; end; somOverrideMethod_t =somOverideMethodStruct; somOverrideMethod_p =^somOverrideMethod_t; (* to inherit a specific parent's method implementation *) somInheritedMethodStruct=record methodId :somIdPtr; (* identify the method *) parentNum :Longint; (* identify the parent *) mToken :somMTokenPtr; (* for parentNumresolve *) end; somInheritedMethod_t =somInheritedMethodStruct; somInheritedMethod_p =^somInheritedMethod_t; (* to register a method that has been moved from this *) (* class upwards in the class hierachy to class *) somMigratedMethodStruct=record clsMToken :somMTokenPtr; (* points into the classdata structure *) (* the method token in will copied here *) destMToken :somMTokenPtr; (* points into the classdata structure *) (* the method token here will be copied to *) end; somMigratedMethod_t =somMigratedMethodStruct; somMigratedMethod_p =^somMigratedMethod_t; (* to specify non-internal data *) somNonInternalDataStruct=record classData :somDTokenPtr; basisForDataOffset :PChar; end; somNonInternalData_t =somNonInternalDataStruct; somNonInternalData_p =^somNonInternalData_t; (* to specify a "procedure" or "classdata" *) somProcMethodsStruct =record classData :somMethodProcPtr; pEntry :somMethodProc; end; somProcMethods_t =somProcMethodsStruct; somProcMethods_p =^somProcMethods_t; (* to specify a general method "action" using somMethodStruct *) (* the type of action is specified by loading the type field of the somMethodStruct. There are three bit fields in the overall type: action (in type & 0xFF) 0: static -- (i.e., virtual) uses somAddStaticMethod 1: dynamic -- uses somAddDynamicMethod (classData==0) 2: nonstatic -- (i.e., nonvirtual) uses somAddMethod 3: udaAssign -- registers a method as the udaAssign (but doesn't add the method) 4: udaConstAssign -- like 3, this doesn't add the method 5: somClassResolve Override (using the class pointed to by *classData) 6: somMToken Override (using the method token pointed to by methodId) (note: classData==0 for this) 7: classAllocate -- indicates the default heap allocator for this class. If classData == 0, then method is the code address (or NULL) If classData != 0, then *classData is the code address. No other info required (or used) 8: classDeallocate -- like 7, but indicates the default heap deallocator. 9: classAllocator -- indicates a non default heap allocator for this class. like 7, but a methodDescriptor can be given. === the following is not currently supported === binary data access -- in (type & 0x100), valid for actions 0,1,2,5,6 0: the method procedure doesn't want binary data access 1: the method procedure does want binary data access aggregate return -- in (type & 0x200), used when binary data access requested 0: method procedure doesn't return a structure 1: method procedure does return a structure *) somMethodStruct =record mtype :Longint; classData :somMTokenPtr; methodId :somIdPtr; methodDescriptor :somIdPtr; method :somMethodProc; redispatchStub :somMethodProc; applyStub :somMethodProc; end; somMethods_t =somMethodStruct; somMethods_p =^somMethods_t; (* to specify a varargs function *) somVarargsFuncsStruct =record classData :somMethodProcPtr; vEntry :somMethodProc; end; somVarargsFuncs_t =somVarargsFuncsStruct; somVarargsFuncs_p =^somVarargsFuncs_t; (* to specify dynamically computed information (incl. embbeded objs) *) somDynamicSCIPtr =^somDynamicSciPtr; somDynamicSCI =record version :Longint; (* 1 for now *) instanceDataSize :Longint; (* true size (incl. embedded objs) *) dataAlignment :Longint; (* true alignment *) embeddedObjs :somEmbeddedObjStructPtr; (* array end == null copp *) end; (* to specify a DTS class, use the somDTSClass entry in the following data structure. This entry is a bit vector interpreted as follows: (somDTSClass & 0x0001) == the class is a DTS C++ class (somDTSClass & 0x0002) == the class wants the initCtrl entries of the somParentMtabStruct filled in. *) (* * The Static Class Info Structure passed to somBuildClass *) somStaticClassInfoStruct=record layoutVersion :Longint; (* this struct defines layout version SOM_SCILEVEL *) numStaticMethods :Longint; (* count of smt entries *) numStaticOverrides :Longint; (* count of omt entries *) numNonInternalData :Longint; (* count of nit entries *) numProcMethods :Longint; (* count of pmt entries *) numVarargsFuncs :Longint; (* count of vft entries *) majorVersion :Longint; minorVersion :Longint; instanceDataSize :Longint; (* instance data introduced by this class *) maxMethods :Longint; (* count numStaticMethods and numMethods *) numParents :Longint; classId :somId; explicitMetaId :somId; implicitParentMeta :Longint; parents :somIdPtr; cds :somClassDataStructurePtr; ccds :somCClassDataStructurePtr; smt :somStaticMethod_p; (* basic "static" methods for mtab *) omt :somOverrideMethod_p; (* overrides for mtab *) nitReferenceBase :PChar; nit :somNonInternalData_p; (* datatokens for instance data *) pmt :somProcMethods_p; (* Arbitrary ClassData members *) vft :somVarargsFuncs_p; (* varargs stubs *) cif :pointer{^somTP_somClassInitFunc}; (* class init function *) (* end of layout version 1 *) (* begin layout version 2 extensions *) dataAlignment :Longint; (* the desired byte alignment for instance data *) (* end of layout version 2 *) //#define SOMSCIVERSION 1 (* begin layout version 3 extensions *) numDirectInitClasses:Longint; directInitClasses :somIdPtr; numMethods :Longint; (* general (including nonstatic) methods for mtab *) mt :somMethods_p; protectedDataOffset :Longint; (* access = resolve(instanceDataToken) + offset *) somSCIVersion :Longint; (* used during development. currently = 1 *) numInheritedMethods :Longint; imt :somInheritedMethod_p; (* inherited method implementations *) numClassDataEntries :Longint; (* should always be filled in *) classDataEntryNames :somIdPtr; (* either NULL or ptr to an array of somIds *) numMigratedMethods :Longint; mmt :somMigratedMethod_p; (* migrated method implementations *) numInitializers :Longint; (* the initializers for this class *) initializers :somIdPtr; (* in order of release *) somDTSClass :Longint; (* used to identify a DirectToSOM class *) dsci :somDynamicSCIPtr; (* used to register dynamically computed info *) (* end of layout version 3 *) end; somStaticClassInfo =somStaticClassInfoStruct; somStaticClassInfoPtr =^somStaticClassInfoStruct; type (*---------------------------------------------------------------------- * Typedefs for pointers to functions *) Contained_Description = record name : Identifier; value : any; end; InterfaceDef_FullInterfaceDescription = record name : Identifier; id, defined_in : RepositoryId; {operation : IDL_SEQUENCE_OperationDef_OperationDescription; attributes : IDL_SEQUENCE_AttributeDef_AttributeDescription;} end; InterfaceDef_InterfaceDescription = record name : Identifier; id, defined_in : RepositoryId; end; (* CORBA 7.6.1, p.139 plus 5.7, p.89 enum Data Type Mapping *) type TCKind = Cardinal; const TypeCode_tk_null = 1; TypeCode_tk_void = 2; TypeCode_tk_short = 3; TypeCode_tk_long = 4; TypeCode_tk_ushort = 5; TypeCode_tk_ulong = 6; TypeCode_tk_float = 7; TypeCode_tk_double = 8; TypeCode_tk_boolean = 9; TypeCode_tk_char = 10; TypeCode_tk_octet = 11; TypeCode_tk_any = 12; TypeCode_tk_TypeCode = 13; TypeCode_tk_Principal = 14; TypeCode_tk_objref = 15; TypeCode_tk_struct = 16; TypeCode_tk_union = 17; TypeCode_tk_enum = 18; TypeCode_tk_string = 19; TypeCode_tk_sequence = 20; TypeCode_tk_array = 21; TypeCode_tk_pointer = 101; (* SOM extension *) TypeCode_tk_self = 102; (* SOM extension *) TypeCode_tk_foreign = 103; (* SOM extension *) (* Short forms of tk_ enumerators *) tk_null = TypeCode_tk_null; tk_void = TypeCode_tk_void; tk_short = TypeCode_tk_short; tk_long = TypeCode_tk_long; tk_ushort = TypeCode_tk_ushort; tk_ulong = TypeCode_tk_ulong; tk_float = TypeCode_tk_float; tk_double = TypeCode_tk_double; tk_boolean = TypeCode_tk_boolean; tk_char = TypeCode_tk_char; tk_octet = TypeCode_tk_octet; tk_any = TypeCode_tk_any; tk_TypeCode = TypeCode_tk_TypeCode; tk_Principal = TypeCode_tk_Principal; tk_objref = TypeCode_tk_objref; tk_struct = TypeCode_tk_struct; tk_union = TypeCode_tk_union; tk_enum = TypeCode_tk_enum; tk_string = TypeCode_tk_string; tk_sequence = TypeCode_tk_sequence; tk_array = TypeCode_tk_array; tk_pointer = TypeCode_tk_pointer; tk_self = TypeCode_tk_self; tk_foreign = TypeCode_tk_foreign; type SOMClass_somOffsets = record cls : SOMClassType; offset : Longint; end; _IDL_SEQUENCE_SOMClass = record _maximum : Cardinal; _length : Cardinal; _buffer : SOMClassPtr; end; _IDL_SEQUENCE_SOMObject = record _maximum : Cardinal; _length : Cardinal; _buffer : SOMObjectPtr; end; SOMClass_SOMClassSequence = _IDL_SEQUENCE_SOMClass; (*---------------------------------------------------------------------- * Windows extra procedures: *) (* * Replaceable character output handler. * Points to the character output routine to be used in development * support. Initialized to , but may be reset at anytime. * Should return 0 (false) if an error occurs and 1 (true) otherwise. *) type somTD_SOMOutCharRoutine =Function(ch:Char):Longint; cdecl; var {$warning support of external vars required} SOMOutCharRoutine :somTD_SOMOutCharRoutine;//³ 00015 ³ SOMOutCharRoutine Procedure somSetOutChar(outch:somTD_SOMOutCharRoutine); cdecl; external 'som' name 'somSetOutChar'; {index 85} Function somMainProgram:SOMClassMgrType; cdecl; external 'som' name 'somMainProgram'; {index 88} Procedure somEnvironmentEnd; cdecl; external 'som' name 'somEnvironmentEnd'; {index 83} Function somAbnormalEnd:Boolean; cdecl; external 'som' name 'somAbnormalEnd'; {index 84} (*--------------------------------------------------------*) (*--------------------------------------------------------------------- * Offset-based method resolution. *) Function somResolve(obj:SOMObjectType; mdata:somMToken):{somMethodProc}pointer; cdecl; external 'som' name 'somResolve'; {index 37} Function somParentResolve(parentMtabs:somMethodTabs; mToken:somMToken):somMethodProc; cdecl; external 'som' name 'somParentResolve'; {index 33} Function somParentNumResolve(parentMtabs:somMethodTabs; parentNum:Longint;mToken:somMToken):{somMethodProc}pointer; cdecl; external 'som' name 'somParentNumResolve'; {index 50} Function somClassResolve(obj:SOMClassType; mdata:somMToken):{somMethodProc}pointer; cdecl; external 'som' name 'somClassResolve'; {index 48} Function somAncestorResolve(obj:SOMObjectType; (* the object *) var ccds:somCClassDataStructure; (* id the ancestor *) mToken:somMToken):{somMethodProc}pointer; cdecl; external 'som' name 'somAncestorResolve'; {index 74} Function somResolveByName(obj:SOMObjectType; methodName:PChar):{somMethodProc}pointer; cdecl; external 'som' name 'somResolveByName'; {index 61} (*------------------------------------------------------------------------------ * Offset-based data resolution *) Function somDataResolve(obj:SOMObjectType; dataId:somDToken):somToken; cdecl; external 'som' name 'somDataResolve'; {index 47} Function somDataResolveChk(obj:SOMObjectType; dataId:somDToken):somToken; cdecl; external 'som' name 'somDataResolveChk'; {index 72} (*---------------------------------------------------------------------- * Misc. procedures: *) (* * Create and initialize the SOM environment * * Can be called repeatedly * * Will be called automatically when first object (including a class * object) is created, if it has not already been done. * * Returns the SOMClassMgrObject *) Function somEnvironmentNew:SOMClassMgrType; cdecl; external 'som' name 'somEnvironmentNew'; {index 30} (* * Test whether is a valid SOM object. This test is based solely on * the fact that (on this architecture) the first word of a SOM object is a * pointer to its method table. The test is therefore most correctly understood * as returning true if and only if is a pointer to a pointer to a * valid SOM method table. If so, then methods can be invoked on . *) Function somIsObj(obj:somToken):Boolean; cdecl; external 'som' name 'somIsObj'; {index 60} (* * Return the class that introduced the method represented by a given method token. *) Function somGetClassFromMToken(mToken:somMToken):SOMClassType; cdecl; external 'som' name 'somGetClassFromMToken'; {index 82} (*---------------------------------------------------------------------- * String Manager: stem *) Function somCheckID(id:somId):somId; cdecl; external 'som' name 'somCheckId'; {index 26} (* makes sure that the id is registered and in normal form, returns *) (* the id *) Function somRegisterId(id:somId):Longint; cdecl; external 'som' name 'somRegisterId'; {index 36} (* Same as somCheckId except returns 1 (true) if this is the first *) (* time the string associated with this id has been registered, *) (* returns 0 (false) otherwise *) Function somIDFromString(aString:PChar):somId; cdecl; external 'som' name 'somIdFromString'; {index 31} (* caller is responsible for freeing the returned id with SOMFree *) // Not found //Function somIdFromStringNoFree(aString:PChar):somId; cdecl; (* call is responsible for *not* freeing the returned id *) Function somStringFromId(id:somId):PChar; cdecl; external 'som' name 'somStringFromId'; {index 40} Function somCompareIds(id1,id2:somId):Longint; cdecl; external 'som' name 'somCompareIds'; {index 27} (* returns true (1) if the two ids are equal, else false (0) *) Function somTotalRegIds:Longint; cdecl; external 'som' name 'somTotalRegIds'; {index 43} (* Returns the total number of ids that have been registered so far, *) (* you can use this to advise the SOM runtime concerning expected *) (* number of ids in later executions of your program, via a call to *) (* somSetExpectedIds defined below *) Procedure somSetExpectedIds(numIds:Longint{ulong}); cdecl; external 'som' name 'somSetExpectedIds'; {index 39} (* Tells the SOM runtime how many unique ids you expect to use during *) (* the execution of your program, this can improve space and time *) (* utilization slightly, this routine must be called before the SOM *) (* environment is created to have any effect *) Function somUniqueKey(id:somId):Longint{ulong}; cdecl; external 'som' name 'somUniqueKey'; {index 44} (* Returns the unique key for this id, this key will be the same as the *) (* key in another id if and only if the other id refers to the same *) (* name as this one *) Procedure somBeginPersistentIds; cdecl; external 'som' name 'somBeginPersistentIds'; {index 24} (* Tells the id manager that strings for any new ids that are *) (* registered will never be freed or otherwise modified. This allows *) (* the id manager to just use a pointer to the string in the *) (* unregistered id as the master copy of the ids string. Thus saving *) (* space *) (* Under normal use (where ids are static varibles) the string *) (* associated with an id would only be freed if the code module in *) (* which it occured was unloaded *) Procedure somEndPersistentIds; cdecl; external 'som' name 'somEndPersistentIds'; {index 29} (* Tells the id manager that strings for any new ids that are *) (* registered may be freed or otherwise modified. Therefore the id *) (* manager must copy the strings inorder to remember the name of an *) (* id. *) (*---------------------------------------------------------------------- * Class Manager: SOMClassMgrType, stem *) (* Global class manager object *) var {$warning support of external vars required} SOMClassMgrObject : SOMClassMgrType;//³ 00007 ³ SOMClassMgrObject //Function SOMClassMgrObject:SOMClassMgrType; (* The somRegisterClassLibrary function is provided for use * in SOM class libraries on platforms that have loader-invoked * entry points associated with shared libraries (DLLs). * * This function registers a SOM Class Library with the SOM Kernel. * The library is identified by its file name and a pointer * to its initialization routine. Since this call may occur * prior to the invocation of somEnvironmentNew, its actions * are deferred until the SOM environment has been initialized. * At that time, the SOMClassMgrObject is informed of all * pending library initializations via the _somRegisterClassLibrary * method. The actual invocation of the library's initialization * routine will occur during the execution of the SOM_MainProgram * macro (for statically linked libraries), or during the _somFindClass * method (for libraries that are dynamically loaded). *) Procedure somRegisterClassLibrary(libraryName:PChar; libraryInitRun:somMethodProc); cdecl; external 'som' name 'somRegisterClassLibrary'; {index 86} (*---------------------------------------------------------------------- * -- somApply -- * * This routine replaces direct use of applyStubs in SOMr1. The reason * for the replacement is that the SOMr1 style of applyStub is not * generally available in SOMr2, which uses a fixed set of applyStubs, * according to method information in the somMethodData. In particular, * neither the redispatch stub nor the apply stub found in the method * data structure are necessarily useful as such. The method somGetRdStub * is the way to get a redispatch stub, and the above function is the * way to call an apply stub. If an appropriate apply stub for the * method indicated by md is available, then this is invoked and TRUE is * returned; otherwise FALSE is returned. * * The va_list passed to somApply *must* include the target object, * somSelf, as its first entry, and any single precision floating point * arguments being passed to the the method procedure must be * represented on the va_list using double precision values. retVal cannot * be NULL. *) Function somApply(var somSelf:SOMObjectType; var retVal:somToken; mdPtr:somMethodDataPtr; var ap):Boolean; cdecl; external 'som' name 'somApply'; {index 69} (*--------------------------------------------------------------------- * -- somBuildClass -- * * This procedure automates construction of a new class object. A variety of * special structures are used to allow language bindings to statically define * the information necessary to specify a class. Pointers to these static * structures are accumulated into an overall "static class information" * structure or SCI, passed to somBuildClass. The SCI has evolved over time. * The current version is defined here. *) Function somBuildClass(inherit_vars:Longint; var sci:somStaticClassInfo; majorVersion,minorVersion:Longint):SOMClassType; cdecl; external 'som' name 'somBuildClass'; {index 49} (* The arguments to somBuildClass are as follows: inherit_vars: a bit mask used to control inheritance of implementation Implementation is inherited from parent i iff the bit 1<=32. sci: the somStaticClassInfo defined above. majorVersion, minorVersion: the version of the class implementation. *) (*--------------------------------------------------------------------- * Used by old single-inheritance emitters to make class creation * an atomic operation. Kept for backwards compatability. *) type somTD_classInitRoutine=Procedure(var a,b:SOMClassType); cdecl; Procedure somConstructClass(classInitRoutine:somTD_ClassInitRoutine; parentClass,metaClass:SOMClassType; var cds :somClassDataStructure); cdecl; external 'som' name 'somConstructClass'; {index 28} (* * Uses to output its arguments under control of the ANSI C * style format. Returns the number of characters output. *) Function somPrintf(fnt:PChar;buf:pointer):Longint; cdecl; external 'som' name 'somPrintf'; {index 35} // vprint form of somPrintf Function somVPrintf(fnt:PChar;var ap):Longint; cdecl; external 'som' name 'somVprintf'; {index 45} // Outputs (via somPrintf) blanks to prefix a line at the indicated level Procedure somPrefixLevel(level:Longint); cdecl; external 'som' name 'somPrefixLevel'; {index 34} // Combines somPrefixLevel and somPrintf Procedure somLPrintf(level:Longint;fmt:PChar;var buf); cdecl; external 'som' name 'somLPrintf'; {index 32} Function SOMObjectNewClass(majorVersion,minorVersion:Longint):SOMClassType; cdecl; external 'som' name 'SOMObjectNewClass'; {index 22} Function SOMClassNewClass(majorVersion,minorVersion:Longint):SOMClassType; cdecl; external 'som' name 'SOMClassNewClass'; {index 21} Function SOMClassMgrNewClass(majorVersion,minorVersion:Longint):SOMClassType; cdecl; external 'som' name 'SOMClassMgrNewClass'; {index 20} (*---------------------------------------------------------------------- * Pointers to routines used to do dynamic code loading and deleting *) type somTD_SOMLoadModule =Function({IN}Module:PChar (* className *); {IN}FileName:PChar (* fileName *); {IN}FuncName:PChar (* functionName *); {IN}MajorVer:Longint (* majorVersion *); {IN}MinorVer:Longint (* minorVersion *); {OUT}var ref:somToken (* modHandle *)):Longint; cdecl; somTD_SOMDeleteModule =Function({IN} ref:somToken (* modHandle *)):Longint; cdecl; somTD_SOMClassInitFuncName =Function:PChar; cdecl; var {$warning support of external vars required} SOMLoadModule :somTD_SOMLoadModule;//³ 00011 ³ SOMLoadModule {$warning support of external vars required} SOMDeleteModule :somTD_SOMDeleteModule;//³ 00008 ³ SOMDeleteModule {$warning support of external vars required} SOMClassInitFuncName :somTD_SOMClassInitFuncName; //³ 00004 ³ SOMClassInitFuncName (*---------------------------------------------------------------------- * Replaceable SOM Memory Management Interface * * External procedure variables SOMCalloc, SOMFree, SOMMalloc, SOMRealloc * have the same interface as their standard C-library analogs. *) type somTD_SOMMalloc =Function({IN} size_t:Longint (* nbytes *)):somToken; cdecl; somTD_SOMCalloc =Function({IN} size_c:Longint (* element_count *); {IN} size_e:Longint (* element_size *)):somToken; cdecl; somTD_SOMRealloc =Function({IN} ref:somToken (* memory *); {IN} size:Longint (* nbytes *)):somToken; cdecl; somTD_SOMFree =Procedure({IN} ref:somToken (* memory *)); cdecl; var {$warning support of external vars required} SOMCalloc :somTD_SOMCalloc; // ³ 00001 ³ SOMCalloc {$warning support of external vars required} SOMFree :somTD_SOMFree; //³ 00010 ³ SOMFree {$warning support of external vars required} SOMMalloc :somTD_SOMMalloc;//³ 00012 ³ SOMMalloc {$warning support of external vars required} SOMRealloc :somTD_SOMRealloc;//³ 00016 ³ SOMRealloc (*---------------------------------------------------------------------- * Replaceable SOM Error handler *) type somTD_SOMError =Procedure({IN} code:Longint (* code *); {IN} fn:PChar (* fileName *); {IN} ln:Longint (* linenum *)); cdecl; var {$warning support of external vars required} SOMError :somTD_SOMError;//³ 00009 ³ SOMError (*---------------------------------------------------------------------- * Replaceable SOM Semaphore Operations * * These operations are used by the SOM Kernel to make thread-safe * state changes to internal resources. *) type somTD_SOMCreateMutexSem =Function({OUT}var sem:somToken ):Longint; cdecl; somTD_SOMRequestMutexSem =Function({IN}sem:somToken ):Longint; cdecl; somTD_SOMReleaseMutexSem =Function({IN}sem:somToken ):Longint; cdecl; somTD_SOMDestroyMutexSem =Function({IN}sem:somToken ):Longint; cdecl; var {$warning support of external vars required} SOMCreateMutexSem :somTD_SOMCreateMutexSem;//³ 00090 ³ SOMCreateMutexSem {$warning support of external vars required} SOMRequestMutexSem :somTD_SOMRequestMutexSem;//³ 00091 ³ SOMRequestMutexSem {$warning support of external vars required} SOMReleaseMutexSem :somTD_SOMReleaseMutexSem;//³ 00092 ³ SOMReleaseMutexSem {$warning support of external vars required} SOMDestroyMutexSem :somTD_SOMDestroyMutexSem;//³ 00093 ³ SOMDestroyMutexSem (*---------------------------------------------------------------------- * Replaceable SOM Thread Identifier Operation * * This operation is used by the SOM Kernel to index data unique to the * currently executing thread. It must return a small integer that * uniquely represents the current thread within the current process. *) type somTD_SOMGetThreadId =Function:Longint; cdecl; var {$warning support of external vars required} SOMGetThreadId :somTD_SOMGetThreadId;//³ 00094 ³ SOMGetThreadId (*---------------------------------------------------------------------- * Externals used in the implementation of SOM, but not part of the * SOM API. *) Function somTestCls(obj:SOMObjectType; classObj:SOMClassType; fileName:PChar; lineNumber:Longint):SOMObjectType; cdecl; external 'som' name 'somTestCls'; {index 42} Procedure somTest(condition,severity:Longint;fileName:PChar; lineNum:Longint;msg:PChar); cdecl; external 'som' name 'somTest'; {index 41} Procedure somAssert(condition,ecode:Longint; fileName:PChar;lineNum:Longint;msg:PChar); cdecl; external 'som' name 'somAssert'; {index 23} type exception_type = (NO_EXCEPTION, USER_EXCEPTION, SYSTEM_EXCEPTION); completion_status = (YES, NO, MAYBE); StExcep = record minot : Cardinal; completed : completion_status; end; Environment =^EnvironmentType; EnvironmentType = record _major : exception_type; exception : record _exception_name : PChar; _params : Pointer; end; _somdAnchor : pointer; end; Function somExceptionId(ev:Environment):PChar; cdecl; external 'som' name 'somExceptionId'; {index 52} Function somExceptionValue(ev:Environment):Pointer; cdecl; external 'som' name 'somExceptionValue'; {index 53} Procedure somExceptionFree(ev:Environment); cdecl; external 'som' name 'somExceptionFree'; {index 54} Procedure somSetException(ev:Environment;major:exception_type;exception_name:PChar;params:pointer); cdecl; external 'som' name 'somSetException'; {index 55} Function somGetGlobalEnvironment:Environment; cdecl; external 'som' name 'somGetGlobalEnvironment'; {index 58} (* Exception function names per CORBA 5.19, p.99 *) Function exception_id(ev:Environment):PChar; cdecl; Function exception_value(ev:Environment):Pointer; cdecl; Procedure exception_free(ev:Environment); cdecl; (* Convenience macros for manipulating environment structures * * SOM_CreateLocalEnvironment returns a pointer to an Environment. * The other 3 macros all expect a single argument that is also * a pointer to an Environment. Use the create/destroy forms for * a dynamic local environment and the init/uninit forms for a stack-based * local environment. * * For example * * Environment *ev; * ev = SOM_CreateLocalEnvironment (); * ... Use ev in methods * SOM_DestroyLocalEnvironment (ev); * * or * * Environment ev; * SOM_InitEnvironment (&ev); * ... Use &ev in methods * SOM_UninitEnvironment (&ev); *) Function SOM_CreateLocalEnvironment:Environment; cdecl; Procedure SOM_DestroyLocalEnvironment(ev:Environment); cdecl; Procedure SOM_InitEnvironment(ev:Environment); cdecl; Procedure SOM_UninitEnvironment(ev:Environment); cdecl; (*---------------------------------------------------------------------- * Macros are used in the C implementation of SOM... However, Pascal * doesn't have macro capability... (from SOMCDEV.H) *) { Change SOM_Resolve(o,ocn,mn) to... somTD_ocn_mn(somResolve(SOM_TestCls(o, ocnClassData.classObject), ocnClassData.mn))) Change SOM_ResolveNoCheck(o,ocn,mn) to... somTD_ocn_mn(somResolve(o,ocnClassData,mn)) Change SOM_ParentNumResolveCC(pcn,pcp,ocn,mn) to... somTD_pcn_mn(somParentNumResolve(ocn_CClassData.parentMtab,pcp,pcnClassData.mn)) Change SOM_ParentNumResolve(pcn,pcp,mtabs,mn) to... somTD_pcn_mn(somParentNumResolve(mtabs,pcp,pcnClassData.mn)) Change SOM_ClassResolve(cn,class,mn) to... somTD_cn_mn(somClassResolve(class,cnClassData.mn)) Change SOM_ResolveD(o,tdc,cdc,mn) to... somTD_tdc_mn(somResolve(SOM_TestCls(o,cdcClassData.classObject), cdcClassData.mn))) Change SOM_ParentResolveE(pcn,mtbls,mn) to... somTD_pcn_mn(somParentResolve(mtbls,pcnClassData.mn)) Change SOM_DataResolve(obj,dataId) to... somDataResolve(obj, dataId) Change SOM_ClassLibrary(name) to... somRegisterClassLibrary(name,somMethodProc(SOMInitModule)) } type SOMClassCClassDataStructure = record parentMtab : somMethodTabs; instanceDataToken : somDToken; end; var {$warning support of external vars required} SOMClassCClassData : SOMClassCClassDataStructure;//³ 00002 ³ SOMClassCClassData type SOMClassClassDataStructure = record classObject : SOMClassType; somNew : somMToken; somRenew : somMToken; somInitClass : somMToken; somClassReady : somMToken; somGetName : somMToken; somGetParent : somMToken; somDescendedFrom : somMToken; somCheckVersion : somMToken; somFindMethod : somMToken; somFindMethodOk : somMToken; somSupportsMethod : somMToken; somGetNumMethods : somMToken; somGetInstanceSize : somMToken; somGetInstanceOffset : somMToken; somGetInstancePartSize : somMToken; somGetMethodIndex : somMToken; somGetNumStaticMethods : somMToken; somGetPClsMtab : somMToken; somGetClassMtab : somMToken; somAddStaticMethod : somMToken; somOverrideSMethod : somMToken; somAddDynamicMethod : somMToken; somcPrivate0 : somMToken; somGetApplyStub : somMToken; somFindSMethod : somMToken; somFindSMethodOk : somMToken; somGetMethodDescriptor : somMToken; somGetNthMethodInfo : somMToken; somSetClassData : somMToken; somGetClassData : somMToken; somNewNoInit : somMToken; somRenewNoInit : somMToken; somGetInstanceToken : somMToken; somGetMemberToken : somMToken; somSetMethodDescriptor : somMToken; somGetMethodData : somMToken; somOverrideMtab : somMToken; somGetMethodToken : somMToken; somGetParents : somMToken; somGetPClsMtabs : somMToken; somInitMIClass : somMToken; somGetVersionNumbers : somMToken; somLookupMethod : somMToken; _get_somInstanceDataOffsets : somMToken; somRenewNoZero : somMToken; somRenewNoInitNoZero : somMToken; somAllocate : somMToken; somDeallocate : somMToken; somGetRdStub : somMToken; somGetNthMethodData : somMToken; somcPrivate1 : somMToken; somcPrivate2 : somMToken; _get_somDirectInitClasses : somMToken; _set_somDirectInitClasses : somMToken; somGetInstanceInitMask : somMToken; somGetInstanceDestructionMask : somMToken; somcPrivate3 : somMToken; somcPrivate4 : somMToken; somcPrivate5 : somMToken; somcPrivate6 : somMToken; somcPrivate7 : somMToken; somDefinedMethod : somMToken; somcPrivate8 : somMToken; somcPrivate9 : somMToken; somcPrivate10 : somMToken; somcPrivate11 : somMToken; somcPrivate12 : somMToken; somcPrivate13 : somMToken; somcPrivate14 : somMToken; somcPrivate15 : somMToken; _get_somDataAlignment : somMToken; somGetInstanceAssignmentMask : somMToken; somcPrivate16 : somMToken; somcPrivate17 : somMToken; _get_somClassAllocate : somMToken; _get_somClassDeallocate : somMToken; end; var {$warning support of external vars required} SOMClassClassData : SOMClassClassDataStructure;//³ 00003 ³ SOMClassClassData {$warning support of external vars required} SOMClassMgrCClassData : somCClassDataStructure;//³ 00005 ³ SOMClassMgrCClassData type SOMClassMgrClassDataStructure = record classObject : SOMClassType; somFindClsInFile : somMToken; somFindClass : somMToken; somClassFromId : somMToken; somRegisterClass : somMToken; somUnregisterClass : somMToken; somLocateClassFile : somMToken; somLoadClassFile : somMToken; somUnloadClassFile : somMToken; somGetInitFunction : somMToken; somMergeInto : somMToken; somGetRelatedClasses : somMToken; somSubstituteClass : somMToken; _get_somInterfaceRepository : somMToken; _set_somInterfaceRepository : somMToken; _get_somRegisteredClasses : somMToken; somBeginPersistentClasses : somMToken; somEndPersistentClasses : somMToken; somcmPrivate1 : somMToken; somcmPrivate2 : somMToken; somRegisterClassLibrary : somMToken; somJoinAffinityGroup : somMToken; end; var {$warning support of external vars required} SOMClassMgrClassData : SOMClassMgrClassDataStructure;//³ 00006 ³ SOMClassMgrClassData type SOMObjectCClassDataStructure = record parentMtab :somMethodTabs; instanceDataToken :somDToken; end; var {$warning support of external vars required} SOMObjectCClassData : SOMObjectCClassDataStructure;//³ 00013 ³ SOMObjectCClassData type SOMObjectClassDataStructure = record classObject : SOMClassType; somInit : somMToken; somUninit : somMToken; somFree : somMToken; somDefaultVCopyInit : somMToken; somGetClassName : somMToken; somGetClass : somMToken; somIsA : somMToken; somRespondsTo : somMToken; somIsInstanceOf : somMToken; somGetSize : somMToken; somDumpSelf : somMToken; somDumpSelfInt : somMToken; somPrintSelf : somMToken; somDefaultConstVCopyInit : somMToken; somDispatchV : somMToken; somDispatchL : somMToken; somDispatchA : somMToken; somDispatchD : somMToken; somDispatch : somMToken; somClassDispatch : somMToken; somCastObj : somMToken; somResetObj : somMToken; somDefaultInit : somMToken; somDestruct : somMToken; somPrivate1 : somMToken; somPrivate2 : somMToken; somDefaultCopyInit : somMToken; somDefaultConstCopyInit : somMToken; somDefaultAssign : somMToken; somDefaultConstAssign : somMToken; somDefaultVAssign : somMToken; somDefaultConstVAssign : somMToken; end; var {$warning support of external vars required} SOMObjectClassData : SOMObjectClassDataStructure;//³ 00014 ³ SOMObjectClassData (* Another not ported vars *) // Control the printing of method and procedure entry messages, // 0-none, 1-user, 2-core&user */ //SOMEXTERN int SOMDLINK SOM_TraceLevel; //³ 00018 ³ SOM_TraceLevel // Control the printing of warning messages, 0-none, 1-all //SOMEXTERN int SOMDLINK SOM_WarnLevel; //³ 00019 ³ SOM_WarnLevel // Control the printing of successful assertions, 0-none, 1-user, // 2-core&user //SOMEXTERN int SOMDLINK SOM_AssertLevel; //³ 00017 ³ SOM_AssertLevel Implementation Function exception_id(ev:Environment):PChar; cdecl; begin Result := somExceptionId(ev) end; Function exception_value(ev:Environment):Pointer; cdecl; begin Result := somExceptionValue(ev) end; Procedure exception_free(ev:Environment); cdecl; begin somExceptionFree(ev) end; Function SOM_CreateLocalEnvironment:Environment; cdecl; begin Result:=SOMCalloc(1, sizeof(EnvironmentType)) end; Procedure SOM_DestroyLocalEnvironment(ev:Environment); cdecl; begin somExceptionFree(ev); if somGetGlobalEnvironment<>ev then SOMFree(ev); end; Procedure SOM_InitEnvironment(ev:Environment); cdecl; begin if somGetGlobalEnvironment<>ev then FillChar(ev^,sizeof(EnvironmentType),0); end; Procedure SOM_UninitEnvironment(ev:Environment); cdecl; begin somExceptionFree(ev); end; End. (* SOMEXTERN void SOMLINK somCheckArgs(int argc, zString argv[]); ³ 00025 ³ somCheckArgs ³ 00038 ³ somSaveMetrics // not found ³ 00046 ³ somWriteMetrics // not found ³ 00051 ³ somCreateDynamicClass // not found ³ 00056 ³ SOM_IdTable // not found ³ 00057 ³ SOM_IdTableSize // not found ³ 00062 ³ somStartCriticalSection // not found ³ 00063 ³ somEndCriticalSection // not found void* va_SOMObject_somDispatchA(SOMObject *somSelf, somId methodId, somId descriptor, ...) ³ 00064 ³ va_SOMObject_somDispatchA double va_SOMObject_somDispatchD(SOMObject *somSelf, somId methodId, somId descriptor, ...) ³ 00065 ³ va_SOMObject_somDispatchD long va_SOMObject_somDispatchL(SOMObject *somSelf, somId methodId, somId descriptor, ...) ³ 00066 ³ va_SOMObject_somDispatchL void va_SOMObject_somDispatchV(SOMObject *somSelf, somId methodId, somId descriptor, ...) ³ 00067 ³ va_SOMObject_somDispatchV boolean va_SOMObject_somDispatch(SOMObject *somSelf, somToken* retValue, somId methodId, ...) ³ 00068 ³ va_SOMObject_somDispatch ³ 00080 ³ somfixMsgTemplate // not found ³ 00087 ³ SOMParentDerivedMetaclassClassData // not found SOMEXTERN void SOMLINK somUnregisterClassLibrary (string libraryName); ³ 00089 ³ somUnregisterClassLibrary void* SOMLINK somva_SOMObject_somDispatchA(SOMObject *somSelf, somId methodId, somId descriptor, ...) ³ 00096 ³ somva_SOMObject_somDispatchA double SOMLINK somva_SOMObject_somDispatchD(SOMObject *somSelf, somId methodId, somId descriptor, ...) ³ 00097 ³ somva_SOMObject_somDispatchD long SOMLINK somva_SOMObject_somDispatchL(SOMObject *somSelf, somId methodId, somId descriptor, ...) ³ 00098 ³ somva_SOMObject_somDispatchL void SOMLINK somva_SOMObject_somDispatchV(SOMObject *somSelf, somId methodId, somId descriptor, ...) ³ 00099 ³ somva_SOMObject_somDispatchV boolean SOMLINK somva_SOMObject_somDispatch(SOMObject *somSelf, somToken* retValue, somId methodId, ...) ³ 00100 ³ somva_SOMObject_somDispatch boolean SOMLINK somva_SOMObject_somClassDispatch(SOMObject *somSelf, SOMClass* clsObj, somToken* retValue, somId methodId, ...) ³ 00101 ³ somva_SOMObject_somClassDispatch ³ 00132 ³ somFreeThreadData // not found SOMEXTERN somMethodProc * SOMLINK somResolveTerminal(SOMClass *, somMToken mdata); ³ 00133 ³ somResolveTerminal ³ 00135 ³ somIdMarshal // not found ³ 00361 ³ somMakeUserRdStub // Not found SOMEXTERN somMethodProc * SOMLINK somPCallResolve(SOMObject *obj, SOMClass *callingCls, somMToken method); Ã 00362 Á somPCallResolve *) { $Log$ Revision 1.1 2003-09-22 13:52:59 yuri + Initial import. Mostly backup. }