Changeset 17623


Ignore:
Timestamp:
Oct 15, 2001, 7:10:55 PM (24 years ago)
Author:
sandervl
Message:

custom build update

Location:
tags/trunk/src
Files:
3 added
14 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified tags/trunk/src/kernel32/directory.cpp

    r17071 r17623  
    1 /* $Id: directory.cpp,v 1.39 2001-08-10 19:32:26 sandervl Exp $ */
     1/* $Id: directory.cpp,v 1.40 2001-10-15 17:10:54 sandervl Exp $ */
    22
    33/*
    … …  
    5353static char DIR_Windows[MAX_PATHNAME_LEN];
    5454static char DIR_System[MAX_PATHNAME_LEN];
     55static BOOL fDirInit = FALSE;
    5556
    5657//******************************************************************************
    … …  
    7374 int   len;
    7475
     76   if(fDirInit == TRUE) return;
     77
     78   fDirInit = TRUE;
    7579   strcpy(DIR_System, kernel32Path);
    7680   len = strlen(DIR_System);
    … …  
    100104   dprintf(("System32 dir: %s", DIR_System));
    101105}
     106//*****************************************************************************
     107//*****************************************************************************
     108void InitDirectoriesCustom(char *szSystemDir, char *szWindowsDir)
     109{
     110   int len;
     111
     112   if(fDirInit == TRUE) return;
     113   fDirInit = TRUE;
     114
     115   strcpy(DIR_System, szSystemDir);
     116   len = strlen(DIR_System);
     117   if(DIR_System[len-1] == '\\') {
     118        DIR_System[len-1] = 0;
     119   }
     120   strcpy(DIR_Windows, szWindowsDir);
     121   len = strlen(DIR_Windows);
     122   if(DIR_Windows[len-1] == '\\') {
     123        DIR_Windows[len-1] = 0;
     124   }
     125
     126   dprintf(("Windows  dir: %s", DIR_Windows));
     127   dprintf(("System32 dir: %s", DIR_System));
     128}
    102129/*****************************************************************************
    103130 * Name      : GetCurrentDirectoryA

  • TabularUnified tags/trunk/src/kernel32/heap.cpp

    r17587 r17623  
    1 /* $Id: heap.cpp,v 1.36 2001-10-12 03:48:06 phaller Exp $ */
     1/* $Id: heap.cpp,v 1.37 2001-10-15 17:10:54 sandervl Exp $ */
    22
    33/*
    … …  
    226226 *      NULL: Failure
    227227 */
    228 ODINFUNCTION2(HGLOBAL, GlobalAlloc,
    229               UINT, flags,
    230               DWORD, size)
    231 {
     228HGLOBAL WINAPI GlobalAlloc(
     229                 UINT flags, /* [in] Object allocation attributes */
     230                 DWORD size    /* [in] Number of bytes to allocate */
     231) {
    232232   PGLOBAL32_INTERN     pintern;
    233233   DWORD                hpflags;
    … …  
    280280 *      NULL: Failure
    281281 */
    282 ODINFUNCTION1(LPVOID, GlobalLock,
    283               HGLOBAL, hmem)
    284 {
     282LPVOID WINAPI GlobalLock(
     283              HGLOBAL hmem /* [in] Handle of global memory object */
     284) {
    285285   PGLOBAL32_INTERN pintern;
    286286   LPVOID           palloc;
    … …  
    328328 *      FALSE: Object is unlocked
    329329 */
    330 ODINFUNCTION1(BOOL, GlobalUnlock,
    331               HGLOBAL, hmem)
    332 {
     330BOOL WINAPI GlobalUnlock(
     331              HGLOBAL hmem /* [in] Handle of global memory object */
     332) {
    333333   PGLOBAL32_INTERN       pintern;
    334334   BOOL                 locked;
     335
     336   dprintf(("KERNEL32: GlobalUnlock %x", hmem));
    335337
    336338   if(hmem == NULL || ISPOINTER(hmem))
    … …  
    375377 *      NULL: Failure
    376378 */
    377 ODINFUNCTION1(HGLOBAL, GlobalHandle,
    378               LPCVOID, pmem)
    379 {
     379HGLOBAL WINAPI GlobalHandle(
     380                 LPCVOID pmem /* [in] Pointer to global memory block */
     381) {
    380382    HGLOBAL handle;
    381383    PGLOBAL32_INTERN  maybe_intern;
    382384    LPCVOID test;
     385
     386    dprintf(("KERNEL32: GlobalHandle %x", pmem));
    383387
    384388    if (!pmem)
    … …  
    466470 *      NULL: Failure
    467471 */
    468 ODINFUNCTION3(HGLOBAL, GlobalReAlloc,
    469                  HGLOBAL, hmem,
    470                  DWORD, size,
    471                  UINT, flags)
    472 {
     472HGLOBAL WINAPI GlobalReAlloc(
     473                 HGLOBAL hmem, /* [in] Handle of global memory object */
     474                 DWORD size,     /* [in] New size of block */
     475                 UINT flags    /* [in] How to reallocate object */
     476) {
    473477   LPVOID               palloc;
    474478   HGLOBAL            hnew;
    … …  
    576580 *      Handle: Failure
    577581 */
    578 ODINFUNCTION1(HGLOBAL, GlobalFree,
    579               HGLOBAL, hmem)
    580 {
     582HGLOBAL WINAPI GlobalFree(
     583                 HGLOBAL hmem /* [in] Handle of global memory object */
     584) {
    581585   PGLOBAL32_INTERN pintern;
    582586   HGLOBAL        hreturned = 0;
     587
     588   dprintf(("KERNEL32: GlobalFree %x", hmem));
    583589
    584590   /* verify lpMem address */
    … …  
    625631 *      0: Failure
    626632 */
    627 ODINFUNCTION1(DWORD, GlobalSize,
    628               HGLOBAL, hmem)
    629 {
     633DWORD WINAPI GlobalSize(
     634             HGLOBAL hmem /* [in] Handle of global memory object */
     635) {
    630636   DWORD                retval;
    631637   PGLOBAL32_INTERN     pintern;
     638
     639   dprintf(("KERNEL32: GlobalSize %x", hmem));
    632640
    633641   if(ISPOINTER(hmem))
    … …  
    666674 *           GlobalWire   (KERNEL32.@)
    667675 */
    668 ODINFUNCTION1(LPVOID, GlobalWire,
    669               HGLOBAL, hmem)
     676LPVOID WINAPI GlobalWire(HGLOBAL hmem)
    670677{
    671678   return GlobalLock( hmem );
    … …  
    676683 *           GlobalUnWire   (KERNEL32.@)
    677684 */
    678 ODINFUNCTION1(BOOL, GlobalUnWire,
    679               HGLOBAL, hmem)
     685BOOL WINAPI GlobalUnWire(HGLOBAL hmem)
    680686{
    681687   return GlobalUnlock( hmem);
    … …  
    686692 *           GlobalFix   (KERNEL32.@)
    687693 */
    688 ODINPROCEDURE1(GlobalFix,
    689                HGLOBAL, hmem)
     694VOID WINAPI GlobalFix(HGLOBAL hmem)
    690695{
    691696    GlobalLock( hmem );
    … …  
    696701 *           GlobalUnfix   (KERNEL32.@)
    697702 */
    698 ODINPROCEDURE1(GlobalUnfix,
    699                HGLOBAL, hmem)
     703VOID WINAPI GlobalUnfix(HGLOBAL hmem)
    700704{
    701705   GlobalUnlock( hmem);
    … …  
    714718 *      GMEM_INVALID_HANDLE: Failure
    715719 */
    716 ODINFUNCTION1(UINT, GlobalFlags,
    717               HGLOBAL, hmem)
    718 {
     720UINT WINAPI GlobalFlags(
     721              HGLOBAL hmem /* [in] Handle to global memory object */
     722) {
    719723   DWORD                retval;
    720724   PGLOBAL32_INTERN     pintern;
    721725
     726   dprintf(("KERNEL32: GlobalFlags %x", hmem));
     727   
    722728   if(ISPOINTER(hmem))
    723729   {
    … …  
    748754 *           GlobalCompact   (KERNEL32.@)
    749755 */
    750 ODINFUNCTION1(DWORD, GlobalCompact,
    751               DWORD, minfree )
    752 {
     756DWORD WINAPI GlobalCompact( DWORD minfree )
     757{
     758    dprintf(("KERNEL32:  GlobalCompact %d OBSOLETE", minfree));
     759
    753760    return 0;  /* GlobalCompact does nothing in Win32 */
    754761}
    … …  
    759766#endif
    760767//******************************************************************************
    761 ODINFUNCTION2(HGLOBAL, GlobalAlloc,
    762               UINT, fuFlags,
    763               DWORD, dwBytes)
     768HGLOBAL WIN32API GlobalAlloc(UINT fuFlags, DWORD dwBytes)
    764769{
    765770 HGLOBAL ret;
    … …  
    769774    totalGlobalAlloc += dwBytes;
    770775#endif
     776    dprintf(("KERNEL32: GlobalAlloc %x %d returned %x (total %x)", fuFlags, dwBytes, ret, totalGlobalAlloc));
    771777    return ret;
    772778}
    773779//******************************************************************************
    774780//******************************************************************************
    775 ODINFUNCTION1(HGLOBAL, GlobalFree,
    776               HGLOBAL, arg1)
     781HGLOBAL WIN32API GlobalFree( HGLOBAL arg1)
    777782{
    778783 HGLOBAL ret;
    … …  
    782787#endif
    783788    ret = O32_GlobalFree(arg1);
     789    dprintf(("KERNEL32: GlobalFree %x returned %x (lasterr=%x) total %x", arg1, ret, GetLastError(), totalGlobalAlloc));
    784790    return ret;
    785791}
    786792//******************************************************************************
    787793//******************************************************************************
    788 ODINFUNCTION1(HGLOBAL, GlobalHandle,
    789               LPCVOID, lpMem)
    790 {
     794HGLOBAL WIN32API GlobalHandle( LPCVOID lpMem)
     795{
     796    dprintf(("KERNEL32: GlobalHandle %x", lpMem));
     797
    791798    return O32_GlobalHandle((LPVOID)lpMem);
    792799}
    793800//******************************************************************************
    794801//******************************************************************************
    795 ODINFUNCTION1(UINT, GlobalFlags,
    796               HGLOBAL, hMem)
    797 {
     802UINT WIN32API GlobalFlags(HGLOBAL hMem)
     803{
     804    dprintf(("KERNEL32: GlobalFlags %x", hMem));
     805
    798806    return O32_GlobalFlags(hMem);
    799807}
    800808//******************************************************************************
    801809//******************************************************************************
    802 ODINFUNCTION1(DWORD, GlobalCompact,
    803               DWORD, dwMinFree)
    804 {
     810DWORD WIN32API GlobalCompact(DWORD dwMinFree)
     811{
     812  dprintf(("KERNEL32:  GlobalCompact, OBSOLETE - stub\n"));
     813
    805814  return(0);
    806815}
    807816//******************************************************************************
    808817//******************************************************************************
    809 ODINFUNCTION1(PVOID, GlobalLock,
    810               HGLOBAL, hMem)
    811 {
    812   return O32_GlobalLock(hMem);
    813 }
    814 //******************************************************************************
    815 //******************************************************************************
    816 ODINFUNCTION3(HGLOBAL, GlobalReAlloc,
    817               HGLOBAL, arg1,
    818               DWORD, arg2,
    819               UINT,  arg3)
    820 {
     818PVOID WIN32API GlobalLock(HGLOBAL hMem)
     819{
     820 PVOID ret;
     821
     822    ret = O32_GlobalLock(hMem);
     823    dprintf(("KERNEL32: GlobalLock %x returned %x", hMem, ret));
     824    return ret;
     825}
     826//******************************************************************************
     827//******************************************************************************
     828HGLOBAL WIN32API GlobalReAlloc(HGLOBAL arg1, DWORD arg2, UINT  arg3)
     829{
     830    dprintf(("KERNEL32: GlobalReAlloc %x %x %d", arg1, arg2, arg3));
     831
    821832    return O32_GlobalReAlloc(arg1, arg2, arg3);
    822833}
    823834//******************************************************************************
    824835//******************************************************************************
    825 ODINFUNCTION1(DWORD, GlobalSize,
    826               HGLOBAL, arg1)
    827 {
     836DWORD WIN32API GlobalSize(HGLOBAL arg1)
     837{
     838    dprintf(("KERNEL32:  GlobalSize\n"));
     839
    828840    return O32_GlobalSize(arg1);
    829841}
    830842//******************************************************************************
    831843//******************************************************************************
    832 ODINFUNCTION1(BOOL, GlobalUnlock,
    833               HGLOBAL, arg1)
    834 {
     844BOOL WIN32API GlobalUnlock(HGLOBAL arg1)
     845{
     846    dprintf(("KERNEL32:  GlobalUnlock\n"));
     847
    835848    return O32_GlobalUnlock(arg1);
    836849}
    … …  
    843856 *
    844857 */
    845 ODINFUNCTION1(LPVOID, GlobalWire,
    846               HGLOBAL, hmem)
     858LPVOID WIN32API GlobalWire(HGLOBAL hmem)
    847859{
    848860   return GlobalLock( hmem );
    … …  
    856868 *
    857869 */
    858 ODINFUNCTION1(BOOL, GlobalUnWire,
    859               HGLOBAL, hmem)
     870BOOL WIN32API GlobalUnWire(HGLOBAL hmem)
    860871{
    861872   return GlobalUnlock( hmem);
    … …  
    863874//******************************************************************************
    864875//******************************************************************************
    865 ODINFUNCTION1(HGLOBAL, GlobalDiscard,
    866               HGLOBAL, hGlobal)
    867 {
     876HGLOBAL WIN32API GlobalDiscard(HGLOBAL hGlobal)
     877{
     878    dprintf(("KERNEL32: GlobalDiscard %x", hGlobal));
     879
    868880    return O32_GlobalDiscard(hGlobal);
    869881}
    … …  
    871883 *           GlobalFix   (KERNEL32.@)
    872884 */
    873 ODINPROCEDURE1(GlobalFix,
    874                HGLOBAL, hmem)
     885VOID WINAPI GlobalFix(HGLOBAL hmem)
    875886{
    876887    GlobalLock( hmem );
    … …  
    879890 *           GlobalUnfix   (KERNEL32.@)
    880891 */
    881 ODINPROCEDURE1(GlobalUnfix,
    882                HGLOBAL, hmem)
     892VOID WINAPI GlobalUnfix(HGLOBAL hmem)
    883893{
    884894   GlobalUnlock( hmem);
    … …  
    887897//******************************************************************************
    888898//******************************************************************************
    889 ODINFUNCTION2(HLOCAL, LocalAlloc,
    890               UINT, fuFlags,
    891               DWORD, cbBytes)
     899HLOCAL WIN32API LocalAlloc(UINT fuFlags, DWORD cbBytes)
    892900{
    893901    HLOCAL hLocal;
    … …  
    908916//******************************************************************************
    909917//******************************************************************************
    910 ODINFUNCTION1(UINT, LocalFlags,
    911               HLOCAL, hMem)
     918UINT WIN32API LocalFlags(HLOCAL hMem)
    912919{
    913920    UINT ret, retG;
     921    dprintf(("KERNEL32: LocalFlags %X\n", hMem));
    914922
    915923    retG = GlobalFlags(hMem);
    … …  
    929937//******************************************************************************
    930938//******************************************************************************
    931 ODINFUNCTION1(HLOCAL, LocalFree,
    932               HLOCAL, hMem)
    933 {
     939HLOCAL WIN32API LocalFree(HLOCAL hMem)
     940{
     941  dprintf(("KERNEL32: LocalFree %X", hMem));
     942
    934943  return GlobalFree(hMem);
    935944}
    936945//******************************************************************************
    937946//******************************************************************************
    938 ODINFUNCTION1(HLOCAL, LocalHandle,
    939               PCVOID, lpMem)
    940 {
     947HLOCAL WIN32API LocalHandle(PCVOID lpMem)
     948{
     949    dprintf(("KERNEL32: LocalHandle %x", lpMem));
     950
    941951    return GlobalHandle(lpMem);
    942952}
    943953//******************************************************************************
    944954//******************************************************************************
    945 ODINFUNCTION1(BOOL, LocalUnlock,
    946               HLOCAL, hMem)
    947 {
     955BOOL WIN32API LocalUnlock(HLOCAL hMem)
     956{
     957    dprintf(("KERNEL32: LocalUnlock %X", hMem));
     958
    948959    return GlobalUnlock(hMem);
    949960}
    … …  
    951962//TODO: cbBytes==0 && fuFlags & LMEM_MOVEABLE not handled!!
    952963//******************************************************************************
    953 ODINFUNCTION3(HLOCAL, LocalReAlloc,
    954               HLOCAL, hMem,
    955               DWORD, cbBytes,
    956               UINT, fuFlags)
     964HLOCAL WIN32API LocalReAlloc(HLOCAL hMem, DWORD cbBytes, UINT fuFlags)
    957965{
    958966  HLOCAL hLocalNew, hLocalOld;
    959967  LPVOID lpMem, lpMemOld;
    960968  DWORD  cbOldSize;
     969
     970    dprintf(("KERNEL32: LocalReAlloc %X %d %X\n", hMem, cbBytes, fuFlags));
    961971
    962972    // Check flags
    … …  
    978988//******************************************************************************
    979989//******************************************************************************
    980 ODINFUNCTION1(UINT, LocalSize,
    981               HLOCAL, hMem)
    982 {
     990UINT WIN32API LocalSize(HLOCAL hMem)
     991{
     992    dprintf(("KERNEL32: LocalSize %X", hMem));
     993
    983994    return GlobalSize(hMem);
    984995}
    985996//******************************************************************************
    986997//******************************************************************************
    987 ODINFUNCTION1(PVOID, LocalLock,
    988               HLOCAL, hMem)
    989 {
     998PVOID WIN32API LocalLock(HLOCAL hMem)
     999{
     1000    dprintf(("KERNEL32:  LocalLock %X\n", hMem));
     1001
    9901002    return GlobalLock(hMem);
    9911003}
    … …  
    9931005//* this function is here for completeness, some stupid software requires it.
    9941006//******************************************************************************
    995 ODINFUNCTION2(UINT, LocalShrink,
    996               HLOCAL, hMem,
    997               UINT, cbNewSize)
    998 {
     1007UINT WIN32API LocalShrink(HLOCAL hMem, UINT cbNewSize)
     1008{
     1009    dprintf(("KERNEL32:  LocalShrink %X, %08xh - OBSOLETE", hMem, cbNewSize));
     1010
    9991011    return cbNewSize;
    10001012}
    … …  
    10021014//* this function is here for completeness, mIRC/32 requires it.
    10031015//******************************************************************************
    1004 ODINFUNCTION1(UINT, LocalCompact,
    1005               UINT, cbNewSize)
    1006 {
     1016UINT WIN32API LocalCompact(UINT cbNewSize)
     1017{
     1018    dprintf(("KERNEL32:  LocalCompact %08xh - OBSOLETE", cbNewSize));
     1019
    10071020    return cbNewSize;
    10081021}

  • TabularUnified tags/trunk/src/kernel32/heapstring.cpp

    r17589 r17623  
    1 /* $Id: heapstring.cpp,v 1.44 2001-10-12 07:05:48 phaller Exp $ */
     1/* $Id: heapstring.cpp,v 1.45 2001-10-15 17:10:54 sandervl Exp $ */
    22
    33/*
    … …  
    5353 *****************************************************************************/
    5454
    55 ODINFUNCTIONNODBG1(int, lstrlenA,
    56                    LPCSTR, arg1)
     55int WIN32API lstrlenA(LPCSTR arg1)
    5756{
    5857  dprintf2(("KERNEL32: lstrlenA(%s)\n",
    … …  
    7978 *****************************************************************************/
    8079
    81 ODINFUNCTIONNODBG1(int, lstrlenW,
    82                    LPCWSTR, arg1)
     80int WIN32API lstrlenW(LPCWSTR arg1)
    8381{
    8482  int rc;
    … …  
    109107 *****************************************************************************/
    110108
    111 ODINFUNCTIONNODBG2(LPSTR, lstrcatA,
    112                    LPSTR, arg1,
    113                    LPCSTR, arg2)
     109LPSTR WIN32API lstrcatA(LPSTR arg1, LPCSTR arg2)
    114110{
    115111  dprintf2(("KERNEL32: lstrcat(%s,%s)\n",
    … …  
    136132 *****************************************************************************/
    137133
    138 ODINFUNCTIONNODBG2(LPWSTR, lstrcatW,
    139                    LPWSTR, arg1,
    140                    LPCWSTR, arg2)
     134LPWSTR WIN32API lstrcatW(LPWSTR arg1, LPCWSTR arg2)
    141135{
    142136  dprintf2(("KERNEL32: OS2lstrcatW(%08xh,%08xh)\n",
    … …  
    164158 *****************************************************************************/
    165159
    166 ODINFUNCTIONNODBG2(int, lstrcmpA,
    167                    LPCSTR, arg1,
    168                    LPCSTR, arg2)
     160int WIN32API lstrcmpA(LPCSTR arg1, LPCSTR  arg2)
    169161{
    170162  dprintf2(("KERNEL32: OS2lstrcmpA(%s,%s)\n",
    … …  
    193185 *****************************************************************************/
    194186
    195 ODINFUNCTIONNODBG3(int, lstrncmpA,
    196                    LPCSTR, arg1,
    197                    LPCSTR, arg2,
    198                    int, l)
     187int WIN32API lstrncmpA(LPCSTR arg1, LPCSTR  arg2, int l)
    199188{
    200189  dprintf2(("KERNEL32: OS2lstrncmpA(%s,%s,%d)\n",
    … …  
    217206 * Author    : Przemyslaw Dobrowolski
    218207 *****************************************************************************/
    219 ODINFUNCTIONNODBG3(INT, lstrncmpiA,
    220                    LPCSTR, str1,
    221                    LPCSTR, str2,
    222                    INT, n )
     208INT WINAPI lstrncmpiA( LPCSTR str1, LPCSTR str2, INT n )
    223209{
    224210  INT firstch,lastch;
    … …  
    241227}
    242228//TODO: Don't know if this is completely correct
    243 ODINFUNCTIONNODBG3(int, lstrncmpiW,
    244                    LPCWSTR, str1,
    245                    LPCWSTR, str2,
    246                    int, n)
     229int WIN32API lstrncmpiW(LPCWSTR str1, LPCWSTR str2, int n)
    247230{
    248231  INT firstch,lastch;
    … …  
    277260 *****************************************************************************/
    278261
    279 ODINFUNCTIONNODBG2(int, lstrcmpW,
    280                    LPCWSTR, arg1,
    281                    LPCWSTR, arg2)
     262int WIN32API lstrcmpW(LPCWSTR arg1, LPCWSTR arg2)
    282263{
    283264    dprintf2(("KERNEL32: lstrcmpW (%08xh, %08xh)\n",
    … …  
    306287 *****************************************************************************/
    307288
    308 ODINFUNCTIONNODBG3(int, lstrncmpW,
    309                    LPCWSTR, arg1,
    310                    LPCWSTR, arg2,
    311                    int, l)
     289int WIN32API lstrncmpW(LPCWSTR arg1, LPCWSTR  arg2, int l)
    312290{
    313291  dprintf2(("KERNEL32: OS2lstrncmpW(%08xh,%08xh,%d)\n",
    … …  
    333311 *****************************************************************************/
    334312
    335 ODINFUNCTIONNODBG2(LPSTR, lstrcpyA,
    336                    LPSTR, dest,
    337                    LPCSTR, src)
     313LPSTR WIN32API lstrcpyA(LPSTR dest, LPCSTR src)
    338314{
    339315    if ( (src == NULL) || (dest == NULL) ) // stupid parameter checking
    … …  
    356332 *****************************************************************************/
    357333
    358 ODINFUNCTIONNODBG2(LPWSTR, lstrcpyW,
    359                    LPWSTR, dest,
    360                    LPCWSTR, src)
     334LPWSTR WIN32API lstrcpyW(LPWSTR dest, LPCWSTR src)
    361335{
    362336    if ( (src == NULL) || (dest == NULL) ) // stupid parameter checking
    … …  
    381355 *****************************************************************************/
    382356
    383 ODINFUNCTIONNODBG3(LPSTR, lstrcpynA,
    384                    LPSTR, arg1,
    385                    LPCSTR, arg2,
    386                    int, arg3)
     357LPSTR WIN32API lstrcpynA(LPSTR arg1, LPCSTR  arg2, int arg3)
    387358{
    388359  register LPSTR p1 = arg1;
    389360  register LPSTR p2 = (LPSTR)arg2;
     361
     362  dprintf2(("KERNEL32: OS2lstrcpyA(%08xh, %08xh, %08xh)\n",
     363           arg1,
     364           arg2,
     365           arg3));
    390366
    391367  if(arg3 == 0) {
    … …  
    419395 *****************************************************************************/
    420396
    421 ODINFUNCTION3(LPWSTR, lstrcpynW,
    422               LPWSTR, dest,
    423               LPCWSTR, src,
    424               int, arg3)
    425 {
     397LPWSTR WIN32API lstrcpynW(LPWSTR dest, LPCWSTR src, int arg3)
     398{
     399  dprintf2(("KERNEL32: lstrcpynW(%08xh,%08xh,%08xh)",
     400           dest,
     401           src,
     402           arg3));
     403
    426404  if (arg3 == 0)
    427405    return NULL;
    … …  
    447425 *****************************************************************************/
    448426
    449 ODINFUNCTIONNODBG2(int, lstrcmpiA,
    450                    LPCSTR, arg1,
    451                    LPCSTR, arg2)
     427int WIN32API lstrcmpiA(LPCSTR arg1, LPCSTR  arg2)
    452428{
    453429  dprintf2(("KERNEL32: lstrcmpiA(%s,%s)\n",
    … …  
    477453 *****************************************************************************/
    478454
    479 ODINFUNCTIONNODBG2(int, lstrcmpiW,
    480                    LPCWSTR, str1,
    481                    LPCWSTR, str2)
    482 {
    483   if (!str1 || !str2) {
    484    
    485     SetLastError(ERROR_INVALID_PARAMETER);
    486     return 0;
    487   }
    488   return strcmpiW( str1, str2 );
     455int WIN32API lstrcmpiW(LPCWSTR str1, LPCWSTR str2)
     456{
     457    dprintf2(("KERNEL32: lstrcmpiW(%08xh,%08xh)", str1, str2));
     458
     459    if (!str1 || !str2) {
     460        SetLastError(ERROR_INVALID_PARAMETER);
     461        return 0;
     462    }
     463    return strcmpiW( str1, str2 );
    489464}
    490465
    … …  
    493468//because Wine code depends on this behaviour (i.e. comdlg32)
    494469//*****************************************************************************
    495 ODINFUNCTIONNODBG3(int, lstrcpynWtoA,
    496                    LPSTR,   astring,
    497                    LPCWSTR, ustring,
    498                    int,     length)
     470int WIN32API lstrcpynWtoA(LPSTR   astring,
     471                          LPCWSTR ustring,
     472                          int     length)
    499473{
    500474 int ret;
    … …  
    518492//lstrcpynWtoA and lstrcpynAtoW must zero-terminate the string
    519493//because Wine code depends on this behaviour (i.e. comdlg32)
    520 ODINFUNCTIONNODBG3(int,     lstrcpynAtoW,
    521                    LPWSTR,  unicode,
    522                    LPCSTR,  ascii,
    523                    int ,    asciilen)
     494int WIN32API lstrcpynAtoW(LPWSTR unicode,
     495                          LPCSTR  ascii,
     496                          int    asciilen)
    524497{
    525498 int ret;
    … …  
    555528 *****************************************************************************/
    556529
    557 ODINFUNCTIONNODBG2(LPSTR, lstrcpyWtoA,
    558                    LPSTR, ascii,
    559                    LPCWSTR, unicode)
     530LPSTR WIN32API lstrcpyWtoA(LPSTR ascii, LPCWSTR unicode)
    560531{
    561532    //@@@PH huh? wuz dat?
    … …  
    593564 *****************************************************************************/
    594565
    595 ODINFUNCTIONNODBG2(LPWSTR, lstrcpyAtoW,
    596                    LPWSTR, unicode,
    597                    LPCSTR, ascii)
     566LPWSTR WIN32API lstrcpyAtoW(LPWSTR unicode, LPCSTR ascii)
    598567{
    599568    /* achimha for security, strlen might trap if garbage in */
    … …  
    631600 *****************************************************************************/
    632601
    633 ODINFUNCTIONNODBG3(LPVOID, HEAP_xalloc,
    634                    HANDLE, heap,
    635                    DWORD, flags,
    636                    DWORD, size )
     602LPVOID WIN32API HEAP_xalloc( HANDLE heap, DWORD flags, DWORD size )
    637603{
    638604  LPVOID p = HeapAlloc( heap, flags, size );
    … …  
    660626 *****************************************************************************/
    661627
    662 ODINFUNCTIONNODBG4(LPVOID, HEAP_xrealloc,
    663                    HANDLE, heap,
    664                    DWORD, flags,
    665                    LPVOID, lpMem,
    666                    DWORD, size )
     628LPVOID WIN32API HEAP_xrealloc( HANDLE heap, DWORD flags, LPVOID lpMem, DWORD size )
    667629{
    668630  LPVOID p = HeapReAlloc( heap, flags, lpMem, size );
    … …  
    691653 *****************************************************************************/
    692654
    693 ODINFUNCTIONNODBG1(LPVOID, HEAP_malloc,
    694                    DWORD, size )
     655LPVOID WIN32API HEAP_malloc(DWORD size )
    695656{
    696657  LPVOID p = HeapAlloc( GetProcessHeap(), 0, size );
    … …  
    716677 *****************************************************************************/
    717678
    718 ODINFUNCTIONNODBG1(DWORD, HEAP_size,
    719                    LPVOID, lpMem)
     679DWORD WIN32API HEAP_size(LPVOID lpMem)
    720680{
    721681  return HeapSize( GetProcessHeap(), 0, lpMem );
    … …  
    735695 *****************************************************************************/
    736696
    737 ODINFUNCTIONNODBG2(LPVOID, HEAP_realloc,
    738                    LPVOID, lpMem,
    739                    DWORD, size )
     697LPVOID WIN32API HEAP_realloc(LPVOID lpMem, DWORD size )
    740698{
    741699  LPVOID p = HeapReAlloc( GetProcessHeap(), 0, lpMem, size );
    … …  
    762720 *****************************************************************************/
    763721
    764 ODINPROCEDURENODBG1(HEAP_free,
    765                     LPVOID, lpMem)
    766 {
     722VOID WIN32API HEAP_free(LPVOID lpMem)
     723{
     724  dprintf2(("KERNEL32: HEAP_free(%08xh)\n",
     725           lpMem));
     726
    767727  HeapFree( GetProcessHeap(), 0, lpMem);
    768728}
    … …  
    781741 *****************************************************************************/
    782742
    783 ODINFUNCTIONNODBG3(LPSTR, HEAP_strdupA,
    784                    HANDLE, heap,
    785                    DWORD, flags,
    786                    LPCSTR, str )
    787 {
    788   int iLength = lstrlenA(str) + 1;
    789   LPSTR p = (LPSTR)HEAP_xalloc( heap, flags, iLength );
    790   memcpy( p, str, iLength );
    791   return p;
    792 }
    793 
    794 
    795 /*****************************************************************************
    796  * Name      :
    797  * Purpose   :
    798  * Parameters:
    799  * Variables :
    800  * Result    :
    801  * Remark    :
    802  * Status    :
    803  *
    804  * Author    : Patrick Haller [Thu, 1999/08/05 20:46]
    805  *****************************************************************************/
    806 
    807 ODINFUNCTIONNODBG3(LPWSTR, HEAP_strdupW,
    808                    HANDLE, heap,
    809                    DWORD, flags,
    810                    LPCWSTR, str )
     743LPSTR WIN32API HEAP_strdupA( HANDLE heap, DWORD flags, LPCSTR str )
     744{
     745    LPSTR p = (LPSTR)HEAP_xalloc( heap, flags, lstrlenA(str) + 1 );
     746    lstrcpyA( p, str );
     747    return p;
     748}
     749
     750
     751/*****************************************************************************
     752 * Name      :
     753 * Purpose   :
     754 * Parameters:
     755 * Variables :
     756 * Result    :
     757 * Remark    :
     758 * Status    :
     759 *
     760 * Author    : Patrick Haller [Thu, 1999/08/05 20:46]
     761 *****************************************************************************/
     762
     763LPWSTR WIN32API HEAP_strdupW( HANDLE heap, DWORD flags, LPCWSTR str )
    811764{
    812765    INT len = lstrlenW(str) + 1;
    813766    LPWSTR p = (LPWSTR)HEAP_xalloc( heap, flags, len * sizeof(WCHAR) );
    814     memcpy( p, str, len );
     767    lstrcpyW( p, str );
    815768    return p;
    816769}
    … …  
    829782 *****************************************************************************/
    830783
    831 ODINFUNCTIONNODBG3(LPWSTR, HEAP_strdupAtoW,
    832                    HANDLE, heap,
    833                    DWORD, flags,
    834                    LPCSTR, str )
     784LPWSTR WIN32API HEAP_strdupAtoW( HANDLE heap, DWORD flags, LPCSTR str )
    835785{
    836786    LPWSTR ret;
    … …  
    859809 *****************************************************************************/
    860810
    861 ODINFUNCTIONNODBG3(LPSTR, HEAP_strdupWtoA,
    862                    HANDLE, heap,
    863                    DWORD, flags,
    864                    LPCWSTR, str )
     811LPSTR WIN32API HEAP_strdupWtoA( HANDLE heap, DWORD flags, LPCWSTR str )
    865812{
    866813    LPSTR ret;

  • TabularUnified tags/trunk/src/kernel32/initterm.cpp

    r17206 r17623  
    1 /* $Id: initterm.cpp,v 1.63 2001-09-05 12:57:58 bird Exp $
     1/* $Id: initterm.cpp,v 1.64 2001-10-15 17:10:54 sandervl Exp $
    22 *
    33 * KERNEL32 DLL entry point
    … …  
    6060
    6161BOOL  fVersionWarp3 = FALSE;
     62BOOL  fCustomBuild  = FALSE;
    6263
    6364//Global DLL Data

  • TabularUnified tags/trunk/src/kernel32/profile.cpp

    r17564 r17623  
    1 /* $Id: profile.cpp,v 1.32 2001-10-10 22:24:35 phaller Exp $ */
     1/* $Id: profile.cpp,v 1.33 2001-10-15 17:10:55 sandervl Exp $ */
    22
    33/*
    … …  
    10421042}
    10431043
     1044static BOOL fDisableOdinIni = FALSE;
     1045
     1046void DisableOdinIni()
     1047{
     1048    fDisableOdinIni = TRUE;
     1049}
     1050
    10441051ODINFUNCTION0(int,PROFILE_SaveOdinIni)
    10451052{
    10461053  int ret;
    10471054  FILE *file;
     1055
     1056  if(fDisableOdinIni) return TRUE;
    10481057
    10491058  EnterCriticalSection( &PROFILE_CritSect );

  • TabularUnified tags/trunk/src/kernel32/version.cpp

    r15869 r17623  
    1 /* $Id: version.cpp,v 1.3 2001-03-13 18:45:34 sandervl Exp $ */
     1/* $Id: version.cpp,v 1.4 2001-10-15 17:10:55 sandervl Exp $ */
    22
    33/*
    … …  
    110110   if(lpVersionInformation->dwOSVersionInfoSize != sizeof(OSVERSIONINFOA))
    111111   {
    112         dprintf(("ERROR: buffer too small"));
     112        dprintf(("ERROR: buffer too small (%d != %d)", lpVersionInformation->dwOSVersionInfoSize, sizeof(OSVERSIONINFOA)));
    113113        SetLastError(ERROR_INSUFFICIENT_BUFFER);
    114114        return(FALSE);

  • TabularUnified tags/trunk/src/user32/oslibres.cpp

    r17606 r17623  
    1 /* $Id: oslibres.cpp,v 1.24 2001-10-14 21:37:03 sandervl Exp $ */
     1/* $Id: oslibres.cpp,v 1.25 2001-10-15 17:09:03 sandervl Exp $ */
    22/*
    33 * Window API wrappers for OS/2
    … …  
    308308    if(lHits == GPI_ERROR) goto fail;
    309309
    310 #ifdef DEBUG
     310//DEBUG_CURSOR
     311#ifdef DEBUG_CURSOR
    311312 {
    312313    dprintf(("colorToMonoBitmap %d %d (%x,%x,%x)(%x,%x,%x)", pBmpDest->cx, pBmpDest->cy, bmpinfo->argbColor[0].bRed, bmpinfo->argbColor[0].bGreen, bmpinfo->argbColor[0].bBlue, bmpinfo->argbColor[1].bRed, bmpinfo->argbColor[1].bGreen, bmpinfo->argbColor[1].bBlue));

  • TabularUnified tags/trunk/src/user32/oslibwin.cpp

    r16961 r17623  
    1 /* $Id: oslibwin.cpp,v 1.108 2001-07-29 18:59:27 sandervl Exp $ */
     1/* $Id: oslibwin.cpp,v 1.109 2001-10-15 17:09:03 sandervl Exp $ */
    22/*
    33 * Window API wrappers for OS/2
    … …  
    157157  }
    158158
    159 #if 0
    160   hwndControl = WinWindowFromID(hwndFrame, FID_SYSMENU);
    161   if(hwndControl) {
    162       swp[i].hwnd = hwndControl;
    163       swp[i].hwndInsertBehind = HWND_TOP;
    164       swp[i].x  = pRect->xLeft;
    165       swp[i].y  = pRect->yBottom;
    166       if(pRect->yTop - pRect->yBottom > minmaxheight) {
    167           swp[i].y += pRect->yTop - pRect->yBottom - minmaxheight;
     159  if(fOS2Look == OS2_APPEARANCE_SYSMENU) {
     160      hwndControl = WinWindowFromID(hwndFrame, FID_SYSMENU);
     161      if(hwndControl) {
     162          swp[i].hwnd = hwndControl;
     163          swp[i].hwndInsertBehind = HWND_TOP;
     164          swp[i].x  = pRect->xLeft;
     165          swp[i].y  = pRect->yBottom;
     166          if(pRect->yTop - pRect->yBottom > minmaxheight) {
     167              swp[i].y += pRect->yTop - pRect->yBottom - minmaxheight;
     168          }
     169          swp[i].cx = minmaxwidth/2;
     170          swp[i].cy = minmaxheight;;
     171          swp[i].fl = SWP_SIZE | SWP_MOVE | SWP_SHOW;
     172          dprintf(("FID_SYSMENU (%d,%d)(%d,%d)", swp[i].x, swp[i].y, swp[i].cx, swp[i].cy));
     173          pRect->xLeft += minmaxwidth/2;
     174          i++;
    168175      }
    169       swp[i].cx = minmaxwidth/2;
    170       swp[i].cy = minmaxheight;;
    171       swp[i].fl = SWP_SIZE | SWP_MOVE | SWP_SHOW;
    172       dprintf(("FID_SYSMENU (%d,%d)(%d,%d)", swp[i].x, swp[i].y, swp[i].cx, swp[i].cy));
    173       pRect->xLeft += minmaxwidth/2;
    174       i++;
    175   }
    176 #else
     176  }
     177  else
    177178  if((dwStyle & WS_SYSMENU_W) && !(dwExStyle & WS_EX_TOOLWINDOW_W) && hSysMenuIcon) {
    178179      pRect->xLeft += minmaxwidth/2;
    179180  }
    180 #endif
     181
    181182  if((dwStyle & WS_CAPTION_W) == WS_CAPTION_W) {
    182183      hwndControl = WinWindowFromID(hwndFrame, FID_TITLEBAR);

  • TabularUnified tags/trunk/src/user32/pmwindow.cpp

    r17525 r17623  
    1 /* $Id: pmwindow.cpp,v 1.154 2001-10-08 12:19:10 sandervl Exp $ */
     1/* $Id: pmwindow.cpp,v 1.155 2001-10-15 17:09:04 sandervl Exp $ */
    22/*
    33 * Win32 Window Managment Code for OS/2
    … …  
    183183BOOL MENU_Init();
    184184//******************************************************************************
    185 void WIN32API SetWindowAppearance(BOOL fLooks)
     185void WIN32API SetWindowAppearance(int fLooks)
    186186{
    187     if(fLooks) {
     187    if(fLooks == OS2_APPEARANCE || fLooks == OS2_APPEARANCE_SYSMENU)
     188    {
    188189        CHAR szDisplay[30];
    189190        HMODULE hModDisplay;

  • TabularUnified tags/trunk/src/user32/syscolor.cpp

    r17159 r17623  
    1 /* $Id: syscolor.cpp,v 1.29 2001-08-27 08:42:11 sandervl Exp $ */
     1/* $Id: syscolor.cpp,v 1.30 2001-10-15 17:09:04 sandervl Exp $ */
    22
    33/*
    … …  
    193193        else    SYSCOLOR_SetColor(x,SysColors[x]);
    194194  }
     195  fColorInit = TRUE;
    195196}
    196197//******************************************************************************

  • TabularUnified tags/trunk/src/user32/win32wbasenonclient.cpp

    r17501 r17623  
    1 /* $Id: win32wbasenonclient.cpp,v 1.36 2001-10-03 18:37:53 sandervl Exp $ */
     1/* $Id: win32wbasenonclient.cpp,v 1.37 2001-10-15 17:09:04 sandervl Exp $ */
    22/*
    33 * Win32 Window Base Class for OS/2 (non-client methods)
    … …  
    889889
    890890  if(fOS2Look) {
    891       if ((dwStyle & WS_SYSMENU) && !(dwExStyle & WS_EX_TOOLWINDOW))
     891      if ((dwStyle & WS_SYSMENU) && !(dwExStyle & WS_EX_TOOLWINDOW) &&
     892           fOS2Look != OS2_APPEARANCE_SYSMENU)
    892893      {
    893894         HICON hSysIcon = IconForWindow(ICON_SMALL);

  • TabularUnified tags/trunk/src/user32/winicon.cpp

    r17605 r17623  
    1 /* $Id: winicon.cpp,v 1.31 2001-10-14 20:55:46 sandervl Exp $ */
     1/* $Id: winicon.cpp,v 1.32 2001-10-15 17:09:05 sandervl Exp $ */
    22/*
    33 * Win32 Icon Code for OS/2
    … …  
    442442    }
    443443
     444    dprintf2(("OSLibWinSetPointer %x", iconinfo->hColorBmp));
    444445    if(OSLibWinSetPointer(iconinfo->hColorBmp) == FALSE) {
    445446        dprintf(("OSLibWinSetPointer %x returned FALSE!!", iconinfo->hColorBmp));

  • TabularUnified tags/trunk/src/wnaspi32/initterm.cpp

    r17199 r17623  
    1 /* $Id: initterm.cpp,v 1.7 2001-09-05 10:28:28 bird Exp $
     1/* $Id: initterm.cpp,v 1.8 2001-10-15 17:06:18 sandervl Exp $
    22 *
    33 * DLL entry point
    … …  
    3636#include <misc.h>       /*PLF Wed  98-03-18 23:18:15*/
    3737#include <initdll.h>
    38 #include "aspilib.h"
    3938
    40 extern "C" {
    41  //Win32 resource table (produced by wrc)
    42  extern DWORD _Resource_PEResTab;
    43 }
    44 
    45 static HMODULE dllHandle = 0;
    46 scsiObj *aspi = NULL;
    47 //******************************************************************************
    48 //******************************************************************************
    49 BOOL WINAPI LibMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID fImpLoad)
    50 {
    51    switch (fdwReason)
    52    {
    53    case DLL_PROCESS_ATTACH:
    54         aspi = new scsiObj();
    55     if(aspi == NULL) {
    56         dprintf(("WNASPI32: LibMain; can't allocate aspi object!"));
    57         return FALSE;
    58     }
    59         if(aspi->init(65535) == FALSE)
    60         {
    61         delete aspi;
    62         aspi = NULL;
    63         dprintf(("WNASPI32: LibMain; can't init aspi object!"));
    64         return FALSE;
    65     }
    66     dprintf(("WNASPI32: LibMain; aspi object created successfully"));
    67     return TRUE;
    68 
    69    case DLL_THREAD_ATTACH:
    70    case DLL_THREAD_DETACH:
    71     return TRUE;
    72 
    73    case DLL_PROCESS_DETACH:
    74     if(aspi) {
    75             aspi->close();
    76         delete aspi;
    77         aspi = NULL;
    78     }
    79     ctordtorTerm();
    80     return TRUE;
    81    }
    82    return FALSE;
    83 }
    8439/****************************************************************************/
    8540/* _DLL_InitTerm is the function that gets called by the operating system   */
    … …  
    9045/* calling this function.                                                   */
    9146/****************************************************************************/
    92 unsigned long SYSTEM _DLL_InitTerm(unsigned long hModule, unsigned long
    93                                    ulFlag)
     47ULONG DLLENTRYPOINT_CCONV DLLENTRYPOINT_NAME(ULONG hModule, ULONG ulFlag)
    9448{
    9549   size_t i;
    … …  
    10862         CheckVersionFromHMOD(PE2LX_VERSION, hModule); /*PLF Wed  98-03-18 05:28:48*/
    10963
    110      dllHandle = RegisterLxDll(hModule, LibMain, (PVOID)&_Resource_PEResTab);
    111          if(dllHandle == 0)
    112         return 0UL;
     64         return inittermWnaspi32(hModule, ulFlag);
    11365
    114          break;
    11566      case 1:
    116          if(dllHandle) {
    117         UnregisterLxDll(dllHandle);
    118          }
     67         inittermWnaspi32(hModule, ulFlag);
     68         ctordtorTerm();
    11969         break;
    12070      default:

  • TabularUnified tags/trunk/src/wnaspi32/makefile

    r15284 r17623  
    1 # $Id: makefile,v 1.13 2000-12-02 23:45:07 bird Exp $
     1# $Id: makefile,v 1.14 2001-10-15 17:06:19 sandervl Exp $
    22
    33#
    … …  
    77#
    88
     9WRC_PREFIX_RESOURCE=1
    910
    1011#
    … …  
    2122$(OBJDIR)\winaspi32.obj \
    2223$(OBJDIR)\wnaspi32rsrc.obj \
     24$(OBJDIR)\initwnaspi32.obj \
    2325$(OBJDIR)\initterm.obj
    2426
Note: See TracChangeset for help on using the changeset viewer.