source: trunk/nom/src/nomtkinit.c@ 177

Last change on this file since 177 was 158, checked in by cinc, 19 years ago

Moved garbage collector functions to a separate source file.
File size: 9.6 KB
Line 
1/* ***** BEGIN LICENSE BLOCK *****
2* Version: CDDL 1.0/LGPL 2.1
3*
4* The contents of this file are subject to the COMMON DEVELOPMENT AND
5* DISTRIBUTION LICENSE (CDDL) Version 1.0 (the "License"); you may not use
6* this file except in compliance with the License. You may obtain a copy of
7* the License at http://www.sun.com/cddl/
8*
9* Software distributed under the License is distributed on an "AS IS" basis,
10* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
11* for the specific language governing rights and limitations under the
12* License.
13*
14* The Original Code is "NOM" Netlabs Object Model
15*
16* The Initial Developer of the Original Code is
17* netlabs.org: Chris Wohlgemuth <cinc-ml@netlabs.org>.
18* Portions created by the Initial Developer are Copyright (C) 2005-2006
19* the Initial Developer. All Rights Reserved.
20*
21* Contributor(s):
22*
23* Alternatively, the contents of this file may be used under the terms of
24* the GNU Lesser General Public License Version 2.1 (the "LGPL"), in which
25* case the provisions of the LGPL are applicable instead of those above. If
26* you wish to allow use of your version of this file only under the terms of
27* the LGPL, and not to allow others to use your version of this file under
28* the terms of the CDDL, indicate your decision by deleting the provisions
29* above and replace them with the notice and other provisions required by the
30* LGPL. If you do not delete the provisions above, a recipient may use your
31* version of this file under the terms of any one of the CDDL or the LGPL.
32*
33* ***** END LICENSE BLOCK ***** */
34
35#define INCL_DOS
36#define INCL_DOSERRORS
37#define INCL_DOSMEMMGR
38#include <os2.h>
39
40#include <stdarg.h>
41#include <stdio.h>
42#include <string.h>
43
44
45/* For nomToken etc. */
46#include <nom.h>
47#include "nomtk.h"
48#include "nomobj.h"
49#include "nomcls.h"
50/* #include "nomtst.h"
51 #include "nomtst2.h" */
52#include <nomclassmanager.h>
53/* Garbage collector */
54#include <gc.h>
55
56/* Undef if you want debugging msg from somEnvironmentNew() */
57#define DEBUG_NOMENVNEW
58
59/********************************************************/
60/********************************************************/
61PNOM_ENV pGlobalNomEnv;
62/* Global class manager object */
63NOMClassMgr* NOMClassMgrObject; /* Referenced from different files */
64
65/********************************************************/
66/* Toolkit functions, exported */
67/********************************************************/
68
69
70/*
71
72 */
73NOMEXTERN int NOMLINK nomPrintf(string chrFormat, ...)
74{
75 long rc;
76
77 va_list arg_ptr;
78
79 va_start (arg_ptr, chrFormat);
80 rc=vprintf( chrFormat, arg_ptr);
81 va_end (arg_ptr);
82 return rc;
83}
84
85
86
87/*
88 This function is called to initialize the NOM runtime.
89 It creates NOMObject, NOMClass and NOMClassMgr classes and the global
90 NOMClassMgrObject.
91*/
92NOMEXTERN NOMClassMgr * NOMLINK nomEnvironmentNew (void)
93{
94 NOMClassPriv* ncPriv;
95 NOMClass* nomCls;
96 NOMObject *nomObj;
97#if 0
98 NOMTest* nomTst;
99 NOMTest* nomTstObj;
100 NOMTest* nomTst2Obj;
101#endif
102
103#ifdef DEBUG_NOMENVNEW
104 nomPrintf("Entering %s to initialize NOM runtime.\n\n", __FUNCTION__);
105 nomPrintf("**** Building NOMObject class...\n");
106#endif
107 nomCls=NOMObjectNewClass(NOMObject_MajorVersion, NOMObject_MinorVersion);
108
109#ifdef DEBUG_NOMENVNEW
110 nomPrintf("NOMObject class: %x\n", nomCls);
111 nomPrintf("\n**** Building NOMClass class...\n");
112#endif
113
114 nomCls=NOMClassNewClass(NOMClass_MajorVersion, NOMClass_MinorVersion);
115#ifdef DEBUG_NOMENVNEW
116 nomPrintf("NOMClass class: %x\n", nomCls);
117 nomPrintf("\n**** Building NOMClassMgr class and NOMClassMgrObject...\n");
118#endif
119 NOMClassMgrObject=NOMClassMgrNew();
120 if(!NOMClassMgrObject)
121 g_error("Can't create the NOMClassMgr class object!\n");
122
123#ifdef DEBUG_NOMENVNEW
124 nomPrintf("%s: NOMClassMgrObject: %x \n", __FUNCTION__, NOMClassMgrObject);
125#endif
126
127 /* Now register the classes we already have */
128 // _nomRegisterClass(NOMClassMgrObject, pGlobalNomEnv->defaultMetaClass->mtab, NULLHANDLE); //NOMClass
129 _nomClassReady(pGlobalNomEnv->defaultMetaClass, NULLHANDLE); //NOMClass
130 //_nomRegisterClass(NOMClassMgrObject, NOMClassMgrObject->mtab, NULLHANDLE); //NOMClassMgr
131 _nomClassReady( _NOMClassMgr, NULLHANDLE); //NOMClassMgr
132 ncPriv=(NOMClassPriv*)pGlobalNomEnv->nomObjectMetaClass->mtab->nomClsInfo;
133
134 /* Do not register the NOMObject metaclass here. It's already registered because it's
135 NOMClass in fact. */
136 //_nomRegisterClass(NOMClassMgrObject, pGlobalNomEnv->nomObjectMetaClass->mtab, NULLHANDLE); //NOMObject
137 //_nomRegisterClass(NOMClassMgrObject, pGlobalNomEnv->ncpNOMObject->mtab, NULLHANDLE); //NOMObject
138 _nomClassReady(_NOMObject, NULLHANDLE); //NOMObject
139
140
141#if 0
142 nomPrintf("\n**** Building NOMTest class...\n");
143 nomTst=NOMTestNewClass(NOMTest_MajorVersion, NOMTest_MinorVersion);
144 nomPrintf("NOMTest class: %x\n", nomTst);
145
146 nomPrintf("Now building a NOMTest object from %x...\n", _NOMTest);
147 nomTstObj= NOMTestNew();
148 nomPrintf("NOMTest object: %x\n", nomTstObj);
149#endif
150
151#if 0
152 nomPrintf("Calling _nomTestFunc() 1\n", nomTstObj);
153 _nomTestFunc(nomTstObj, NULLHANDLE);
154 nomPrintf("Calling _nomTestFuncString() 1\n", nomTstObj);
155 nomPrintf("--> %s\n",_nomTestFuncString(nomTstObj, NULLHANDLE));
156
157 nomPrintf("Calling _nomTestFunc() 2\n", nomTstObj);
158 _nomTestFunc(nomTstObj, NULLHANDLE);
159 nomPrintf("Calling _nomTestFuncString() 2\n", nomTstObj);
160 nomPrintf("--> %s\n",_nomTestFuncString(nomTstObj, NULLHANDLE));
161#endif
162
163#if 0
164 //#if 0
165 nomPrintf("\n**** Building NOMTest2 class...\n");
166 nomPrintf("\nNow building a NOMTest2 object...\n");
167 // NOMTest2NewClass(NOMTest2_MajorVersion, NOMTest2_MinorVersion);
168 nomTst2Obj= NOMTest2New();
169 nomPrintf("NOMTest2 object: %x\n", nomTst2Obj);
170 //#endif
171
172
173 nomPrintf("\nCalling _nomTestFunc_NOMTest2() 1\n", nomTst2Obj);
174 _nomTestFunc_NOMTest2(nomTst2Obj, NULLHANDLE);
175 nomPrintf("\nCalling _nomTestFuncString_NOMTest2() 1\n", nomTst2Obj);
176 nomPrintf("--> %s\n",_nomTestFuncString_NOMTest2(nomTst2Obj, NULLHANDLE));
177 nomPrintf("\nCalling _nomTestFunc_NOMTest2() 2\n", nomTst2Obj);
178 _nomTestFunc_NOMTest2(nomTst2Obj, NULLHANDLE);
179
180 nomPrintf("\nCalling _nomTestFunc() with NOMTest2 object: %x\n", nomTst2Obj);
181 _nomTestFunc(nomTst2Obj, NULLHANDLE);
182 nomPrintf("\nCalling _nomTestFuncString() with NOMTest2: %x\n", nomTst2Obj);
183 nomPrintf("--> %s\n",_nomTestFuncString(nomTst2Obj, NULLHANDLE));
184 nomPrintf("\n");
185 _nomTestFunc(nomTst2Obj, NULLHANDLE);
186 _nomTestFunc_NOMTest2(nomTst2Obj, NULLHANDLE);
187#endif
188
189#if 0
190 _dumpMtab(nomTstObj->mtab);
191 _dumpMtab(nomTst2Obj->mtab);
192 // _dumpMtab(NOMClassMgrObject->mtab);
193 // _dumpClasses();
194 _nomTestFunc(nomTstObj, NULLHANDLE);
195 _nomTestFunc(nomTst2Obj, NULLHANDLE);
196 _nomTestFunc(nomTstObj, NULLHANDLE);
197 _nomTestFunc(nomTst2Obj, NULLHANDLE);
198#endif
199
200#if 0
201 nomPrintf("NOMTest object: %x, %x\n", nomTstObj, NOMTestClassData.classObject);
202 nomTstObj=_nomNew((_NOMTest ? _NOMTest : NOMTestNewClass(NOMTest_MajorVersion, NOMTest_MinorVersion)), (void*) 0);
203 nomPrintf("NOMTest object: %x\n", nomTstObj);
204 nomTstObj= NOMTestNew();
205 nomPrintf("NOMTest object: %x\n", nomTstObj);
206#endif
207
208 return NOMClassMgrObject;
209}
210
211
212
213NOMEXTERN PNOM_ENV NOMLINK nomTkInit(void)
214{
215
216
217 PVOID memPtr;
218 PVOID memPool;
219
220 nomPrintf("Entering %s...\n", __FUNCTION__);
221 nomPrintf("*************************************\n");
222 nomPrintf("!! This function must be rewritten !!\n");
223 nomPrintf("!! It's using OS/2 only memory !!\n");
224 nomPrintf("!! functions. !!\n");
225 nomPrintf("*************************************\n");
226
227 /* Check if we already allocated our shared mem */
228 if(NO_ERROR==DosGetNamedSharedMem(&memPtr,SOMTK_SHARED_MEM_NAME_ROOT , PAG_EXECUTE|PAG_READ|PAG_WRITE)) {
229 nomPrintf("%s: Found root shared mem: %x.\n", __FUNCTION__, memPtr);
230 /* Give process access to memory pool*/
231 DosGetSharedMem( ((PNOM_ENV)memPtr)->pMemPool, PAG_READ|PAG_WRITE|PAG_EXECUTE);
232 if(NO_ERROR!=DosSubSetMem(((PNOM_ENV)memPtr)->pMemPool, DOSSUB_SPARSE_OBJ|DOSSUB_SERIALIZE, SOMTK_SHARED_MEM_SIZE_POOL)) {
233 DosFreeMem(memPool);
234 DosFreeMem(memPtr);
235 return NULL;
236 }
237 pGlobalNomEnv=(PNOM_ENV)memPtr;
238 return (PNOM_ENV)memPtr;
239 }
240 nomPrintf("%s: No root memory yet\n", __FUNCTION__);
241
242 /* Get the mem for the root structure in a shared memory area */
243 if(NO_ERROR!=DosAllocSharedMem(&memPtr, SOMTK_SHARED_MEM_NAME_ROOT, SOMTK_SHARED_MEM_SIZE_ROOT,
244 PAG_COMMIT | PAG_EXECUTE | PAG_READ | PAG_WRITE))
245 return NULL;
246
247 nomPrintf("%s: Got root memory: %x\n", __FUNCTION__, memPtr);
248
249 /* Get our shared memory pool */
250 if(NO_ERROR!=DosAllocSharedMem(&memPool, NULL, SOMTK_SHARED_MEM_SIZE_POOL,OBJ_GETTABLE | PAG_EXECUTE|PAG_READ|PAG_WRITE)) {
251 DosFreeMem(memPtr);
252 return NULL;
253 }
254 nomPrintf("%s: Got shared memory pool: %x\n", __FUNCTION__, memPool);
255
256 /* Now init the structure */
257 memset(memPtr, 0, 1 /*SOMTK_SHARED_MEM_SIZE_ROOT*/);
258 nomPrintf("%s: zeroed memory\n", __FUNCTION__);
259
260 ((PNOM_ENV)memPtr)->cbSize=sizeof(NOM_ENV);
261 /* Init memory pool */
262 if(NO_ERROR!=DosSubSetMem(memPool, DOSSUB_INIT|DOSSUB_SPARSE_OBJ|DOSSUB_SERIALIZE, SOMTK_SHARED_MEM_SIZE_POOL)) {
263 DosFreeMem(memPool);
264 DosFreeMem(memPtr);
265 return NULL;
266 }
267 ((PNOM_ENV)memPtr)->pMemPool=memPool;
268 if(NO_ERROR!=DosCreateMutexSem(NULL, &((PNOM_ENV)memPtr)->hmtx, DC_SEM_SHARED, FALSE))
269 {
270 DosFreeMem(memPool);
271 DosFreeMem(memPtr);
272 return NULL;
273 }
274 pGlobalNomEnv=(PNOM_ENV)memPtr;
275
276 return (PNOM_ENV)memPtr;
277}
278
279
280
281
282
283
284
285
286
287
288
Note: See TracBrowser for help on using the repository browser.