Changeset 326 for trunk/nom/src


Ignore:
Timestamp:
Apr 9, 2008, 10:22:08 PM (17 years ago)
Author:
cinc
Message:

Portability patches for Windows, Linux, Darwin by Bird.

Location:
trunk/nom/src
Files:
1 added
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/nom/src/nombuildclass.c

    r255 r326  
    3636 */
    3737
    38 #define INCL_DOS
    39 #define INCL_DOSERRORS
    40 
    41 #include <os2.h>
     38#ifdef __OS2__
     39# define INCL_DOS
     40# define INCL_DOSERRORS
     41# include <os2.h>
     42#endif /* __OS2__ */
     43
    4244#include <stdarg.h>
    4345#include <stdio.h>
    4446#include <string.h>
    45 #include <alloca.h>
     47#include <stdlib.h>
     48#if !defined(_MSC_VER)
     49# include <alloca.h>
     50#endif
    4651#include <glib.h>
    4752#define SOM_NO_OBJECTS  /* Otherwise som.h includes the IBM SOM classes */
    … …  
    6974#endif
    7075
    71 #ifdef DEBUG_NOMBUILDCLASS
    72 #define DBG_BUILD_LINE(a)
    73 #define DBG_NOMBUILDCLASS(a, b,...)   if(a) nomPrintf("%d: " b , __LINE__,  __VA_ARGS__);
     76#ifdef _MSC_VER
     77void _inline DBG_NOMBUILDCLASS(gboolean a, const char fmt, ...)
     78{
     79    /* sorry nothing here. */
     80}
    7481#else
    75 #define DBG_NOMBUILDCLASS(a, b,...)
    76 #endif
     82# ifdef DEBUG_NOMBUILDCLASS
     83#  define DBG_BUILD_LINE(a)
     84#  define DBG_NOMBUILDCLASS(a, b,...)   if(a) nomPrintf("%d: " b , __LINE__,  __VA_ARGS__);
     85# else
     86#  define DBG_NOMBUILDCLASS(a, b,...)
     87# endif
     88#endif
    7789
    7890#define DBGBUILDNOMCLASS_ENTER BUILDNOMCLASS_ENTER
    … …  
    95107*/
    96108
    97 static ULONG thunk[]={0x0424448b, 0x00000405, 0x0000c300};
     109static gulong thunk[]={0x0424448b, 0x00000405, 0x0000c300};
    98110
    99111/*
    … …  
    102114JMP DWORD PTR [EDX+0ACh]  : JMP to address pointing to by EDX+0ACh
    103115 */
    104 static ULONG mThunkCode[]={0x04244c8b, 0xff00518b, 0x0000aca2 , 0x16000000};
     116static gulong mThunkCode[]={0x04244c8b, 0xff00518b, 0x0000aca2 , 0x16000000};
    105117
    106118
    … …  
    116128 */
    117129
    118 static BOOL priv_nomIsA(NOMObject *nomSelf, NOMClass* aClassObj)
     130static gboolean priv_nomIsA(NOMObject *nomSelf, NOMClass* aClassObj)
    119131{
    120132  nomParentMtabStructPtr pParentMtab=&((NOMClassPriv * )nomSelf)->parentMtabStruct;
    … …  
    195207                    __FUNCTION__, __LINE__, gstr->str);
    196208          idx++; /* This is the position for the class pointer */
    197           ncPriv=_nomGetClassInfoPtrFromName(NOMClassMgrObject, sci->chrParentClassNames[a], NULLHANDLE);
     209          ncPriv=_nomGetClassInfoPtrFromName(NOMClassMgrObject, sci->chrParentClassNames[a], NULL);
    198210          /* now find the index */
    199211          ulNumMethods=nomGetNumIntroducedMethods(ncPriv);
    … …  
    245257          }
    246258          else{
    247             ncPriv=_nomGetClassInfoPtrFromName(NOMClassMgrObject, sci->chrParentClassNames[a], NULLHANDLE);
     259            ncPriv=_nomGetClassInfoPtrFromName(NOMClassMgrObject, sci->chrParentClassNames[a], NULL);
    248260            //nomPrintf("   %s did not introduce the method. Adding %d to index\n",
    249261            //        sci->chrParentClassNames[a], nomGetNumIntroducedMethods(ncPriv)+1);
    … …  
    275287    for(b=0;b<sci->ulNumStaticOverrides;b++) {/* For every overriden method do */
    276288      nomMethodProc** entries;
    277       ULONG index;
     289      gulong index;
    278290
    279291      entries=&nClass->mtab->entries[0];  /* Adress of array where we enter our resoved method */
    … …  
    333345boolean addMethodAndDataToThisPrivClassStruct(NOMClassPriv* nClass, NOMClassPriv* ncpParent, nomStaticClassInfo *sci)
    334346{
    335   BYTE * mem;
     347  guint8 * mem;
    336348  int a;
    337349
    … …  
    389401    /* Now finally put the thunking in so the procedures are resolved correctly. */
    390402    for(a=0;a<sci->ulNumStaticMethods;a++) {
    391       ULONG ulOffset;
     403      gulong ulOffset;
    392404
    393405      memcpy(&nClass->mThunk[a], mThunkCode, sizeof(mThunkCode)); /* Copy thunking code */
    394406
    395       ulOffset=(ULONG)((char*)(mem+sizeof(NOMClass*))-(char*)nClass->mtab); /* Skip class object pointer */
     407      ulOffset=(gulong)((char*)(mem+sizeof(NOMClass*))-(char*)nClass->mtab); /* Skip class object pointer */
    396408      nClass->mThunk[a].thunk[2]=((ulOffset+a*sizeof(nomMethodProc*))<<8)+0xa2;
    397409      /* Put thunking code address into CClassStruct */
    … …  
    431443    {
    432444      ncpParent=_nomGetClassInfoPtrFromName(NOMClassMgrObject, chrClassName,
    433                                   NULLHANDLE);
     445                                  NULL);
    434446    }
    435447
    … …  
    495507                                                        NOMClass* nomClass)
    496508{
    497   ULONG ulParentDataSize=0;
    498   ULONG mtabSize;
    499   ULONG ulMemSize=0;
     509  gulong ulParentDataSize=0;
     510  gulong mtabSize;
     511  gulong ulMemSize=0;
    500512  NOMClassPriv  *nClass, *ncpParent;
    501513
    … …  
    503515
    504516  if(!nomClass||!sci)
    505     return NULLHANDLE;
     517    return NULL;
    506518
    507519  /* The addresse of static methods in sci are already resolved. See nomBuildClass() */
    … …  
    512524  }/* nomIdAllParents */
    513525  else
    514     ncpParent = NULLHANDLE;
     526    ncpParent = NULL;
    515527
    516528  if(!ncpParent) {
    … …  
    518530    /* FIXME:       
    519531       Maybe we should panic here.  */
    520     return NULLHANDLE; /* Only NOMObject has no parent, so we have a problem here. */
     532    return NULL; /* Only NOMObject has no parent, so we have a problem here. */
    521533  }
    522534
    … …  
    540552
    541553  /* Alloc private class struct using NOMCalloc. */
    542   if((nClass=(NOMClassPriv*)NOMCalloc(1, ulMemSize))==NULLHANDLE)
    543     return NULLHANDLE;
     554  if((nClass=(NOMClassPriv*)NOMCalloc(1, ulMemSize))==NULL)
     555    return NULL;
    544556#if 0
    545557  //Moved to addMethodAndDataToThisPrivClassStruct()
    … …  
    549561    if(!nClass->mThunk) {
    550562      NOMFree(nClass);
    551       return NULLHANDLE;
     563      return NULL;
    552564    }
    553565  }
    … …  
    561573  if(!addMethodAndDataToThisPrivClassStruct( nClass, ncpParent, sci)){
    562574    NOMFree(nClass);
    563     return NULLHANDLE;
     575    return NULL;
    564576  };
    565577 
    … …  
    580592  nClass->mtab->nomClassObject=nomClass; /* Class object (metaclass). We build a normal class here. */
    581593  nClass->mtab->nomClsInfo=(nomClassInfo*)nClass;
     594#ifndef _MSC_VER
    582595#warning !!!!! Change this when nomId is a GQuark !!!!!
     596#endif
    583597  nClass->mtab->nomClassName=*sci->nomClassId;
    584598  nClass->mtab->ulInstanceSize=sci->ulInstanceDataSize+ulParentDataSize; /* Size of instance data of this class and all
    … …  
    589603  DBG_NOMBUILDCLASS(TRUE, "New NOMClassPriv*: %x\n", nClass);
    590604
    591   _nomSetObjectCreateInfo(nomClass, nClass, NULLHANDLE);
     605  _nomSetObjectCreateInfo(nomClass, nClass, NULL);
    592606
    593607  /* Mark the class as using nomUnInit() if any parent did that. We just have to
    … …  
    610624 
    611625  if(NULL==NOMClassMgrObject)
    612     return NULLHANDLE;
     626    return NULL;
    613627
    614628  /* Search for meta class. */
     629#ifndef _MSC_VER
    615630#warning !!!!! Change this when nomID is a GQuark !!!!!
    616   nomClassMeta=_nomFindClassFromName(NOMClassMgrObject, *sci->nomExplicitMetaId, majorVersion, minorVersion, NULLHANDLE);
     631#endif
     632  nomClassMeta=_nomFindClassFromName(NOMClassMgrObject, *sci->nomExplicitMetaId, majorVersion, minorVersion, NULL);
    617633
    618634    DBG_NOMBUILDCLASS(TRUE, "%x %s %s\n", nomClassMeta, *sci->nomClassId, *sci->nomExplicitMetaId);
    619635
    620636  if(!nomClassMeta)
    621     return NULLHANDLE;
     637    return NULL;
    622638
    623639  /* Create a new class object. We create a copy here because we may change the mtab entries
    … …  
    625641     sizes, methods etc. I wonder how IBM SOM manages to use the same metaclass
    626642     for different classes without (apparently) copying it for different uses... */
    627   if((nomClass=(NOMClass*)NOMCalloc(1, _nomGetSize(nomClassMeta, NULLHANDLE)))==NULLHANDLE)
    628     return NULLHANDLE;
     643  if((nomClass=(NOMClass*)NOMCalloc(1, _nomGetSize(nomClassMeta, NULL)))==NULL)
     644    return NULL;
    629645
    630646  /* Maybe we should just copy the whole struct here? */
    631647  nomClass->mtab=nomClassMeta->mtab;
     648#ifndef _MSC_VER
    632649#warning !!!!! No call of _nomSetInstanceSize  !!!!!
    633650#warning !!!!! No call of _nomSetObjectsSCI   !!!!!
     651#endif
    634652#if 0
    635653  /* Set object data */
    … …  
    678696    {
    679697      NOMObject *nObject;
    680       nObject=_nomFindClassFromName(NOMClassMgrObject, sci->chrParentClassNames[a], 0, 0, NULLHANDLE);
     698      nObject=_nomFindClassFromName(NOMClassMgrObject, sci->chrParentClassNames[a], 0, 0, NULL);
    681699
    682700      DBG_NOMBUILDCLASS( TRUE , "   Parent %d: %s, class object: %x\n" ,
    … …  
    710728
    711729#ifdef DEBUG_NOMBUILDCLASS
     730# ifndef _MSC_VER
    712731#warning !!!!! Change this when nomId is a GQuark !!!!!
     732# endif
    713733  nomPrintf("\n%d: Entering %s to build %s\n", __LINE__, __FUNCTION__, *sci->nomClassId);
    714734#endif
    … …  
    722742
    723743  if(!nomClassDefault)
    724     return NULLHANDLE;
     744    return NULL;
    725745
    726746  /* Found NOMClass object */
    727747
    728   //nomPrintf("_nomGetSize(): %d\n", _nomGetSize(nomClassParent, NULLHANDLE));
     748  //nomPrintf("_nomGetSize(): %d\n", _nomGetSize(nomClassParent, NULL));
    729749
    730750  /* Create an object */
    731   if((nomClass=(NOMClass*)NOMCalloc(1, _nomGetSize(nomClassDefault, NULLHANDLE)))==NULLHANDLE)
    732     return NULLHANDLE;
     751  if((nomClass=(NOMClass*)NOMCalloc(1, _nomGetSize(nomClassDefault, NULL)))==NULL)
     752    return NULL;
    733753
    734754  nomClass->mtab=nomClassDefault->mtab;
    735755
     756#ifndef _MSC_VER
    736757#warning !!!!! _nomSetInstanceSize() not called here !!!!!
    737758#warning !!!!! _nomSetObjectsSCI() not called here !!!!!
     759#endif
    738760#if 0
    739761  /* Set object data */
    … …  
    783805
    784806  /* Allocate a class object for NOMObject for creating NOMObject instances. */
    785   if((nomObjClass=(NOMClass*)NOMCalloc(1, ulSize))==NULLHANDLE) {
     807  if((nomObjClass=(NOMClass*)NOMCalloc(1, ulSize))==NULL) {
    786808    /* We panic here for the simple reason that without a working NOMObject the whole object system
    787809       will not work. */
    788810    g_error("No memory for building the class object _NOMObject for NOMObject.");
    789     return NULLHANDLE;
     811    return NULL;
    790812  }
    791813
    792814  nomObjClass->mtab=nomClass->mtab;         /* Now it's an object */
    793815
    794   _nomSetObjectCreateInfo(nomObjClass, pGlobalNomEnv->ncpNOMObject, NULLHANDLE); /* This NOMClassPriv holds all info to build
     816  _nomSetObjectCreateInfo(nomObjClass, pGlobalNomEnv->ncpNOMObject, NULL); /* This NOMClassPriv holds all info to build
    795817                                                                                    instances of NOMObject (not that anybody
    796818                                                                                    should do that but... */
     819#ifndef _MSC_VER
    797820#warning !!!!!!!!!!!!! _somSetObjectsSCI() not called!!!!!!!!!!!!!!!!
    798821#warning !!!!!!!!!!!!! _somSetClassData() not called!!!!!!!!!!!!!!!!
     822#endif
    799823#if 0
    800824  _somSetObjectsSCI(nomObjClass, ncp->sci);
    … …  
    828852  NOMClassPriv *nClass;
    829853  NOMClassPriv *ncpParent;
    830   ULONG ulParentDataSize=0;
    831   ULONG mtabSize;
    832   ULONG ulMemSize=0;
     854  gulong ulParentDataSize=0;
     855  gulong mtabSize;
     856  gulong ulMemSize=0;
    833857  int a;
    834858
    … …  
    856880
    857881  if(!strcmp(*sci->nomClassId, "NOMObject")){
    858     if(pGlobalNomEnv->ncpNOMObject!=NULLHANDLE){
     882    if(pGlobalNomEnv->ncpNOMObject!=NULL){
    859883      DBG_NOMBUILDCLASS(TRUE, "Class %s already built. returning 0x%x\n",
    860884                        *sci->nomClassId, sci->nomCds->nomClassObject);
    861885      /* FIXME: this seems to be broken!! */
    862       return NULLHANDLE; /* NOMObject already built */
     886      return NULL; /* NOMObject already built */
    863887    }
    864888  }
    … …  
    871895  if(sci->ulNumStaticMethods!=0 && !sci->nomSMethods){
    872896    nomPrintf("  !!! %s line %d: sci->nomSMethods is NULL for %s !!!\n", __FUNCTION__, __LINE__, *sci->nomClassId);
    873     return NULLHANDLE;
     897    return NULL;
    874898  }
    875899  /* Fill static classdata with the info from nomStaticMethodDesc array. This means
    … …  
    903927    priv_buildNOMObjectClassInfo(ulReserved, sci, /* yes */
    904928                                 ulMajorVersion, ulMinorVersion);
    905     return NULLHANDLE; /* We can't return a NOMClass for NOMObject because NOMClass isn't built yet. */
     929    return NULL; /* We can't return a NOMClass for NOMObject because NOMClass isn't built yet. */
    906930  }
    907931
    … …  
    914938  if(sci->nomIdAllParents) {
    915939#ifdef DEBUG_NOMBUILDCLASS
     940# ifndef _MSC_VER
    916941#warning !!!!! Change this when nomId is a GQuark !!!!!
     942# endif
    917943    nomPrintf("%d: About to search parent %s...\n", __LINE__, **(sci->nomIdAllParents));
    918944#endif
    … …  
    927953#endif
    928954    if(!ncpParent)
    929       return NULLHANDLE; /* Every class except NOMObject must have a parent!! */
     955      return NULL; /* Every class except NOMObject must have a parent!! */
    930956  }/* nomIdAllParents */
    931957  else
    932     return NULLHANDLE; /* Every class except NOMObject must have a parent!! */
     958    return NULL; /* Every class except NOMObject must have a parent!! */
    933959
    934960  if(!ncpParent)
    935     return NULLHANDLE; /* Every class except NOMObject must have a parent!! */
     961    return NULL; /* Every class except NOMObject must have a parent!! */
    936962
    937963#ifdef DEBUG_NOMBUILDCLASS
    … …  
    10291055
    10301056  /* Alloc class struct using NOMCalloc. */
    1031   if((nClass=(NOMClassPriv*)NOMCalloc(1, ulMemSize))==NULLHANDLE)
    1032     return NULLHANDLE;
     1057  if((nClass=(NOMClassPriv*)NOMCalloc(1, ulMemSize))==NULL)
     1058    return NULL;
    10331059
    10341060#if 0
    … …  
    10391065    if(!nClass->mThunk) {
    10401066      NOMFree(nClass);
    1041       return NULLHANDLE;
     1067      return NULL;
    10421068    }
    10431069  }
    … …  
    10461072  nClass->ulClassSize=sci->ulInstanceDataSize+ulParentDataSize;
    10471073
    1048   if((nomClass=(NOMClass*)NOMCalloc(1, sci->ulInstanceDataSize+ulParentDataSize))==NULLHANDLE) {
     1074  if((nomClass=(NOMClass*)NOMCalloc(1, sci->ulInstanceDataSize+ulParentDataSize))==NULL) {
    10491075    //NOMFree(nClass->mThunk);
    10501076    NOMFree(nClass);
    1051     return NULLHANDLE;
     1077    return NULL;
    10521078  }
    10531079
    … …  
    10581084    NOMFree(nClass);
    10591085    NOMFree(nomClass);
    1060     return NULLHANDLE;
     1086    return NULL;
    10611087  };
    10621088
    … …  
    10881114
    10891115  /* Set this class size into instance var */
     1116#ifndef _MSC_VER
    10901117#warning !!!!! No call of _nomSetInstanceSize() here !!!!!
     1118#endif
    10911119  // _nomSetInstanceSize(nomClass, sci->ulInstanceDataSize+ulParentDataSize);
    10921120
    … …  
    11491177    sID=SOMMalloc(sizeof(void*));
    11501178    if(!sID)
    1151       return NULLHANDLE;
     1179      return NULL;
    11521180
    11531181    *sID=(char*)sid;
    … …  
    11561184
    11571185  /* No somId registered  yet, so create one */
    1158   if((sid=(somIdItem*)SOMCalloc(1, sizeof(somIdItem)))==NULLHANDLE)
    1159     return NULLHANDLE;
     1186  if((sid=(somIdItem*)SOMCalloc(1, sizeof(somIdItem)))==NULL)
     1187    return NULL;
    11601188
    11611189  sid->idString=SOMMalloc(strlen(aString)+1);
    … …  
    11631191    {
    11641192      SOMFree(sid);
    1165       return NULLHANDLE;
     1193      return NULL;
    11661194    }
    11671195
    … …  
    11721200    SOMFree(sid->idString);
    11731201    SOMFree(sid);
    1174     return NULLHANDLE;
     1202    return NULL;
    11751203  }
    11761204
    11771205  sID=SOMMalloc(sizeof(void*));
    11781206  if(!sID)
    1179     return NULLHANDLE;
     1207    return NULL;
    11801208
    11811209  *sID=(char*)sid;
    … …  
    11931221  char* chrPtr;
    11941222  SOMClassPriv *scp;
    1195   ULONG ulLen;
     1223  gulong ulLen;
    11961224  char *chrMem;
    11971225
    11981226  if(!sid)
    1199     return NULLHANDLE;
    1200 
    1201   if((chrPtr=strchr(**sid, ':'))==NULLHANDLE)
    1202     return NULLHANDLE;
     1227    return NULL;
     1228
     1229  if((chrPtr=strchr(**sid, ':'))==NULL)
     1230    return NULL;
    12031231
    12041232  /* Create local copy */
    12051233  ulLen=strlen(**sid);
    12061234  if(ulLen>5000) /* prevent stack overflow in case of error */
    1207     return NULLHANDLE;
     1235    return NULL;
    12081236
    12091237  chrMem=alloca(ulLen);
    12101238  strcpy(chrMem, **sid);
    12111239
    1212   if((chrPtr=strchr(chrMem, ':'))==NULLHANDLE)
    1213     return NULLHANDLE; /* How should that happen, but anyway... */
     1240  if((chrPtr=strchr(chrMem, ':'))==NULL)
     1241    return NULL; /* How should that happen, but anyway... */
    12141242
    12151243  *chrPtr=0; /* Now we have separated the class name */
    … …  
    12221250#endif
    12231251  if(!scp)
    1224     return NULLHANDLE;
     1252    return NULL;
    12251253#ifdef DEBUG_SOMBUILDCLASS
    12261254  somPrintf("%d: %s: found %x (SOMClassPriv) ->%x (SOMClass)\n", __LINE__, __FUNCTION__, scp, scp->mtab->classObject);
    … …  
    12401268  char* chrPtr;
    12411269  SOMClassPriv *scp;
    1242   ULONG ulLen;
     1270  gulong ulLen;
    12431271  char *chrMem;
    12441272
    12451273  if(!sid)
    1246     return NULLHANDLE;
    1247 
    1248   if((chrPtr=strchr(**sid, ':'))==NULLHANDLE)
    1249     return NULLHANDLE;
     1274    return NULL;
     1275
     1276  if((chrPtr=strchr(**sid, ':'))==NULL)
     1277    return NULL;
    12501278
    12511279  /* Create local copy */
    12521280  ulLen=strlen(**sid);
    12531281  if(ulLen>5000) /* prevent stack overflow in case of error */
    1254     return NULLHANDLE;
     1282    return NULL;
    12551283
    12561284  chrMem=alloca(ulLen);
    12571285  strcpy(chrMem, **sid);
    12581286
    1259   if((chrPtr=strchr(chrMem, ':'))==NULLHANDLE)
    1260     return NULLHANDLE; /* How should that happen, but anyway... */
     1287  if((chrPtr=strchr(chrMem, ':'))==NULL)
     1288    return NULL; /* How should that happen, but anyway... */
    12611289
    12621290  *chrPtr=0; /* Now we have separated the class name */
    … …  
    12671295  somPrintf("%d: %s: found %x (SOMClassPriv)\n", __LINE__, __FUNCTION__, scp);
    12681296  if(!scp)
    1269     return NULLHANDLE;
     1297    return NULL;
    12701298#ifdef DEBUG_SOMBUILDCLASS
    12711299  somPrintf("%d: %s: found %x (SOMClassPriv) ->%x\n", __LINE__, __FUNCTION__, scp, scp->mtab->classObject);
    … …  
    12841312  FIXME: semaphores ????
    12851313 */
    1286 static ULONG priv_getIndexOfMethodToBeOverriden(somId *methodId )
     1314static gulong priv_getIndexOfMethodToBeOverriden(somId *methodId )
    12871315{
    12881316  return 0;
    … …  
    12971325  struct somMethodTabListStruct;
    12981326  struct somParentMtabStruct;               Struct to place parent mtab pointer
    1299   ULONG  thunk[3];                       Assembler thunking code
     1327  gulong  thunk[3];                       Assembler thunking code
    13001328  somMethodTabStruct mtabStruct;         See beloe
    13011329  ClassDataStruct class1;
    … …  
    13671395                                       long minorVersion)
    13681396{
    1369   BYTE * mem;
     1397  guint8 * mem;
    13701398  SOMClassPriv *sClass; /* This struct holds our private data. A pointer will be in mtab->classInfo */
    13711399  SOMClass *somClass;   /* A real SOMClass pointer */
    13721400  int a;
    1373   ULONG mtabSize;
    1374   ULONG ulMemSize=0;
    1375   ULONG ulParentDataSize=0;
     1401  gulong mtabSize;
     1402  gulong ulMemSize=0;
     1403  gulong ulParentDataSize=0;
    13761404
    13771405#ifdef DEBUG_BUILDSOMOBJECT
    … …  
    13821410
    13831411  /* Note: SOMObject has no parents */
    1384   return NULLHANDLE;
     1412  return NULL;
    13851413 
    13861414  /* ulMemsize will be the size of our private class structure SOMClassPriv */
    … …  
    13971425
    13981426  /* Alloc private class struct using SOMCalloc. */
    1399   if((sClass=(SOMClassPriv*)SOMCalloc(1, ulMemSize))==NULLHANDLE)
    1400     return NULLHANDLE;
     1427  if((sClass=(SOMClassPriv*)SOMCalloc(1, ulMemSize))==NULL)
     1428    return NULL;
    14011429
    14021430  /* Get mem for method thunking code. This assembler code is needed so the indirect
    … …  
    14071435  if(!sClass->mThunk) {
    14081436    SOMFree(sClass);
    1409     return NULLHANDLE;
     1437    return NULL;
    14101438  }
    14111439
    … …  
    14251453  /* And now the real SOMClass struct which will be seen by the user. A SOMClass has a mTab pointer
    14261454     at the beginning and the instance data following. */
    1427   if((somClass=(SOMClass*)SOMCalloc(1, sci->instanceDataSize+sizeof(somMethodTab*)))==NULLHANDLE) {
     1455  if((somClass=(SOMClass*)SOMCalloc(1, sci->instanceDataSize+sizeof(somMethodTab*)))==NULL) {
    14281456    SOMFree(sClass->mThunk);
    14291457    SOMFree(sClass);
    1430     return NULLHANDLE;
     1458    return NULL;
    14311459  }
    14321460  somClass->mtab=sClass->mtab;
    … …  
    14611489    /* Now finally put the thunking in so the procedures are resolved correctly. */
    14621490    for(a=0;a<sci->numStaticMethods;a++) {
    1463       ULONG ulOffset;
     1491      gulong ulOffset;
    14641492
    14651493      memcpy(&sClass->mThunk[a], mThunkCode, sizeof(mThunkCode));               /* Copy method thunking code template  */
    1466       ulOffset=(ULONG)((char*)(mem+sizeof(SOMClass*))-(char*)somClass->mtab);   /* Skip priv class data pointer        */
     1494      ulOffset=(gulong)((char*)(mem+sizeof(SOMClass*))-(char*)somClass->mtab);   /* Skip priv class data pointer        */
    14671495      sClass->mThunk[a].thunk[2]=((ulOffset+a*sizeof(somMethodProc*))<<8)+0xa2; /* Calculate offset for assembler code */
    14681496#ifdef DEBUG_BUILDSOMOBJECT

  • trunk/nom/src/nombuildnomcls.c

    r255 r326  
    3333* ***** END LICENSE BLOCK ***** */
    3434
    35 #define INCL_DOS
    36 #define INCL_DOSERRORS
    37 
    38 #include <os2.h>
     35#ifdef __OS2__
     36# define INCL_DOS
     37# define INCL_DOSERRORS
     38# include <os2.h>
     39#endif /* __OS2__ */
     40
    3941#include <stdio.h>
    4042
    … …  
    6365    #define BUILDNOMCLASS_ENTER
    6466    #define BUILDNOMCLASS_LEAVE
     67#   ifdef _MSC_VER
     68void _inline DBG_BUILDNOMCLASS(gboolean a, const char *msg, ...)
     69{
     70    /* sorry, nothing here. */
     71}
     72#   else
    6573    #define DBG_BUILDNOMCLASS(a, b,...)
     74#   endif
    6675#endif
    6776
    … …  
    7180
    7281extern PNOM_ENV pGlobalNomEnv;
    73 extern ULONG thunk[];
    74 extern ULONG mThunkCode[];
     82extern gulong thunk[];
     83extern gulong mThunkCode[];
    7584
    7685/********************************************************/
    … …  
    119128
    120129  /* Alloc private class struct using SOMCalloc. */
    121   if((nClass=(NOMClassPriv*)NOMCalloc(1, gulMemSize))==NULLHANDLE)
    122     return NULLHANDLE;
     130  if((nClass=(NOMClassPriv*)NOMCalloc(1, gulMemSize))==NULL)
     131    return NULL;
    123132
    124133  /* Get mem for method thunking code. This assembler code is needed so the indirect
    … …  
    132141    if(!nClass->mThunk) {
    133142      NOMFree(nClass);
    134       return NULLHANDLE;
     143      return NULL;
    135144    }
    136145  }
    … …  
    150159  if(!addMethodAndDataToThisPrivClassStruct( nClass, ncpParent, sci)){
    151160    NOMFree(nClass);
    152     return NULLHANDLE;
     161    return NULL;
    153162  };
    154163
    … …  
    158167  nClass->mtab->mtabSize=mtabSize;
    159168  nClass->mtab->nomClsInfo=(nomClassInfo*)nClass;  /* Hold a pointer to the private data that is this NOMClassPriv */
     169#ifndef _MSC_VER
    160170#warning !!!!! Change this when nomId is a GQuark !!!!!
     171#endif
    161172  nClass->mtab->nomClassName=*sci->nomClassId;
    162173  nClass->mtab->ulInstanceSize=sci->ulInstanceDataSize+gulParentDataSize; /* Size of instance data of this class and all
    … …  
    205216  else{
    206217    g_error("No NOMObject while trying to build NOMClass."); /* This will result in a termination of the app! */
    207     return NULLHANDLE;                                       /* NOMClass *must* have an object as parent!
     218    return NULL;                                       /* NOMClass *must* have an object as parent!
    208219                                                                We won't reach this point */
    209220  }
    … …  
    223234
    224235  /* Build the NOMClassPriv for NOMClass */
    225   if((nClass=buildNOMClassPrivStruct(sci, ncpParent))==NULLHANDLE)
    226     return NULLHANDLE;
     236  if((nClass=buildNOMClassPrivStruct(sci, ncpParent))==NULL)
     237    return NULL;
    227238
    228239  ulParentDataSize=ncpParent->mtab->ulInstanceSize; /* Parent instance size. This is the mtab pointer + instance vars */
    … …  
    231242  /* And now the NOMClass struct. A NOMClass has a mTab pointer at the beginning and the instance data
    232243     following (including the parent instance data).*/
    233   if((nomClass=(NOMClass*)NOMCalloc(1, sci->ulInstanceDataSize+ulParentDataSize))==NULLHANDLE) {
     244  if((nomClass=(NOMClass*)NOMCalloc(1, sci->ulInstanceDataSize+ulParentDataSize))==NULL) {
    234245    NOMFree(nClass->mThunk);
    235246    NOMFree(nClass);
    236     return NULLHANDLE;
     247    return NULL;
    237248  }
    238249
    … …  
    274285  pGlobalNomEnv->defaultMetaClass=nomClass;
    275286
     287#ifndef _MSC_VER
    276288#warning !!!!! _nomSetInstanceSize() not called !!!!!
     289#endif
    277290#if 0
    278291  /* Set this class size into instance var */
    … …  
    281294
    282295  /* Run initialization code if any */
    283   _nomInit(nomClass, NULLHANDLE);
     296  _nomInit(nomClass, NULL);
    284297  return nomClass;
    285298}

  • trunk/nom/src/nombuildnomobj.c

    r255 r326  
    3333* ***** END LICENSE BLOCK ***** */
    3434
    35 #define INCL_DOS
    36 #define INCL_DOSERRORS
    37 
    38 #include <os2.h>
     35#ifdef __OS2__
     36# define INCL_DOS
     37# define INCL_DOSERRORS
     38# include <os2.h>
     39#endif /* __OS2__ */
     40
    3941#include <stdio.h>
    4042#include <string.h>
    … …  
    6769*/
    6870
    69 static ULONG thunk[]={0x0424448b, 0x00000405, 0x0000c300};
     71static gulong thunk[]={0x0424448b, 0x00000405, 0x0000c300};
    7072
    7173/*
    … …  
    7476JMP DWORD PTR [EDX+0ACh]  : JMP to address pointing to by EDX+0ACh
    7577 */
    76 static ULONG mThunkCode[]={0x04244c8b, 0xff00518b, 0x0000aca2 , 0x16000000};
     78static gulong mThunkCode[]={0x04244c8b, 0xff00518b, 0x0000aca2 , 0x16000000};
    7779
    7880/********************************************************/
    … …  
    100102  gulong mtabSize;
    101103  gulong ulMemSize=0;
    102   BYTE * mem;
     104  guint8 * mem;
    103105  int a;
    104106
    … …  
    116118 
    117119  /* Alloc private class struct using NOMCalloc. */
    118   if((nClass=(NOMClassPriv*)NOMCalloc(1, ulMemSize))==NULLHANDLE)
    119     return NULLHANDLE;
     120  if((nClass=(NOMClassPriv*)NOMCalloc(1, ulMemSize))==NULL)
     121    return NULL;
    120122 
    121123
    … …  
    138140  nClass->mtab->mtabSize=mtabSize;        /* This mtab is the same as the one used in the public NOMClass */
    139141  nClass->mtab->nomClsInfo=(nomClassInfo*)nClass;        /* Hold a pointer to the private data that is this NOMClassPriv */
     142#ifndef _MSC_VER
    140143#warning !!!!! Change this when nomId is a GQuark !!!!!
     144#endif
    141145  nClass->mtab->nomClassName=*sci->nomClassId;
    142146  nClass->mtab->ulInstanceSize=sci->ulInstanceDataSize+sizeof(nomMethodTabPtr); /* sizeof(methodTabStruct*) + size of instance data of this class
    … …  
    151155    if(!nClass->mThunk) {
    152156      NOMFree(nClass);
    153       return NULLHANDLE;
     157      return NULL;
    154158    }
    155159  }
    … …  
    172176    /* Now finally put the thunking in so the procedures are resolved correctly. */
    173177    for(a=0;a<sci->ulNumStaticMethods;a++) {
    174       ULONG ulOffset;
     178      gulong ulOffset;
    175179
    176180      memcpy(&nClass->mThunk[a], mThunkCode, sizeof(mThunkCode));               /* Copy method thunking code template  */
    177       ulOffset=(ULONG)((char*)(mem+sizeof(NOMClass*))-(char*)nClass->mtab);     /* Skip priv class data pointer        */
     181      ulOffset=(gulong)((char*)(mem+sizeof(NOMClass*))-(char*)nClass->mtab);     /* Skip priv class data pointer        */
    178182      nClass->mThunk[a].thunk[2]=((ulOffset+a*sizeof(nomMethodProc*))<<8)+0xa2; /* Calculate offset for assembler code */
    179183#ifdef DEBUG_BUILDNOMOBJECT
    … …  
    202206{
    203207  NOMClassPriv *nClassPriv; /* This struct holds our private data. A pointer will be in mtab->nomClsInfo */
    204   ULONG ulParentDataSize=0;
     208  gulong ulParentDataSize=0;
    205209
    206210#ifdef DEBUG_BUILDNOMOBJECT
    … …  
    210214
    211215  /* Note: NOMObject has no parents */
    212   if((nClassPriv=buildNOMClassPrivStructForNOMObject(sci))==NULLHANDLE)
    213     return NULLHANDLE;
     216  if((nClassPriv=buildNOMClassPrivStructForNOMObject(sci))==NULL)
     217    return NULL;
    214218
    215219#ifdef DEBUG_BUILDNOMOBJECT
    … …  
    221225  sci->ccds->parentMtab->mtab=nClassPriv->mtab;         /* This class mtab                               */
    222226  sci->ccds->parentMtab->next=NULL;                     /* We dont have parents because we are NOMObject */
    223   sci->ccds->parentMtab->nomClassObject=NULLHANDLE;     /* NOMClass* Class object. We don't have one yet */
     227  sci->ccds->parentMtab->nomClassObject=NULL;     /* NOMClass* Class object. We don't have one yet */
    224228  sci->ccds->parentMtab->ulInstanceSize=nClassPriv->mtab->ulInstanceSize;
    225229  /* C Class data structure */
    … …  
    267271
    268272  /* Run initialization code if any */
    269   _nomInit((NOMObject*)nClassPriv, NULLHANDLE);
    270   return NULLHANDLE;
     273  _nomInit((NOMObject*)nClassPriv, NULL);
     274  return NULL;
    271275}
    272276

  • trunk/nom/src/nomdebug.c

    r281 r326  
    3333* ***** END LICENSE BLOCK ***** */
    3434
    35 #define INCL_DOS
    36 #define INCL_DOSFILEMGR
    37 #define INCL_DOSERRORS
    38 #define INCL_WIN
    39 #define INCL_WINWORKPLACE
    40 #define INCL_OS2MM
    41 #define INCL_MMIOOS2
    42 #define INCL_MCIOS2
    43 #define INCL_GPI
    44 #define INCL_PM
    45 
    46 #include <os2.h>
     35#ifdef __OS2__
     36# define INCL_DOS
     37# define INCL_DOSFILEMGR
     38# define INCL_DOSERRORS
     39# define INCL_WIN
     40# define INCL_WINWORKPLACE
     41# define INCL_OS2MM
     42# define INCL_MMIOOS2
     43# define INCL_MCIOS2
     44# define INCL_GPI
     45# define INCL_PM
     46# include <os2.h>
     47#endif /* __OS2__ */
     48
    4749#include <stdarg.h>
    4850#include <stdio.h>
    … …  
    6567      g_error("The object used to call the method %s is not a valid NOM object. ", chrMethodName);
    6668    else
    67       g_error("The object for which the method %s should be called is not valid for this method.\nThe object must be some instance of class %s (or of a subclass) but is a %s.", chrMethodName, NOMClass_nomGetCreatedClassName(nomClass, NULLHANDLE),
    68                 NOMObject_nomGetClassName(nomObject, NULLHANDLE));
     69      g_error("The object for which the method %s should be called is not valid for this method.\nThe object must be some instance of class %s (or of a subclass) but is a %s.", chrMethodName, NOMClass_nomGetCreatedClassName(nomClass, NULL),
     70                NOMObject_nomGetClassName(nomObject, NULL));
    6971  }
    7072}
    … …  
    114116
    115117  //  g_message("In %s with %s %px nomClass: %px (%s)", __FUNCTION__, chrMethodName, nomSelf, nomClass, nomClass->mtab->nomClassName);
    116   if(!nomIsObj(nomSelf) || !_nomIsANoClsCheck(nomSelf, nomClass, NULLHANDLE))
     118  if(!nomIsObj(nomSelf) || !_nomIsANoClsCheck(nomSelf, nomClass, NULL))
    117119    {
    118120      nomPrintObjectPointerErrorMsg(nomSelf, nomClass, chrMethodName);
    … …  
    154156  nomPrintf("----- %s -----  NOMClassMgrObject: %lx\n", __FUNCTION__, NOMClassMgrObject);
    155157
    156   pgdata=_nomGetClassList(NOMClassMgrObject, NULLHANDLE);
     158  pgdata=_nomGetClassList(NOMClassMgrObject, NULL);
    157159  if(pgdata){
    158160    nomPrintf("%s: classlist: %lx\n", __FUNCTION__, pgdata);
    … …  
    176178    nomPrintf("explicitMetaId (meta class): %s\n", *sci->nomExplicitMetaId);
    177179  else
    178     nomPrintf("explicitMetaId (meta class): NULLHANDLE\n");
     180    nomPrintf("explicitMetaId (meta class): NULL\n");
    179181  //  somPrintf("*parents: 0x%x\n", sci->parents);
    180182  nomPrintf("somClassDataStructure cds: 0x%x\n",sci->nomCds);
    … …  
    190192
    191193
    192 void _dumpClassDataStruct(nomClassDataStructure* cds, ULONG ulNumMethods)
     194void _dumpClassDataStruct(nomClassDataStructure* cds, gulong ulNumMethods)
    193195{
    194196  int a;
    … …  
    215217  nomPrintf("  instanceSize (this and all parents): %d 0x%x\n", mtab->ulInstanceSize, mtab->ulInstanceSize);
    216218  nomPrintf("  mtabSize: %d 0x%x\n", mtab->mtabSize, mtab->mtabSize);
    217   nomPrintf("  somMethodProcs: (%ld)\n", (mtab->mtabSize-(LONG)sizeof(nomMethodTab))/4);
     219  nomPrintf("  somMethodProcs: (%ld)\n", (mtab->mtabSize-(glong)sizeof(nomMethodTab))/4);
    218220  //  entries=sObj->mtab->entries[0];
    219221   for(a=0; a<=(mtab->mtabSize-sizeof(nomMethodTab))/4; a++)
    … …  
    234236  nomPrintf("*classInfo: 0x%x\n", *sObj->mtab->nomClsInfo);
    235237
    236   so=(ULONG*)sObj->mtab->classInfo;
     238  so=(gulong*)sObj->mtab->classInfo;
    237239#endif
    238240  nomPrintf("className: %s\n", sObj->mtab->nomClassName);
    … …  
    249251
    250252#if 0
    251 void _dumpStaticMTab(somStaticMethod_t* smt, ULONG ulMethod)
     253void _dumpStaticMTab(somStaticMethod_t* smt, gulong ulMethod)
    252254{
    253255  somStaticMethod_t* tmpSmt=&smt[ulMethod];
    … …  
    262264}
    263265
    264 void _dumpOverrideMTab(somOverrideMethod_t* omt, ULONG ulMethod)
     266void _dumpOverrideMTab(somOverrideMethod_t* omt, gulong ulMethod)
    265267{
    266268  somOverrideMethod_t* tmpOmt=&omt[ulMethod];
    … …  
    300302      tempPtr=(void*)tempPtr->next->mtab;
    301303    else
    302       tempPtr=NULLHANDLE;
     304      tempPtr=NULL;
    303305  }
    304306
    … …  
    400402  somPrintf("  instanceSize (this and all parents): %d 0x%x\n", sObj->mtab->instanceSize, sObj->mtab->instanceSize);
    401403  somPrintf("  mtabSize: %d 0x%x\n", sObj->mtab->mtabSize, sObj->mtab->mtabSize);
    402   somPrintf("  somMethodProcs: (%ld)\n", (sObj->mtab->mtabSize-(LONG)sizeof(somMethodTab))/4);
     404  somPrintf("  somMethodProcs: (%ld)\n", (sObj->mtab->mtabSize-(glong)sizeof(somMethodTab))/4);
    403405  //  entries=sObj->mtab->entries[0];
    404406   for(a=0; a<=(sObj->mtab->mtabSize-sizeof(somMethodTab))/4; a++)

  • trunk/nom/src/nomgc.c

    r286 r326  
    3737 */
    3838
    39 #define INCL_DOS
    40 #define INCL_DOSERRORS
    41 #define INCL_DOSMEMMGR
    42 #include <os2.h>
     39#ifdef __OS2__
     40# define INCL_DOS
     41# define INCL_DOSERRORS
     42# define INCL_DOSMEMMGR
     43# include <os2.h>
     44#endif /* __OS2__ */
    4345
    4446#include <stdio.h>
    … …  
    8385  memory functions as the GLIB default allocation function.
    8486 */
     87#ifdef __OS2__
    8588void _System  nomInitGarbageCollection(void* pMemInExe)
     89#else
     90void nomInitGarbageCollection(void* pMemInExe)
     91#endif
    8692{
    8793 GMemVTable vtbl={0};
    … …  
    98104
    99105 /* Cretea tree holding the already registered DLLs */
     106#ifdef _MSC_VER
    100107 treeRegisteredDLL=g_tree_new((GCompareFunc)stricmp);
     108#else
     109 treeRegisteredDLL=g_tree_new((GCompareFunc)strcasecmp);
     110#endif
    101111
    102112 bUseGC=TRUE;
    … …  
    104114
    105115
     116#ifdef __OS2__
    106117void test()
    107118{
    … …  
    110121  HMODULE hModule;
    111122
    112   if(DosQueryModFromEIP( &hModule, &ulObj, CCHMAXPATH, thePath, &ulOffset, (ULONG)test)!=0) {
     123  if(DosQueryModFromEIP( &hModule, &ulObj, CCHMAXPATH, thePath, &ulOffset, (gulong)test)!=0) {
    113124    hModule=0;
    114125    return ; /* Error */
    … …  
    116127
    117128}
     129#endif /* __OS2__ */
    118130
    119131NOMEXTERN void NOMLINK  nomRegisterDataAreaForGC(char* pStart, char* pEnd)
    … …  
    122134}
    123135
     136#ifdef __OS2__
     137
    124138static void qsAddDLLToList(HREGDLL hReg, qsLrec_t* rec)
    125139{
    126   if(NULLHANDLE==g_slist_find(hReg->dllList, rec))
     140  if(NULL==g_slist_find(hReg->dllList, rec))
    127141    hReg->dllList=g_slist_append(hReg->dllList, rec);
    128142}
    … …  
    160174      /* g_message("%d Checking: %x -> %04X (%s)", a, pModRec, pModRec->hmte, pModRec->pName); */
    161175
    162       if (NULLHANDLE==pModRec->pObjInfo   && pModRec->ctObj > 0)
     176      if (NULL==pModRec->pObjInfo   && pModRec->ctObj > 0)
    163177        {
    164178          pModRec->pObjInfo = (qsLObjrec_t*)((char*)pModRec
    … …  
    179193}
    180194
     195
    181196/**
    182197   Get the info about the current DLLs from OS/2. Go over all found
    … …  
    187202NOMEXTERN HREGDLL NOMLINK nomBeginRegisterDLLWithGC(void)
    188203{
    189   ULONG rc;
    190   HREGDLL hReg=NULLHANDLE;
     204  gulong rc;
     205  HREGDLL hReg=NULL;
    191206  PTIB     ptib;
    192207  PPIB     ppib;
    193208  char *  buf;
    194   HREGDLL  pRegDLL=NULLHANDLE;
     209  HREGDLL  pRegDLL=NULL;
    195210
    196211  rc = DosGetInfoBlocks(&ptib, &ppib);
    197212  if (rc!=NO_ERROR)
    198     return NULLHANDLE;
     213    return NULL;
    199214
    200215  buf = malloc(BUFSIZE);
    201216  if(!buf)
    202     return NULLHANDLE;
     217    return NULL;
    203218
    204219  pRegDLL =(HREGDLL) malloc(sizeof(REGDLL));
    205220  if(!pRegDLL){
    206221    free(buf);
    207     return NULLHANDLE;
     222    return NULL;
    208223  }
    209   pRegDLL->dllList=NULLHANDLE;
     224  pRegDLL->dllList=NULL;
    210225
    211226  memset(buf,0,BUFSIZE);
    … …  
    303318#define OBJWRITE        0x0002L
    304319#define OBJINVALID      0x0080L
    305 NOMEXTERN BOOL NOMLINK nomRegisterDLLByName(const HREGDLL hRegisterDLL, const char* chrDLLName)
     320NOMEXTERN gboolean NOMLINK nomRegisterDLLByName(const HREGDLL hRegisterDLL, const char* chrDLLName)
    306321{
    307322  GSList* lTemp;
    … …  
    316331      if(pModRec){
    317332        //  g_message("DLL name: %s", pModRec->pName);
    318         if(pModRec->pName && (NULLHANDLE!=strstr( pModRec->pName, chrDLLName)))
     333        if(pModRec->pName && (NULL!=strstr( pModRec->pName, chrDLLName)))
    319334          {
    320335            qsLObjrec_t  *pObjInfo;
    321336            //g_message("    --> Found DLL %s", pModRec->pName);
    322337            pObjInfo=pModRec->pObjInfo;
    323             if(NULLHANDLE!=pObjInfo)
     338            if(NULL!=pObjInfo)
    324339              {
    325340                int iObj;
    … …  
    344359}
    345360
    346 
    347 NOMEXTERN BOOL NOMLINK nomQueryUsingNameIsDLLRegistered(const gchar *chrName)
    348 {
    349   if(NULLHANDLE!=g_tree_lookup(treeRegisteredDLL, chrName))
     361//#elif defined(_WIN32)
     362#else /* PORTME */
     363
     364NOMEXTERN HREGDLL NOMLINK nomBeginRegisterDLLWithGC(void)
     365{
     366    HREGDLL pRegDLL;
     367
     368    pRegDLL =(HREGDLL) malloc(sizeof(REGDLL));
     369    if(pRegDLL)
     370      pRegDLL->dllList=NULL;
     371    return pRegDLL;
     372}
     373
     374NOMEXTERN void NOMLINK nomEndRegisterDLLWithGC(const HREGDLL hRegisterDLL )
     375{
     376}
     377
     378NOMEXTERN gboolean NOMLINK nomRegisterDLLByName(const HREGDLL hRegisterDLL, const char* chrDLLName)
     379{
    350380    return TRUE;
     381}
     382
     383#endif
     384
     385NOMEXTERN gboolean NOMLINK nomQueryUsingNameIsDLLRegistered(const gchar *chrName)
     386{
     387  if(NULL!=g_tree_lookup(treeRegisteredDLL, chrName))
     388    return TRUE;
    351389
    352390  return FALSE;

  • trunk/nom/src/nomid.c

    r190 r326  
    3333* ***** END LICENSE BLOCK ***** */
    3434
    35 #define INCL_DOS
    36 #define INCL_DOSERRORS
    37 
    38 #include <os2.h>
     35#ifdef __OS2__
     36# define INCL_DOS
     37# define INCL_DOSERRORS
     38# include <os2.h>
     39#endif /* __OS2__ */
    3940
    4041#include "nom.h"

  • trunk/nom/src/nommemory.c

    r193 r326  
    3333* ***** END LICENSE BLOCK ***** */
    3434
    35 #define INCL_DOS
    36 #define INCL_DOSERRORS
    37 #define INCL_DOSMEMMGR
     35#ifdef __OS2__
     36# define INCL_DOS
     37# define INCL_DOSERRORS
     38# define INCL_DOSMEMMGR
     39# include <os2.h>
     40#endif /* __OS2__ */
    3841
    39 #include <os2.h>
    4042
    4143#include <string.h>
    4244#include <stdlib.h>
    4345
    44 #include <gtk/gtk.h>
     46/* #include <gtk/gtk.h> - why? */
    4547#include <nom.h>
    4648#include <nomtk.h>
    … …  
    4951extern gboolean bUseGC; /* Set during initialization */
    5052
    51 NOMEXTERN nomToken NOMLINK NOMMalloc(ULONG size)
     53NOMEXTERN nomToken NOMLINK NOMMalloc(const gulong size)
    5254{
    5355  gchar* memPtr;
    5456
    55   if((memPtr=g_malloc(size))==NULLHANDLE)
    56     return NULLHANDLE;
     57  if((memPtr=g_malloc(size))==NULL)
     58    return NULL;
    5759
    5860  return (nomToken) memPtr;
    … …  
    6163  PULONG memPtr;
    6264
    63   if((memPtr=g_malloc(size+sizeof(gpointer)))==NULLHANDLE)
    64     return NULLHANDLE;
     65  if((memPtr=g_malloc(size+sizeof(gpointer)))==NULL)
     66    return NULL;
    6567
    6668  *memPtr=size;
    … …  
    7072}
    7173
    72 nomToken NOMLINK NOMCalloc(const ULONG num, const ULONG size)
     74nomToken NOMLINK NOMCalloc(const gulong num, const gulong size)
    7375{
    7476  gchar* memPtr;
    7577
    76   if((memPtr=g_malloc(size*num ))==NULLHANDLE)
    77     return NULLHANDLE; /* We won't end here because GLib just terminates the process :-/
     78  if((memPtr=g_malloc(size*num ))==NULL)
     79    return NULL; /* We won't end here because GLib just terminates the process :-/
    7880                          A really sick idea imho. */
    7981  if(!bUseGC)
    … …  
    8587  PULONG memPtr;
    8688
    87   if((memPtr=g_malloc(size*num + sizeof(ULONG)))==NULLHANDLE)
    88     return NULLHANDLE; /* We won't end here because GLib just terminates the process :-/
     89  if((memPtr=g_malloc(size*num + sizeof(gulong)))==NULL)
     90    return NULL; /* We won't end here because GLib just terminates the process :-/
    8991                          A really sick idea imho. */
    9092  if(!bUseGC)
    91     memset(memPtr, 0, size*num + sizeof(ULONG)); /* GC always returns zeroed memory */
     93    memset(memPtr, 0, size*num + sizeof(gulong)); /* GC always returns zeroed memory */
    9294
    9395  *memPtr=size;
    … …  
    103105{
    104106#if 0
    105   ULONG* pul=(PULONG)memPtr;
     107  gulong* pul=(PULONG)memPtr;
    106108
    107109  pul--;

  • trunk/nom/src/nomtkinit.c

    r284 r326  
    3333* ***** END LICENSE BLOCK ***** */
    3434
    35 #define INCL_DOS
    36 #define INCL_DOSERRORS
    37 #define INCL_DOSMEMMGR
    38 #include <os2.h>
     35#ifdef __OS2__
     36# define INCL_DOS
     37# define INCL_DOSERRORS
     38# define INCL_DOSMEMMGR
     39# include <os2.h>
     40#endif /* __OS2__ */
    3941
    4042#include <stdarg.h>
    … …  
    5961PNOM_ENV pGlobalNomEnv;
    6062/* Global class manager object */
    61 NOMClassMgr* NOMClassMgrObject=NULLHANDLE; /* Referenced from different files */
     63NOMClassMgr* NOMClassMgrObject=NULL; /* Referenced from different files */
    6264
    6365gboolean fInitialized=FALSE;
    … …  
    8082{
    8183  if(NOMClassMgrObject)
    82     return NOMClassMgr_nomIsObject(NOMClassMgrObject, (PNOMObject)nomObj, NULLHANDLE);
     84    return NOMClassMgr_nomIsObject(NOMClassMgrObject, (PNOMObject)nomObj, NULL);
    8385
    8486  if(!nomObj)
    … …  
    104106NOMEXTERN PNOM_ENV NOMLINK nomTkInit(void)
    105107{
    106   PVOID memPtr;
     108  void *memPtr;
    107109
    108110  if(pGlobalNomEnv)
    … …  
    170172
    171173  /* Now register the classes we already have */
    172   _nomClassReady(pGlobalNomEnv->defaultMetaClass, NULLHANDLE); //NOMClass
    173   _nomClassReady(  _NOMClassMgr, NULLHANDLE); //NOMClassMgr
     174  _nomClassReady(pGlobalNomEnv->defaultMetaClass, NULL); //NOMClass
     175  _nomClassReady(  _NOMClassMgr, NULL); //NOMClassMgr
    174176  ncPriv=(NOMClassPriv*)pGlobalNomEnv->nomObjectMetaClass->mtab->nomClsInfo;
    175177
    176178  /* Do not register the NOMObject metaclass here. It's already registered because it's
    177179     NOMClass in fact. */
    178   _nomClassReady(_NOMObject, NULLHANDLE); //NOMObject
     180  _nomClassReady(_NOMObject, NULL); //NOMObject
    179181
    180182
    … …  
    186188
    187189  nomPrintf("\nCalling _nomTestFunc_NOMTest2() 1\n", nomTst2Obj);
    188   _nomTestFunc_NOMTest2(nomTst2Obj, NULLHANDLE);
     190  _nomTestFunc_NOMTest2(nomTst2Obj, NULL);
    189191  nomPrintf("\nCalling _nomTestFuncString_NOMTest2() 1\n", nomTst2Obj);
    190   nomPrintf("--> %s\n",_nomTestFuncString_NOMTest2(nomTst2Obj, NULLHANDLE));
     192  nomPrintf("--> %s\n",_nomTestFuncString_NOMTest2(nomTst2Obj, NULL));
    191193  nomPrintf("\nCalling _nomTestFunc_NOMTest2() 2\n", nomTst2Obj);
    192   _nomTestFunc_NOMTest2(nomTst2Obj, NULLHANDLE);
     194  _nomTestFunc_NOMTest2(nomTst2Obj, NULL);
    193195
    194196  nomPrintf("\nCalling _nomTestFunc() with NOMTest2 object: %x\n", nomTst2Obj);
    195   _nomTestFunc(nomTst2Obj, NULLHANDLE);
     197  _nomTestFunc(nomTst2Obj, NULL);
    196198  nomPrintf("\nCalling _nomTestFuncString() with NOMTest2: %x\n", nomTst2Obj);
    197   nomPrintf("--> %s\n",_nomTestFuncString(nomTst2Obj, NULLHANDLE));
     199  nomPrintf("--> %s\n",_nomTestFuncString(nomTst2Obj, NULL));
    198200  nomPrintf("\n");
    199   _nomTestFunc(nomTst2Obj, NULLHANDLE);
    200   _nomTestFunc_NOMTest2(nomTst2Obj, NULLHANDLE);
     201  _nomTestFunc(nomTst2Obj, NULL);
     202  _nomTestFunc_NOMTest2(nomTst2Obj, NULL);
    201203#endif
    202204  /* This must be done last! */
Note: See TracChangeset for help on using the changeset viewer.