Changeset 21717 for branches/gcc-kmk/src


Ignore:
Timestamp:
Oct 18, 2011, 9:16:41 PM (14 years ago)
Author:
dmik
Message:

Use const char * for arguments accepting literal strings.

This is more correct and also clears GCC warnings.

Location:
branches/gcc-kmk/src
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • branches/gcc-kmk/src/kernel32/HandleManager.cpp

    r21374 r21717  
    533533 *****************************************************************************/
    534534
    535 DWORD   HMDeviceRegisterEx(LPSTR           pszDeviceName,
     535DWORD   HMDeviceRegisterEx(LPCSTR          pszDeviceName,
    536536                           HMDeviceHandler *pDeviceHandler,
    537537                           VOID            *pDevData)
    … …  
    564564}
    565565
    566 DWORD   HMDeviceRegister(LPSTR           pszDeviceName,
     566DWORD   HMDeviceRegister(LPCSTR          pszDeviceName,
    567567                         HMDeviceHandler *pDeviceHandler)
    568568{

  • branches/gcc-kmk/src/kernel32/_ras.cpp

    r21342 r21717  
    1818
    1919/* RAS functions to isolate all RAS related services:
    20  * 
     20 *
    2121 * - Common statistic functions to track objects allocations/deallocations.
    2222 *
    … …  
    2929 * Note: RAS subsystem does not use any other Odin subsystem, and IMO must not.
    3030 *       That is RAS has its own heap, serialization, logging.
    31  *       External stuff that is used: 
     31 *       External stuff that is used:
    3232 *           - from Odin: asm helpers from interlock.asm
    3333 *           - from libc: uheap functions
    34  *       
     34 *
    3535 *       The following has been borrowed from other Odin parts and adapted:
    3636 *           - critical section
    … …  
    4848typedef struct _RAS_TRACK RAS_TRACK;
    4949
    50 typedef struct _RAS_OBJECT_INFO 
     50typedef struct _RAS_OBJECT_INFO
    5151{
    5252    struct _RAS_OBJECT_INFO *next;
    5353    struct _RAS_OBJECT_INFO *prev;
    54    
     54
    5555    RAS_TRACK_HANDLE h;
    56    
     56
    5757    ULONG objident;
    5858    ULONG usecount;
    59    
     59
    6060    ULONG objhandle;
    61    
     61
    6262    void *objdata;
    6363    ULONG cbobjdata;
    64    
     64
    6565    char userdata[1];
    6666} RAS_OBJECT_INFO;
    … …  
    7373    RAS_OBJECT_INFO *objfirst;
    7474    RAS_OBJECT_INFO *objlast;
    75    
     75
    7676    char objname[80];
    77    
     77
    7878    ULONG cbuserdata;
    79    
     79
    8080    ULONG fLogObjectContent: 1;
    8181    ULONG fMemory: 1;
    8282    ULONG fLogAtExit: 1;
    8383    ULONG fLogObjectsAtExit: 1;
    84    
     84
    8585    FNLOC *pfnLogObjectContent;
    8686    FNCOC *pfnCompareObjectContent;
    87    
     87
    8888    /* Used when fMemory = 1 for RasTrackAlloc, Realloc and Free calls */
    8989    ULONG cAllocs;
    9090    ULONG cFrees;
    9191    ULONG cbTotalAllocated;
    92    
     92
    9393};
    9494
    … …  
    119119
    120120    ULONG hlogfile;         // filehandle if default logging functions are used
    121    
     121
    122122    HMODULE hmod;
    123123} RasLogChannel;
    … …  
    126126{
    127127    HMODULE hmod;           // handle of this dll
    128    
     128
    129129    RasLogChannel rlc;
    130    
     130
    131131    Heap_t rasheap;
    132132    void *pHeapMem;
    133133    ULONG ulRefCount;
    134134    ULONG flAllocMem;
    135    
     135
    136136    HMODULE hmodPlugin;
    137    
     137
    138138    RasEntryTable ret;
    139139    RasPluginEntryTable pet;
    … …  
    181181
    182182    DosGetInfoBlocks(&ptib, &ppib);
    183    
     183
    184184    return ppib->pib_ulpid << 16 | ptib->tib_ptib2->tib2_ultid;
    185185}
    … …  
    188188{
    189189    int rc = NO_ERROR;
    190    
     190
    191191    rc = DosCreateEventSem (NULL, &crit->hevLock, DC_SEM_SHARED, 0);
    192        
     192
    193193    if (rc != NO_ERROR)
    194194    {
    195195        crit->hevLock = 0;
    196196    }
    197    
     197
    198198    return rc;
    199199}
    … …  
    207207{
    208208    APIRET rc = NO_ERROR;
    209            
     209
    210210    ULONG threadid = rasGetCurrentThreadId ();
    211            
     211
    212212    // We want to acquire the section, count the entering
    213213    DosInterlockedIncrement (&crit->LockCount);
    214    
     214
    215215    if (crit->OwningThread == threadid)
    216216    {
    … …  
    228228            break;
    229229        }
    230        
     230
    231231        rc = DosWaitEventSem (crit->hevLock, ulTimeout);
    232        
    233         if (rc != NO_ERROR) 
     232
     233        if (rc != NO_ERROR)
    234234        {
    235235            // We fail, deregister itself
    … …  
    238238        }
    239239    }
    240    
     240
    241241    // the section was successfully aquired
    242242    crit->RecursionCount = 1;
    243    
     243
    244244    return NO_ERROR;
    245245}
    … …  
    256256    {
    257257        DosInterlockedDecrement (&crit->LockCount);
    258        
     258
    259259        return NO_ERROR;
    260260    }
    261    
     261
    262262    crit->OwningThread = 0;
    263263
    … …  
    270270        DosResetEventSem (crit->hevLock, &ulnrposts);
    271271    }
    272    
     272
    273273    return NO_ERROR;
    274274}
    … …  
    287287void ulong2string (unsigned long number, char *string, int n, int base)
    288288{
    289     static char *digits = "0123456789ABCDEF";
    290    
     289    static const char *digits = "0123456789ABCDEF";
     290
    291291    unsigned long tmp = number;
    292292    char *s = string;
    … …  
    294294    int l = 0;
    295295    int i;
    296    
     296
    297297    if (n <= 0)
    298298    {
    299299        return;
    300300    }
    301    
     301
    302302    if (tmp == 0)
    303303    {
    304304        s[l++] = digits[0];
    305305    }
    306    
     306
    307307    while (tmp != 0)
    308308    {
    … …  
    319319        s[l++] = '\0';
    320320    }
    321    
     321
    322322    s = string;
    323    
     323
    324324    for (i = 0; i < len/2; i++)
    325325    {
    … …  
    338338        return;
    339339    }
    340    
     340
    341341    if (number < 0)
    342342    {
    … …  
    345345        n--;
    346346    }
    347    
     347
    348348    ulong2string (number, string, n, base);
    349349}
    350  
     350
    351351int string2ulong (const char *string, char **pstring2, unsigned long *pvalue, int base)
    352352{
    353353    unsigned long value = 0;
    354354    int sign = 1;
    355    
     355
    356356    const char *p = string;
    357    
     357
    358358    if (p[0] == '-')
    359359    {
    … …  
    361361        p++;
    362362    }
    363    
     363
    364364    if (base == 0)
    365365    {
    … …  
    379379        }
    380380    }
    381            
     381
    382382    while (*p)
    383383    {
    384384        int digit = 0;
    385        
     385
    386386        if ('0' <= *p && *p <= '9')
    387387        {
    … …  
    400400            break;
    401401        }
    402        
     402
    403403        if (digit >= base)
    404404        {
    405405            break;
    406406        }
    407        
     407
    408408        value = value*base + digit;
    409        
     409
    410410        p++;
    411411    }
    412    
     412
    413413    if (pstring2)
    414414    {
    415415        *pstring2 = (char *)p;
    416416    }
    417    
     417
    418418    *pvalue = sign*value;
    419    
     419
    420420    return 1;
    421421}
    … …  
    426426    char *s = (char *)fmt;
    427427    char *d = buf;
    428    
     428
    429429    if (n <= 0)
    430430    {
    431431        return 0;
    432432    }
    433    
     433
    434434    n--;
    435    
     435
    436436    while (*s && count < n)
    437437    {
    438438        char tmpstr[16];
    439      
     439
    440440        char *str = NULL;
    441        
     441
    442442        int width = 0;
    443443        int precision = 0;
    444            
     444
    445445        if (*s == '%')
    446446        {
    447447            s++;
    448            
     448
    449449            if ('0' <= *s && *s <= '9' || *s == '-')
    450450            {
    … …  
    462462                string2ulong (s, &s, (unsigned long *)&precision, 10);
    463463            }
    464            
     464
    465465            if (*s == 's')
    466466            {
    … …  
    480480            {
    481481                int num = va_arg(args, int);
    482            
     482
    483483                ulong2string (num, tmpstr, sizeof (tmpstr), 16);
    484                
     484
    485485                str = &tmpstr[0];
    486486                s++;
    … …  
    494494                    s++;
    495495                }
    496                
     496
    497497                if (*s == 'd' || *s == 'i')
    498498                {
    499499                    int num = va_arg(args, int);
    500                
     500
    501501                    long2string (num, tmpstr, sizeof (tmpstr), 10);
    502                
     502
    503503                    str = &tmpstr[0];
    504504                    s++;
    … …  
    507507                {
    508508                    int num = va_arg(args, int);
    509                
     509
    510510                    ulong2string (num, tmpstr, sizeof (tmpstr), 10);
    511                
     511
    512512                    str = &tmpstr[0];
    513513                    s++;
    … …  
    516516                {
    517517                    int num = va_arg(args, int);
    518                
     518
    519519                    ulong2string (num, tmpstr, sizeof (tmpstr), 16);
    520                
     520
    521521                    str = &tmpstr[0];
    522522                    s++;
    … …  
    524524            }
    525525        }
    526        
     526
    527527        if (str != NULL)
    528528        {
    … …  
    531531            int len = strlen (str);
    532532            int leftalign = 0;
    533            
     533
    534534            if (width < 0)
    535535            {
    … …  
    537537                leftalign = 1;
    538538            }
    539            
     539
    540540            if (precision)
    541541            {
    … …  
    546546                    precision--;
    547547                }
    548                
     548
    549549                memcpy (&numstr[i], str, len);
    550                
     550
    551551                str = &numstr[0];
    552552                len += i;
    553553            }
    554            
     554
    555555            if (len < width && !leftalign)
    556556            {
    … …  
    561561                    count++;
    562562                }
    563                
     563
    564564                if (count >= n)
    565565                {
    … …  
    567567                }
    568568            }
    569            
     569
    570570            i = 0;
    571571            while (i < len && count < n)
    … …  
    574574                count++;
    575575            }
    576                
     576
    577577            if (count >= n)
    578578            {
    579579                break;
    580580            }
    581            
     581
    582582            if (len < width && leftalign)
    583583            {
    … …  
    588588                    count++;
    589589                }
    590                
     590
    591591                if (count >= n)
    592592                {
    … …  
    601601        }
    602602    }
    603    
     603
    604604    *d = '\0';
    605    
     605
    606606    return count + 1;
    607607}
    … …  
    610610{
    611611    va_list args;
    612    
     612
    613613    int rc = 0;
    614614
    615615    va_start (args, fmt);
    616    
     616
    617617    rc = vsnprintf (buf, n, fmt, args);
    618618
    619619    va_end (args);
    620    
     620
    621621    return rc;
    622622}
    … …  
    625625{
    626626    ULONG ulAction = 0;
    627    
     627
    628628    int rc = DosOpen (logfilename, ph, &ulAction, 0L, FILE_ARCHIVED,
    629629                      OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_REPLACE_IF_EXISTS,
    630630                      OPEN_FLAGS_NOINHERIT | OPEN_SHARE_DENYNONE |
    631631                      OPEN_ACCESS_READWRITE, 0L);
    632                          
     632
    633633    if (rc == ERROR_TOO_MANY_OPEN_FILES)
    634634    {
    635635        LONG lReqCount = 10l;
    636636        ULONG ulCurMaxFH = 0ul;
    637          
     637
    638638        DosSetRelMaxFH (&lReqCount, &ulCurMaxFH);
    639            
     639
    640640        rc = DosOpen (logfilename, ph, &ulAction, 0L, FILE_ARCHIVED,
    641641                      OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_REPLACE_IF_EXISTS,
    … …  
    643643                      OPEN_ACCESS_READWRITE, 0L);
    644644    }
    645        
     645
    646646    if (rc != NO_ERROR)
    647647    {
    648648        *ph = -1;
    649649    }
    650    
     650
    651651    return rc;
    652652}
    … …  
    660660{
    661661    ULONG ulActual = 0;
    662            
     662
    663663    DosWrite ((HFILE)h, msg, len, &ulActual);
    664664}
    … …  
    671671        prlc->hlogfile = -1;
    672672    }
    673    
     673
    674674    if (prlc->hmod)
    675675    {
    … …  
    677677        prlc->hmod            = NULLHANDLE;
    678678    }
    679    
     679
    680680    prlc->pfnWriteLog     = NULL;
    681681    prlc->pfnOpenLogFile  = NULL;
    … …  
    687687{
    688688    int rc = NO_ERROR;
    689    
     689
    690690    const char *env = NULL;
    691        
     691
    692692    DosScanEnv (env_loghandler, &env);
    693    
     693
    694694    HMODULE hmod = NULLHANDLE;
    695        
     695
    696696    PFN popenlogfile = NULL;
    697697    PFN pcloselogfile = NULL;
    698698    PFN pwritelog = NULL;
    699          
     699
    700700    if (env)
    701701    {
    702702        rc = DosLoadModule (NULL, 0, env, &hmod);
    703            
     703
    704704        if (rc == NO_ERROR)
    705705        {
    706706            rc = DosQueryProcAddr (hmod, 0, "WIN32RAS_OPENLOGFILE", &popenlogfile);
    707707        }
    708            
     708
    709709        if (rc == NO_ERROR)
    710710        {
    711711            rc = DosQueryProcAddr (hmod, 0, "WIN32RAS_CLOSELOGFILE", &pcloselogfile);
    712712        }
    713            
     713
    714714        if (rc == NO_ERROR)
    715715        {
    716716            rc = DosQueryProcAddr (hmod, 0, "WIN32RAS_WRITELOG", &pwritelog);
    717717        }
    718            
     718
    719719        if (rc != NO_ERROR && hmod)
    720720        {
    … …  
    723723        }
    724724    }
    725        
     725
    726726    if (rc == NO_ERROR && hmod && popenlogfile && pcloselogfile && pwritelog)
    727727    {
    … …  
    739739        prlc->hlogfile        = -1;
    740740        prlc->hmod            = NULLHANDLE;
    741        
     741
    742742        rc = NO_ERROR;
    743743    }
    744        
     744
    745745    rc = prlc->pfnOpenLogFile (&prlc->hlogfile, filename);
    746    
     746
    747747    if (rc != NO_ERROR)
    748748    {
    … …  
    750750        rasCloseLogChannel (prlc);
    751751    }
    752        
     752
    753753    return rc;
    754754}
    … …  
    757757{
    758758    int rc = NO_ERROR;
    759    
     759
    760760    const char *filename = "win32ras.log";
    761    
     761
    762762    const char *env = NULL;
    763    
     763
    764764    DosScanEnv ("WIN32RAS_LOG_FILENAME", &env);
    765        
     765
    766766    if (env)
    767767    {
    768768        filename = env;
    769769    }
    770        
     770
    771771    char uniqueLogFileName[260];
    772        
     772
    773773    snprintf (uniqueLogFileName, sizeof(uniqueLogFileName),
    774774              "%s.%d", filename, loadNr);
    775        
     775
    776776    if (rasdata.rlc.hlogfile == -1)
    777777    {
    778778        rc = rasOpenLogChannel ("WIN32RAS_LOGHANDLER", &rasdata.rlc, uniqueLogFileName);
    779779    }
    780    
     780
    781781    return rc;
    782782}
    … …  
    787787}
    788788
    789 void rasLogInternalV (RAS_LOG_CHANNEL_H hchannel, char *fmt, va_list args)
     789void rasLogInternalV (RAS_LOG_CHANNEL_H hchannel, const char *fmt, va_list args)
    790790{
    791791    static char szOutMsg[4096];
    792792
    793793    ULONG ulHdrLen = snprintf (szOutMsg, sizeof (szOutMsg), "%s", "");
    794    
     794
    795795    ulHdrLen -= 1;
    796    
     796
    797797    ULONG ulMsgLen = vsnprintf (&szOutMsg[ulHdrLen], sizeof (szOutMsg) - ulHdrLen, fmt, args);
    798798
    799799    ulMsgLen -= 1;
    800    
     800
    801801    if (ulMsgLen > 0)
    802802    {
    … …  
    810810            }
    811811        }
    812        
     812
    813813        RasLogChannel *prlc = hchannel? (RasLogChannel *)hchannel: &rasdata.rlc;
    814      
     814
    815815        prlc->pfnWriteLog (prlc->hlogfile, szOutMsg, ulMsgLen + ulHdrLen);
    816816    }
    817817}
    818818
    819 void rasLog (char *fmt, ...)
     819void rasLog (const char *fmt, ...)
    820820{
    821821    va_list args;
    822822
    823823    va_start (args, fmt);
    824    
     824
    825825    rasLogInternalV (NULL, fmt, args);
    826    
     826
    827827    va_end (args);
    828828}
    829829
    830 void rasLogInternal (char *fmt, ...)
     830void rasLogInternal (const char *fmt, ...)
    831831{
    832832    va_list args;
    833833
    834834    va_start (args, fmt);
    835    
     835
    836836    rasLogInternalV (NULL, fmt, args);
    837    
     837
    838838    va_end (args);
    839839}
    840840
    841 void WIN32API rasLogExternal (char *fmt, ...)
     841void WIN32API rasLogExternal (const char *fmt, ...)
    842842{
    843843    va_list args;
    … …  
    846846
    847847    va_start (args, fmt);
    848    
     848
    849849    rasLogInternalV (NULL, fmt, args);
    850    
     850
    851851    va_end (args);
    852    
     852
    853853    SetFS (sel);
    854854}
    … …  
    876876
    877877    *clean = _BLOCK_CLEAN;
    878    
     878
    879879    rc = DosAllocSharedMem (&p, NULL, *size, rasdata.flAllocMem | OBJ_GETTABLE);
    880    
     880
    881881    if (rc != NO_ERROR)
    882882    {
    883883        rasLog ("RAS heap: getmore_fn: DosAllocSharedMem failed, rc = %d\n", rc);
    884884    }
    885    
     885
    886886    return p;
    887887}
    … …  
    906906    {
    907907        rasdata.flAllocMem = PAG_READ | PAG_WRITE | PAG_COMMIT;
    908    
     908
    909909        if (rascfg.fUseHighMem)
    910910        {
    911911            ULONG ulSysinfo = 0;
    912        
     912
    913913            rc = DosQuerySysInfo (QSV_VIRTUALADDRESSLIMIT, QSV_VIRTUALADDRESSLIMIT, &ulSysinfo, sizeof (ulSysinfo));
    914    
     914
    915915            if (rc == NO_ERROR && ulSysinfo > 512)   // VirtualAddresslimit is in MB
    916916            {
    917917                rasdata.flAllocMem |= PAG_ANY;
    918            
     918
    919919                rasLog ("RAS heap initialization: will use high memory\n");
    920920            }
    921921        }
    922922
    923         rc = DosAllocSharedMem (&rasdata.pHeapMem, NULL, rascfg.ulInitHeapSize, 
     923        rc = DosAllocSharedMem (&rasdata.pHeapMem, NULL, rascfg.ulInitHeapSize,
    924924                                rasdata.flAllocMem | OBJ_GETTABLE);
    925925        if (rc != NO_ERROR)
    … …  
    928928            return NO_ERROR;
    929929        }
    930        
    931         rasdata.rasheap = _ucreate (rasdata.pHeapMem, rascfg.ulInitHeapSize, 
     930
     931        rasdata.rasheap = _ucreate (rasdata.pHeapMem, rascfg.ulInitHeapSize,
    932932                                    _BLOCK_CLEAN, _HEAP_REGULAR | _HEAP_SHARED,
    933933                                    getmore_fn, release_fn);
    … …  
    936936        {
    937937            rasLog ("RAS heap initialization: _ucreate failed\n");
    938            
     938
    939939            DosFreeMem (rasdata.pHeapMem);
    940940            rasdata.pHeapMem = NULL;
    941            
     941
    942942            return ERROR_NOT_ENOUGH_MEMORY;
    943943        }
    … …  
    949949         */
    950950        rc = DosGetSharedMem (rasdata.pHeapMem, rasdata.flAllocMem);
    951        
     951
    952952        if (rc != NO_ERROR)
    953953        {
    954954            rasLog ("RAS heap initialization: DosGetSharedMem failed %d\n", rc);
    955            
     955
    956956            return rc;
    957957        }
    … …  
    960960        {
    961961            rasLog ("RAS heap initialization: _uopen failed\n");
    962            
     962
    963963            DosFreeMem (rasdata.pHeapMem);
    964            
     964
    965965            return ERROR_NOT_ENOUGH_MEMORY;
    966966        }
    967967    }
    968    
     968
    969969    rasdata.ulRefCount++;
    970    
     970
    971971    return NO_ERROR;
    972972}
    … …  
    980980       return 1;
    981981    }
    982    
    983     if (useflag == _USEDENTRY) 
     982
     983    if (useflag == _USEDENTRY)
    984984    {
    985985        if (filename)
    … …  
    10011001    {
    10021002        rasLog ("RAS heap uninitialization: privateRefCount = %d\n", privateRefCount);
    1003    
     1003
    10041004        return;
    10051005    }
    … …  
    10171017
    10181018            _uclose (rasdata.rasheap);
    1019            
     1019
    10201020            _udestroy (rasdata.rasheap, _FORCE);
    10211021            rasdata.rasheap = NULL;
    10221022        }
    1023        
     1023
    10241024        if (rasdata.pHeapMem)
    10251025        {
    … …  
    10281028        }
    10291029    }
    1030     else 
     1030    else
    10311031    {
    10321032        _uclose (rasdata.rasheap);
    … …  
    10371037{
    10381038    void *p = _umalloc(rasdata.rasheap, size);
    1039    
     1039
    10401040    if (p)
    10411041    {
    … …  
    10461046        rasLog ("RAS heap: allocation failed, %d bytes\n", size);
    10471047    }
    1048    
     1048
    10491049    return p;
    10501050}
    … …  
    10601060{
    10611061    RAS_TRACK_HANDLE iter = rasdata.firsttrack;
    1062    
     1062
    10631063    while (iter)
    10641064    {
    … …  
    10671067            break;
    10681068        }
    1069        
     1069
    10701070        iter = iter->next;
    10711071    }
    1072    
     1072
    10731073    return iter;
    10741074}
    … …  
    10771077{
    10781078    static objident = 0;
    1079    
     1079
    10801080    objident++;
    1081    
     1081
    10821082    if (objident == 0)
    10831083    {
    10841084        objident++;
    10851085    }
    1086    
     1086
    10871087    return objident;
    10881088}
    … …  
    11001100        h->objlast = h->objfirst = pinfo;
    11011101    }
    1102    
     1102
    11031103    return NO_ERROR;
    11041104}
    1105      
     1105
    11061106void rasRemoveObjectInfo (RAS_OBJECT_INFO *pinfo)
    11071107{
    … …  
    11151115        pinfo->h->objlast = pinfo->prev;
    11161116    }
    1117    
     1117
    11181118    if (pinfo->prev)
    11191119    {
    … …  
    11311131{
    11321132    pinfo->objhandle = objhandle;
    1133    
     1133
    11341134    pinfo->h = h;
    1135    
     1135
    11361136    pinfo->usecount = 1;
    1137    
     1137
    11381138    pinfo->objident = rasGenObjIdent ();
    11391139
    … …  
    11461146        }
    11471147    }
    1148    
     1148
    11491149    pinfo->cbobjdata = cbobjdata;
    11501150}
    … …  
    11521152struct _RAS_OBJECT_INFO *rasSearchObject2 (RAS_TRACK_HANDLE h, ULONG objident)
    11531153{
    1154     if (!h) 
     1154    if (!h)
    11551155    {
    11561156        return NULL;
    … …  
    11581158
    11591159    RAS_OBJECT_INFO *iter = h->objfirst;
    1160    
     1160
    11611161    while (iter)
    11621162    {
    … …  
    11671167        iter = iter->next;
    11681168    }
    1169    
     1169
    11701170    return iter;
    11711171}
    … …  
    11811181struct _RAS_OBJECT_INFO *rasSearchObject (RAS_TRACK_HANDLE h, ULONG objhandle, RAS_OBJECT_INFO **ppinfo_next)
    11821182{
    1183     if (!h) 
     1183    if (!h)
    11841184    {
    11851185        return NULL;
    … …  
    11871187
    11881188    RAS_OBJECT_INFO *iter = h->objfirst;
    1189    
     1189
    11901190    while (iter)
    11911191    {
    … …  
    11941194            break;
    11951195        }
    1196        
     1196
    11971197        iter = iter->next;
    11981198    }
    1199    
     1199
    12001200    if (iter && ppinfo_next)
    12011201    {
    12021202        *ppinfo_next = iter->next;
    12031203    }
    1204    
     1204
    12051205    return iter;
    12061206}
    … …  
    12141214{
    12151215    pinfo->usecount--;
    1216    
     1216
    12171217    return pinfo->usecount;
    12181218}
    … …  
    12231223    char buf[128];
    12241224    char *p = &buf[0];
    1225    
     1225
    12261226    if (!objdata)
    12271227    {
    12281228        return NO_ERROR;
    12291229    }
    1230    
     1230
    12311231    for (i = 0; i < cbobjdata; i++)
    12321232    {
    … …  
    12381238                 p = &buf[0];
    12391239             }
    1240              
     1240
    12411241             snprintf (p, sizeof(buf) - (p - &buf[0]), "%8.8x:", i / 16);
    12421242             p += strlen (p);
    12431243        }
    1244        
     1244
    12451245        snprintf (p, sizeof(buf) - (p - &buf[0]), " %2.2x", ((char *)objdata)[i]);
    12461246        p += strlen (p);
    12471247    }
    1248    
     1248
    12491249    pRasLog ("%s\n", buf);
    1250    
     1250
    12511251    return NO_ERROR;
    12521252}
    … …  
    12581258        return 1;
    12591259    }
    1260    
     1260
    12611261    if (objdata1 == NULL || objdata2 == NULL)
    12621262    {
    … …  
    12641264        return 1;
    12651265    }
    1266    
     1266
    12671267    return memcmp (objdata1, objdata2, cbobjdata1);
    12681268}
    12691269
    1270 ULONG rasCallLogObjectContent (RAS_TRACK_HANDLE h, RASCONTEXT_I *pctx, 
    1271                                ULONG objident, ULONG objhandle, 
     1270ULONG rasCallLogObjectContent (RAS_TRACK_HANDLE h, RASCONTEXT_I *pctx,
     1271                               ULONG objident, ULONG objhandle,
    12721272                               void *objdata, ULONG cbobjdata, FNRASLOG_EXTERNAL *rasLogExternal)
    12731273{
    12741274    rasRestoreContext (pctx);
    1275    
     1275
    12761276    ULONG rc = h->pfnLogObjectContent (objident, objhandle, objdata, cbobjdata, rasLogExternal);
    1277    
     1277
    12781278    rasSaveContext (pctx);
    1279    
     1279
    12801280    return rc;
    12811281}
    12821282
    1283 ULONG WIN32API rasCallCompareObjectContent (RAS_TRACK_HANDLE h, RASCONTEXT_I *pctx, 
     1283ULONG WIN32API rasCallCompareObjectContent (RAS_TRACK_HANDLE h, RASCONTEXT_I *pctx,
    12841284                                            ULONG objhandle, void *objdata1, ULONG cbobjdata1, void *objdata2, ULONG cbobjdata2)
    12851285{
    12861286    rasRestoreContext (pctx);
    1287    
     1287
    12881288    ULONG rc = h->pfnCompareObjectContent (objhandle, objdata1, cbobjdata1, objdata2, cbobjdata2);
    1289    
     1289
    12901290    rasSaveContext (pctx);
    1291    
     1291
    12921292    return rc;
    12931293}
    … …  
    13011301{
    13021302   const char *env = NULL;
    1303    
     1303
    13041304   DosScanEnv (name, &env);
    1305        
     1305
    13061306   if (env)
    13071307   {
    13081308       ULONG ul = 0;
    13091309       char *e = NULL;
    1310        
     1310
    13111311       string2ulong (env, &e, &ul, 10);
    1312            
     1312
    13131313       if (e && *e == '\0')
    13141314       {
    … …  
    13241324{
    13251325    int rc = NO_ERROR;
    1326    
     1326
    13271327    if (!rasdata.hmodPlugin)
    13281328    {
    13291329        rasdata.ret.cb = sizeof (RasEntryTable);
    1330                
     1330
    13311331        rasdata.ret.RasRegisterObjectTracking   = RasRegisterObjectTracking;
    13321332        rasdata.ret.RasDeregisterObjectTracking = RasDeregisterObjectTracking;
    … …  
    13531353        rasdata.ret.RasTrackMemFree             = RasTrackMemFree;
    13541354        rasdata.ret.RasGetTrackHandle           = RasGetTrackHandle;
    1355        
     1355
    13561356        rasdata.pet.cb = sizeof (RasPluginEntryTable);
    1357          
     1357
    13581358        rasdata.pet.RasEntry                    = _RasEntry;
    13591359
    13601360        const char *env = NULL;
    1361        
     1361
    13621362        DosScanEnv ("WIN32RAS_PLUGIN", &env);
    1363          
     1363
    13641364        if (env)
    13651365        {
    13661366            HMODULE hmod = NULLHANDLE;
    13671367            FNPI *pfnPluginInit  = NULL;
    1368          
     1368
    13691369            rc = DosLoadModule (NULL, 0, env, &hmod);
    1370            
     1370
    13711371            if (rc == NO_ERROR)
    13721372            {
    13731373                rc = DosQueryProcAddr (hmod, 0, "WIN32RAS_PLUGIN_INIT", (PFN *)&pfnPluginInit);
    13741374            }
    1375            
     1375
    13761376            if (rc != NO_ERROR)
    13771377            {
    13781378                rasLogInternal ("Could not load RAS plugin %s rc = %d", env, rc);
    13791379            }
    1380            
     1380
    13811381            if (rc != NO_ERROR && hmod)
    13821382            {
    … …  
    13861386            {
    13871387                rasdata.hmodPlugin = hmod;
    1388                
     1388
    13891389                pfnPluginInit (rasdata.hmod, &rasdata.ret, &rasdata.pet);
    13901390            }
    13911391        }
    13921392    }
    1393    
     1393
    13941394    return rc;
    13951395}
    … …  
    13981398{
    13991399    int rc = NO_ERROR;
    1400    
     1400
    14011401    if (rasdata.hmodPlugin)
    14021402    {
    14031403        HMODULE hmod = rasdata.hmodPlugin;
    14041404        FNPE *pfnPluginExit  = NULL;
    1405        
     1405
    14061406        rc = DosQueryProcAddr (hmod, 0, "WIN32RAS_PLUGIN_EXIT", (PFN *)&pfnPluginExit);
    1407            
     1407
    14081408        if (rc == NO_ERROR)
    14091409        {
    14101410            pfnPluginExit (rasdata.hmod);
    14111411        }
    1412        
     1412
    14131413        DosFreeModule (hmod);
    14141414    }
    1415    
     1415
    14161416    return rc;
    14171417}
    … …  
    14631463{
    14641464   int rc = NO_ERROR;
    1465    
     1465
    14661466   if (!rasInitialized)
    14671467   {
    14681468       rasInitialized = 1;
    1469        
     1469
    14701470       memset (&rascfg, 0, sizeof (rascfg));
    1471        
     1471
    14721472       rascfg.ulTimeout = 60000; // default 1 minute
    14731473       rasQueryEnvUlong ("WIN32RAS_TIMEOUT", &rascfg.ulTimeout, 1, 3600, 1000);
    1474        
     1474
    14751475       rascfg.ulInitHeapSize = 128*1024;
    14761476       rasQueryEnvUlong ("WIN32RAS_INITHEAPSIZE", &rascfg.ulInitHeapSize, 64, 16*1024, 1024);
    1477        
     1477
    14781478       ULONG ul = 0;
    14791479       rasQueryEnvUlong ("WIN32RAS_DUMPHEAPOBJECTS", &ul, 0, 1, 1);
    14801480       rascfg.fDumpHeapObjects = ul;
    1481        
     1481
    14821482       ul = 1;
    14831483       rasQueryEnvUlong ("WIN32RAS_USEHIGHMEM", &ul, 0, 1, 1);
    14841484       rascfg.fUseHighMem = ul;
    1485        
     1485
    14861486       ul = 0;
    14871487       rasQueryEnvUlong ("WIN32RAS_ENABLE", &ul, 0, 1, 1);
    14881488       rascfg.fRasEnable = ul;
    1489        
     1489
    14901490       ul = 0;
    14911491       rasQueryEnvUlong ("WIN32RAS_BREAKPOINT", &ul, 0, 1, 1);
    14921492       rascfg.fRasBreakPoint = ul;
    1493        
     1493
    14941494       memset (&rasdata, 0, sizeof (rasdata));
    14951495       rasdata.rlc.hlogfile = -1;
    14961496       rasdata.hmod = hmod;
    1497        
     1497
    14981498       rc = NO_ERROR;
    14991499   }
    1500    
     1500
    15011501   if (!rascfg.fRasEnable)
    15021502   {
    … …  
    15101510
    15111511   rc = rasInitializeLog ();
    1512    
     1512
    15131513   if (rc == NO_ERROR)
    15141514   {
    15151515       rc = rasInitializeCriticalSection (&csras);
    15161516   }
    1517    
     1517
    15181518   if (rc == NO_ERROR)
    15191519   {
    15201520       rc = rasInitializeHeap ();
    15211521   }
    1522    
     1522
    15231523   if (rc == NO_ERROR)
    15241524   {
    15251525       rc = rasInitializePlugin ();
    15261526   }
    1527    
     1527
    15281528   return rc;
    15291529}
    … …  
    15321532{
    15331533    ENTER_RAS(NO_HANDLE);
    1534    
     1534
    15351535    /* Deregister all objects */
    15361536    while (rasdata.firsttrack)
    15371537    {
    15381538        RAS_TRACK_HANDLE iter = rasdata.firsttrack;
    1539        
     1539
    15401540        if (iter->fLogAtExit)
    15411541        {
    15421542            RasLogObjects (iter, iter->fLogObjectsAtExit? RAS_FLAG_LOG_OBJECTS: 0);
    15431543        }
    1544        
     1544
    15451545        RasDeregisterObjectTracking (iter);
    1546        
     1546
    15471547        rasFree (iter);
    15481548    }
    1549    
     1549
    15501550    rasUninitializePlugin ();
    1551    
     1551
    15521552    rasUninitializeHeap ();
    1553    
     1553
    15541554    EXIT_RAS();
    1555    
     1555
    15561556    rasUninitializeCriticalSection (&csras);
    1557    
    1558     rasUninitializeLog (); 
     1557
     1558    rasUninitializeLog ();
    15591559}
    15601560
    … …  
    15621562{
    15631563    ENTER_RAS_RET(NO_HANDLE, NULL);
    1564    
     1564
    15651565    RAS_TRACK_HANDLE iter = rasdata.firsttrack;
    1566    
     1566
    15671567    while (iter)
    15681568    {
    … …  
    15711571            break;
    15721572        }
    1573        
     1573
    15741574        iter = iter->next;
    15751575    }
    1576    
     1576
    15771577    EXIT_RAS();
    1578    
     1578
    15791579    return iter;
    15801580}
    15811581
    1582 void WIN32API RasRegisterObjectTracking (RAS_TRACK_HANDLE *ph, char *objname,
     1582void WIN32API RasRegisterObjectTracking (RAS_TRACK_HANDLE *ph, const char *objname,
    15831583                                         ULONG cbuserdata,
    15841584                                         ULONG flags,
    … …  
    15871587{
    15881588    ENTER_RAS(NO_HANDLE);
    1589    
     1589
    15901590    RAS_TRACK *prt = (RAS_TRACK *)rasAlloc (sizeof (RAS_TRACK));
    1591    
     1591
    15921592    if (prt)
    15931593    {
    15941594        strcpy (prt->objname, objname);
    1595        
     1595
    15961596        prt->cbuserdata = cbuserdata;
    1597    
     1597
    15981598        if (flags & RAS_TRACK_FLAG_LOGOBJECTCONTENT)
    15991599        {
    16001600            prt->fLogObjectContent = 1;
    16011601        }
    1602    
     1602
    16031603        if (flags & RAS_TRACK_FLAG_MEMORY)
    16041604        {
    16051605            prt->fMemory = 1;
    16061606        }
    1607        
     1607
    16081608        if (flags & RAS_TRACK_FLAG_LOG_AT_EXIT)
    16091609        {
    16101610            prt->fLogAtExit = 1;
    16111611        }
    1612    
     1612
    16131613        if (flags & RAS_TRACK_FLAG_LOG_OBJECTS_AT_EXIT)
    16141614        {
    16151615            prt->fLogObjectsAtExit = 1;
    16161616        }
    1617    
     1617
    16181618        if (pfnLogObjectContent)
    16191619        {
    … …  
    16241624            prt->pfnLogObjectContent = rasLogObjectContent;
    16251625        }
    1626        
     1626
    16271627        if (pfnCompareObjectContent)
    16281628        {
    … …  
    16331633            prt->pfnCompareObjectContent = pfnCompareObjectContent;
    16341634        }
    1635        
     1635
    16361636        /* Insert the new tracking record in the list */
    16371637        if (rasdata.firsttrack)
    … …  
    16451645            rasdata.lasttrack = rasdata.firsttrack = prt;
    16461646        }
    1647        
     1647
    16481648        *ph = prt;
    16491649    }
    … …  
    16571657
    16581658    h = rasVerifyTrackHandle (h);
    1659    
     1659
    16601660    if (h)
    16611661    {
    … …  
    16641664        {
    16651665            RAS_OBJECT_INFO *iter = h->objfirst;
    1666            
     1666
    16671667            rasRemoveObjectInfo (iter);
    1668            
     1668
    16691669            rasFree (iter);
    16701670        }
    1671        
     1671
    16721672        /* Remove the track record */
    16731673        if (h->next)
    … …  
    16801680            rasdata.lasttrack = h->prev;
    16811681        }
    1682    
     1682
    16831683        if (h->prev)
    16841684        {
    … …  
    16911691        }
    16921692    }
    1693    
     1693
    16941694    EXIT_RAS ();
    16951695}
    … …  
    17001700{
    17011701    ENTER_RAS_RET (h, 0);
    1702    
     1702
    17031703    struct _RAS_OBJECT_INFO *pinfo_next = NULL;
    1704    
     1704
    17051705    struct _RAS_OBJECT_INFO *pinfo = rasSearchObject (h, objhandle, &pinfo_next);
    1706    
     1706
    17071707//    rasLog ("Object added: handle = %8.8X\n", objhandle);
    1708    
     1708
    17091709    if (pinfo != NULL)
    17101710    {
    … …  
    17151715         */
    17161716        rasIncUseCount (pinfo);
    1717        
     1717
    17181718        /* log this event */
    17191719        rasLog ("Dublicate object added: handle = %8.8X\n", objhandle);
    … …  
    17221722            rasLogInternal ("Added object content:\n");
    17231723            rasCallLogObjectContent (h, &ctx, pinfo->objident, objhandle, objdata, cbobjdata, rasLogExternal);
    1724            
     1724
    17251725            rasLogInternal ("Existing object content:\n");
    17261726            rasCallLogObjectContent (h, &ctx, pinfo->objident, objhandle, pinfo->objdata, pinfo->cbobjdata, rasLogExternal);
    1727            
     1727
    17281728            if (rasCallCompareObjectContent (h, &ctx, objhandle, objdata, cbobjdata, pinfo->objdata, pinfo->cbobjdata) != 0)
    17291729            {
    … …  
    17341734    else
    17351735    {
    1736         pinfo = (RAS_OBJECT_INFO *)rasAlloc (sizeof (RAS_OBJECT_INFO) - sizeof (RAS_OBJECT_INFO::userdata) 
    1737                                              + h->cbuserdata 
     1736        pinfo = (RAS_OBJECT_INFO *)rasAlloc (sizeof (RAS_OBJECT_INFO) - sizeof (RAS_OBJECT_INFO::userdata)
     1737                                             + h->cbuserdata
    17381738                                             + (objdata? cbobjdata: 0));
    17391739        if (pinfo)
    17401740        {
    17411741            rasInitObjectInfo (pinfo, h, objhandle, objdata, cbobjdata);
    1742    
     1742
    17431743            int rc = rasAddObjectInfo (pinfo, h, pinfo_next);
    1744            
     1744
    17451745            if (rc != NO_ERROR)
    17461746            {
    1747                 rasFree (pinfo); 
     1747                rasFree (pinfo);
    17481748                pinfo = NULL;
    17491749            }
    … …  
    17521752
    17531753    EXIT_RAS ();
    1754    
     1754
    17551755    if (pinfo)
    17561756    {
    17571757        return pinfo->objident;
    17581758    }
    1759    
     1759
    17601760    return 0;
    17611761}
    … …  
    17641764{
    17651765    ENTER_RAS (h);
    1766    
     1766
    17671767//    rasLog ("Object to remove: handle = %8.8X\n", objhandle);
    1768    
     1768
    17691769    struct _RAS_OBJECT_INFO *pinfo = rasSearchObject (h, objhandle, NULL);
    1770    
     1770
    17711771//    rasLog ("Objects pinfo = %8.8X\n", pinfo);
    1772    
     1772
    17731773    if (pinfo != NULL)
    17741774    {
    … …  
    17761776        {
    17771777            rasRemoveObjectInfo (pinfo);
    1778            
     1778
    17791779            rasFree (pinfo);
    17801780        }
    17811781    }
    1782    
     1782
    17831783    EXIT_RAS ();
    17841784}
    1785              
     1785
    17861786
    17871787void WIN32API RasQueryObjectUserData (RAS_TRACK_HANDLE h, ULONG objident, void *pdata, ULONG cbdata, ULONG *pcbdataret)
    17881788{
    17891789    ENTER_RAS (h);
    1790    
     1790
    17911791    struct _RAS_OBJECT_INFO *pinfo = rasSearchObject2 (h, objident);
    1792    
     1792
    17931793    if (pinfo)
    17941794    {
    … …  
    17971797            cbdata = pinfo->h->cbuserdata;
    17981798        }
    1799    
     1799
    18001800        memcpy (pdata, &pinfo->userdata, cbdata);
    18011801    }
    … …  
    18041804        cbdata = 0;
    18051805    }
    1806    
     1806
    18071807    EXIT_RAS ();
    1808    
     1808
    18091809    if (pcbdataret)
    18101810    {
    18111811        *pcbdataret = cbdata;
    18121812    }
    1813    
     1813
    18141814    return;
    18151815}
    … …  
    18181818{
    18191819    ENTER_RAS (h);
    1820    
     1820
    18211821    struct _RAS_OBJECT_INFO *pinfo = rasSearchObject2 (h, objident);
    1822    
     1822
    18231823    if (pinfo)
    18241824    {
    … …  
    18271827            cbdata = pinfo->h->cbuserdata;
    18281828        }
    1829    
     1829
    18301830        memcpy (&pinfo->userdata, pdata, cbdata);
    18311831    }
    … …  
    18341834        cbdata = 0;
    18351835    }
    1836    
     1836
    18371837    EXIT_RAS ();
    1838    
     1838
    18391839    if (pcbdataret)
    18401840    {
    18411841        *pcbdataret = cbdata;
    18421842    }
    1843    
     1843
    18441844    return;
    18451845}
    18461846
    18471847
    1848 void WIN32API RasLog (char *fmt, ...)
     1848void WIN32API RasLog (const char *fmt, ...)
    18491849{
    18501850    ENTER_RAS (NO_HANDLE);
    1851    
     1851
    18521852    va_list args;
    18531853
    18541854    va_start (args, fmt);
    1855    
     1855
    18561856    rasLogInternalV (NULL, fmt, args);
    1857    
     1857
    18581858    va_end (args);
    1859    
     1859
    18601860    EXIT_RAS ();
    18611861}
    18621862
    1863 void WIN32API RasLogNoEOL (char *fmt, ...)
     1863void WIN32API RasLogNoEOL (const char *fmt, ...)
    18641864{
    18651865    va_list args;
    1866    
     1866
    18671867    ENTER_RAS (NO_HANDLE);
    1868    
     1868
    18691869    va_start (args, fmt);
    1870    
     1870
    18711871    ULONG noeolstate = rasdata.fNoEOL;
    18721872
    18731873    rasdata.fNoEOL = 1;
    1874    
     1874
    18751875    rasLogInternalV (NULL, fmt, args);
    1876    
     1876
    18771877    rasdata.fNoEOL = noeolstate;
    1878    
     1878
    18791879    va_end (args);
    1880    
     1880
    18811881    EXIT_RAS ();
    18821882}
    … …  
    18851885{
    18861886    ENTER_RAS (NO_HANDLE);
    1887    
     1887
    18881888    EXIT_RAS ();
    18891889}
    1890        
     1890
    18911891void WIN32API RasLogObjects (RAS_TRACK_HANDLE h, ULONG flags)
    18921892{
    18931893    ENTER_RAS (h);
    1894    
     1894
    18951895    rasLogInternal ("[%s] objects", h->objname);
    1896    
     1896
    18971897    if (h->fMemory)
    18981898    {
    … …  
    19041904        }
    19051905    }
    1906    
     1906
    19071907    RAS_OBJECT_INFO *iter = h->objfirst;
    1908    
     1908
    19091909    int count = 0;
    19101910    ULONG cb = 0; // count total memory allocated if fMemory is set
    1911    
     1911
    19121912    while (iter)
    19131913    {
    … …  
    19161916            cb += iter->cbobjdata;
    19171917        }
    1918        
     1918
    19191919        if (flags & RAS_FLAG_LOG_OBJECTS)
    19201920        {
    … …  
    19261926            {
    19271927                rasLogInternal ("  handle = %8.8X\n", iter->objhandle);
    1928        
     1928
    19291929                if (h->fLogObjectContent)
    19301930                {
    … …  
    19331933            }
    19341934        }
    1935        
     1935
    19361936        count++;
    1937        
     1937
    19381938        iter = iter->next;
    19391939    }
    1940    
     1940
    19411941    rasLogInternal ("%d [%s] objects", count, h->objname);
    1942    
     1942
    19431943    if (h->fMemory && count > 0)
    19441944    {
    19451945        rasLogInternal ("%d bytes allocated", cb);
    19461946    }
    1947    
     1947
    19481948    EXIT_RAS ();
    1949    
     1949
    19501950    return;
    19511951}
    … …  
    19541954{
    19551955    ENTER_RAS (h);
    1956    
     1956
    19571957    RAS_OBJECT_INFO *iter = h->objfirst;
    1958    
     1958
    19591959    int count = 0;
    19601960    ULONG cb = 0; // count total memory allocated if fMemory is set
    1961    
     1961
    19621962    while (iter)
    19631963    {
    … …  
    19661966            cb += iter->cbobjdata;
    19671967        }
    1968        
     1968
    19691969        count++;
    1970        
     1970
    19711971        iter = iter->next;
    19721972    }
    1973    
     1973
    19741974    if (h->fMemory)
    19751975    {
    … …  
    19791979        }
    19801980    }
    1981    
     1981
    19821982    if (pcount)
    19831983    {
    19841984        *pcount = count;
    19851985    }
    1986    
     1986
    19871987    EXIT_RAS ();
    1988    
     1988
    19891989    return;
    19901990}
    … …  
    19931993{
    19941994    ENTER_RAS (NO_HANDLE);
    1995    
     1995
    19961996    va_list args;
    19971997
    19981998    va_start (args, fmt);
    1999    
     1999
    20002000    rasLogInternalV (hchannel, fmt, args);
    2001    
     2001
    20022002    va_end (args);
    2003    
     2003
    20042004    EXIT_RAS ();
    20052005}
    … …  
    20082008{
    20092009    va_list args;
    2010    
     2010
    20112011    ENTER_RAS (NO_HANDLE);
    2012    
     2012
    20132013    va_start (args, fmt);
    2014    
     2014
    20152015    ULONG noeolstate = rasdata.fNoEOL;
    20162016
    20172017    rasdata.fNoEOL = 1;
    2018    
     2018
    20192019    rasLogInternalV (hchannel, fmt, args);
    2020    
     2020
    20212021    rasdata.fNoEOL = noeolstate;
    2022    
     2022
    20232023    va_end (args);
    2024    
     2024
    20252025    EXIT_RAS ();
    20262026}
    … …  
    20292029{
    20302030    ENTER_RAS (NO_HANDLE);
    2031    
     2031
    20322032    EXIT_RAS ();
    20332033}
    … …  
    20472047{
    20482048    ENTER_RAS_RET (NO_HANDLE, ERROR_GEN_FAILURE);
    2049    
     2049
    20502050    int rc = NO_ERROR;
    2051    
     2051
    20522052    RasLogChannel *prlc = (RasLogChannel *)rasAlloc (sizeof (RasLogChannel));
    2053    
     2053
    20542054    if (!prlc)
    20552055    {
    … …  
    20592059    {
    20602060        rc = rasOpenLogChannel (env_loghandler, prlc, filename);
    2061        
     2061
    20622062        if (rc != NO_ERROR)
    20632063        {
    … …  
    20692069        }
    20702070    }
    2071    
     2071
    20722072    EXIT_RAS ();
    2073    
     2073
    20742074    return rc;
    20752075}
    2076        
     2076
    20772077void WIN32API RasWriteLogChannel (RAS_LOG_CHANNEL_H hchannel, const char *msg, ULONG length)
    20782078{
    20792079    ENTER_RAS (NO_HANDLE);
    2080    
     2080
    20812081    if (length > 0)
    20822082    {
    20832083        RasLogChannel *prlc = (RasLogChannel *)hchannel;
    2084      
     2084
    20852085        prlc->pfnWriteLog (prlc->hlogfile, (char *)msg, length);
    20862086    }
    2087    
     2087
    20882088    EXIT_RAS ();
    20892089}
    2090        
     2090
    20912091void WIN32API RasCloseLogChannel (RAS_LOG_CHANNEL_H hchannel)
    20922092{
    20932093    ENTER_RAS (NO_HANDLE);
    2094    
     2094
    20952095    RasLogChannel *prlc = (RasLogChannel *)hchannel;
    2096        
     2096
    20972097    rasCloseLogChannel (prlc);
    2098    
     2098
    20992099    rasFree (prlc);
    2100    
     2100
    21012101    EXIT_RAS ();
    21022102}
    2103        
     2103
    21042104
    21052105void WIN32API RasEntry (ULONG ulEvent, void *p, ULONG cb)
    21062106{
    21072107    ENTER_RAS (NO_HANDLE);
    2108    
     2108
    21092109    if (rasdata.pet.RasEntry)
    21102110    {
    21112111        rasdata.pet.RasEntry (ulEvent, p, cb);
    21122112    }
    2113    
     2113
    21142114    EXIT_RAS ();
    21152115}
    … …  
    21402140{
    21412141    ENTER_RAS (h);
    2142    
     2142
    21432143    if (h->fMemory && size > 0)
    21442144    {
    … …  
    21462146        h->cbTotalAllocated += size;
    21472147    }
    2148    
     2148
    21492149    EXIT_RAS ();
    21502150}
    2151              
     2151
    21522152void WIN32API RasTrackMemRealloc (RAS_TRACK_HANDLE h, ULONG oldsize, ULONG newsize)
    21532153{
    21542154    ENTER_RAS (h);
    2155    
     2155
    21562156    if (h->fMemory)
    21572157    {
    … …  
    21622162        }
    21632163    }
    2164    
     2164
    21652165    EXIT_RAS ();
    21662166}
    2167              
     2167
    21682168void WIN32API RasTrackMemFree (RAS_TRACK_HANDLE h, ULONG size)
    21692169{
    21702170    ENTER_RAS (h);
    2171    
     2171
    21722172    if (h->fMemory && size > 0)
    21732173    {
    … …  
    21752175        h->cbTotalAllocated -= size;
    21762176    }
    2177    
     2177
    21782178    EXIT_RAS ();
    21792179}
    2180              
     2180

  • branches/gcc-kmk/src/kernel32/dbglog.cpp

    r21343 r21717  
    9393/* arguments.                                                        */
    9494/* ----------------------------------------------------------------- */
    95 int SYSTEM WriteLog(char *f, ...)
     95int SYSTEM WriteLog(const char *f, ...)
    9696  {
    9797  TIB    *ptib;                    /* process/thread id structures */
    … …  
    305305}
    306306
    307 int SYSTEM WriteLog(char *tekst, ...)
     307int SYSTEM WriteLog(const char *tekst, ...)
    308308{
    309309  USHORT  sel = RestoreOS2FS();
    … …  
    348348        sprintf(szLogFile, "%s%d.log", pszLogBase, loadNr);
    349349        flog = fopen(szLogFile, "w");
    350         if(flog == NULL) 
     350        if(flog == NULL)
    351351        {//probably running exe on readonly device
    352352            sprintf(szLogFile, "%sodin32_%d.log", kernel32Path, loadNr);
    … …  
    385385    if(logSocket == -1) {
    386386#endif
    387     if(teb) 
     387    if(teb)
    388388    {
    389389      ULONG ulCallDepth;
    … …  
    393393      ulCallDepth = 0;
    394394#endif
    395      
     395
    396396      teb->o.odin.logfile = (DWORD)flog;
    397      
     397
    398398#ifdef LOG_TIME
    399399      if(sel == 0x150b && fSwitchTIBSel)
    400         fprintf(flog, 
     400        fprintf(flog,
    401401                "t%02d (%3d): (%x) (FS=150B) ",
    402402                LOWORD(teb->o.odin.threadId),
    403403                ulCallDepth,
    404404                GetTickCount());
    405       else 
    406         fprintf(flog, 
     405      else
     406        fprintf(flog,
    407407                "t%02d (%3d): (%x) ",
    408408                LOWORD(teb->o.odin.threadId),
    … …  
    410410                GetTickCount());
    411411#else
    412       if(sel == 0x150b && fSwitchTIBSel) 
    413         fprintf(flog, 
     412      if(sel == 0x150b && fSwitchTIBSel)
     413        fprintf(flog,
    414414#ifdef SHOW_FPU_CONTROLREG
    415415                "t%02d (%3d)(%3x): ",
    … …  
    422422                ulCallDepth);
    423423#endif
    424       else 
    425         fprintf(flog, 
     424      else
     425        fprintf(flog,
    426426#ifdef SHOW_FPU_CONTROLREG
    427427                "t%02d (%3d)(%3x): ",
    … …  
    450450        int  prefixlen = 0;
    451451
    452         if(teb) 
     452        if(teb)
    453453        {
    454454            ULONG ulCallDepth;
    … …  
    459459#endif
    460460#ifdef LOG_TIME
    461             if(sel == 0x150b && fSwitchTIBSel) 
     461            if(sel == 0x150b && fSwitchTIBSel)
    462462                sprintf(logbuffer, "t%02d (%3d): %x (FS=150B) ",
    463463                        LOWORD(teb->o.odin.threadId), ulCallDepth, GetTickCount());
    464             else 
     464            else
    465465                sprintf(logbuffer, "t%02d (%3d): %x ",
    466466                        LOWORD(teb->o.odin.threadId), ulCallDepth, GetTickCount());
    467467#else
    468             if(sel == 0x150b && fSwitchTIBSel) 
     468            if(sel == 0x150b && fSwitchTIBSel)
    469469                sprintf(logbuffer, "t%02d (%3d): (FS=150B) ",
    470470                        LOWORD(teb->o.odin.threadId), ulCallDepth);
    471             else 
     471            else
    472472                sprintf(logbuffer, "t%02d (%3d): ",
    473473                        LOWORD(teb->o.odin.threadId), ulCallDepth);
    … …  
    497497        if(tekst[strlen(tekst)-1] != '\n')
    498498            fprintf(flog, "\n");
    499 #if 0       
     499#if 0
    500500if (teb && LOWORD(teb->o.odin.threadId) > 1)
    501501{
    … …  
    514514            break;
    515515        }
    516        
     516
    517517        if ((ULONG)pframe < getESP())
    518518        {
    … …  
    554554//******************************************************************************
    555555//******************************************************************************
    556 int SYSTEM WriteLogNoEOL(char *tekst, ...)
     556int SYSTEM WriteLogNoEOL(const char *tekst, ...)
    557557{
    558558  USHORT  sel = RestoreOS2FS();
    … …  
    612612//******************************************************************************
    613613//******************************************************************************
    614 int SYSTEM WritePrivateLog(void *logfile, char *tekst, ...)
     614int SYSTEM WritePrivateLog(void *logfile, const char *tekst, ...)
    615615{
    616616  USHORT  sel = RestoreOS2FS();

  • branches/gcc-kmk/src/kernel32/exceptions.cpp

    r21662 r21717  
    756756    }
    757757
    758     PSZ    pszExceptionName = "<unknown>";        /* points to name/type excpt */
     758    PCSZ   pszExceptionName = "<unknown>";        /* points to name/type excpt */
    759759    APIRET rc               = XCPT_CONTINUE_SEARCH;        /* excpt-dep.  code */
    760760    BOOL   fExcptSoftware   = FALSE;         /* software/hardware gen. exceptn */
    … …  
    11811181
    11821182            if(lpszExeName) {
    1183                 DosWrite(hFile, "\n", 2, &ulBytesWritten);
     1183                DosWrite(hFile, (PVOID)"\n", 2, &ulBytesWritten);
    11841184                DosWrite(hFile, lpszExeName, strlen(lpszExeName), &ulBytesWritten);
    1185                 DosWrite(hFile, "\n", 2, &ulBytesWritten);
     1185                DosWrite(hFile, (PVOID)"\n", 2, &ulBytesWritten);
    11861186            }
    11871187        }

  • branches/gcc-kmk/src/kernel32/exceptstackdump.cpp

    r21611 r21717  
    3030#include "dbglocal.h"
    3131
    32 int SYSTEM EXPORT WriteLogNoEOL(char *tekst, ...);
     32int SYSTEM EXPORT WriteLogNoEOL(const char *tekst, ...);
    3333
    3434#define FIX64KLIMIT

  • branches/gcc-kmk/src/kernel32/handlenames.cpp

    r21302 r21717  
    2727#define INCL_DOSSEMAPHORES
    2828#define INCL_DOSERRORS
    29 #include <os2.h>
     29#include <os2wrap.h>
    3030
    3131#include <stdlib.h>
    … …  
    5353  PSZ   pszTarget;
    5454  ULONG ulTargetLength;
    55  
     55
    5656  // the alias prefix
    5757  PSZ   pszSymbolicLink;
    … …  
    6565    VMutex       mtxHandleNameMgr;
    6666    CLinearList* pSymbolicLinks;
    67  
    68     PHANDLENAME findSymbolicLink(PSZ pszSymbolicLink,
     67
     68    PHANDLENAME findSymbolicLink(PCSZ pszSymbolicLink,
    6969                                 BOOL fCaseInsensitive);
    70  
    71     PHANDLENAME findSymbolicLinkExact(PSZ pszSymbolicLink);
    72  
     70
     71    PHANDLENAME findSymbolicLinkExact(PCSZ pszSymbolicLink);
     72
    7373  public:
    7474    HandleNames(void);
    7575    ~HandleNames();
    76  
    77     BOOL addSymbolicLink(PSZ pszSymbolicLink,
    78                          PSZ pszTarget);
    79  
    80     BOOL removeSymbolicLink(PSZ pszSymbolicLink);
    81  
    82     BOOL removeTarget(PSZ pszTarget);
    83  
    84     BOOL resolveName(PSZ pszName,
    85                      PSZ pszTarget, 
    86                      ULONG ulTargetLength, 
     76
     77    BOOL addSymbolicLink(PCSZ pszSymbolicLink,
     78                         PCSZ pszTarget);
     79
     80    BOOL removeSymbolicLink(PCSZ pszSymbolicLink);
     81
     82    BOOL removeTarget(PCSZ pszTarget);
     83
     84    BOOL resolveName(PCSZ pszName,
     85                     PSZ pszTarget,
     86                     ULONG ulTargetLength,
    8787                     BOOL fCaseInsensitive);
    8888};
    … …  
    107107 * Name      : HandleNames::HandleNames
    108108 * Purpose   : Constructor for handle name mapper
    109  * Parameters: 
    110  * Variables :
    111  * Result    : 
     109 * Parameters:
     110 * Variables :
     111 * Result    :
    112112 * Remark    :
    113113 * Status    :
    … …  
    127127 * Name      : HandleNames::~HandleNames
    128128 * Purpose   : destructor for handle name mapper
    129  * Parameters: 
    130  * Variables :
    131  * Result    : 
     129 * Parameters:
     130 * Variables :
     131 * Result    :
    132132 * Remark    :
    133133 * Status    :
    … …  
    148148 *             BOOL fCaseInsensitive - TRUE for a case-insensitive lookup
    149149 * Variables :
    150  * Result    : 
     150 * Result    :
    151151 * Remark    : The comparison here is not meant to be "identity" but
    152152 *             "startsWith" because for the name resolver, the first
    … …  
    161161 *****************************************************************************/
    162162
    163 PHANDLENAME HandleNames::findSymbolicLink(PSZ pszSymbolicLink,
     163PHANDLENAME HandleNames::findSymbolicLink(PCSZ pszSymbolicLink,
    164164                                          BOOL fCaseInsensitive)
    165165{
    … …  
    170170    PHANDLENAME pHandleName = (PHANDLENAME)pLE->pObject;
    171171    int cch = pHandleName->ulSymbolicLinkLength; //strlen(pHandleName->pszSymbolicLink);
    172    
     172
    173173    /* pszSymbolicLink must end a path component at cch. */
    174174    if (    cch <= cchSymbolicLink
    … …  
    186186    }
    187187    }
    188    
     188
    189189    // skip to the next entry
    190190    pLE = pSymbolicLinks->getNext(pLE);
    191191  }
    192  
     192
    193193  // not found
    194194  return NULL;
    … …  
    202202 *             BOOL fCaseInsensitive - TRUE for a case-insensitive lookup
    203203 * Variables :
    204  * Result    : 
     204 * Result    :
    205205 * Remark    : The comparison here is not meant to be "identity" but
    206206 *             "startsWith" because for the name resolver, the first
    … …  
    215215 *****************************************************************************/
    216216
    217 PHANDLENAME HandleNames::findSymbolicLinkExact(PSZ pszSymbolicLink)
     217PHANDLENAME HandleNames::findSymbolicLinkExact(PCSZ pszSymbolicLink)
    218218{
    219219  PLINEARLISTENTRY pLE = pSymbolicLinks->getFirst();
    … …  
    221221  {
    222222    PHANDLENAME pHandleName = (PHANDLENAME)pLE->pObject;
    223    
     223
    224224    if (strcmp(pHandleName->pszSymbolicLink, pszSymbolicLink) == 0)
    225225      return pHandleName;
    226    
     226
    227227    // skip to the next entry
    228228    pLE = pSymbolicLinks->getNext(pLE);
    229229  }
    230  
     230
    231231  // not found
    232232  return NULL;
    … …  
    248248 *****************************************************************************/
    249249
    250 BOOL HandleNames::addSymbolicLink(PSZ pszSymbolicLink,
    251                                   PSZ pszTarget)
     250BOOL HandleNames::addSymbolicLink(PCSZ pszSymbolicLink,
     251                                  PCSZ pszTarget)
    252252{
    253253  BOOL rc = TRUE;
    254  
     254
    255255  mtxHandleNameMgr.enter();
    256  
     256
    257257  // 1 - find symbolic link with same name
    258258  PHANDLENAME pHandleName = findSymbolicLinkExact(pszSymbolicLink);
    259  
    260   // 2 - if found 
     259
     260  // 2 - if found
    261261  if (NULL != pHandleName)
    262262  {
    … …  
    264264    if (strcmp(pszTarget, pHandleName->pszTarget) == 0)
    265265      rc = TRUE;
    266    
     266
    267267    // 2.2 - and targets are identical, return TRUE
    268268    else
    … …  
    297297          pHandleName->ulTargetLength = strlen(pszTarget);
    298298          pHandleName->ulSymbolicLinkLength = strlen(pszSymbolicLink);
    299          
     299
    300300          // OK, finally add to the list
    301301          pSymbolicLinks->addFirst(pHandleName);
    … …  
    304304    }
    305305  }
    306  
     306
    307307  mtxHandleNameMgr.leave();
    308  
     308
    309309  return rc;
    310310}
    … …  
    312312
    313313/*****************************************************************************
    314  * Name      : 
    315  * Purpose   : 
    316  * Parameters: 
     314 * Name      :
     315 * Purpose   :
     316 * Parameters:
    317317 * Variables :
    318318 * Result    : TRUE if successful, FALSE if otherwise
    … …  
    323323 *****************************************************************************/
    324324
    325 BOOL HandleNames::removeSymbolicLink(PSZ pszSymbolicLink)
     325BOOL HandleNames::removeSymbolicLink(PCSZ pszSymbolicLink)
    326326{
    327327  BOOL rc = TRUE;
    328  
     328
    329329  mtxHandleNameMgr.enter();
    330  
     330
    331331  // 1 - find symbolic name
    332332  PHANDLENAME pHandleName = findSymbolicLinkExact(pszSymbolicLink);
    … …  
    337337    // 2 - remove the link
    338338    pSymbolicLinks->removeObject(pHandleName);
    339    
     339
    340340    if (NULL != pHandleName->pszSymbolicLink )
    341341      free( pHandleName->pszSymbolicLink );
    342    
     342
    343343    if (NULL != pHandleName->pszTarget )
    344344      free( pHandleName->pszTarget );
    345    
     345
    346346    free( pHandleName );
    347347  }
    348  
     348
    349349  mtxHandleNameMgr.leave();
    350  
     350
    351351  return rc;
    352352}
    … …  
    365365 *****************************************************************************/
    366366
    367 BOOL HandleNames::removeTarget(PSZ pszTarget)
     367BOOL HandleNames::removeTarget(PCSZ pszTarget)
    368368{
    369369  BOOL rc = FALSE;
    370  
     370
    371371  mtxHandleNameMgr.enter();
    372  
     372
    373373  // iterate over all registered symbolic links
    374374  PLINEARLISTENTRY pLE = pSymbolicLinks->getFirst();
    … …  
    376376  {
    377377    PHANDLENAME pHandleName = (PHANDLENAME)pLE->pObject;
    378    
     378
    379379    // check the name
    380380    if (strcmp(pszTarget, pHandleName->pszTarget) == 0)
    381381    {
    382382      pSymbolicLinks->removeElement(pLE);
    383      
     383
    384384      // at least one removal succeeded
    385385      rc = TRUE;
    386386    }
    387387  }
    388  
     388
    389389  mtxHandleNameMgr.leave();
    390  
     390
    391391  return rc;
    392392}
    … …  
    403403 * Variables :
    404404 * Result    : FALSE if name was not modified, TRUE if name was resolved
    405  * Remark    : This is a very easy, cheesy implementation of a pathname 
     405 * Remark    : This is a very easy, cheesy implementation of a pathname
    406406 *             cracker. Should be sufficient at the moment though.
    407407 * Status    :
    … …  
    410410 *****************************************************************************/
    411411
    412 BOOL HandleNames::resolveName(PSZ pszName,
    413                               PSZ pszTarget, 
     412BOOL HandleNames::resolveName(PCSZ pszName,
     413                              PSZ pszTarget,
    414414                              ULONG ulTargetLength,
    415415                              BOOL fCaseInsensitive)
    416416{
    417417  BOOL rc = FALSE;
    418  
     418
    419419  mtxHandleNameMgr.enter();
    420  
     420
    421421  // scan through the names (case-insensitive)
    422422  PHANDLENAME pHandleName = findSymbolicLink(pszName, fCaseInsensitive);
    … …  
    425425    // rebuild the target name
    426426    int iNameLength     = strlen(pszName);
    427    
     427
    428428    // first copy the resolved target name fragment
    429429    strncpy(pszTarget,
    430430            pHandleName->pszTarget,
    431431            ulTargetLength);
    432    
     432
    433433    // now append the rest of the specified name with the
    434434    // now resolved symbolic cut away
    … …  
    437437              pszName + pHandleName->ulSymbolicLinkLength,
    438438              ulTargetLength - pHandleName->ulTargetLength);
    439    
     439
    440440    // tell caller the name has been resolved
    441441    // (is different from the source name)
    442442    rc = TRUE;
    443443  }
    444  
     444
    445445  mtxHandleNameMgr.leave();
    446  
     446
    447447  return rc;
    448448}
    … …  
    454454 * Exported Wrapper Functions
    455455 *****************************************************************************/
    456  
    457 BOOL HandleNamesResolveName(PSZ pszName,
     456
     457BOOL HandleNamesResolveName(PCSZ pszName,
    458458                            PSZ pszTarget,
    459459                            ULONG ulTargetLength,
    … …  
    467467
    468468
    469 BOOL HandleNamesAddSymbolicLink(PSZ pszSymbolicLink,
    470                                 PSZ pszTarget)
     469BOOL HandleNamesAddSymbolicLink(PCSZ pszSymbolicLink,
     470                                PCSZ pszTarget)
    471471{
    472472  return pHandleNameMgr->addSymbolicLink(pszSymbolicLink,
    473473                                         pszTarget);
    474474}
    475  
    476 
    477 BOOL HandleNamesRemoveSymbolicLink(PSZ pszSymbolicLink)
     475
     476
     477BOOL HandleNamesRemoveSymbolicLink(PCSZ pszSymbolicLink)
    478478{
    479479  return pHandleNameMgr->removeSymbolicLink(pszSymbolicLink);
    480480}
    481  
    482 
    483 BOOL HandleNamesRemoveTarget(PSZ pszTarget)
     481
     482
     483BOOL HandleNamesRemoveTarget(PCSZ pszTarget)
    484484{
    485485  return pHandleNameMgr->removeTarget(pszTarget);

  • branches/gcc-kmk/src/kernel32/handlenames.h

    r7441 r21717  
    1717 * Exported Wrapper Functions
    1818 *****************************************************************************/
    19  
    20 BOOL HandleNamesResolveName(PSZ pszName,
    21                             PSZ pszTarget,
     19
     20BOOL HandleNamesResolveName(PCSZ pszName,
     21                            PCSZ pszTarget,
    2222                            ULONG ulTargetLength,
    2323                            BOOL fCaseInsensitive);
    2424
    25 BOOL HandleNamesAddSymbolicLink(PSZ pszSymbolicLink,
    26                                 PSZ pszTarget);
     25BOOL HandleNamesAddSymbolicLink(PCSZ pszSymbolicLink,
     26                                PCSZ pszTarget);
    2727
    28 BOOL HandleNamesRemoveSymbolicLink(PSZ pszSymbolicLink);
     28BOOL HandleNamesRemoveSymbolicLink(PCSZ pszSymbolicLink);
    2929
    30 BOOL HandleNamesRemoveTarget(PSZ pszTarget);
     30BOOL HandleNamesRemoveTarget(PCSZ pszTarget);
    3131
    3232

  • branches/gcc-kmk/src/kernel32/hmdevice.h

    r21302 r21717  
    451451
    452452                            /* register a new device with the handle manager */
    453 DWORD  HMDeviceRegister(LPSTR           pszDeviceName,
     453DWORD  HMDeviceRegister(LPCSTR           pszDeviceName,
    454454                        HMDeviceHandler *pDeviceHandler);
    455455
    456 DWORD  HMDeviceRegisterEx(LPSTR           pszDeviceName,
     456DWORD  HMDeviceRegisterEx(LPCSTR           pszDeviceName,
    457457                          HMDeviceHandler *pDeviceHandler,
    458458                          VOID            *pDevData);

  • branches/gcc-kmk/src/kernel32/kdbhookhlp.cpp

    r10382 r21717  
    3434//******************************************************************************
    3535//******************************************************************************
    36 char *WIN32API QueryCustomStdClassName()
     36const char *WIN32API QueryCustomStdClassName()
    3737{
    3838   return ODIN_WIN32_STDCLASS;

  • branches/gcc-kmk/src/user32/pmwindow.cpp

    r21556 r21717  
    27472747//******************************************************************************
    27482748//******************************************************************************
    2749 char *WIN32API QueryCustomStdClassName()
     2749const char *WIN32API QueryCustomStdClassName()
    27502750{
    27512751   return WIN32_STDCLASS;
Note: See TracChangeset for help on using the changeset viewer.