user32.dll minimal implementation
authorEmanuele Aliberti <ea@iol.it>
Sat, 8 May 1999 07:09:31 +0000 (07:09 +0000)
committerEmanuele Aliberti <ea@iol.it>
Sat, 8 May 1999 07:09:31 +0000 (07:09 +0000)
svn path=/trunk/; revision=435

reactos/lib/user32/makefile_rex [new file with mode: 0644]
reactos/lib/user32/misc/dllmain.c [new file with mode: 0644]
reactos/lib/user32/misc/sprintf.c [new file with mode: 0644]
reactos/lib/user32/user32.def [new file with mode: 0644]
reactos/lib/user32/user32.rc [new file with mode: 0644]
reactos/lib/user32/user32_specs [new file with mode: 0644]

diff --git a/reactos/lib/user32/makefile_rex b/reactos/lib/user32/makefile_rex
new file mode 100644 (file)
index 0000000..918fa88
--- /dev/null
@@ -0,0 +1,63 @@
+include ../../rules.mak
+
+ifneq ($(HOST),mingw32-windows)
+  ifneq ($(HOST),mingw32-linux)
+    DLLTARGET=user32.a
+  else
+    DLLTARGET=user32.dll
+  endif
+else
+  DLLTARGET=user32.dll
+endif
+
+all: $(DLLTARGET)
+
+
+MISC_OBJECTS = misc/sprintf.o misc/dllmain.o
+
+RESOURCE_OBJECT = user32.coff
+
+
+OBJECTS = $(MISC_OBJECTS) $(RESOURCE_OBJECT)
+
+ifeq ($(DOSCLI),yes)
+CLEAN_FILES = misc\*.o \
+              user32.o user32.a junk.tmp base.tmp temp.exp user32.dll user32.sym
+else
+CLEAN_FILES = misc/*.o  \
+              user32.o user32.a junk.tmp base.tmp temp.exp user32.dll user32.sym
+endif
+
+user32.coff: user32.rc ../../include/reactos/resource.h
+       windres user32.rc user32.coff
+
+user32.a: $(OBJECTS)
+       $(AR) csr user32.a $(OBJECTS)
+
+user32.dll: $(DLLMAIN) $(OBJECTS) user32.def
+       $(LD) -r $(OBJECTS) -o user32.o
+       $(DLLTOOL) --dllname user32.dll --def user32.def \
+                  --output-lib user32.a --add-stdcall-alias \
+                  --kill-at
+       $(CC) -specs=user32_specs -mdll -o junk.tmp \
+             -Wl,--base-file,base.tmp user32.o  ../ntdll/ntdll.a
+       - $(RM) junk.tmp
+       $(DLLTOOL) --dllname user32.dll --base-file base.tmp \
+                  --output-exp temp.exp --def user32.def \
+                  --add-stdcall-alias --kill-at
+       - $(RM) base.tmp
+       $(CC) -specs=user32_specs -mdll -o user32.dll user32.o  ../ntdll/ntdll.a\
+             -Wl,--image-base,0x70000000 \
+             -Wl,--file-alignment,0x1000 \
+             -Wl,--section-alignment,0x1000 \
+             -Wl,temp.exp
+       - $(RM) temp.exp
+       $(NM) --numeric-sort user32.dll > user32.sym
+
+clean: $(CLEAN_FILES:%=%_clean)
+
+$(CLEAN_FILES:%=%_clean): %_clean:
+       - $(RM) $*
+
+.PHONY: clean $(CLEAN_FILES:%=%_clean)
+
diff --git a/reactos/lib/user32/misc/dllmain.c b/reactos/lib/user32/misc/dllmain.c
new file mode 100644 (file)
index 0000000..7d00df9
--- /dev/null
@@ -0,0 +1,23 @@
+#include <windows.h>
+INT
+STDCALL
+DllMain(
+       PVOID   hinstDll,
+       ULONG   dwReason,
+       PVOID   reserved
+       )
+{
+       switch (dwReason)
+       {
+               case DLL_PROCESS_ATTACH:
+                       break;
+               case DLL_THREAD_ATTACH:
+                       break;
+               case DLL_THREAD_DETACH:
+                       break;
+               case DLL_PROCESS_DETACH:
+                       break;
+       }
+       return(1);
+}
+
diff --git a/reactos/lib/user32/misc/sprintf.c b/reactos/lib/user32/misc/sprintf.c
new file mode 100644 (file)
index 0000000..3c60023
--- /dev/null
@@ -0,0 +1,940 @@
+/* $Id: sprintf.c,v 1.1 1999/05/08 07:09:31 ea Exp $
+ *
+ * user32.dll
+ *
+ * wsprintf functions
+ *
+ * Copyright 1996 Alexandre Julliard
+ *
+ * 1999-05-01 (Emanuele Aliberti)
+ *     Adapted from Wine to ReactOS
+ */
+
+#include <stdarg.h>
+#include <string.h>
+#include "windows.h"
+
+#define WPRINTF_LEFTALIGN   0x0001  /* Align output on the left ('-' prefix) */
+#define WPRINTF_PREFIX_HEX  0x0002  /* Prefix hex with 0x ('#' prefix) */
+#define WPRINTF_ZEROPAD     0x0004  /* Pad with zeros ('0' prefix) */
+#define WPRINTF_LONG        0x0008  /* Long arg ('l' prefix) */
+#define WPRINTF_SHORT       0x0010  /* Short arg ('h' prefix) */
+#define WPRINTF_UPPER_HEX   0x0020  /* Upper-case hex ('X' specifier) */
+#define WPRINTF_WIDE        0x0040  /* Wide arg ('w' prefix) */
+
+typedef enum
+{
+       WPR_UNKNOWN,
+       WPR_CHAR,
+       WPR_WCHAR,
+       WPR_STRING,
+       WPR_WSTRING,
+       WPR_SIGNED,
+       WPR_UNSIGNED,
+       WPR_HEXA
+               
+} WPRINTF_TYPE;
+
+
+typedef struct
+{
+       UINT            flags;
+       UINT            width;
+       UINT            precision;
+       WPRINTF_TYPE    type;
+       
+} WPRINTF_FORMAT;
+
+
+static const LPSTR     null_stringA = "(null)";
+static const LPWSTR    null_stringW = L"(null)";
+
+
+/* === COMMON === */
+
+
+/***********************************************************************
+ * NAME                                                                PRIVATE
+ *     WPRINTF_GetLen
+ *
+ * DESCRIPTION
+ *     ?
+ *
+ * ARGUMENTS
+ *     format
+ *             ?
+ *     arg
+ *             ?
+ *     number
+ *             ?
+ *     maxlen
+ *             ?
+ *
+ * RETURN VALUE
+ *     ?
+ */
+static
+UINT
+WPRINTF_GetLen(
+       WPRINTF_FORMAT  *format,
+       LPCVOID         arg,
+       LPSTR           number,
+       UINT            maxlen
+       )
+{
+       UINT len;
+
+       if (format->flags & WPRINTF_LEFTALIGN)
+       {
+               format->flags &= ~WPRINTF_ZEROPAD;
+       }
+       if (format->width > maxlen)
+       {
+               format->width = maxlen;
+       }
+       switch(format->type)
+       {
+       case WPR_CHAR:
+       case WPR_WCHAR:
+               return (format->precision = 1);
+               
+       case WPR_STRING:
+               if (!*(LPCSTR *)arg)
+               {
+                       *(LPCSTR *)arg = null_stringA;
+               }
+               for (   len = 0;
+                       (!format->precision || (len < format->precision));
+                       len++
+                       )
+               {
+                       if (!*(*(LPCSTR *)arg + len))
+                       {
+                               break;
+                       }
+               }
+               if (len > maxlen)
+               {
+                       len = maxlen;
+               }
+               return (format->precision = len);
+
+       case WPR_WSTRING:
+               if (!*(LPCWSTR *)arg)
+               {
+                       *(LPCWSTR *)arg = null_stringW;
+               }
+               for (   len = 0;
+                       (!format->precision || (len < format->precision));
+                       len++
+                       )
+               {
+                   if (!*(*(LPCWSTR *)arg + len))
+                           break;
+               }
+               if (len > maxlen)
+               {
+                       len = maxlen;
+               }
+               return (format->precision = len);
+               
+       case WPR_SIGNED:
+               len = sprintf(
+                       number,
+                       "%d",
+                       *(INT *) arg
+                       );
+               break;
+               
+       case WPR_UNSIGNED:
+               len = sprintf(
+                       number,
+                       "%u",
+                       *(UINT *) arg
+                       );
+               break;
+               
+       case WPR_HEXA:
+               len = sprintf(
+                       number,
+                        ((format->flags & WPRINTF_UPPER_HEX)
+                               ? "%X"
+                               : "%x"),
+                        *(UINT *) arg
+                       );
+               if (format->flags & WPRINTF_PREFIX_HEX)
+               {
+                       len += 2;
+               }
+               break;
+       
+       default:
+               return 0;
+       }
+       if (len > maxlen)
+       {
+               len = maxlen;
+       }
+       if (format->precision < len)
+       {
+               format->precision = len;
+       }
+       if (format->precision > maxlen)
+       {
+               format->precision = maxlen;
+       }
+       if (    (format->flags & WPRINTF_ZEROPAD)
+               && (format->width > format->precision)
+               )
+       {
+               format->precision = format->width;
+       }
+       return len;
+}
+
+
+/* === ANSI VERSION === */
+
+
+/***********************************************************************
+ * NAME                                                                PRIVATE
+ *     WPRINTF_ParseFormatA
+ *
+ * DESCRIPTION
+ *     Parse a format specification. A format specification has the
+ *     form:
+ *
+ *     [-][#][0][width][.precision]type
+ *
+ * ARGUMENTS
+ *     format
+ *             ?
+ *     res
+ *             ?
+ *
+ * RETURN VALUE
+ *     The length of the format specification in characters.
+ */
+static
+INT
+WPRINTF_ParseFormatA(
+       LPCSTR          format,
+       WPRINTF_FORMAT  *res
+       )
+{
+       LPCSTR p = format;
+
+       res->flags = 0;
+       res->width = 0;
+       res->precision = 0;
+       if (*p == '-')
+       {
+               res->flags |= WPRINTF_LEFTALIGN;
+               p++;
+       }
+       if (*p == '#')
+       {
+               res->flags |= WPRINTF_PREFIX_HEX;
+               p++;
+       }
+       if (*p == '0')
+       {
+               res->flags |= WPRINTF_ZEROPAD;
+               p++;
+       }
+       while ((*p >= '0') && (*p <= '9'))  /* width field */
+       {
+               res->width =
+                       (res->width * 10)
+                       + (*p - '0');
+               p++;
+       }
+       if (*p == '.')  /* precision field */
+       {
+               p++;
+               while ((*p >= '0') && (*p <= '9'))
+               {
+                       res->precision =
+                               (res->precision * 10)
+                               + (*p - '0');
+                       p++;
+               }
+       }
+       if (*p == 'l')
+       {
+               res->flags |= WPRINTF_LONG;
+               p++;
+       }
+       else if (*p == 'h')
+       {
+               res->flags |= WPRINTF_SHORT;
+               p++;
+       }
+       else if (*p == 'w')
+       {
+               res->flags |= WPRINTF_WIDE;
+               p++;
+       }
+       
+       switch (*p)
+       {
+       case 'c':
+               res->type =
+                       (res->flags & WPRINTF_LONG)
+                               ? WPR_WCHAR
+                               : WPR_CHAR;
+               break;
+               
+       case 'C':
+               res->type =
+                       (res->flags & WPRINTF_SHORT)
+                               ? WPR_CHAR
+                               : WPR_WCHAR;
+               break;
+               
+       case 'd':
+       case 'i':
+               res->type = WPR_SIGNED;
+               break;
+               
+       case 's':
+               res->type =
+                       (res->flags & (WPRINTF_LONG |WPRINTF_WIDE)) 
+                               ? WPR_WSTRING
+                               : WPR_STRING;
+               break;
+               
+       case 'S':
+               res->type =
+                       (res->flags & (WPRINTF_SHORT|WPRINTF_WIDE))
+                               ? WPR_STRING
+                               : WPR_WSTRING;
+               break;
+               
+       case 'u':
+               res->type = WPR_UNSIGNED;
+               break;
+               
+       case 'X':
+               res->flags |= WPRINTF_UPPER_HEX;
+               /* fall through */
+               
+       case 'x':
+               res->type = WPR_HEXA;
+               break;
+               
+       default: /* unknown format char */
+               res->type = WPR_UNKNOWN;
+               p--;  /* print format as normal char */
+               break;
+
+       } /* switch */
+       
+       return (INT) (p - format) + 1;
+}
+
+
+/***********************************************************************
+ * NAME                                                                PRIVATE
+ *     wvsnprintfA   (Not a Windows API)
+ */
+static
+INT
+STDCALL
+wvsnprintfA(
+       LPSTR   buffer,
+       UINT    maxlen,
+       LPCSTR  spec,
+       va_list args
+       )
+{
+       WPRINTF_FORMAT  format;
+       LPSTR           p = buffer;
+       UINT            i;
+       UINT            len;
+       CHAR            number [20];
+
+       while (*spec && (maxlen > 1))
+       {
+               if (*spec != '%')
+               {
+                       *p++ = *spec++;
+                       maxlen--;
+                       continue;
+               }
+               spec++;
+               if (*spec == '%')
+               {
+                       *p++ = *spec++;
+                       maxlen--;
+                       continue;
+               }
+               spec += WPRINTF_ParseFormatA(
+                               spec,
+                               & format
+                               );
+               len = WPRINTF_GetLen(
+                               & format,
+                               args,
+                               number,
+                               (maxlen - 1)
+                               );
+               if (!(format.flags & WPRINTF_LEFTALIGN))
+               {
+                       for (   i = format.precision;
+                               (i < format.width);
+                               i++, maxlen--
+                               )
+                       {
+                               *p++ = ' ';
+                       }
+               }
+               switch (format.type)
+               {
+               case WPR_WCHAR:
+                       if ((*p = (CHAR) va_arg( args, WCHAR )))
+                       {
+                               p++;
+                       }
+                       else if (format.width > 1)
+                       {
+                               *p++ = ' ';
+                       }
+                       else
+                       {
+                               len = 0;
+                       }
+                       break;
+                       
+               case WPR_CHAR:
+                       if ((*p = va_arg( args, CHAR )))
+                       {
+                               p++;
+                       }
+                       else if (format.width > 1)
+                       {
+                               *p++ = ' ';
+                       }
+                       else
+                       {
+                               len = 0;
+                       }
+                       break;
+                       
+               case WPR_STRING:
+                       memcpy(
+                               p,
+                               va_arg( args, LPCSTR ),
+                               len
+                               );
+                       p += len;
+                       break;
+                       
+               case WPR_WSTRING:
+               {
+                       LPCWSTR ptr = va_arg( args, LPCWSTR );
+                       
+                       for (   i = 0;
+                               (i < len);
+                               i++
+                               )
+                       {
+                               *p++ = (CHAR) *ptr++;
+                       }
+               }
+                       break;
+               
+               case WPR_HEXA:
+                       if (    (format.flags & WPRINTF_PREFIX_HEX)
+                               && (maxlen > 3)
+                               )
+                       {
+                               *p++ = '0';
+                               *p++ = (format.flags & WPRINTF_UPPER_HEX)
+                                       ? 'X'
+                                       : 'x';
+                               maxlen -= 2;
+                               len -= 2;
+                               format.precision -= 2;
+                               format.width -= 2;
+                       }
+                       /* fall through */
+                       
+               case WPR_SIGNED:
+               case WPR_UNSIGNED:
+                       for (   i = len;
+                               (i < format.precision);
+                               i++, maxlen--
+                               )
+                       {
+                               *p++ = '0';
+                       }
+                       memcpy(
+                               p,
+                               number,
+                               len
+                               );
+                       p += len;
+                       (void) va_arg( args, INT ); /* Go to the next arg */
+                       break;
+                       
+               case WPR_UNKNOWN:
+                       continue;
+               } /* switch */
+               
+               if (format.flags & WPRINTF_LEFTALIGN)
+               {
+                       for (   i = format.precision;
+                               (i < format.width);
+                               i++, maxlen--
+                               )
+                       {
+                               *p++ = ' ';
+                       }
+               }
+               maxlen -= len;
+       } /* while */
+       
+       *p = '\0';
+       return (maxlen > 1)
+               ? (INT) (p - buffer)
+               : -1;
+}
+
+
+/***********************************************************************
+ * NAME                                                                PUBLIC
+ *     wsprintfA   (USER32.585)
+ *
+ * DESCRIPTION
+ *
+ * ARGUMENTS
+ *
+ * RETURN VALUE
+ */
+INT
+CDECL
+wsprintfA(
+       LPSTR   buffer,
+       LPCSTR  spec,
+       ...
+       )
+{
+       va_list valist;
+       INT     res;
+
+       va_start( valist, spec );
+       res = wvsnprintfA(
+                       buffer,
+                       0xffffffff,
+                       spec,
+                       valist
+                       );
+       va_end( valist );
+       return res;
+}
+
+
+/***********************************************************************
+ * NAME                                                                PUBLIC
+ *     wvsprintfA   (USER32.587)
+ *
+ * DESCRIPTION
+ *
+ * ARGUMENTS
+ *
+ * RETURN VALUE
+ */
+INT
+STDCALL
+wvsprintfA(
+       LPSTR   buffer,
+       LPCSTR  spec,
+       va_list args
+       )
+{
+       return wvsnprintfA(
+                       buffer,
+                       0xffffffff,
+                       spec,
+                       args
+                       );
+}
+
+
+/* === UNICODE VERSION === */
+
+
+/***********************************************************************
+ * NAME                                                                PRIVATE
+ *     WPRINTF_ParseFormatW
+ *
+ * DESCRIPTION
+ *     Parse a format specification. A format specification has
+ *     the form:
+ *
+ *     [-][#][0][width][.precision]type
+ *
+ * ARGUMENTS
+ *     format
+ *             ?
+ *     res
+ *             ?
+ *
+ * RETURN VALUE
+ *     The length of the format specification in characters.
+ */
+static
+INT
+WPRINTF_ParseFormatW(
+       LPCWSTR         format,
+       WPRINTF_FORMAT  *res
+       )
+{
+       LPCWSTR p = format;
+
+       res->flags = 0;
+       res->width = 0;
+       res->precision = 0;
+       if (*p == L'-')
+       {
+               res->flags |= WPRINTF_LEFTALIGN;
+               p++;
+       }
+       if (*p == L'#')
+       {
+               res->flags |= WPRINTF_PREFIX_HEX;
+               p++;
+       }
+       if (*p == L'0')
+       {
+               res->flags |= WPRINTF_ZEROPAD;
+               p++;
+       }
+       
+       while ((*p >= L'0') && (*p <= L'9'))  /* width field */
+       {
+               res->width = 
+                       (res->width * 10)
+                       + (*p - L'0');
+               p++;
+       }
+
+       if (*p == L'.')  /* precision field */
+       {
+               p++;
+               while ((*p >= L'0') && (*p <= L'9'))
+               {
+                       res->precision =
+                               (res->precision * 10)
+                               + (*p - '0');
+                       p++;
+               }
+       }
+       if (*p == L'l')
+       {
+               res->flags |= WPRINTF_LONG;
+               p++;
+       }
+       else if (*p == L'h')
+       {
+               res->flags |= WPRINTF_SHORT;
+               p++;
+       }
+       else if (*p == L'w')
+       {
+               res->flags |= WPRINTF_WIDE;
+               p++;
+       }
+       
+       switch ((CHAR)*p)
+       {
+       case L'c':
+               res->type =
+                       (res->flags & WPRINTF_SHORT)
+                               ? WPR_CHAR
+                               : WPR_WCHAR;
+               break;
+               
+       case L'C':
+               res->type =
+                       (res->flags & WPRINTF_LONG)
+                               ? WPR_WCHAR
+                               : WPR_CHAR;
+               break;
+               
+       case L'd':
+       case L'i':
+               res->type = WPR_SIGNED;
+               break;
+               
+       case L's':
+               res->type =
+                       ((res->flags & WPRINTF_SHORT)
+                        && !(res->flags & WPRINTF_WIDE)
+                       )
+                               ? WPR_STRING
+                               : WPR_WSTRING;
+               break;
+               
+       case L'S':
+               res->type =
+                       (res->flags & (WPRINTF_LONG | WPRINTF_WIDE))
+                               ? WPR_WSTRING
+                               : WPR_STRING;
+               break;
+               
+       case L'u':
+               res->type = WPR_UNSIGNED;
+               break;
+               
+       case L'X':
+               res->flags |= WPRINTF_UPPER_HEX;
+               /* fall through */
+               
+       case L'x':
+               res->type = WPR_HEXA;
+               break;
+               
+       default:
+               res->type = WPR_UNKNOWN;
+               p--;  /* print format as normal char */
+               break;
+       } /* switch */
+       
+       return (INT) (p - format) + 1;
+}
+
+
+/***********************************************************************
+ * NAME                                                                PRIVATE
+ *           wvsnprintfW   (Not a Windows API)
+ */
+static
+INT
+wvsnprintfW(
+       LPWSTR  buffer,
+       UINT    maxlen,
+       LPCWSTR spec,
+       va_list args
+       )
+{
+       WPRINTF_FORMAT  format;
+       LPWSTR          p = buffer;
+       UINT            i;
+       UINT            len;
+       CHAR            number [20];
+
+       while (*spec && (maxlen > 1))
+       {
+               if (*spec != L'%')
+               {
+                       *p++ = *spec++;
+                       maxlen--;
+                       continue;
+               }
+               spec++;
+               if (*spec == L'%')
+               {
+                       *p++ = *spec++;
+                       maxlen--;
+                       continue;
+               }
+               spec += WPRINTF_ParseFormatW(
+                               spec,
+                               & format
+                               );
+               len = WPRINTF_GetLen(
+                               & format,
+                               args,
+                               number,
+                               (maxlen - 1)
+                               );
+               if (!(format.flags & WPRINTF_LEFTALIGN))
+               {
+                       for (   i = format.precision;
+                               (i < format.width);
+                               i++, maxlen--
+                               )
+                       {
+                               *p++ = L' ';
+                       }
+               }
+               switch (format.type)
+               {
+               case WPR_WCHAR:
+                       if ((*p = va_arg( args, WCHAR )))
+                       {
+                               p++;
+                       }
+                       else if (format.width > 1)
+                       {
+                               *p++ = L' ';
+                       }
+                       else
+                       {
+                               len = 0;
+                       }
+                       break;
+                       
+               case WPR_CHAR:
+                       if ((*p = (WCHAR) va_arg( args, CHAR )))
+                       {
+                               p++;
+                       }
+                       else if (format.width > 1)
+                       {
+                               *p++ = L' ';
+                       }
+                       else
+                       {
+                               len = 0;
+                       }
+                       break;
+                       
+               case WPR_STRING:
+               {
+                       LPCSTR ptr = va_arg( args, LPCSTR );
+                       
+                       for (   i = 0;
+                               (i < len);
+                               i++
+                               )
+                       {
+                               *p++ = (WCHAR) *ptr++;
+                       }
+               }
+                       break;
+                       
+               case WPR_WSTRING:
+                       if (len)
+                       {
+                               memcpy(
+                                       p,
+                                       va_arg( args, LPCWSTR ),
+                                       (len * sizeof (WCHAR))
+                                       );
+                       }
+                       p += len;
+                       break;
+                       
+               case WPR_HEXA:
+                       if (    (format.flags & WPRINTF_PREFIX_HEX)
+                               && (maxlen > 3)
+                               )
+                       {
+                               *p++ = L'0';
+                               *p++ = (format.flags & WPRINTF_UPPER_HEX)
+                                       ? L'X'
+                                       : L'x';
+                               maxlen -= 2;
+                               len -= 2;
+                               format.precision -= 2;
+                               format.width -= 2;
+                       }
+                       /* fall through */
+                       
+               case WPR_SIGNED:
+               case WPR_UNSIGNED:
+                       for (   i = len;
+                               (i < format.precision);
+                               i++, maxlen--
+                               )
+                       {
+                               *p++ = L'0';
+                       }
+                       for (   i = 0;
+                               (i < len);
+                               i++
+                               )
+                       {
+                               *p++ = (WCHAR) number[i];
+                       }
+                       (void) va_arg( args, INT ); /* Go to the next arg */
+                       break;
+                       
+               case WPR_UNKNOWN:
+                       continue;
+               } /* switch */
+
+               if (format.flags & WPRINTF_LEFTALIGN)
+               {
+                       for (   i = format.precision;
+                               (i < format.width);
+                               i++, maxlen--
+                               )
+                       {
+                               *p++ = L' ';
+                       }
+               }
+               maxlen -= len;
+       } /* while */
+       
+       *p = L'\0';
+       return (maxlen > 1)
+               ? (INT) (p - buffer)
+               : -1;
+}
+
+
+/***********************************************************************
+ * NAME                                                                PUBLIC
+ *     wsprintfW   (USER32.586)
+ *
+ * DESCRIPTION
+ *
+ * ARGUMENTS
+ *
+ * RETURN VALUE
+ */
+INT
+CDECL
+wsprintfW(
+       LPWSTR  buffer,
+       LPCWSTR spec,
+       ...
+       )
+{
+       va_list valist;
+       INT     res;
+
+       va_start( valist, spec );
+       res = wvsnprintfW(
+                       buffer,
+                       0xffffffff,
+                       spec,
+                       valist
+                       );
+       va_end( valist );
+       return res;
+}
+
+
+/***********************************************************************
+ * NAME                                                                PUBLIC
+ *           wvsprintfW   (USER32.588)
+ *
+ * DESCRIPTION
+ *
+ * ARGUMENTS
+ *
+ * RETURN VALUE
+ */
+INT
+STDCALL
+wvsprintfW(
+       LPWSTR  buffer,
+       LPCWSTR spec,
+       va_list args
+       )
+{
+       return wvsnprintfW(
+                       buffer,
+                       0xffffffff,
+                       spec,
+                       args
+                       );
+}
+
+
+/* EOF */
diff --git a/reactos/lib/user32/user32.def b/reactos/lib/user32/user32.def
new file mode 100644 (file)
index 0000000..2660996
--- /dev/null
@@ -0,0 +1,634 @@
+LIBRARY user32
+EXPORTS
+;ActivateKeyboardLayout
+;AdjustWindowRect
+;AdjustWindowRectEx
+;AnyPopup
+;AppendMenuA
+;AppendMenuW
+;ArrangeIconicWindows
+;AttachThreadInput
+;BeginDeferWindowPos
+;BeginPaint
+;BringWindowToTop
+;BroadcastSystemMessage
+;BroadcastSystemMessageA
+;BroadcastSystemMessageW
+;CallMsgFilter
+;CallMsgFilterA
+;CallMsgFilterW
+;CallNextHookEx
+;CallWindowProcA
+;CallWindowProcW
+;CascadeChildWindows
+;CascadeWindows
+;ChangeClipboardChain
+;ChangeDisplaySettingsA
+;ChangeDisplaySettingsExA
+;ChangeDisplaySettingsExW
+;ChangeDisplaySettingsW
+;ChangeMenuA
+;ChangeMenuW
+;CharLowerA
+;CharLowerBuffA
+;CharLowerBuffW
+;CharLowerW
+;CharNextA
+;CharNextExA
+;CharNextW
+;CharPrevA
+;CharPrevExA
+;CharPrevW
+;CharToOemA
+;CharToOemBuffA
+;CharToOemBuffW
+;CharToOemW
+;CharUpperA
+;CharUpperBuffA
+;CharUpperBuffW
+;CharUpperW
+;CheckDlgButton
+;CheckMenuItem
+;CheckMenuRadioItem
+;CheckRadioButton
+;ChildWindowFromPoint
+;ChildWindowFromPointEx
+;ClientThreadSetup
+;ClientToScreen
+;ClipCursor
+;CloseClipboard
+;CloseDesktop
+;CloseWindow
+;CloseWindowStation
+;CopyAcceleratorTableA
+;CopyAcceleratorTableW
+;CopyIcon
+;CopyImage
+;CopyRect
+;CountClipboardFormats
+;CreateAcceleratorTableA
+;CreateAcceleratorTableW
+;CreateCaret
+;CreateCursor
+;CreateDesktopA
+;CreateDesktopW
+;CreateDialogIndirectParamA
+;CreateDialogIndirectParamAorW
+;CreateDialogIndirectParamW
+;CreateDialogParamA
+;CreateDialogParamW
+;CreateIcon
+;CreateIconFromResource
+;CreateIconFromResourceEx
+;CreateIconIndirect
+;CreateMDIWindowA
+;CreateMDIWindowW
+;CreateMenu
+;CreatePopupMenu
+;CreateWindowExA
+;CreateWindowExW
+;CreateWindowStationA
+;CreateWindowStationW
+;DdeAbandonTransaction
+;DdeAccessData
+;DdeAddData
+;DdeClientTransaction
+;DdeCmpStringHandles
+;DdeConnect
+;DdeConnectList
+;DdeCreateDataHandle
+;DdeCreateStringHandleA
+;DdeCreateStringHandleW
+;DdeDisconnect
+;DdeDisconnectList
+;DdeEnableCallback
+;DdeFreeDataHandle
+;DdeFreeStringHandle
+;DdeGetData
+;DdeGetLastError
+;DdeGetQualityOfService
+;DdeImpersonateClient
+;DdeInitializeA
+;DdeInitializeW
+;DdeKeepStringHandle
+;DdeNameService
+;DdePostAdvise
+;DdeQueryConvInfo
+;DdeQueryNextServer
+;DdeQueryStringA
+;DdeQueryStringW
+;DdeReconnect
+;DdeSetQualityOfService
+;DdeSetUserHandle
+;DdeUnaccessData
+;DdeUninitialize
+;DefDlgProcA
+;DefDlgProcW
+;DefFrameProcA
+;DefFrameProcW
+;DefMDIChildProcA
+;DefMDIChildProcW
+;DefWindowProcA
+;DefWindowProcW
+;DeferWindowPos
+;DeleteMenu
+;DeregisterShellHookWindow
+;DestroyAcceleratorTable
+;DestroyCaret
+;DestroyCursor
+;DestroyIcon
+;DestroyMenu
+;DestroyWindow
+;DialogBoxIndirectParamA
+;DialogBoxIndirectParamAorW
+;DialogBoxIndirectParamW
+;DialogBoxParamA
+;DialogBoxParamW
+;DispatchMessageA
+;DispatchMessageW
+;DlgDirListA
+;DlgDirListComboBoxA
+;DlgDirListComboBoxW
+;DlgDirListW
+;DlgDirSelectComboBoxExA
+;DlgDirSelectComboBoxExW
+;DlgDirSelectExA
+;DlgDirSelectExW
+;DragDetect
+;DragObject
+;DrawAnimatedRects
+;DrawCaption
+;DrawCaptionTempA
+;DrawCaptionTempW
+;DrawEdge
+;DrawFocusRect
+;DrawFrame
+;DrawFrameControl
+;DrawIcon
+;DrawIconEx
+;DrawMenuBar
+;DrawMenuBarTemp
+;DrawStateA
+;DrawStateW
+;DrawTextA
+;DrawTextExA
+;DrawTextExW
+;DrawTextW
+;EditWndProc
+;EmptyClipboard
+;EnableMenuItem
+;EnableScrollBar
+;EnableWindow
+;EndDeferWindowPos
+;EndDialog
+;EndMenu
+;EndPaint
+;EndTask
+;EnumChildWindows
+;EnumClipboardFormats
+;EnumDesktopWindows
+;EnumDesktopsA
+;EnumDesktopsW
+;EnumDisplayDevicesA
+;EnumDisplayDevicesW
+;EnumDisplaySettingsA
+;EnumDisplaySettingsW
+;EnumPropsA
+;EnumPropsExA
+;EnumPropsExW
+;EnumPropsW
+;EnumThreadWindows
+;EnumWindowStationsA
+;EnumWindowStationsW
+;EnumWindows
+;EqualRect
+;ExcludeUpdateRgn
+;ExitWindowsEx
+;FillRect
+;FindWindowA
+;FindWindowExA
+;FindWindowExW
+;FindWindowW
+;FlashWindow
+;FrameRect
+;FreeDDElParam
+;FullScreenControl
+;GetActiveWindow
+;GetAncestor
+;GetAppCompatFlags
+;GetAsyncKeyState
+;GetCapture
+;GetCaretBlinkTime
+;GetCaretPos
+;GetClassInfoA
+;GetClassInfoExA
+;GetClassInfoExW
+;GetClassInfoW
+;GetClassLongA
+;GetClassLongW
+;GetClassNameA
+;GetClassNameW
+;GetClassWord
+;GetClientRect
+;GetClipCursor
+;GetClipboardData
+;GetClipboardFormatNameA
+;GetClipboardFormatNameW
+;GetClipboardOwner
+;GetClipboardViewer
+;GetCursor
+;GetCursorInfo
+;GetCursorPos
+;GetDC
+;GetDCEx
+;GetDesktopWindow
+;GetDialogBaseUnits
+;GetDlgCtrlID
+;GetDlgItem
+;GetDlgItemInt
+;GetDlgItemTextA
+;GetDlgItemTextW
+;GetDoubleClickTime
+;GetFocus
+;GetForegroundWindow
+;GetGUIThreadInfo
+;GetIconInfo
+;GetInputDesktop
+;GetInputState
+;GetInternalWindowPos
+;GetKBCodePage
+;GetKeyNameTextA
+;GetKeyNameTextW
+;GetKeyState
+;GetKeyboardLayout
+;GetKeyboardLayoutList
+;GetKeyboardLayoutNameA
+;GetKeyboardLayoutNameW
+;GetKeyboardState
+;GetKeyboardType
+;GetLastActivePopup
+;GetMenu
+;GetMenuCheckMarkDimensions
+;GetMenuContextHelpId
+;GetMenuDefaultItem
+;GetMenuItemCount
+;GetMenuItemID
+;GetMenuItemInfoA
+;GetMenuItemInfoW
+;GetMenuItemRect
+;GetMenuState
+;GetMenuStringA
+;GetMenuStringW
+;GetMessageA
+;GetMessageExtraInfo
+;GetMessagePos
+;GetMessageTime
+;GetMessageW
+;GetNextDlgGroupItem
+;GetNextDlgTabItem
+;GetOpenClipboardWindow
+;GetParent
+;GetPriorityClipboardFormat
+;GetProcessWindowStation
+;GetProgmanWindow
+;GetPropA
+;GetPropW
+;GetQueueStatus
+;GetScrollInfo
+;GetScrollPos
+;GetScrollRange
+;GetShellWindow
+;GetSubMenu
+;GetSysColor
+;GetSysColorBrush
+;GetSystemMenu
+;GetSystemMetrics
+;GetTabbedTextExtentA
+;GetTabbedTextExtentW
+;GetTaskmanWindow
+;GetThreadDesktop
+;GetTopWindow
+;GetUpdateRect
+;GetUpdateRgn
+;GetUserObjectInformationA
+;GetUserObjectInformationW
+;GetUserObjectSecurity
+;GetWindow
+;GetWindowContextHelpId
+;GetWindowDC
+;GetWindowLongA
+;GetWindowLongW
+;GetWindowModuleFileName
+;GetWindowModuleFileNameA
+;GetWindowModuleFileNameW
+;GetWindowPlacement
+;GetWindowRect
+;GetWindowRgn
+;GetWindowTextA
+;GetWindowTextLengthA
+;GetWindowTextLengthW
+;GetWindowTextW
+;GetWindowThreadProcessId
+;GetWindowWord
+;GrayStringA
+;GrayStringW
+;HideCaret
+;HiliteMenuItem
+;ImpersonateDdeClientWindow
+;InSendMessage
+;InflateRect
+;InsertMenuA
+;InsertMenuItemA
+;InsertMenuItemW
+;InsertMenuW
+;InternalGetWindowText
+;IntersectRect
+;InvalidateRect
+;InvalidateRgn
+;InvertRect
+;IsCharAlphaA
+;IsCharAlphaNumericA
+;IsCharAlphaNumericW
+;IsCharAlphaW
+;IsCharLowerA
+;IsCharLowerW
+;IsCharUpperA
+;IsCharUpperW
+;IsChild
+;IsClipboardFormatAvailable
+;IsDialogMessage
+;IsDialogMessageA
+;IsDialogMessageW
+;IsDlgButtonChecked
+;IsHungAppWindow
+;IsIconic
+;IsMenu
+;IsRectEmpty
+;IsWindow
+;IsWindowEnabled
+;IsWindowUnicode
+;IsWindowVisible
+;IsZoomed
+;KillSystemTimer
+;KillTimer
+;LoadAcceleratorsA
+;LoadAcceleratorsW
+;LoadBitmapA
+;LoadBitmapW
+;LoadCursorA
+;LoadCursorFromFileA
+;LoadCursorFromFileW
+;LoadCursorW
+;LoadIconA
+;LoadIconW
+;LoadImageA
+;LoadImageW
+;LoadKeyboardLayoutA
+;LoadKeyboardLayoutEx
+;LoadKeyboardLayoutW
+;LoadLocalFonts
+;LoadMenuA
+;LoadMenuIndirectA
+;LoadMenuIndirectW
+;LoadMenuW
+;LoadRemoteFonts
+;LoadStringA
+;LoadStringW
+;LockWindowStation
+;LockWindowUpdate
+;LookupIconIdFromDirectory
+;LookupIconIdFromDirectoryEx
+;MBToWCSEx
+;MB_GetString
+;MapDialogRect
+;MapVirtualKeyA
+;MapVirtualKeyExA
+;MapVirtualKeyExW
+;MapVirtualKeyW
+;MapWindowPoints
+;MenuItemFromPoint
+;MenuWindowProcA
+;MenuWindowProcW
+;MessageBeep
+;MessageBoxA
+;MessageBoxExA
+;MessageBoxExW
+;MessageBoxIndirectA
+;MessageBoxIndirectW
+;MessageBoxW
+;ModifyMenuA
+;ModifyMenuW
+;MoveWindow
+;MsgWaitForMultipleObjects
+;MsgWaitForMultipleObjectsEx
+;NotifyWinEvent
+;OemKeyScan
+;OemToCharA
+;OemToCharBuffA
+;OemToCharBuffW
+;OemToCharW
+;OffsetRect
+;OpenClipboard
+;OpenDesktopA
+;OpenDesktopW
+;OpenIcon
+;OpenInputDesktop
+;OpenWindowStationA
+;OpenWindowStationW
+;PackDDElParam
+;PaintDesktop
+;PeekMessageA
+;PeekMessageW
+;PostMessageA
+;PostMessageW
+;PostQuitMessage
+;PostThreadMessageA
+;PostThreadMessageW
+;PrivateExtractIconExA
+;PrivateExtractIconExW
+;PrivateExtractIconsA
+;PrivateExtractIconsW
+;PrivateKDBreakPoint
+;PtInRect
+;QuerySendMessage
+;RealChildWindowFromPoint
+;RealGetWindowClass
+;RealGetWindowClassA
+;RealGetWindowClassW
+;RedrawWindow
+;RegisterClassA
+;RegisterClassExA
+;RegisterClassExW
+;RegisterClassW
+;RegisterClipboardFormatA
+;RegisterClipboardFormatW
+;RegisterHotKey
+;RegisterLogonProcess
+;RegisterServicesProcess
+;RegisterShellHookWindow
+;RegisterSystemThread
+;RegisterTasklist
+;RegisterWindowMessageA
+;RegisterWindowMessageW
+;ReleaseCapture
+;ReleaseDC
+;RemoveMenu
+;RemovePropA
+;RemovePropW
+;ReplyMessage
+;ReuseDDElParam
+;ScreenToClient
+;ScrollChildren
+;ScrollDC
+;ScrollWindow
+;ScrollWindowEx
+;SendDlgItemMessageA
+;SendDlgItemMessageW
+;SendInput
+;SendMessageA
+;SendMessageCallbackA
+;SendMessageCallbackW
+;SendMessageTimeoutA
+;SendMessageTimeoutW
+;SendMessageW
+;SendNotifyMessageA
+;SendNotifyMessageW
+;SetActiveWindow
+;SetCapture
+;SetCaretBlinkTime
+;SetCaretPos
+;SetClassLongA
+;SetClassLongW
+;SetClassWord
+;SetClipboardData
+;SetClipboardViewer
+;SetConsoleReserveKeys
+;SetCursor
+;SetCursorContents
+;SetCursorPos
+;SetDebugErrorLevel
+;SetDeskWallpaper
+;SetDlgItemInt
+;SetDlgItemTextA
+;SetDlgItemTextW
+;SetDoubleClickTime
+;SetFocus
+;SetForegroundWindow
+;SetInternalWindowPos
+;SetKeyboardState
+;SetLastErrorEx
+;SetLogonNotifyWindow
+;SetMenu
+;SetMenuContextHelpId
+;SetMenuDefaultItem
+;SetMenuItemBitmaps
+;SetMenuItemInfoA
+;SetMenuItemInfoW
+;SetMessageExtraInfo
+;SetMessageQueue
+;SetParent
+;SetProcessWindowStation
+;SetProgmanWindow
+;SetPropA
+;SetPropW
+;SetRect
+;SetRectEmpty
+;SetScrollInfo
+;SetScrollPos
+;SetScrollRange
+;SetShellWindow
+;SetShellWindowEx
+;SetSysColors
+;SetSysColorsTemp
+;SetSystemCursor
+;SetSystemMenu
+;SetSystemTimer
+;SetTaskmanWindow
+;SetThreadDesktop
+;SetTimer
+;SetUserObjectInformationA
+;SetUserObjectInformationW
+;SetUserObjectSecurity
+;SetWinEventHook
+;SetWindowContextHelpId
+;SetWindowLongA
+;SetWindowLongW
+;SetWindowPlacement
+;SetWindowPos
+;SetWindowRgn
+;SetWindowStationUser
+;SetWindowTextA
+;SetWindowTextW
+;SetWindowWord
+;SetWindowsHookA
+;SetWindowsHookExA
+;SetWindowsHookExW
+;SetWindowsHookW
+;ShowCaret
+;ShowCursor
+;ShowOwnedPopups
+;ShowScrollBar
+;ShowStartGlass
+;ShowWindow
+;ShowWindowAsync
+;SoftModalMessageBox
+;SubtractRect
+;SwapMouseButton
+;SwitchDesktop
+;SwitchToThisWindow
+;SystemParametersInfoA
+;SystemParametersInfoW
+;TabbedTextOutA
+;TabbedTextOutW
+;TileChildWindows
+;TileWindows
+;ToAscii
+;ToAsciiEx
+;ToUnicode
+;ToUnicodeEx
+;TrackMouseEvent
+;TrackPopupMenu
+;TrackPopupMenuEx
+;TranslateAccelerator
+;TranslateAcceleratorA
+;TranslateAcceleratorW
+;TranslateMDISysAccel
+;TranslateMessage
+;TranslateMessageEx
+;UnhookWinEvent
+;UnhookWindowsHook
+;UnhookWindowsHookEx
+;UnionRect
+;UnloadKeyboardLayout
+;UnlockWindowStation
+;UnpackDDElParam
+;UnregisterClassA
+;UnregisterClassW
+;UnregisterHotKey
+;UpdatePerUserSystemParameters
+;UpdateWindow
+;UserClientDllInitialize
+;UserRealizePalette
+;UserRegisterWowHandlers
+;ValidateRect
+;ValidateRgn
+;VkKeyScanA
+;VkKeyScanExA
+;VkKeyScanExW
+;VkKeyScanW
+;WCSToMBEx
+;WaitForInputIdle
+;WaitMessage
+;WinHelpA
+;WinHelpW
+;WindowFromDC
+;WindowFromPoint
+;keybd_event
+;mouse_event
+wsprintfA
+wsprintfW
+wvsprintfA@12
+wvsprintfA = wvsprintfA@12
+wvsprintfW@12
+wvsprintfW = wvsprintfW@12
+
diff --git a/reactos/lib/user32/user32.rc b/reactos/lib/user32/user32.rc
new file mode 100644 (file)
index 0000000..a84c8f4
--- /dev/null
@@ -0,0 +1,38 @@
+#include <windows32/defines.h>
+#include "../../include/reactos/resource.h"
+
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+
+VS_VERSION_INFO VERSIONINFO
+       FILEVERSION     0,0,13,RES_UINT_FILE_VERSION
+       PRODUCTVERSION  0,0,13,0
+       FILEFLAGSMASK   0x3fL
+#ifdef _DEBUG
+       FILEFLAGS       0x1L
+#else
+       FILEFLAGS       0x0L
+#endif
+       FILEOS          0x40004L
+       FILETYPE        0x2L
+       FILESUBTYPE     0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "CompanyName",       RES_STR_COMPANY_NAME
+            VALUE "FileDescription",   "ReactOS User API Client Dll\0"
+            VALUE "FileVersion",       "post 0.0.13\0"
+            VALUE "InternalName",      "user32\0"
+            VALUE "LegalCopyright",    RES_STR_LEGAL_COPYRIGHT
+            VALUE "OriginalFilename",  "user32.dll\0"
+            VALUE "ProductName",       RES_STR_PRODUCT_NAME
+            VALUE "ProductVersion",    RES_STR_PRODUCT_VERSION
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+
diff --git a/reactos/lib/user32/user32_specs b/reactos/lib/user32/user32_specs
new file mode 100644 (file)
index 0000000..096efd6
--- /dev/null
@@ -0,0 +1,78 @@
+*asm:
+
+
+*asm_final:
+
+
+*cpp:
+-remap %(cpp_cpu) %{posix:-D_POSIX_SOURCE}
+
+*cc1:
+%(cc1_spec) 
+
+*cc1plus:
+
+
+*endfile:
+
+
+*link:
+%{mwindows:--subsystem windows} %{mdll:--dll -e _DllMainCRTStartup@12}
+
+*lib:
+
+
+*libgcc:
+-lgcc
+
+*startfile:
+
+
+*switches_need_spaces:
+
+
+*signed_char:
+%{funsigned-char:-D__CHAR_UNSIGNED__}
+
+*predefines:
+-Di386 -D_WIN32 -DWIN32 -D__WIN32__   -D__MINGW32__ -DWINNT  -D_X86_=1 -D__STDC__=1  -D__stdcall=__attribute__((__stdcall__))   _D_stdcall=__attribute__((__stdcall__))   -D__cdecl=__attribute__((__cdecl__))   -D__declspec(x)=__attribute__((x))   -Asystem(winnt) -Acpu(i386) -Amachine(i386)
+
+*cross_compile:
+1
+
+*version:
+egcs-2.91.57
+
+*multilib:
+. ;
+
+*multilib_defaults:
+
+
+*multilib_extra:
+
+
+*multilib_matches:
+
+
+*linker:
+collect2
+
+*cpp_486:
+%{!ansi:-Di486} -D__i486 -D__i486__
+
+*cpp_586:
+%{!ansi:-Di586 -Dpentium}      -D__i586 -D__i586__ -D__pentium -D__pentium__
+
+*cpp_686:
+%{!ansi:-Di686 -Dpentiumpro}   -D__i686 -D__i686__ -D__pentiumpro -D__pentiumpro__
+
+*cpp_cpu_default:
+%(cpp_586)
+
+*cpp_cpu:
+-Acpu(i386) -Amachine(i386) %{!ansi:-Di386} -D__i386 -D__i386__ %{mcpu=i486:%(cpp_486)} %{m486:%(cpp_486)} %{mpentium:%(cpp_586)} %{mcpu=pentium:%(cpp_586)} %{mpentiumpro:%(cpp_686)} %{mcpu=pentiumpro:%(cpp_686)} %{!mcpu*:%{!m486:%{!mpentium*:%(cpp_cpu_default)}}}
+
+*cc1_cpu:
+%{!mcpu*: %{m386:-mcpu=i386 -march=i386} %{mno-486:-mcpu=i386 -march=i386} %{m486:-mcpu=i486 -march=i486} %{mno-386:-mcpu=i486 -march=i486} %{mno-pentium:-mcpu=i486 -march=i486} %{mpentium:-mcpu=pentium} %{mno-pentiumpro:-mcpu=pentium} %{mpentiumpro:-mcpu=pentiumpro}}
+