home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Professional Developers Kit 1992 November / Disc01 / Disc01.mdf / os2tk20 / c / os2h / som.h__ / SOM.H
Encoding:
C/C++ Source or Header  |  1992-07-15  |  10.8 KB  |  295 lines
  1. /*
  2.  *    SOM.H
  3.  *    First level include file for System Object Model
  4.  *
  5.  *    Copyright (c) International Business Machines Corporation
  6.  *            1991, 1992
  7.  *
  8.  *    @(#)som.h 1.18 1/30/92 16:53:00 [1/30/92] (c)IBM Corp. 1992
  9.  */
  10.  
  11. #ifndef som_h
  12. #define som_h
  13.  
  14. #include <somnames.h>
  15.  
  16. #ifdef __cplusplus
  17. #define SOMEXTERN extern "C"
  18. #else
  19. #define SOMEXTERN extern
  20. #endif
  21.  
  22. #ifdef _CL386
  23.   #define SOMLINK _syscall
  24. #else
  25.   #define SOMLINK
  26.   #ifdef __IBMC__
  27.     #pragma linkage(somAssert              , system)
  28.     #pragma linkage(somBeginPersistentIds     , system)
  29.     #pragma linkage(somCheckId              , system)
  30.     #pragma linkage(somCompareIds          , system)
  31.     #pragma linkage(somConstructClass          , system)
  32.     #pragma linkage(somDataResolve          , system)
  33.     #pragma linkage(somEndPersistentIds       , system)
  34.     #pragma linkage(somEnvironmentNew          , system)
  35.     #pragma linkage(somGenericApply          , system)
  36.     #pragma linkage(somGetClass           , system)
  37.     #pragma linkage(somIdFromString          , system)
  38.     #pragma linkage(somLPrintf              , system)
  39.     #pragma linkage(somParentResolve          , system)
  40.     #pragma linkage(somPrefixLevel          , system)
  41.     #pragma linkage(somPrintf              , system)
  42.     #pragma linkage(somRegisterId          , system)
  43.     #pragma linkage(somResolve              , system)
  44.     #pragma linkage(somSetExpectedIds          , system)
  45.     #pragma linkage(somStringFromId          , system)
  46.     #pragma linkage(somTest              , system)
  47.     #pragma linkage(somTestCls              , system)
  48.     #pragma linkage(somTotalRegIds          , system)
  49.     #pragma linkage(somUniqueKey          , system)
  50.     #pragma linkage(somVprintf              , system)
  51.     #pragma linkage(somTD_classInitRoutine    , system)
  52.     #pragma linkage(somTD_SOMCalloc          , system)
  53.     #pragma linkage(somTD_SOMClassInitFuncName, system)
  54.     #pragma linkage(somTD_SOMDeleteModule     , system)
  55.     #pragma linkage(somTD_SOMError          , system)
  56.     #pragma linkage(somTD_SOMFree          , system)
  57.     #pragma linkage(somTD_SOMLoadModule       , system)
  58.     #pragma linkage(somTD_SOMMalloc          , system)
  59.     #pragma linkage(somTD_SOMOutCharRoutine   , system)
  60.     #pragma linkage(somTD_SOMRealloc          , system)
  61.   #endif
  62. #endif
  63.  
  64. #include <stdarg.h>
  65. #include <stddef.h>
  66. #include <somtypes.h>
  67. #include <somerr.h>
  68. #include <somcdev.h>
  69.  
  70. /*----------------------------------------------------------------------
  71.  *  Typedefs for pointers to functions
  72.  */
  73.  
  74. typedef void    SOMLINK somTD_classInitRoutine(SOMClass *, SOMClass *);
  75. typedef int    SOMLINK somTD_SOMOutCharRoutine(char);
  76. typedef int    SOMLINK somTD_SOMLoadModule(IN zString /* className */,
  77.                     IN zString     /* fileName */,
  78.                     IN zString     /* functionName */,
  79.                     IN integer4    /* majorVersion */,
  80.                     IN integer4    /* minorVersion */,
  81.                     OUT somToken * /* modHandle */);
  82. typedef int    SOMLINK somTD_SOMDeleteModule(IN somToken /* modHandle */);
  83. typedef zString SOMLINK somTD_SOMClassInitFuncName(void);
  84. typedef void *    SOMLINK somTD_SOMMalloc(IN size_t /* nbytes */);
  85. typedef void *    SOMLINK somTD_SOMCalloc(IN size_t /* element_count */,
  86.                     IN size_t /* element_size */);
  87. typedef void *    SOMLINK somTD_SOMRealloc(IN void * /* memory */,
  88.                      IN size_t /* nbytes */);
  89. typedef void    SOMLINK somTD_SOMFree(IN void * /* memory */);
  90. typedef void    SOMLINK somTD_SOMError(IN int       /* code */,
  91.                        IN zString  /* fileName */,
  92.                        IN int       /* lineNum */);
  93.  
  94. /*----------------------------------------------------------------------
  95.  *  Misc. procedures:
  96.  */
  97.  
  98. /*
  99.  *  Create and initialize the SOM environment
  100.  *
  101.  *  Can be called repeatedly
  102.  *
  103.  *  Will be called automatically when first object (including a class
  104.  *  object) is created, if it has not already been done.
  105.  *
  106.  *  Returns the SOMClassMgrObject
  107.  */
  108.  
  109. SOMEXTERN SOMClassMgr * SOMLINK somEnvironmentNew (void);
  110.  
  111. /*----------------------------------------------------------------------
  112.  *  String Manager: stem <somsm>
  113.  */
  114. /* makes sure that the id is registered and in normal form, returns */
  115. /* the id */
  116. SOMEXTERN somId SOMLINK somCheckId (somId id);
  117.  
  118. /* Same as somCheckId except returns 1 (true) if this is the first */
  119. /* time the string associated with this id has been registered, */
  120. /* returns 0 (false) otherwise */
  121. SOMEXTERN int SOMLINK somRegisterId(somId id);
  122.  
  123. SOMEXTERN somId SOMLINK somIdFromString (zString aString);
  124.  
  125. SOMEXTERN zString SOMLINK somStringFromId (somId id);
  126.  
  127. SOMEXTERN int SOMLINK somCompareIds(somId id1, somId id2);
  128.  
  129. /* Returns the total number of ids that have been registered so far, */
  130. /* you can use this to advise the SOM runtime concerning expected */
  131. /* number of ids in later executions of your program, via a call to */
  132. /* somSetExpectedIds defined below */
  133. SOMEXTERN unsigned long SOMLINK somTotalRegIds(void);
  134.  
  135. /* Tells the SOM runtime how many unique ids you expect to use during */
  136. /* the execution of your program, this can improve space and time */
  137. /* utilization slightly, this routine must be called before the SOM */
  138. /* environment is created to have any effect */
  139. SOMEXTERN void SOMLINK somSetExpectedIds(unsigned long numIds);
  140.  
  141. /* Returns the unique key for this id, this key will be the same as the */
  142. /* key in another id if and only if the other id refers to the same */
  143. /* name as this one */
  144. SOMEXTERN unsigned long SOMLINK somUniqueKey(somId id);
  145.  
  146. /* Tells the id manager that strings for any new ids that are */
  147. /* registered will never be freed or otherwise modified. This allows */
  148. /* the id manager to just use a pointer to the string in the */
  149. /* unregistered id as the master copy of the ids string. Thus saving */
  150. /* space */
  151. /* Under normal use (where ids are static varibles) the string */
  152. /* associated with an id would only be freed if the code module in */
  153. /* which it occured was unloaded */
  154. SOMEXTERN void SOMLINK somBeginPersistentIds(void);
  155.  
  156. /* Tells the id manager that strings for any new ids that are */
  157. /* registered may be freed or otherwise modified.  Therefore the id */
  158. /* manager must copy the strings inorder to remember the name of an */
  159. /* id. */
  160. SOMEXTERN void SOMLINK somEndPersistentIds(void);
  161.  
  162. /*----------------------------------------------------------------------
  163.  *  Root object: SOMObject, stem <somob>
  164.  */
  165. #include <somobj.h>
  166.  
  167. /*----------------------------------------------------------------------
  168.  *  Root meta class: SOMClass, stem <sommc>
  169.  */
  170. #include <somcls.h>
  171.  
  172. /*----------------------------------------------------------------------
  173.  *  Class Manager: SOMClassMgr, stem <somcm>
  174.  */
  175. #include <somcm.h>
  176.  
  177. /* Global class manager object */
  178. SOMEXTERN SOMClassMgr *SOMClassMgrObject;
  179.  
  180. /*----------------------------------------------------------------------
  181.  *  Dispatch meta class: SOMClassDispatch, stem <sommd>
  182.  */
  183.  
  184. /*---------------------------------------------------------------------
  185.  *  Basic offset based method resolution, this is used in every method
  186.  *  class that uses offset resolution
  187.  *  It returns the appropriate method procedure for the method
  188.  *  identified by <mdata>, Mdata id the 32 bit value stored in the
  189.  *  class data structure in the entry with the methods name. I.e., if
  190.  *  a object, obj, of class, Foo, has a method, bar, then:
  191.  *    somResolve(obj, FooClassData.bar)
  192.  *  will return the appropriate method procedure for bar.
  193.  *  The way that <mdata> identifies a method and the algorithm used by
  194.  *  somResolve to locate the appropriate method procedure is not part
  195.  *  of the visible SOM architecture and is subject to change in
  196.  *  subsequent releases.
  197.  */
  198. SOMEXTERN somMethodProc * SOMLINK somResolve(SOMAny *obj, somMToken mdata);
  199. SOMEXTERN somMethodProc * SOMLINK somParentResolve(somMethodTab *parentMtab,
  200.                      somMToken mdata);
  201. SOMEXTERN void * SOMLINK somDataResolve(SOMAny *obj, somDToken dataId);
  202.  
  203. /*---------------------------------------------------------------------
  204.  *  Used to make class object creation an atomic operation, this is
  205.  *  called by the generated <class name>NewClass routine.  You should
  206.  *  never call this routine directly.
  207.  */
  208. SOMEXTERN void SOMLINK somConstructClass (
  209.             somTD_classInitRoutine *classInitRoutine,
  210.             SOMClass *parentClass,
  211.             SOMClass *metaClass,
  212.             somClassDataStructure *cds);
  213.  
  214. /*---------------------------------------------------------------------
  215.  *  Generic apply function
  216.  */
  217. SOMEXTERN void SOMLINK somGenericApply (SOMAny *obj,
  218.        somId methodID,
  219.        somId methodDescriptor,
  220.        va_list ap);
  221.  
  222. /*
  223.  * Convenience function to obtain the class object for a given object
  224.  */
  225. #ifndef SOMObject_Class_Source
  226. SOMEXTERN SOMClass * SOMLINK somGetClass (SOMAny *self);
  227. #endif
  228.  
  229. /*
  230.  * Uses <SOMOutCharRoutine> to output its arguments under control of the ANSI C
  231.  * style format.  Returns the number of characters output.
  232.  */
  233. SOMEXTERN int SOMLINK somPrintf (zString fmt, ...);
  234. /*
  235.  * vprint form of somPrintf
  236.  */
  237. SOMEXTERN int SOMLINK somVprintf (zString fmt, va_list ap);
  238. /*
  239.  * Outputs (via somPrintf) blanks to prefix a line at the indicated level
  240.  */
  241. SOMEXTERN void SOMLINK somPrefixLevel (int level);
  242. /*
  243.  * Combines somPrefixLevel and somPrintf
  244.  */
  245. SOMEXTERN int SOMLINK somLPrintf (int level, zString fmt, ...);
  246.  
  247. /*
  248.  *  Replaceable character output handler.
  249.  *  Points to the character output routine to be used in development
  250.  *  support.  Initialized to <somOutChar>, but may be reset at anytime.
  251.  *  Should return 0 (false) if an error occurs and 1 (true) otherwise.
  252.  */
  253.  
  254. SOMEXTERN somTD_SOMOutCharRoutine *SOMOutCharRoutine;
  255.  
  256. /*----------------------------------------------------------------------
  257.  * Pointers to routines used to do dynamic code loading and deleting
  258.  */
  259.  
  260. SOMEXTERN somTD_SOMLoadModule      *SOMLoadModule;
  261. SOMEXTERN somTD_SOMDeleteModule   *SOMDeleteModule;
  262. SOMEXTERN somTD_SOMClassInitFuncName *SOMClassInitFuncName;
  263.  
  264. /*----------------------------------------------------------------------
  265.  *  Replaceable SOM Memory Management Interface
  266.  *
  267.  *  External procedure variables SOMCalloc, SOMFree, SOMMalloc, SOMRealloc
  268.  *  have the same interface as their standard C-library analogs.
  269.  */
  270.  
  271. SOMEXTERN somTD_SOMCalloc    *SOMCalloc;
  272. SOMEXTERN somTD_SOMFree *SOMFree;
  273. SOMEXTERN somTD_SOMMalloc    *SOMMalloc;
  274. SOMEXTERN somTD_SOMRealloc *SOMRealloc;
  275.  
  276. /*----------------------------------------------------------------------
  277.  *  Replaceable SOM Error handler
  278.  */
  279.  
  280. SOMEXTERN somTD_SOMError *SOMError;
  281.  
  282. /*----------------------------------------------------------------------
  283.  * Externals used in the implementation of SOM, but not part of the
  284.  * SOM API.
  285.  */
  286.  
  287. SOMEXTERN SOMAny * SOMLINK somTestCls(SOMAny *obj, SOMClass *classObj,
  288.                    zString fileName, int lineNumber);
  289. SOMEXTERN void SOMLINK somTest(int condition, int severity, zString fileName,
  290.                 int lineNum, zString msg);
  291. SOMEXTERN void SOMLINK somAssert(int condition, int ecode,
  292.                  zString fileName, int lineNum, zString msg);
  293.  
  294. #endif
  295.