source: trunk/Lucide/SOURCE/sominc/somapi.h @ 88

Last change on this file since 88 was 88, checked in by Eugene Romanenko, 15 years ago

UI improvements, save files, ability to compile plugins with gcc, saveAs for djvu plugin, djvu plugin compiled with gcc, get rid of ddjvuapi.dll

File size: 35.4 KB
Line 
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
14/* @(#) 2.44.2.7 src/somk/somapi.h, somk.api, som2.1 2/29/96 10:19:03 [7/30/96 14:46:36] */
15
16/*
17 *    SOMAPI.H
18 *
19 *    Note: Typedefs, function prototypes, and structure fields declared here
20 *    explicitly use a star (*) to indicate references to objects that support
21 *    IDL interfaces. For example, the first argument in the following
22 *    function prototype is typed as pointer to an object that supports the
23 *    SOMObject interface:
24 *
25 *    somMethodProc * SOMLINK somResolve(SOMObject *obj, somMToken mdata)
26 *
27 *    These types reflect the actual implementation of object references
28 *    in SOM as pointers. The CORBA compliant C language bindings are
29 *    designed so that programmers don't explicitly indicate pointers when
30 *    declaring object reference types, but this header is included into
31 *    the CORBA compliant C language binding files before this capability
32 *    has been enabled. Thus, at this point in the processing of header files
33 *    by a C compiler, it is appropriate that the explicit star appear in
34 *    object reference types. You can view the header file som.h to see how
35 *    the ability to omit the explicit star is enabled after this header is
36 *    processed, but, in any case, you can be assured that the typedefs,
37 *    function prototypes, and structure fields declared here all "work"
38 *    with the CORBA compliant C language bindings.
39 */
40
41#ifndef somapi_h
42#define somapi_h
43
44/*  SOM Version Numbers  */
45SOMEXTERN long SOMDLINK SOM_MajorVersion;
46SOMEXTERN long SOMDLINK SOM_MinorVersion;
47
48/*  SOM Thread Support  */
49SOMEXTERN long SOMDLINK SOM_MaxThreads;
50
51/*----------------------------------------------------------------------
52 *  Typedefs for pointers to functions
53 */
54
55typedef void    SOMLINK somTD_classInitRoutine(SOMClass *, SOMClass *);
56typedef int     SOMLINK somTD_SOMOutCharRoutine(char);
57typedef int     SOMLINK somTD_SOMLoadModule(IN string /* className */,
58                                        IN string     /* fileName */,
59                                        IN string     /* functionName */,
60                                        IN long    /* majorVersion */,
61                                        IN long    /* minorVersion */,
62                                        OUT somToken * /* modHandle */);
63typedef int     SOMLINK somTD_SOMDeleteModule(IN somToken /* modHandle */);
64typedef string SOMLINK somTD_SOMClassInitFuncName(void);
65typedef somToken        SOMLINK somTD_SOMMalloc(IN size_t /* nbytes */);
66typedef somToken        SOMLINK somTD_SOMCalloc(IN size_t /* element_count */,
67                                        IN size_t /* element_size */);
68typedef somToken        SOMLINK somTD_SOMRealloc(IN somToken /* memory */,
69                                         IN size_t /* nbytes */);
70typedef void    SOMLINK somTD_SOMFree(IN somToken /* memory */);
71typedef void    SOMLINK somTD_SOMError(IN int      /* code */,
72                                       IN string  /* fileName */,
73                                       IN int      /* lineNum */);
74typedef unsigned long SOMLINK somTD_SOMCreateMutexSem (OUT somToken *sem);
75typedef unsigned long SOMLINK somTD_SOMRequestMutexSem (IN somToken sem);
76typedef unsigned long SOMLINK somTD_SOMReleaseMutexSem (IN somToken sem);
77typedef unsigned long SOMLINK somTD_SOMDestroyMutexSem (IN somToken sem);
78typedef unsigned long SOMLINK somTD_SOMGetThreadId (void);
79
80/*----------------------------------------------------------------------
81 *  Windows extra procedures:
82 */
83
84SOMEXTERN void SOMLINK somSetOutChar(somTD_SOMOutCharRoutine *outch);
85SOMEXTERN SOMClassMgr * SOMLINK somMainProgram (void);
86SOMEXTERN void SOMLINK somEnvironmentEnd (void);
87SOMEXTERN boolean SOMLINK somAbnormalEnd (void);
88
89/*--------------------------------------------------------*/
90
91
92#ifndef SOM_MDT_DEFINED
93/* -- Method/Data Tokens -- For locating methods and data members. */
94typedef somToken somMToken;
95typedef somToken somDToken;
96#endif
97
98/*----------------------------------------------------------------------
99 *  The Method Table Structure
100 */
101
102#ifndef SOM_MTAB_DEFINED
103/* -- to specify an embedded object (or array of objects). */
104typedef struct {
105    SOMClass     **copp; /* address of class of object ptr */
106    long         cnt;    /* object count */
107    long         offset; /* Offset to pointer (to embedded objs) */
108} somEmbeddedObjStruct;
109
110#ifndef SOM_CLASSINFO_DEFINED
111typedef somToken somClassInfo;
112#endif
113
114typedef struct somMethodTabStruct {
115    SOMClass        *classObject;
116    somClassInfo    *classInfo;
117    char            *className;
118    long            instanceSize;
119    long            dataAlignment;
120    long            mtabSize;
121    long            protectedDataOffset; /* from class's introduced data */
122    somDToken       protectedDataToken;
123    somEmbeddedObjStruct *embeddedObjs;
124    /* remaining structure is opaque */
125    somMethodProc* entries[1];
126} somMethodTab, *somMethodTabPtr;
127#endif
128
129
130/* -- For building lists of method tables */
131typedef
132    struct somMethodTabList {
133        somMethodTab             *mtab;
134        struct somMethodTabList  *next;
135    } somMethodTabList, *somMethodTabs;
136
137
138/* -- For building lists of class objects */
139typedef
140    struct somClassList {
141        SOMClass   *cls;
142        struct somClassList *next;
143    } somClassList, *somClasses;
144
145/* -- For building lists of objects */
146typedef struct somObjectList {
147    SOMObject   *obj;
148    struct somObjectList *next;
149} somObjectList, *somObjects;
150
151/*---------------------------------------------------------------------
152 * C++-style constructors are called initializers in SOM. Initializers
153 * are methods that receive a pointer to a somCtrlStruct as an argument.
154 */
155
156typedef  struct  {
157    SOMClass      *cls;  /* the class whose introduced data is to be initialized */
158    somMethodProc *defaultInit;
159    somMethodProc *defaultCopyInit;
160    somMethodProc *defaultConstCopyInit;
161    somMethodProc *defaultNCArgCopyInit;
162    long          dataOffset;
163    somMethodProc *legacyInit;
164} somInitInfo;
165
166typedef struct {
167    SOMClass      *cls;  /* the class whose introduced data is to be destroyed */
168    somMethodProc *defaultDestruct;
169    long          dataOffset;
170    somMethodProc *legacyUninit;
171} somDestructInfo;
172
173typedef struct {
174    SOMClass      *cls;  /* the class whose introduced data is to be assigned */
175    somMethodProc *defaultAssign;
176    somMethodProc *defaultConstAssign;
177    somMethodProc *defaultNCArgAssign;
178    somMethodProc *udaAssign;
179    somMethodProc *udaConstAssign;
180    long          dataOffset;
181} somAssignInfo;
182
183typedef octet *somBooleanVector;
184#ifndef SOM_CTI_DEFINED
185typedef somToken somCtrlInfo;
186#endif
187
188typedef struct somInitCtrlStruct {
189    somBooleanVector mask; /* an array of booleans to control ancestor calls */
190    somInitInfo     *info; /* an array of structs */
191    int              infoSize; /* increment for info access */
192    somCtrlInfo      ctrlInfo;
193} somInitCtrl,som3InitCtrl;
194
195typedef struct somDestructCtrlStruct {
196    somBooleanVector  mask; /* an array of booleans to control ancestor calls */
197    somDestructInfo  *info; /* an array of structs */
198    int               infoSize; /* increment for info access */
199    somCtrlInfo       ctrlInfo;
200} somDestructCtrl,som3DestructCtrl;
201
202typedef struct somAssignCtrlStruct {
203    somBooleanVector  mask; /* an array of booleans to control ancestor calls */
204    somAssignInfo    *info; /* an array of structs */
205    int               infoSize; /* increment for info access */
206    somCtrlInfo       ctrlInfo;
207} somAssignCtrl,som3AssignCtrl;
208
209
210
211
212/*----------------------------------------------------------------------
213 *  The Class Data Structures -- these are used to implement static
214 *  method and data interfaces to SOM objects.
215 */
216
217/* -- (Generic) Class data Structure */
218typedef struct {
219    SOMClass *classObject; /* changed by shadowing */
220    somToken tokens[1];    /* method tokens, etc. */
221} somClassDataStructure, *somClassDataStructurePtr;
222
223/*
224 * A special info access structure pointed to by
225 * the parentMtab entry of somCClassDataStructure.
226 */
227typedef void somTP_somRenewNoInitNoZeroThunk(void*);
228#if (defined(__IBMC__) && !defined(__cplusplus))
229#pragma linkage(somTP_somRenewNoInitNoZeroThunk, system)
230#endif
231typedef somTP_somRenewNoInitNoZeroThunk *somTD_somRenewNoInitNoZeroThunk;
232
233typedef struct {
234    somMethodTab    *mtab; /* this class' mtab -- changed by shadowing */
235    somMethodTabs   next; /* the parent mtabs -- unchanged by shadowing */
236    SOMClass        *classObject; /* unchanged by shadowing */
237    somTD_somRenewNoInitNoZeroThunk somRenewNoInitNoZeroThunk; /* changed by shadowing */
238    long            instanceSize; /* changed by shadowing */
239    somMethodProc   **initializers; /* resolved initializer array in releaseorder */
240    somMethodProc   **resolvedMTokens;  /* resolved methods */
241    somInitCtrl     initCtrl; /* these fields are filled in if somDTSClass&2 is on */
242    somDestructCtrl destructCtrl;
243    somAssignCtrl   assignCtrl;
244    long            embeddedTotalCount;
245    long            hierarchyTotalCount;
246    long            unused;
247} somParentMtabStruct, *somParentMtabStructPtr;
248
249/*
250 * (Generic) Auxiliary Class Data Structure
251 */
252typedef struct {
253    somParentMtabStructPtr parentMtab;
254    somDToken              instanceDataToken;
255    somMethodProc          *wrappers[1]; /* for valist methods */
256} somCClassDataStructure, *somCClassDataStructurePtr;
257
258
259/*---------------------------------------------------------------------
260 *  Offset-based method resolution.
261 */
262
263SOMEXTERN somMethodProc * SOMLINK somResolve(SOMObject *obj, somMToken mdata);
264SOMEXTERN somMethodProc * SOMLINK somParentResolve(somMethodTabs parentMtabs,
265                                         somMToken mToken);
266SOMEXTERN somMethodProc * SOMLINK somParentNumResolve(somMethodTabs parentMtabs,
267                                         int parentNum,
268                                         somMToken mToken);
269SOMEXTERN somMethodProc * SOMLINK somClassResolve(SOMClass *, somMToken mdata);
270SOMEXTERN somMethodProc * SOMLINK somResolveTerminal(SOMClass *, somMToken mdata);
271SOMEXTERN somMethodProc * SOMLINK somPCallResolve(SOMObject *obj,
272                                                  SOMClass *callingCls,
273                                                  somMToken method);
274SOMEXTERN somMethodProc * SOMLINK somAncestorResolve(SOMObject *obj, /* the object */
275                                           somCClassDataStructure *ccds, /* id the ancestor */
276                                           somMToken mToken);
277SOMEXTERN somMethodProc * SOMLINK somResolveByName(SOMObject *obj,
278                                                   char *methodName);
279/*------------------------------------------------------------------------------
280 * Offset-based data resolution
281 */
282SOMEXTERN somToken SOMLINK somDataResolve(SOMObject *obj, somDToken dataId);
283SOMEXTERN somToken SOMLINK somDataResolveChk(SOMObject *obj, somDToken dataId);
284
285
286/*----------------------------------------------------------------------
287 *  Misc. procedures:
288 */
289
290/*
291 *  Create and initialize the SOM environment
292 *
293 *  Can be called repeatedly
294 *
295 *  Will be called automatically when first object (including a class
296 *  object) is created, if it has not already been done.
297 *
298 *  Returns the SOMClassMgrObject
299 */
300SOMEXTERN SOMClassMgr * SOMLINK somEnvironmentNew (void);
301
302
303/*
304 * Test whether <obj> is a valid SOM object. This test is based solely on
305 * the fact that (on this architecture) the first word of a SOM object is a
306 * pointer to its method table. The test is therefore most correctly understood
307 * as returning true if and only if <obj> is a pointer to a pointer to a
308 * valid SOM method table. If so, then methods can be invoked on <obj>.
309 */
310SOMEXTERN boolean SOMLINK somIsObj(somToken obj);
311
312/*
313 * Return the class that introduced the method represented by a given method token.
314 */
315SOMEXTERN SOMClass* SOMLINK somGetClassFromMToken(somMToken mToken);
316
317
318/*----------------------------------------------------------------------
319 *  String Manager: stem <somsm>
320 */
321SOMEXTERN somId SOMLINK somCheckId (somId id);
322/* makes sure that the id is registered and in normal form, returns */
323/* the id */
324
325SOMEXTERN int SOMLINK somRegisterId(somId id);
326/* Same as somCheckId except returns 1 (true) if this is the first */
327/* time the string associated with this id has been registered, */
328/* returns 0 (false) otherwise */
329
330SOMEXTERN somId SOMLINK somIdFromString (string aString);
331/* caller is responsible for freeing the returned id with SOMFree */
332
333SOMEXTERN string SOMLINK somStringFromId (somId id);
334
335SOMEXTERN int SOMLINK somCompareIds(somId id1, somId id2);
336/* returns true (1) if the two ids are equal, else false (0) */
337
338SOMEXTERN unsigned long SOMLINK somTotalRegIds(void);
339/* Returns the total number of ids that have been registered so far, */
340/* you can use this to advise the SOM runtime concerning expected */
341/* number of ids in later executions of your program, via a call to */
342/* somSetExpectedIds defined below */
343
344SOMEXTERN void SOMLINK somSetExpectedIds(unsigned long numIds);
345/* Tells the SOM runtime how many unique ids you expect to use during */
346/* the execution of your program, this can improve space and time */
347/* utilization slightly, this routine must be called before the SOM */
348/* environment is created to have any effect */
349
350SOMEXTERN unsigned long SOMLINK somUniqueKey(somId id);
351/* Returns the unique key for this id, this key will be the same as the */
352/* key in another id if and only if the other id refers to the same */
353/* name as this one */
354
355SOMEXTERN void SOMLINK somBeginPersistentIds(void);
356/* Tells the id manager that strings for any new ids that are */
357/* registered will never be freed or otherwise modified. This allows */
358/* the id manager to just use a pointer to the string in the */
359/* unregistered id as the master copy of the ids string. Thus saving */
360/* space */
361/* Under normal use (where ids are static varibles) the string */
362/* associated with an id would only be freed if the code module in */
363/* which it occured was unloaded */
364
365SOMEXTERN void SOMLINK somEndPersistentIds(void);
366/* Tells the id manager that strings for any new ids that are */
367/* registered may be freed or otherwise modified.  Therefore the id */
368/* manager must copy the strings inorder to remember the name of an */
369/* id. */
370
371/*----------------------------------------------------------------------
372 *  Class Manager: SOMClassMgr, stem <somcm>
373 */
374
375/* Global class manager object */
376SOMEXTERN SOMClassMgr * SOMDLINK SOMClassMgrObject;
377
378/* The somRegisterClassLibrary function is provided for use
379 * in SOM class libraries on platforms that have loader-invoked
380 * entry points associated with shared libraries (DLLs).
381 *
382 * This function registers a SOM Class Library with the SOM Kernel.
383 * The library is identified by its file name and a pointer
384 * to its initialization routine.  Since this call may occur
385 * prior to the invocation of somEnvironmentNew, its actions
386 * are deferred until the SOM environment has been initialized.
387 * At that time, the SOMClassMgrObject is informed of all
388 * pending library initializations via the _somRegisterClassLibrary
389 * method.  The actual invocation of the library's initialization
390 * routine will occur during the execution of the SOM_MainProgram
391 * macro (for statically linked libraries), or during the _somFindClass
392 * method (for libraries that are dynamically loaded).
393 */
394SOMEXTERN void SOMLINK somRegisterClassLibrary (string libraryName,
395    somMethodProc *libraryInitRtn);
396SOMEXTERN void SOMLINK somUnregisterClassLibrary (string libraryName);
397
398/*----------------------------------------------------------------------
399 * Method Stubs -- Signature Support
400 *
401 *
402 * This section defines the structures used to pass method signature
403 * ingo to the runtime. This supports selection of generic apply stubs
404 * and runtime generation of redispatchstubs when these are needed. The
405 * information is registered with the runtime when methods are defined.
406 *
407 * When calling somAddStaticMethod, if the redispatchStub is -1, then a
408 * pointer to a struct of type somApRdInfo is passed as the applyStub.
409 * Otherwise, the passed redispatchstub and applystub are taken as given.
410 * When calling somAddDynamicMethod, an actual apply stub must be passed.
411 * Redispatch stubs for dynamic methods are not available, nor is
412 * automated support for dynamic method apply stubs. The following
413 * atructures only appropriate in relation to static methods.
414 *
415 * In SOMr2, somAddStaticMethod can be called with an actual redispatchstub
416 * and applystub *ONLY* if the method doesn't return a structure. Recall
417 * that no SOMr1 methods returned structures, so SOMr1 binaries obey this
418 * restriction. The reason for this rule is that SOMr2 *may* use thunks,
419 * and thunks need to know if a structure is returned. We therefore assume
420 * that if no signature information is provided for a method through the
421 * somAddStaticMethod interface, then the method returns a scalar.
422 *
423 * If a structure is returned, then a -1 *must* be passed to
424 * somAddStaticMethod as a redispatchstub. In any case, if a -1 is passed,
425 * then this means that the applystub actually points to a structure of type
426 * somApRdInfo. This structure is used to hold and access signature
427 * information encoded as follows.
428 *
429 * If the somApRdInfo pointer is NULL, then, if the runtime was built with
430 * SOM_METHOD_STUBS defined, a default signature is assumed (no arguments,
431 * and no structure returned); otherwise, the stubs are taken as
432 * somDefaultMethod (which produces a runtime error when used) if dynamic
433 * stubs are not available.
434 *
435 * If the somApRdInfo pointer is not NULL, then the structure it points to can
436 * either include (non-null) redispatch and applystubs (the method is then
437 * assumed to return a structure), or null stubs followed by information needed
438 * to generate necessary stubs dynamically.
439 */
440
441typedef unsigned long somRdAppType; /* method signature code -- see def below */
442typedef unsigned long somFloatMap[13]; /* float map -- see def below */
443typedef struct somMethodInfoStruct {
444    somRdAppType       callType;
445    long               va_listSize;
446    somFloatMap        *float_map;
447} somMethodInfo;
448
449typedef struct somApRdInfoStruct {
450    somMethodProc *rdStub;
451    somMethodProc *apStub;
452    somMethodInfo *stubInfo;
453} somApRdInfo;
454
455/*
456 * Values for somRdAppType are generated by summing one from column A and one
457 * from column B of the following constants:
458 */
459/* Column A: return type */
460#define SOMRdRetsimple     0 /* Return type is a non-float fullword */
461#define SOMRdRetfloat      2 /* Return type is (single) float */
462#define SOMRdRetdouble     4 /* Return type is double */
463#define SOMRdRetlongdouble 6 /* Return type is long double */
464#define SOMRdRetaggregate  8 /* Return type is struct or union */
465#define SOMRdRetbyte      10 /* Return type is a byte */
466#define SOMRdRethalf      12 /* Return type is a (2 byte) halfword */
467/* Column B: are there any floating point scalar arguments? */
468#define SOMRdNoFloatArgs   0
469#define SOMRdFloatArgs     1
470
471/* A somFloatMap is only needed on RS/6000 */
472/*
473 * This is an array of offsets for up to the first 13 floating point arguments.
474 * If there are fewer than 13 floating point arguments, then there will be
475 * zero entries following the non-zero entries which represent the float args.
476 * A non-zero entry signals either a single- or a double-precision floating point
477 * argument. For a double-precision argument, the entry is the stack
478 * frame offset. For a single-precision argument the entry is the stack
479 * frame offset + 1. For the final floating point argument, add 2 to the
480 * code that would otherwise be used.
481 */
482#define SOMFMSingle 1        /* add to indicate single-precision */
483#define SOMFMLast   2        /* add to indicate last floating point arg */
484
485
486/*----------------------------------------------------------------------
487 * -- somApply --
488 *
489 * This routine replaces direct use of applyStubs in SOMr1. The reason
490 * for the replacement is that the SOMr1 style of applyStub is not
491 * generally available in SOMr2, which uses a fixed set of applyStubs,
492 * according to method information in the somMethodData. In particular,
493 * neither the redispatch stub nor the apply stub found in the method
494 * data structure are necessarily useful as such. The method somGetRdStub
495 * is the way to get a redispatch stub, and the above function is the
496 * way to call an apply stub. If an appropriate apply stub for the
497 * method indicated by md is available, then this is invoked and TRUE is
498 * returned; otherwise FALSE is returned.
499 *
500 * The va_list passed to somApply *must* include the target object,
501 * somSelf, as its first entry, and any single precision floating point
502 * arguments being passed to the the method procedure must be
503 * represented on the va_list using double precision values. retVal cannot
504 * be NULL.
505 */
506
507#ifndef SOM_SMD_DEFINED
508typedef somToken somSharedMethodData;
509#endif
510
511typedef struct somMethodDataStruct {
512    somId id;
513    long type;          /* 0=static, 1=dynamic 2=nonstatic */
514    somId descriptor;        /* for use with IR interfaces */
515    somMToken mToken;        /* NULL for dynamic methods */
516    somMethodPtr method;     /* depends on resolution context */
517    somSharedMethodData *shared;
518} somMethodData, *somMethodDataPtr;
519
520
521SOMEXTERN boolean SOMLINK somApply(SOMObject *somSelf,
522                                somToken *retVal,
523                                somMethodDataPtr mdPtr,
524                                va_list ap);
525
526/*---------------------------------------------------------------------
527 * -- somBuildClass --
528 *
529 * This procedure automates construction of a new class object. A variety of
530 * special structures are used to allow language bindings to statically define
531 * the information necessary to specify a class. Pointers to these static
532 * structures are accumulated into an overall "static class information"
533 * structure or SCI, passed to somBuildClass. The SCI has evolved over time.
534 * The current version is defined here.
535 */
536
537#define SOM_SCILEVEL 4
538
539
540/* The SCI includes the following information:
541 *
542 * The address of a class's ClassData structure is passed.
543 * This structure should have the external name,
544 * <className>ClassData. The classObject field should be NULL
545 * (if it is not NULL, then a new class will not be built). somBuildClass will
546 * set this field to the address of the new class object when it is built.
547 *
548 * The address of the class's auxiliary ClassData structure is passed.
549 * Thi structure should have the external name,
550 * <className>CClassData. The parentMtab field will be set by somBuildClass.
551 * This field often allows method calls to a class object to be avoided.
552 *
553 * The other structures referenced by the static class information (SCI)
554 * are used to:
555 */
556
557/*
558 * to specify a static method. The methodId used here must be
559 * a simple name (i.e., no colons). In all other cases,
560 * where a somId is used to identify a registered method,
561 * the somId can include explicit scoping. An explicitly-scoped
562 * method name is called a method descriptor. For example,
563 * the method introduced by SOMObject as somGetClass has the
564 * method descriptor "SOMObject::somGetClass". When a
565 * class is contained in an IDL module, the descriptor syntax
566 * <moduleName>::<className>::<methodName> can be used. Method
567 * descriptors can be useful when a class supports different methods
568 * that have the same name (note: IDL prevents this from occuring
569 * statically, but SOM itself has no problems with this).
570 */
571typedef struct somStaticMethodStruct {
572    somMToken *classData;
573    somId *methodId; /* this must be a simple name (no colons) */
574    somId *methodDescriptor;
575    somMethodProc *method;
576    somMethodProc *redispatchStub;
577    somMethodProc *applyStub;
578} somStaticMethod_t;
579
580/* to specify an overridden method */
581typedef struct somOverideMethodStruct {
582    somId *methodId; /* this can be a method descriptor */
583    somMethodProc *method;
584} somOverrideMethod_t;
585
586/* to inherit a specific parent's method implementation */
587typedef struct somInheritedMethodStruct {
588    somId     *methodId;  /* identify the method */
589    long parentNum;       /* identify the parent */
590    somMToken *mToken;    /* for parentNumresolve */
591} somInheritedMethod_t;
592
593/* to register a method that has been moved from this */
594/* class <cls> upwards in the class hierachy to class <dest> */
595typedef struct somMigratedMethodStruct {
596    somMToken *clsMToken; /* points into the <cls> classdata structure */
597                          /* the method token in <dest> will copied here */
598    somMToken *destMToken;/* points into the <dest> classdata structure */
599                          /* the method token here will be copied to <cls> */
600} somMigratedMethod_t;
601
602/* to specify non-internal data */
603typedef struct somNonInternalDataStruct {
604    somDToken *classData;
605    char *basisForDataOffset;
606} somNonInternalData_t;
607
608/* to specify a "procedure" or "classdata" */
609typedef struct somProcMethodsStruct {
610    somMethodProc **classData, *pEntry;
611} somProcMethods_t;
612
613/* to specify a general method "action" using somMethodStruct */
614/*
615  the type of action is specified by loading the type field of the
616  somMethodStruct. There are three bit fields in the overall type:
617
618  action (in type & 0xFF)
619   0: static -- (i.e., virtual) uses somAddStaticMethod
620   1: dynamic -- uses somAddDynamicMethod (classData==0)
621   2: nonstatic -- (i.e., nonvirtual) uses somAddMethod
622   3: udaAssign -- registers a method as the udaAssign (but doesn't add the method)
623   4: udaConstAssign -- like 3, this doesn't add the method
624   5: somClassResolve Override (using the class pointed to by *classData)
625   6: somMToken Override (using the method token pointed to by methodId)
626                         (note: classData==0 for this)
627   7: classAllocate -- indicates the default heap allocator for this class.
628                       If classData == 0, then method is the code address (or NULL)
629                       If classData != 0, then *classData is the code address.
630                       No other info required (or used)
631   8: classDeallocate -- like 7, but indicates the default heap deallocator.
632   9: classAllocator -- indicates a non default heap allocator for this class.
633                        like 7, but a methodDescriptor can be given.
634
635   === the following is not currently supported ===
636   binary data access -- in (type & 0x100), valid for actions 0,1,2,5,6
637   0: the method procedure doesn't want binary data access
638   1: the method procedure does want binary data access
639
640   aggregate return -- in (type & 0x200), used when binary data access requested
641   0: method procedure doesn't return a structure
642   1: method procedure does return a structure
643*/
644
645typedef struct somMethodStruct {
646    unsigned long type;
647    somMToken *classData;
648    somId *methodId;
649    somId *methodDescriptor;
650    somMethodProc *method;
651    somMethodProc *redispatchStub;
652    somMethodProc *applyStub;
653} somMethods_t;
654
655/* to specify a varargs function */
656typedef struct somVarargsFuncsStruct {
657    somMethodProc **classData, *vEntry;
658} somVarargsFuncs_t;
659
660/* to specify dynamically computed information (incl. embbeded objs) */
661typedef struct {
662    int   version;              /* 1 for now */
663    long    instanceDataSize;   /* true size (incl. embedded objs) */
664    long    dataAlignment;      /* true alignment */
665    somEmbeddedObjStruct *embeddedObjs; /* array end == null copp */
666} somDynamicSCI;
667
668
669/*
670   to specify a DTS class, use the somDTSClass entry in the following
671   data structure. This entry is a bit vector interpreted as follows:
672
673   (somDTSClass & 0x0001) == the class is a DTS C++ class
674   (somDTSClass & 0x0002) == the class wants the initCtrl entries
675                             of the somParentMtabStruct filled in.
676
677*/
678
679
680
681/*
682 *  The Static Class Info Structure passed to somBuildClass
683 */
684
685typedef struct somStaticClassInfoStruct {
686    unsigned long layoutVersion;  /* this struct defines layout version SOM_SCILEVEL */
687    unsigned long numStaticMethods;   /* count of smt entries */
688    unsigned long numStaticOverrides; /* count of omt entries */
689    unsigned long numNonInternalData; /* count of nit entries */
690    unsigned long numProcMethods;     /* count of pmt entries */
691    unsigned long numVarargsFuncs;    /* count of vft entries */
692    unsigned long majorVersion;
693    unsigned long minorVersion;
694    unsigned long instanceDataSize;   /* instance data introduced by this class */
695    unsigned long maxMethods;         /* count numStaticMethods and numMethods */
696    unsigned long numParents;
697    somId    classId;
698    somId    explicitMetaId;
699    long implicitParentMeta;
700    somId                  *parents;
701    somClassDataStructure  *cds;
702    somCClassDataStructure *ccds;
703    somStaticMethod_t      *smt; /* basic "static" methods for mtab */
704    somOverrideMethod_t    *omt; /* overrides for mtab */
705    char                   *nitReferenceBase;
706    somNonInternalData_t   *nit; /* datatokens for instance data */
707    somProcMethods_t       *pmt; /* Arbitrary ClassData members */
708    somVarargsFuncs_t      *vft; /* varargs stubs */
709    somTP_somClassInitFunc *cif; /* class init function */
710    /* end of layout version 1 */
711
712    /* begin layout version 2 extensions */
713    long dataAlignment; /* the desired byte alignment for instance data */
714    /* end of layout version 2 */
715
716#define SOMSCIVERSION 1
717
718    /* begin layout version 3 extensions */
719    long numDirectInitClasses;
720    somId *directInitClasses;
721    unsigned long numMethods; /* general (including nonstatic) methods for mtab */
722    somMethods_t       *mt;
723    unsigned long protectedDataOffset; /* access = resolve(instanceDataToken) + offset */
724    unsigned long somSCIVersion;  /* used during development. currently = 1 */
725    unsigned long numInheritedMethods;
726    somInheritedMethod_t *imt; /* inherited method implementations */
727    unsigned long numClassDataEntries; /* should always be filled in */
728    somId *classDataEntryNames; /* either NULL or ptr to an array of somIds */
729    unsigned long numMigratedMethods;
730    somMigratedMethod_t *mmt; /* migrated method implementations */
731    unsigned long numInitializers; /* the initializers for this class */
732    somId *initializers;     /* in order of release */
733    unsigned long somDTSClass; /* used to identify a DirectToSOM class */
734    somDynamicSCI *dsci;  /* used to register dynamically computed info */
735    /* end of layout version 3 */
736
737} somStaticClassInfo, *somStaticClassInfoPtr;
738
739SOMEXTERN SOMClass * SOMLINK somBuildClass (
740                    long inherit_vars,
741                    somStaticClassInfo *sci,
742                    long majorVersion,
743                    long minorVersion);
744
745  /*
746  The arguments to somBuildClass are as follows:
747
748   inherit_vars: a bit mask used to control inheritance of implementation
749   Implementation is inherited from parent i iff the bit 1<<i is on, or i>=32.
750
751   sci: the somStaticClassInfo defined above.
752
753   majorVersion, minorVersion: the version of the class implementation.
754
755   */
756
757
758/*---------------------------------------------------------------------
759 *  Used by old single-inheritance emitters to make class creation
760 *  an atomic operation. Kept for backwards compatability.
761 */
762SOMEXTERN void SOMLINK somConstructClass (
763                    somTD_classInitRoutine *classInitRoutine,
764                    SOMClass *parentClass,
765                    SOMClass *metaClass,
766                    somClassDataStructure *cds);
767
768
769/*
770 * Uses <SOMOutCharRoutine> to output its arguments under control of the ANSI C
771 * style format.  Returns the number of characters output.
772 */
773SOMEXTERN int SOMLINK somPrintf (string fmt, ...);
774/*
775 * vprint form of somPrintf
776 */
777SOMEXTERN int SOMLINK somVprintf (string fmt, va_list ap);
778/*
779 * Outputs (via somPrintf) blanks to prefix a line at the indicated level
780 */
781SOMEXTERN void SOMLINK somPrefixLevel (long level);
782/*
783 * Combines somPrefixLevel and somPrintf
784 */
785SOMEXTERN int SOMLINK somLPrintf (int level, string fmt, ...);
786
787/*
788 *  Replaceable character output handler.
789 *  Points to the character output routine to be used in development
790 *  support.  Initialized to <somOutChar>, but may be reset at anytime.
791 *  Should return 0 (false) if an error occurs and 1 (true) otherwise.
792 */
793
794SOMEXTERN somTD_SOMOutCharRoutine * SOMDLINK SOMOutCharRoutine;
795
796/*----------------------------------------------------------------------
797 * Pointers to routines used to do dynamic code loading and deleting
798 */
799
800SOMEXTERN somTD_SOMLoadModule     * SOMDLINK SOMLoadModule;
801SOMEXTERN somTD_SOMDeleteModule   * SOMDLINK SOMDeleteModule;
802SOMEXTERN somTD_SOMClassInitFuncName * SOMDLINK SOMClassInitFuncName;
803
804/*----------------------------------------------------------------------
805 *  Replaceable SOM Memory Management Interface
806 *
807 *  External procedure variables SOMCalloc, SOMFree, SOMMalloc, SOMRealloc
808 *  have the same interface as their standard C-library analogs.
809 */
810
811SOMEXTERN somTD_SOMCalloc  * SOMDLINK SOMCalloc;
812SOMEXTERN somTD_SOMFree    * SOMDLINK SOMFree;
813SOMEXTERN somTD_SOMMalloc  * SOMDLINK SOMMalloc;
814SOMEXTERN somTD_SOMRealloc * SOMDLINK SOMRealloc;
815
816/*----------------------------------------------------------------------
817 *  Replaceable SOM Error handler
818 */
819
820SOMEXTERN somTD_SOMError * SOMDLINK SOMError;
821
822/*----------------------------------------------------------------------
823 *  Replaceable SOM Semaphore Operations
824 *
825 *  These operations are used by the SOM Kernel to make thread-safe
826 *  state changes to internal resources.
827 */
828SOMEXTERN somTD_SOMCreateMutexSem  * SOMDLINK SOMCreateMutexSem;
829SOMEXTERN somTD_SOMRequestMutexSem * SOMDLINK SOMRequestMutexSem;
830SOMEXTERN somTD_SOMReleaseMutexSem * SOMDLINK SOMReleaseMutexSem;
831SOMEXTERN somTD_SOMDestroyMutexSem * SOMDLINK SOMDestroyMutexSem;
832
833/*----------------------------------------------------------------------
834 *  Replaceable SOM Thread Identifier Operation
835 *
836 *  This operation is used by the SOM Kernel to index data unique to the
837 *  currently executing thread.  It must return a small integer that
838 *  uniquely represents the current thread within the current process.
839 */
840SOMEXTERN somTD_SOMGetThreadId * SOMDLINK SOMGetThreadId;
841
842/*----------------------------------------------------------------------
843 * Externals used in the implementation of SOM, but not part of the
844 * SOM API.
845 */
846
847SOMEXTERN SOMObject * SOMLINK somTestCls(SOMObject *obj, SOMClass *classObj,
848                                         string fileName, int lineNumber);
849SOMEXTERN void SOMLINK somTest(int condition, int severity, string fileName,
850                               int lineNum, string msg);
851SOMEXTERN void SOMLINK somAssert(int condition, int ecode,
852                                 string fileName, int lineNum, string msg);
853
854
855#endif /* somapi_h */
Note: See TracBrowser for help on using the repository browser.