Changeset 6199 for trunk/src


Ignore:
Timestamp:
Jul 7, 2001, 3:58:37 PM (24 years ago)
Author:
sandervl
Message:

Rewrote Atom functions + GetAtomNameW fix

Location:
trunk/src/kernel32
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kernel32/Fileio.cpp

    r6090 r6199  
    1 /* $Id: Fileio.cpp,v 1.50 2001-06-24 14:13:03 sandervl Exp $ */
     1/* $Id: Fileio.cpp,v 1.51 2001-07-07 13:58:36 sandervl Exp $ */
    22
    33/*
    … …  
    250250{
    251251   if (lpft1 == NULL || lpft2 == NULL) {
    252   SetLastError(ERROR_INVALID_PARAMETER);
    253   return -1;
     252       SetLastError(ERROR_INVALID_PARAMETER);
     253       return -1;
    254254   }
    255255
    256256   if(lpft1->dwHighDateTime > lpft2->dwHighDateTime)
    257   return 1;
     257       return 1;
    258258
    259259   if(lpft1->dwHighDateTime < lpft2->dwHighDateTime)
    260   return -1;
     260       return -1;
    261261
    262262   if(lpft1->dwLowDateTime > lpft2->dwLowDateTime)
    263   return 1;
     263       return 1;
    264264
    265265   if(lpft1->dwLowDateTime < lpft2->dwLowDateTime)
    266   return -1;
     266       return -1;
    267267
    268268   return 0; //equal

  • trunk/src/kernel32/KERNEL32.DEF

    r6176 r6199  
    1 ; $Id: KERNEL32.DEF,v 1.112 2001-07-05 18:10:07 sandervl Exp $
     1; $Id: KERNEL32.DEF,v 1.113 2001-07-07 13:58:36 sandervl Exp $
    22
    33;Basis is Windows95 KERNEL32
    … …  
    3333  WinXxCreateHeap               = PMMERGE.5425
    3434  WinXxDestroyHeap              = PMMERGE.5426
     35  LookupAtom                    = PMMERGE.10020
    3536
    3637EXPORTS

  • trunk/src/kernel32/atom.cpp

    r3512 r6199  
    1 /* $Id: atom.cpp,v 1.8 2000-05-10 13:13:31 sandervl Exp $ */
     1/* $Id: atom.cpp,v 1.9 2001-07-07 13:58:37 sandervl Exp $ */
    22
    33/*
    44 * Win32 ATOM api functions
    55 *
    6  * Copyright 1998 Sander van Leeuwen (sandervl@xs4all.nl)
    7  *
     6 * Copyright 1998-2001 Sander van Leeuwen (sandervl@xs4all.nl)
     7 *
     8 *
     9 * TODO: DeleteAtom doesn't appear to work properly. FindAtom still works
     10 *       after deleting it.
    811 *
    912 * Project Odin Software License can be found in LICENSE.TXT
    1013 *
    1114 */
    12 #include <os2win.h>
    13 #include "unicode.h"
     15#define INCL_WIN
     16#include <os2wrap.h>
     17#include <win32api.h>
     18#include <winconst.h>
     19#include <unicode.h>
    1420#include <heapstring.h>
     21#include <misc.h>
    1522
    1623#define DBG_LOCALLOG    DBG_atom
    1724#include "dbglocal.h"
    1825
    19 //******************************************************************************
    20 //******************************************************************************
    21 ATOM WIN32API FindAtomA( LPCSTR arg1)
    22 {
    23     dprintf(("KERNEL32:  FindAtomA\n"));
    24     return O32_FindAtom(arg1);
    25 }
    26 //******************************************************************************
    27 //******************************************************************************
    28 ATOM WIN32API FindAtomW(LPCWSTR arg1)
     26// action codes for LookupAtom
     27#define LOOKUP_FIND     0
     28#define LOOKUP_ADD      1
     29#define LOOKUP_DELETE   2
     30#define LOOKUP_NOCASE   0x80000000
     31
     32ATOM APIENTRY LookupAtom(HATOMTBL hAtomTbl, PSZ psz, ULONG actionMask);
     33
     34HATOMTBL privateAtomTable = NULL;
     35HATOMTBL systemAtomTable  = NULL;
     36//******************************************************************************
     37//******************************************************************************
     38HATOMTBL inline getPrivateAtomTable()
     39{
     40    if(privateAtomTable == NULL) {
     41        privateAtomTable = WinCreateAtomTable(0, 37);
     42    }
     43    return privateAtomTable;
     44}
     45//******************************************************************************
     46//******************************************************************************
     47HATOMTBL inline getSystemAtomTable()
     48{
     49    if(systemAtomTable == NULL) {
     50        systemAtomTable = WinQuerySystemAtomTable();
     51    }
     52    return systemAtomTable;
     53}
     54//******************************************************************************
     55//******************************************************************************
     56BOOL WIN32API InitAtomTable(DWORD numEntries)
     57{
     58    dprintf(("KERNEL32: InitAtomTable %d", numEntries));
     59
     60    if(privateAtomTable == NULL) {
     61        privateAtomTable = WinCreateAtomTable(0, numEntries);
     62    }
     63    return (privateAtomTable != NULL);
     64}
     65//******************************************************************************
     66//******************************************************************************
     67ATOM WIN32API FindAtomA( LPCSTR atomName)
     68{
     69    HATOMTBL atomTable = getPrivateAtomTable();
     70    ATOM     atom = 0;
     71 
     72    if(HIWORD(atomName)) {
     73         dprintf(("FindAtomA %s", atomName));
     74    }
     75    else dprintf(("FindAtomA %x", atomName));
     76
     77    if(atomTable != NULL) {
     78        atom = LookupAtom(atomTable, HIWORD(atomName) ?
     79                          (PSZ) atomName : (PSZ) LOWORD(atomName),
     80                          LOOKUP_ADD | LOOKUP_NOCASE);
     81    }
     82    dprintf(("FindAtomA returned %x", atom));
     83
     84    if(!atom) {
     85         SetLastError(ERROR_INVALID_PARAMETER_W); //TODO: find real error
     86    }
     87    else SetLastError(ERROR_SUCCESS_W);
     88    return atom;
     89}
     90//******************************************************************************
     91//******************************************************************************
     92ATOM WIN32API FindAtomW(LPCWSTR atomName)
     93{
     94    ATOM  rc;
     95    char *astring;
     96
     97    dprintf(("KERNEL32: FindAtomW"));
     98    if(HIWORD(atomName))
     99    {
     100         astring = UnicodeToAsciiString((LPWSTR)atomName);
     101         rc = FindAtomA(astring);
     102         FreeAsciiString(astring);
     103    }
     104    else rc = FindAtomA((char*)atomName);
     105
     106    return(rc);
     107}
     108//******************************************************************************
     109//******************************************************************************
     110ATOM WIN32API AddAtomA(LPCSTR atomName)
     111{
     112    ATOM atom = 0;
     113    HATOMTBL atomTable = getPrivateAtomTable();
     114
     115    if(atomTable != NULL)
     116    {
     117        atom = LookupAtom(atomTable, HIWORD(atomName) ?
     118                          (PSZ) atomName : (PSZ) LOWORD(atomName),
     119                          LOOKUP_ADD | LOOKUP_NOCASE);
     120    }
     121
     122    if(HIWORD(atomName)) {
     123         dprintf(("KERNEL32: AddAtomA %s returned %x", atomName, atom));
     124    }
     125    else dprintf(("KERNEL32: AddAtomA %x returned %x", atomName, atom));
     126
     127    if(!atom) {
     128         SetLastError(ERROR_INVALID_PARAMETER_W); //TODO: find real error
     129    }
     130    else SetLastError(ERROR_SUCCESS_W);
     131    return atom;
     132}
     133//******************************************************************************
     134//******************************************************************************
     135ATOM WIN32API AddAtomW(LPCWSTR atomName)
    29136{
    30137 ATOM  rc;
    31138 char *astring;
    32139
    33     dprintf(("KERNEL32:  FindAtomW"));
    34     if (arg1 < (LPCWSTR)0x10000)
    35         rc = O32_FindAtom((char*)arg1);
     140    if(HIWORD(atomName) == 0) {
     141        rc = AddAtomA((char*)atomName);
     142    }
    36143    else
    37144    {
    38         astring = UnicodeToAsciiString((LPWSTR)arg1);
    39         rc = O32_FindAtom(astring);
    40         FreeAsciiString(astring);
    41     }
    42     return(rc);
    43 }
    44 //******************************************************************************
    45 //******************************************************************************
    46 ATOM WIN32API AddAtomA(LPCSTR arg1)
    47 {
    48  ATOM atom;
    49 
    50     atom = O32_AddAtom(arg1);
    51     if(HIWORD(arg1)) {
    52          dprintf(("KERNEL32: AddAtomA %s returned %x", arg1, atom));
    53     }
    54     else dprintf(("KERNEL32: AddAtomA %x returned %x", arg1, atom));
    55     return atom;
    56 }
    57 //******************************************************************************
    58 //******************************************************************************
    59 ATOM WIN32API AddAtomW(LPCWSTR arg1)
    60 {
    61  ATOM  rc;
    62  char *astring;
    63 
    64     if(HIWORD(arg1) == 0) {
    65         rc = AddAtomA((char*)arg1);
    66     }
    67     else
    68     {
    69         astring = UnicodeToAsciiString((LPWSTR)arg1);
     145        astring = UnicodeToAsciiString((LPWSTR)atomName);
    70146        rc = AddAtomA(astring);
    71147        FreeAsciiString(astring);
    … …  
    74150}
    75151//******************************************************************************
    76 //SvL: 24-6-'97 - Added
    77 //******************************************************************************
    78 UINT WIN32API GetAtomNameA( ATOM arg1, LPSTR arg2, int  arg3)
    79 {
    80     dprintf(("KERNEL32:  GetAtomNameA\n"));
    81     return O32_GetAtomName(arg1, arg2, arg3);
    82 }
    83 //******************************************************************************
    84 //SvL: 24-6-'97 - Added
    85 //******************************************************************************
    86 UINT WIN32API GetAtomNameW(ATOM arg1, LPWSTR arg2, int arg3)
    87 {
    88  UINT  rc;
    89  char *astring;
    90 
    91     dprintf(("KERNEL32:  GetAtomNameW\n"));
    92     astring = UnicodeToAsciiString(arg2); /* FIXME! */
    93     rc = O32_GetAtomName(arg1, astring, arg3);
    94     FreeAsciiString(astring);
    95     return(rc);
    96 }
    97 //******************************************************************************
    98 //******************************************************************************
    99 ATOM WIN32API DeleteAtom( ATOM arg1)
    100 {
    101     dprintf(("KERNEL32:  DeleteAtom\n"));
    102     return O32_DeleteAtom(arg1);
    103 }
    104 //******************************************************************************
    105 //******************************************************************************
    106 ATOM WIN32API GlobalDeleteAtom( ATOM arg1)
    107 {
    108     dprintf(("KERNEL32:  GlobalDeleteAtom\n"));
    109     return O32_GlobalDeleteAtom(arg1);
    110 }
    111 //******************************************************************************
    112 //******************************************************************************
    113 BOOL WIN32API InitAtomTable( DWORD arg1)
    114 {
    115     dprintf(("KERNEL32:  InitAtomTable\n"));
    116     return O32_InitAtomTable(arg1);
    117 }
    118 //******************************************************************************
    119 //******************************************************************************
    120 ATOM WIN32API GlobalAddAtomA(LPCSTR arg1)
    121 {
    122  ATOM atom;
    123 
    124     atom = O32_GlobalAddAtom(arg1);
    125     if(HIWORD(arg1)) {
    126          dprintf(("KERNEL32: GlobalAddAtomA %s returned %x", arg1, atom));
    127     }
    128     else dprintf(("KERNEL32: GlobalAddAtomA %x returned %x", arg1, atom));
     152//******************************************************************************
     153UINT WIN32API GetAtomNameA( ATOM atom, LPSTR atomName, int nameLen)
     154{
     155    UINT     result = 0;
     156    HATOMTBL atomTable = getPrivateAtomTable();
     157
     158    dprintf(("KERNEL32: GetAtomNameA %x %x %d", LOWORD(atom), atomName, nameLen));
     159    if(atomTable != NULL)
     160        result = (UINT)WinQueryAtomName( atomTable, LOWORD(atom), atomName, nameLen);
     161
     162    dprintf(("KERNEL32: GetAtomNameA returned %s", (result) ? atomName : NULL));
     163
     164    if(!result) {
     165         SetLastError(ERROR_INVALID_PARAMETER_W); //TODO: find real error
     166    }
     167    else SetLastError(ERROR_SUCCESS_W);
     168    return (result);
     169}
     170//******************************************************************************
     171//******************************************************************************
     172UINT WIN32API GetAtomNameW(ATOM atom, LPWSTR lpszBuffer, int cchBuffer)
     173{
     174 char *astring;
     175 UINT rc;
     176
     177    dprintf(("KERNEL32: GetAtomNameW %x %x %d", atom, lpszBuffer, cchBuffer));
     178    astring = (char *)alloca(cchBuffer);
     179    if(astring == NULL) {
     180        dprintf(("GlobalGetAtomNameW: alloca failed!!"));
     181        DebugInt3();
     182        return 0;
     183    }
     184    rc = GetAtomNameA(atom, astring, cchBuffer);
     185    if(rc) {
     186         lstrcpyAtoW(lpszBuffer, astring);
     187    }
     188    else lpszBuffer[0] = 0; //necessary?
     189    return rc;
     190}
     191//******************************************************************************
     192//******************************************************************************
     193ATOM WIN32API DeleteAtom(ATOM atom)
     194{
     195   HATOMTBL atomTable = getPrivateAtomTable();
     196
     197   dprintf(("DeleteAtom %x", atom));
     198   if (atomTable != NULL) {
     199       return (ATOM) LookupAtom(atomTable, (PSZ) MAKEULONG(atom, 0xFFFF),
     200                                LOOKUP_DELETE | LOOKUP_NOCASE);
     201   }
     202   return 0;
     203}
     204//******************************************************************************
     205//******************************************************************************
     206ATOM WIN32API GlobalDeleteAtom(ATOM atom)
     207{
     208   HATOMTBL atomTable = getSystemAtomTable();
     209
     210   dprintf(("KERNEL32: GlobalDeleteAtom %x", atom));
     211   return (ATOM) LookupAtom(atomTable, (PSZ) MAKEULONG(atom, 0xFFFF),
     212                            LOOKUP_DELETE | LOOKUP_NOCASE);
     213}
     214//******************************************************************************
     215//******************************************************************************
     216ATOM WIN32API GlobalAddAtomA(LPCSTR atomName)
     217{
     218    ATOM atom = 0;
     219    HATOMTBL atomTable = getSystemAtomTable();
     220
     221    if(atomTable != NULL)
     222    {
     223        atom = LookupAtom(atomTable, HIWORD(atomName) ?
     224                          (PSZ) atomName : (PSZ) LOWORD(atomName),
     225                          LOOKUP_ADD | LOOKUP_NOCASE);
     226    }
     227
     228    if(HIWORD(atomName)) {
     229         dprintf(("KERNEL32: GlobalAddAtomA %s returned %x", atomName, atom));
     230    }
     231    else dprintf(("KERNEL32: GlobalAddAtomA %x returned %x", atomName, atom));
     232
     233    if(!atom) {
     234         SetLastError(ERROR_INVALID_PARAMETER_W); //TODO: find real error
     235    }
     236    else SetLastError(ERROR_SUCCESS_W);
    129237    return atom;
    130238}
    131239//******************************************************************************
    132240//******************************************************************************
    133 ATOM WIN32API GlobalAddAtomW(LPCWSTR arg1)
     241ATOM WIN32API GlobalAddAtomW(LPCWSTR atomName)
    134242{
    135243 char *astring;
    136244 ATOM  rc;
    137245
    138     if(HIWORD(arg1) == 0)
    139     {
    140         rc = GlobalAddAtomA((char*)arg1);
     246    if(HIWORD(atomName) == 0)
     247    {
     248        rc = GlobalAddAtomA((char*)atomName);
    141249    }
    142250    else
    143251    {
    144         astring = UnicodeToAsciiString((LPWSTR)arg1);
     252        astring = UnicodeToAsciiString((LPWSTR)atomName);
    145253        rc = GlobalAddAtomA(astring);
    146254        FreeAsciiString(astring);
    … …  
    150258//******************************************************************************
    151259//******************************************************************************
    152 ATOM WIN32API GlobalFindAtomA( LPCSTR arg1)
    153 {
    154     if (arg1 < (LPCSTR)0x10000)
    155       dprintf(("KERNEL32:  GlobalFindAtomA %#4x\n", arg1));
    156     else
    157       dprintf(("KERNEL32:  GlobalFindAtomA %s\n", arg1));
    158     return O32_GlobalFindAtom(arg1);
    159 }
    160 //******************************************************************************
    161 //******************************************************************************
    162 ATOM WIN32API GlobalFindAtomW( LPCWSTR arg1)
    163 {
    164  char *astring;
     260ATOM WIN32API GlobalFindAtomA( LPCSTR atomName)
     261{
     262    HATOMTBL atomTable = getSystemAtomTable();
     263    ATOM     atom = 0;
     264
     265    if(HIWORD(atomName)) {
     266         dprintf(("GlobalFindAtomA %s", atomName));
     267    }
     268    else dprintf(("GlobalFindAtomA %x", atomName));
     269
     270    atom = LookupAtom(atomTable, HIWORD(atomName) ?
     271                      (PSZ) atomName : (PSZ) LOWORD(atomName),
     272                      LOOKUP_ADD | LOOKUP_NOCASE);
     273    dprintf(("GlobalFindAtomA returned %x", atom));
     274
     275    if(!atom) {
     276         SetLastError(ERROR_INVALID_PARAMETER_W); //TODO: find real error
     277    }
     278    else SetLastError(ERROR_SUCCESS_W);
     279
     280    return atom;
     281}
     282//******************************************************************************
     283//******************************************************************************
     284ATOM WIN32API GlobalFindAtomW(LPCWSTR atomName)
     285{
    165286 ATOM  rc;
    166 
    167     if(HIWORD(arg1) == 0)
    168         rc = GlobalFindAtomA((char*)arg1);
    169     else
    170     {
    171         astring = UnicodeToAsciiString((LPWSTR)arg1);
    172         rc = GlobalFindAtomA(astring);
    173         FreeAsciiString(astring);
    174     }
     287 char *astring;
     288
     289    dprintf(("KERNEL32: GlobalFindAtomW"));
     290    if(HIWORD(atomName))
     291    {
     292         astring = UnicodeToAsciiString((LPWSTR)atomName);
     293         rc = GlobalFindAtomA(astring);
     294         FreeAsciiString(astring);
     295    }
     296    else rc = GlobalFindAtomA((char*)atomName);
     297
    175298    return(rc);
    176299}
    … …  
    179302UINT WIN32API GlobalGetAtomNameA(ATOM atom, LPSTR lpszBuffer, int cchBuffer)
    180303{
    181     dprintf(("KERNEL32: GlobalGetAtomNameA %x %x %d", atom, lpszBuffer, cchBuffer));
    182     return O32_GlobalGetAtomName(atom, lpszBuffer, cchBuffer);
     304    UINT     result = 0;
     305    HATOMTBL atomTable = getSystemAtomTable();
     306
     307    dprintf(("KERNEL32: GlobalGetAtomNameA %x %x %d", LOWORD(atom), lpszBuffer, cchBuffer));
     308    if(atomTable != NULL)
     309        result = (UINT)WinQueryAtomName( atomTable, LOWORD(atom), lpszBuffer, cchBuffer);
     310
     311    if(!result) {
     312         SetLastError(ERROR_INVALID_PARAMETER_W); //TODO: find real error
     313    }
     314    else SetLastError(ERROR_SUCCESS_W);
     315
     316    dprintf(("KERNEL32: GlobalGetAtomNameA returned %s", (result) ? lpszBuffer : NULL));
     317    return (result);
    183318}
    184319//******************************************************************************
Note: See TracChangeset for help on using the changeset viewer.