/* DEPENDENCIES **************************************************************/
#include <ntnls.h>
+#include "extypes.h"
+#include "rtltypes.h"
/* PROTOTYPES ****************************************************************/
<file>sscanf.c</file>
<file>swprintf.c</file>
</directory>
- <directory name="stdlib">
- <file>abs.c</file>
- <file>atoi64.c</file>
- <file>atoi.c</file>
- <file>atol.c</file>
- <file>bsearch.c</file>
- <file>itoa.c</file>
- <file>itow.c</file>
- <file>labs.c</file>
- <file>lfind.c</file>
- <file>mbstowcs.c</file>
- <file>splitp.c</file>
- <file>strtol.c</file>
- <file>strtoul.c</file>
- <file>wcstol.c</file>
- <file>wcstombs.c</file>
- <file>wcstoul.c</file>
- <file>wtoi64.c</file>
- <file>wtoi.c</file>
- <file>wtol.c</file>
- </directory>
<directory name="def">
<file>ntdll.rc</file>
</directory>
+++ /dev/null
-/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
-#include <ntdll.h>
-
-/*
- * @implemented
- */
-int
-abs(int j)
-{
- return j<0 ? -j : j;
-}
+++ /dev/null
-/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
-#include <ntdll.h>
-
-/*
- * @implemented
- */
-long
-labs(long j)
-{
- return j<0 ? -j : j;
-}
--- /dev/null
+#include <string.h>\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+int\r
+abs(int j)\r
+{\r
+ return j<0 ? -j : j;\r
+}\r
-/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
-#include <ntdll.h>
-
-/*
- * @implemented
- */
-int
-atoi(const char *str)
-{
- return (int)strtol(str, 0, 10);
-}
+#include <string.h>\r
+#include <stdlib.h>\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+int\r
+atoi(const char *str)\r
+{\r
+ return (int)strtol(str, 0, 10);\r
+}\r
-/* $Id$
- *
- * COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS kernel
- * FILE: lib/ntdll/stdlib/atoi64.c
- * PURPOSE: converts an ascii string to 64 bit integer
- */
-
-#include <ntdll.h>
-
-/*
- * @implemented
- */
-__int64
-_atoi64 (const char *nptr)
-{
- int c;
- __int64 value;
- int sign;
-
- while (isspace((int)*nptr))
- ++nptr;
-
- c = (int)*nptr++;
- sign = c;
- if (c == '-' || c == '+')
- c = (int)*nptr++;
-
- value = 0;
-
- while (isdigit(c))
- {
- value = 10 * value + (c - '0');
- c = (int)*nptr++;
- }
-
- if (sign == '-')
- return -value;
- else
- return value;
-}
-
-/* EOF */
+#include <string.h>\r
+#include <ctype.h>\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+__int64\r
+_atoi64 (const char *nptr)\r
+{\r
+ int c;\r
+ __int64 value;\r
+ int sign;\r
+\r
+ while (isspace((int)*nptr))\r
+ ++nptr;\r
+\r
+ c = (int)*nptr++;\r
+ sign = c;\r
+ if (c == '-' || c == '+')\r
+ c = (int)*nptr++;\r
+\r
+ value = 0;\r
+\r
+ while (isdigit(c))\r
+ {\r
+ value = 10 * value + (c - '0');\r
+ c = (int)*nptr++;\r
+ }\r
+\r
+ if (sign == '-')\r
+ return -value;\r
+ else\r
+ return value;\r
+}\r
+\r
+/* EOF */\r
-/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
-#include <ntdll.h>
-
-/*
- * @implemented
- */
-long
-atol(const char *str)
-{
- return strtol(str, 0, 10);
-}
+#include <string.h>\r
+#include <stdlib.h>\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+long\r
+atol(const char *str)\r
+{\r
+ return strtol(str, 0, 10);\r
+}\r
-/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
-#include <ntdll.h>
-
-/*
- * @implemented
- */
-void *
-bsearch(const void *key, const void *base0, size_t nelem,
- size_t size, int (*cmp)(const void *ck, const void *ce))
-{
- char *base = (char *)base0;
- int lim, cmpval;
- void *p;
-
- for (lim = nelem; lim != 0; lim >>= 1)
- {
- p = base + (lim >> 1) * size;
- cmpval = (*cmp)(key, p);
- if (cmpval == 0)
- return p;
- if (cmpval > 0)
- { /* key > p: move right */
- base = (char *)p + size;
- lim--;
- } /* else move left */
- }
- return 0;
-}
+#include <string.h>\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+void *\r
+bsearch(const void *key, const void *base0, size_t nelem,\r
+ size_t size, int (*cmp)(const void *ck, const void *ce))\r
+{\r
+ char *base = (char *)base0;\r
+ int lim, cmpval;\r
+ void *p;\r
+\r
+ for (lim = nelem; lim != 0; lim >>= 1)\r
+ {\r
+ p = base + (lim >> 1) * size;\r
+ cmpval = (*cmp)(key, p);\r
+ if (cmpval == 0)\r
+ return p;\r
+ if (cmpval > 0)\r
+ { /* key > p: move right */\r
+ base = (char *)p + size;\r
+ lim--;\r
+ } /* else move left */\r
+ }\r
+ return 0;\r
+}\r
-/*
- * COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS system libraries
- * FILE: lib/ntdll/stdlib/itoa.c
- * PURPOSE: converts an integer to ascii
- * PROGRAMER:
- * UPDATE HISTORY:
- * 1995: Created
- * 1998: Added ltoa Boudewijn Dekker
- * 2003: Corrected ltoa implementation - Steven Edwards
- */
-/* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details
- * Copyright 2000 Alexandre Julliard
- * Copyright 2000 Jon Griffiths
- * Copyright 2003 Thomas Mertes
- */
-
-#include <ntdll.h>
-
-/*
- * @implemented
- */
-char *
-_i64toa(__int64 value, char *string, int radix)
-{
- char tmp[65];
- char *tp = tmp;
- __int64 i;
- unsigned __int64 v;
- __int64 sign;
- char *sp;
-
- if (radix > 36 || radix <= 1)
- {
- return 0;
- }
-
- sign = (radix == 10 && value < 0);
- if (sign)
- v = -value;
- else
- v = (unsigned __int64)value;
- while (v || tp == tmp)
- {
- i = v % radix;
- v = v / radix;
- if (i < 10)
- *tp++ = i+'0';
- else
- *tp++ = i + 'a' - 10;
- }
-
- sp = string;
- if (sign)
- *sp++ = '-';
- while (tp > tmp)
- *sp++ = *--tp;
- *sp = 0;
- return string;
-}
-
-
-/*
- * @implemented
- */
-char *
-_ui64toa(unsigned __int64 value, char *string, int radix)
-{
- char tmp[65];
- char *tp = tmp;
- __int64 i;
- unsigned __int64 v;
- char *sp;
-
- if (radix > 36 || radix <= 1)
- {
- return 0;
- }
-
- v = (unsigned __int64)value;
- while (v || tp == tmp)
- {
- i = v % radix;
- v = v / radix;
- if (i < 10)
- *tp++ = i+'0';
- else
- *tp++ = i + 'a' - 10;
- }
-
- sp = string;
- while (tp > tmp)
- *sp++ = *--tp;
- *sp = 0;
- return string;
-}
-
-
-/*
- * @implemented
- */
-char *
-_itoa(int value, char *string, int radix)
-{
- return _ltoa(value, string, radix);
-}
-
-
-/*
- * @implemented
- */
-char *
-_ltoa(long value, char *string, int radix)
-{
- unsigned long val;
- int negative;
- char buffer[33];
- char *pos;
- int digit;
-
- if (value < 0 && radix == 10) {
- negative = 1;
- val = -value;
- } else {
- negative = 0;
- val = value;
- } /* if */
-
- pos = &buffer[32];
- *pos = '\0';
-
- do {
- digit = val % radix;
- val = val / radix;
- if (digit < 10) {
- *--pos = '0' + digit;
- } else {
- *--pos = 'a' + digit - 10;
- } /* if */
- } while (val != 0L);
-
- if (negative) {
- *--pos = '-';
- } /* if */
-
- memcpy(string, pos, &buffer[32] - pos + 1);
- return string;
-}
-
-
-/*
- * @implemented
- */
-char *
-_ultoa(unsigned long value, char *string, int radix)
-{
- char tmp[33];
- char *tp = tmp;
- long i;
- unsigned long v = value;
- char *sp;
-
- if (radix > 36 || radix <= 1)
- {
- return 0;
- }
-
- while (v || tp == tmp)
- {
- i = v % radix;
- v = v / radix;
- if (i < 10)
- *tp++ = i+'0';
- else
- *tp++ = i + 'a' - 10;
- }
-
- sp = string;
- while (tp > tmp)
- *sp++ = *--tp;
- *sp = 0;
- return string;
-}
+#include <string.h>\r
+#include <stdlib.h>\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+char *\r
+_i64toa(__int64 value, char *string, int radix)\r
+{\r
+ char tmp[65];\r
+ char *tp = tmp;\r
+ __int64 i;\r
+ unsigned __int64 v;\r
+ __int64 sign;\r
+ char *sp;\r
+\r
+ if (radix > 36 || radix <= 1)\r
+ {\r
+ return 0;\r
+ }\r
+\r
+ sign = (radix == 10 && value < 0);\r
+ if (sign)\r
+ v = -value;\r
+ else\r
+ v = (unsigned __int64)value;\r
+ while (v || tp == tmp)\r
+ {\r
+ i = v % radix;\r
+ v = v / radix;\r
+ if (i < 10)\r
+ *tp++ = i+'0';\r
+ else\r
+ *tp++ = i + 'a' - 10;\r
+ }\r
+\r
+ sp = string;\r
+ if (sign)\r
+ *sp++ = '-';\r
+ while (tp > tmp)\r
+ *sp++ = *--tp;\r
+ *sp = 0;\r
+ return string;\r
+}\r
+\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+char *\r
+_ui64toa(unsigned __int64 value, char *string, int radix)\r
+{\r
+ char tmp[65];\r
+ char *tp = tmp;\r
+ __int64 i;\r
+ unsigned __int64 v;\r
+ char *sp;\r
+\r
+ if (radix > 36 || radix <= 1)\r
+ {\r
+ return 0;\r
+ }\r
+\r
+ v = (unsigned __int64)value;\r
+ while (v || tp == tmp)\r
+ {\r
+ i = v % radix;\r
+ v = v / radix;\r
+ if (i < 10)\r
+ *tp++ = i+'0';\r
+ else\r
+ *tp++ = i + 'a' - 10;\r
+ }\r
+\r
+ sp = string;\r
+ while (tp > tmp)\r
+ *sp++ = *--tp;\r
+ *sp = 0;\r
+ return string;\r
+}\r
+\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+char *\r
+_itoa(int value, char *string, int radix)\r
+{\r
+ return _ltoa(value, string, radix);\r
+}\r
+\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+char *\r
+_ltoa(long value, char *string, int radix)\r
+{\r
+ unsigned long val;\r
+ int negative;\r
+ char buffer[33];\r
+ char *pos;\r
+ int digit;\r
+\r
+ if (value < 0 && radix == 10) {\r
+ negative = 1;\r
+ val = -value;\r
+ } else {\r
+ negative = 0;\r
+ val = value;\r
+ } /* if */\r
+\r
+ pos = &buffer[32];\r
+ *pos = '\0';\r
+\r
+ do {\r
+ digit = val % radix;\r
+ val = val / radix;\r
+ if (digit < 10) {\r
+ *--pos = '0' + digit;\r
+ } else {\r
+ *--pos = 'a' + digit - 10;\r
+ } /* if */\r
+ } while (val != 0L);\r
+\r
+ if (negative) {\r
+ *--pos = '-';\r
+ } /* if */\r
+\r
+ memcpy(string, pos, &buffer[32] - pos + 1);\r
+ return string;\r
+}\r
+\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+char *\r
+_ultoa(unsigned long value, char *string, int radix)\r
+{\r
+ char tmp[33];\r
+ char *tp = tmp;\r
+ long i;\r
+ unsigned long v = value;\r
+ char *sp;\r
+\r
+ if (radix > 36 || radix <= 1)\r
+ {\r
+ return 0;\r
+ }\r
+\r
+ while (v || tp == tmp)\r
+ {\r
+ i = v % radix;\r
+ v = v / radix;\r
+ if (i < 10)\r
+ *tp++ = i+'0';\r
+ else\r
+ *tp++ = i + 'a' - 10;\r
+ }\r
+\r
+ sp = string;\r
+ while (tp > tmp)\r
+ *sp++ = *--tp;\r
+ *sp = 0;\r
+ return string;\r
+}\r
-/*
- * COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS system libraries
- * FILE: lib/ntdll/stdlib/itow.c
- * PURPOSE: converts an integer to Unicode
- * PROGRAMER:
- * UPDATE HISTORY:
- * 1995: Created
- * 1998: Added ltoa Boudewijn Dekker
- */
-/* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */
-#include <ntdll.h>
-
-/*
- * @implemented
- */
-wchar_t *
-_i64tow(__int64 value, wchar_t *string, int radix)
-{
- wchar_t tmp[65];
- wchar_t *tp = tmp;
- __int64 i;
- unsigned __int64 v;
- __int64 sign;
- wchar_t *sp;
-
- if (radix > 36 || radix <= 1)
- {
- return 0;
- }
-
- sign = (radix == 10 && value < 0);
- if (sign)
- v = -value;
- else
- v = (unsigned __int64)value;
- while (v || tp == tmp)
- {
- i = v % radix;
- v = v / radix;
- if (i < 10)
- *tp++ = i+L'0';
- else
- *tp++ = i + L'a' - 10;
- }
-
- sp = string;
- if (sign)
- *sp++ = L'-';
- while (tp > tmp)
- *sp++ = *--tp;
- *sp = 0;
- return string;
-}
-
-
-/*
- * @implemented
- */
-wchar_t *
-_ui64tow(unsigned __int64 value, wchar_t *string, int radix)
-{
- wchar_t tmp[65];
- wchar_t *tp = tmp;
- __int64 i;
- unsigned __int64 v;
- wchar_t *sp;
-
- if (radix > 36 || radix <= 1)
- {
- return 0;
- }
-
- v = (unsigned __int64)value;
- while (v || tp == tmp)
- {
- i = v % radix;
- v = v / radix;
- if (i < 10)
- *tp++ = i+L'0';
- else
- *tp++ = i + L'a' - 10;
- }
-
- sp = string;
- while (tp > tmp)
- *sp++ = *--tp;
- *sp = 0;
- return string;
-}
-
-
-/*
- * @implemented
- */
-wchar_t *
-_itow(int value, wchar_t *string, int radix)
-{
- wchar_t tmp[33];
- wchar_t *tp = tmp;
- int i;
- unsigned v;
- int sign;
- wchar_t *sp;
-
- if (radix > 36 || radix <= 1)
- {
- return 0;
- }
-
- sign = (radix == 10 && value < 0);
- if (sign)
- v = -value;
- else
- v = (unsigned)value;
- while (v || tp == tmp)
- {
- i = v % radix;
- v = v / radix;
- if (i < 10)
- *tp++ = i+L'0';
- else
- *tp++ = i + L'a' - 10;
- }
-
- sp = string;
- if (sign)
- *sp++ = L'-';
- while (tp > tmp)
- *sp++ = *--tp;
- *sp = 0;
- return string;
-}
-
-
-/*
- * @implemented
- */
-wchar_t *
-_ltow(long value, wchar_t *string, int radix)
-{
- wchar_t tmp[33];
- wchar_t *tp = tmp;
- long i;
- unsigned long v;
- int sign;
- wchar_t *sp;
-
- if (radix > 36 || radix <= 1)
- {
- return 0;
- }
-
- sign = (radix == 10 && value < 0);
- if (sign)
- v = -value;
- else
- v = (unsigned long)value;
- while (v || tp == tmp)
- {
- i = v % radix;
- v = v / radix;
- if (i < 10)
- *tp++ = i+L'0';
- else
- *tp++ = i + L'a' - 10;
- }
-
- sp = string;
- if (sign)
- *sp++ = L'-';
- while (tp > tmp)
- *sp++ = *--tp;
- *sp = 0;
- return string;
-}
-
-
-/*
- * @implemented
- */
-wchar_t *
-_ultow(unsigned long value, wchar_t *string, int radix)
-{
- wchar_t tmp[33];
- wchar_t *tp = tmp;
- long i;
- unsigned long v = value;
- wchar_t *sp;
-
- if (radix > 36 || radix <= 1)
- {
- return 0;
- }
-
- while (v || tp == tmp)
- {
- i = v % radix;
- v = v / radix;
- if (i < 10)
- *tp++ = i+L'0';
- else
- *tp++ = i + L'a' - 10;
- }
-
- sp = string;
- while (tp > tmp)
- *sp++ = *--tp;
- *sp = 0;
- return string;
-}
+#include <string.h>\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+wchar_t *\r
+_i64tow(__int64 value, wchar_t *string, int radix)\r
+{\r
+ wchar_t tmp[65];\r
+ wchar_t *tp = tmp;\r
+ __int64 i;\r
+ unsigned __int64 v;\r
+ __int64 sign;\r
+ wchar_t *sp;\r
+\r
+ if (radix > 36 || radix <= 1)\r
+ {\r
+ return 0;\r
+ }\r
+\r
+ sign = (radix == 10 && value < 0);\r
+ if (sign)\r
+ v = -value;\r
+ else\r
+ v = (unsigned __int64)value;\r
+ while (v || tp == tmp)\r
+ {\r
+ i = v % radix;\r
+ v = v / radix;\r
+ if (i < 10)\r
+ *tp++ = i+L'0';\r
+ else\r
+ *tp++ = i + L'a' - 10;\r
+ }\r
+\r
+ sp = string;\r
+ if (sign)\r
+ *sp++ = L'-';\r
+ while (tp > tmp)\r
+ *sp++ = *--tp;\r
+ *sp = 0;\r
+ return string;\r
+}\r
+\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+wchar_t *\r
+_ui64tow(unsigned __int64 value, wchar_t *string, int radix)\r
+{\r
+ wchar_t tmp[65];\r
+ wchar_t *tp = tmp;\r
+ __int64 i;\r
+ unsigned __int64 v;\r
+ wchar_t *sp;\r
+\r
+ if (radix > 36 || radix <= 1)\r
+ {\r
+ return 0;\r
+ }\r
+\r
+ v = (unsigned __int64)value;\r
+ while (v || tp == tmp)\r
+ {\r
+ i = v % radix;\r
+ v = v / radix;\r
+ if (i < 10)\r
+ *tp++ = i+L'0';\r
+ else\r
+ *tp++ = i + L'a' - 10;\r
+ }\r
+\r
+ sp = string;\r
+ while (tp > tmp)\r
+ *sp++ = *--tp;\r
+ *sp = 0;\r
+ return string;\r
+}\r
+\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+wchar_t *\r
+_itow(int value, wchar_t *string, int radix)\r
+{\r
+ wchar_t tmp[33];\r
+ wchar_t *tp = tmp;\r
+ int i;\r
+ unsigned v;\r
+ int sign;\r
+ wchar_t *sp;\r
+\r
+ if (radix > 36 || radix <= 1)\r
+ {\r
+ return 0;\r
+ }\r
+\r
+ sign = (radix == 10 && value < 0);\r
+ if (sign)\r
+ v = -value;\r
+ else\r
+ v = (unsigned)value;\r
+ while (v || tp == tmp)\r
+ {\r
+ i = v % radix;\r
+ v = v / radix;\r
+ if (i < 10)\r
+ *tp++ = i+L'0';\r
+ else\r
+ *tp++ = i + L'a' - 10;\r
+ }\r
+\r
+ sp = string;\r
+ if (sign)\r
+ *sp++ = L'-';\r
+ while (tp > tmp)\r
+ *sp++ = *--tp;\r
+ *sp = 0;\r
+ return string;\r
+}\r
+\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+wchar_t *\r
+_ltow(long value, wchar_t *string, int radix)\r
+{\r
+ wchar_t tmp[33];\r
+ wchar_t *tp = tmp;\r
+ long i;\r
+ unsigned long v;\r
+ int sign;\r
+ wchar_t *sp;\r
+\r
+ if (radix > 36 || radix <= 1)\r
+ {\r
+ return 0;\r
+ }\r
+\r
+ sign = (radix == 10 && value < 0);\r
+ if (sign)\r
+ v = -value;\r
+ else\r
+ v = (unsigned long)value;\r
+ while (v || tp == tmp)\r
+ {\r
+ i = v % radix;\r
+ v = v / radix;\r
+ if (i < 10)\r
+ *tp++ = i+L'0';\r
+ else\r
+ *tp++ = i + L'a' - 10;\r
+ }\r
+\r
+ sp = string;\r
+ if (sign)\r
+ *sp++ = L'-';\r
+ while (tp > tmp)\r
+ *sp++ = *--tp;\r
+ *sp = 0;\r
+ return string;\r
+}\r
+\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+wchar_t *\r
+_ultow(unsigned long value, wchar_t *string, int radix)\r
+{\r
+ wchar_t tmp[33];\r
+ wchar_t *tp = tmp;\r
+ long i;\r
+ unsigned long v = value;\r
+ wchar_t *sp;\r
+\r
+ if (radix > 36 || radix <= 1)\r
+ {\r
+ return 0;\r
+ }\r
+\r
+ while (v || tp == tmp)\r
+ {\r
+ i = v % radix;\r
+ v = v / radix;\r
+ if (i < 10)\r
+ *tp++ = i+L'0';\r
+ else\r
+ *tp++ = i + L'a' - 10;\r
+ }\r
+\r
+ sp = string;\r
+ while (tp > tmp)\r
+ *sp++ = *--tp;\r
+ *sp = 0;\r
+ return string;\r
+}\r
--- /dev/null
+#include <string.h>\r
+/*\r
+ * @implemented\r
+ */\r
+long\r
+labs(long j)\r
+{\r
+ return j<0 ? -j : j;\r
+}\r
-#include <ntdll.h>
-
-
-/*
- * @implemented
- */
-void *_lfind(const void *key, const void *base, size_t *nelp,
- size_t width, int (*compar)(const void *, const void *))
-{
- char* char_base = (char*)base;
- size_t i;
-
- for (i = 0; i < *nelp; i++)
- {
- if (compar(key, char_base) == 0)
- return char_base;
-
- char_base += width;
- }
-
- return NULL;
-}
+#include <string.h>\r
+/*\r
+ * @implemented\r
+ */\r
+void *_lfind(const void *key, const void *base, size_t *nelp,\r
+ size_t width, int (*compar)(const void *, const void *))\r
+{\r
+ char* char_base = (char*)base;\r
+ size_t i;\r
+\r
+ for (i = 0; i < *nelp; i++)\r
+ {\r
+ if (compar(key, char_base) == 0)\r
+ return char_base;\r
+\r
+ char_base += width;\r
+ }\r
+\r
+ return NULL;\r
+}\r
-/* $Id$
- *
- * COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS kernel
- * FILE: lib/ntdll/stdlib/mbstowcs.c
- * PURPOSE: converts a multi byte string to a unicode string
- */
-
-#include <ntdll.h>
-#define NDEBUG
-#include <debug.h>
-#include <stdlib.h>
-#include <string.h>
-/*
- * @implemented
- */
-size_t mbstowcs (wchar_t *wcstr, const char *mbstr, size_t count)
-{
- NTSTATUS Status;
- ULONG Size;
- ULONG Length;
-
- Length = strlen (mbstr);
-
- if (wcstr == NULL)
- {
- RtlMultiByteToUnicodeSize (&Size,
- (char *)mbstr,
- Length);
-
- return (size_t)Size;
- }
-
- Status = RtlMultiByteToUnicodeN (wcstr,
- count,
- &Size,
- (char *)mbstr,
- Length);
- if (!NT_SUCCESS(Status))
- return -1;
-
- return (size_t)Size;
-}
-
-/* EOF */
+#include <windows.h>\r
+#define NTOS_MODE_USER\r
+#define _NTSYSTEM_\r
+#include <ndk/umtypes.h>\r
+#include <ndk/rtlfuncs.h>\r
+#include <string.h>\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+int mbtowc (wchar_t *wchar, const char *mbchar, size_t count)\r
+{\r
+ NTSTATUS Status;\r
+ ULONG Size;\r
+\r
+ if (wchar == NULL)\r
+ return 0;\r
+\r
+ Status = RtlMultiByteToUnicodeN (wchar,\r
+ sizeof(WCHAR),\r
+ &Size,\r
+ (char *)mbchar,\r
+ count);\r
+ if (!NT_SUCCESS(Status))\r
+ return -1;\r
+\r
+ return (int)Size;\r
+}\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+size_t mbstowcs (wchar_t *wcstr, const char *mbstr, size_t count)\r
+{\r
+ NTSTATUS Status;\r
+ ULONG Size;\r
+ ULONG Length;\r
+\r
+ Length = strlen (mbstr);\r
+\r
+ if (wcstr == NULL)\r
+ {\r
+ RtlMultiByteToUnicodeSize (&Size,\r
+ (char *)mbstr,\r
+ Length);\r
+\r
+ return (size_t)Size;\r
+ }\r
+\r
+ Status = RtlMultiByteToUnicodeN (wcstr,\r
+ count,\r
+ &Size,\r
+ (char *)mbstr,\r
+ Length);\r
+ if (!NT_SUCCESS(Status))\r
+ return -1;\r
+\r
+ return (size_t)Size;\r
+}\r
+\r
+/* EOF */\r
--- /dev/null
+#include <stdlib.h>\r
+\r
+#if defined(__GNUC__)\r
+static unsigned long long next = 0;\r
+#else\r
+static unsigned __int64 next = 0;\r
+#endif\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+int rand(void)\r
+{\r
+#if defined(__GNUC__)\r
+ next = next * 0x5deece66dLL + 11;\r
+#else\r
+ next = next * 0x5deece66di64 + 11;\r
+#endif\r
+ return (int)((next >> 16) & RAND_MAX);\r
+}\r
+\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+void srand(unsigned seed)\r
+{\r
+ next = seed;\r
+}\r
-#include <ntdll.h>
-
-/*
- * @implemented
- */
-void _splitpath(const char* path, char* drive, char* dir, char* fname, char* ext)
-{
- char* tmp_drive;
- char* tmp_dir;
- char* tmp_ext;
-
- tmp_drive = (char*)strchr(path,':');
- if (drive) {
- if (tmp_drive) {
- strncpy(drive,tmp_drive-1,2);
- *(drive+2) = 0;
- } else {
- *drive = 0;
- }
- }
- if (!tmp_drive) {
- tmp_drive = (char*)path - 1;
- }
-
- tmp_dir = (char*)strrchr(path,'\\');
- if (dir) {
- if (tmp_dir) {
- strncpy(dir,tmp_drive+1,tmp_dir-tmp_drive);
- *(dir+(tmp_dir-tmp_drive)) = 0;
- } else {
- *dir =0;
- }
- }
-
- tmp_ext = (char*)strrchr(path,'.');
- if (!tmp_ext) {
- tmp_ext = (char*)path+strlen(path);
- }
- if (ext) {
- strcpy(ext,tmp_ext);
- }
-
- if (tmp_dir) {
- strncpy(fname,tmp_dir+1,tmp_ext-tmp_dir-1);
- *(fname+(tmp_ext-tmp_dir-1)) = 0;
- } else {
- strncpy(fname,tmp_drive+1,tmp_ext-tmp_drive-1);
- *(fname+(tmp_ext-path))=0;
- }
-}
-
+#include <string.h>\r
+/*\r
+ * @implemented\r
+ */\r
+void _splitpath(const char* path, char* drive, char* dir, char* fname, char* ext)\r
+{\r
+ char* tmp_drive;\r
+ char* tmp_dir;\r
+ char* tmp_ext;\r
+\r
+ tmp_drive = (char*)strchr(path,':');\r
+ if (drive) {\r
+ if (tmp_drive) {\r
+ strncpy(drive,tmp_drive-1,2);\r
+ *(drive+2) = 0;\r
+ } else {\r
+ *drive = 0;\r
+ }\r
+ }\r
+ if (!tmp_drive) {\r
+ tmp_drive = (char*)path - 1;\r
+ }\r
+\r
+ tmp_dir = (char*)strrchr(path,'\\');\r
+ if (dir) {\r
+ if (tmp_dir) {\r
+ strncpy(dir,tmp_drive+1,tmp_dir-tmp_drive);\r
+ *(dir+(tmp_dir-tmp_drive)) = 0;\r
+ } else {\r
+ *dir =0;\r
+ }\r
+ }\r
+\r
+ tmp_ext = (char*)strrchr(path,'.');\r
+ if (!tmp_ext) {\r
+ tmp_ext = (char*)path+strlen(path);\r
+ }\r
+ if (ext) {\r
+ strcpy(ext,tmp_ext);\r
+ }\r
+\r
+ if (tmp_dir) {\r
+ strncpy(fname,tmp_dir+1,tmp_ext-tmp_dir-1);\r
+ *(fname+(tmp_ext-tmp_dir-1)) = 0;\r
+ } else {\r
+ strncpy(fname,tmp_drive+1,tmp_ext-tmp_drive-1);\r
+ *(fname+(tmp_ext-path))=0;\r
+ }\r
+}\r
+\r
<file>wstring.c</file>
<file>wcsrev.c</file>
<file>wcsnset.c</file>
+ <file>abs.c</file>
+ <file>atoi64.c</file>
+ <file>atoi.c</file>
+ <file>atol.c</file>
+ <file>bsearch.c</file>
+ <file>itoa.c</file>
+ <file>itow.c</file>
+ <file>labs.c</file>
+ <file>lfind.c</file>
+ <file>mbstowcs.c</file>
+ <file>splitp.c</file>
+ <file>strtol.c</file>
+ <file>strtoul.c</file>
+ <file>wcstol.c</file>
+ <file>wcstombs.c</file>
+ <file>wcstoul.c</file>
+ <file>wtoi64.c</file>
+ <file>wtoi.c</file>
+ <file>wtol.c</file>
+ <file>rand.c</file>
</module>
-/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
-#include <ntdll.h>
-
-/*
- * @implemented
- */
-long
-strtol(const char *nptr, char **endptr, int base)
-{
- const char *s = nptr;
- unsigned long acc;
- int c;
- unsigned long cutoff;
- int neg = 0, any, cutlim;
-
- /*
- * Skip white space and pick up leading +/- sign if any.
- * If base is 0, allow 0x for hex and 0 for octal, else
- * assume decimal; if base is already 16, allow 0x.
- */
- do {
- c = *s++;
- } while (isspace(c));
- if (c == '-')
- {
- neg = 1;
- c = *s++;
- }
- else if (c == '+')
- c = *s++;
- if ((base == 0 || base == 16) &&
- c == '0' && (*s == 'x' || *s == 'X'))
- {
- c = s[1];
- s += 2;
- base = 16;
- }
- if (base == 0)
- base = c == '0' ? 8 : 10;
-
- /*
- * Compute the cutoff value between legal numbers and illegal
- * numbers. That is the largest legal value, divided by the
- * base. An input number that is greater than this value, if
- * followed by a legal input character, is too big. One that
- * is equal to this value may be valid or not; the limit
- * between valid and invalid numbers is then based on the last
- * digit. For instance, if the range for longs is
- * [-2147483648..2147483647] and the input base is 10,
- * cutoff will be set to 214748364 and cutlim to either
- * 7 (neg==0) or 8 (neg==1), meaning that if we have accumulated
- * a value > 214748364, or equal but the next digit is > 7 (or 8),
- * the number is too big, and we will return a range error.
- *
- * Set any if any `digits' consumed; make it negative to indicate
- * overflow.
- */
- cutoff = neg ? -(unsigned long)LONG_MIN : LONG_MAX;
- cutlim = cutoff % (unsigned long)base;
- cutoff /= (unsigned long)base;
- for (acc = 0, any = 0;; c = *s++)
- {
- if (isdigit(c))
- c -= '0';
- else if (isalpha(c))
- c -= isupper(c) ? 'A' - 10 : 'a' - 10;
- else
- break;
- if (c >= base)
- break;
- if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))
- any = -1;
- else
- {
- any = 1;
- acc *= base;
- acc += c;
- }
- }
- if (any < 0)
- {
- acc = neg ? LONG_MIN : LONG_MAX;
- }
- else if (neg)
- acc = -acc;
- if (endptr != 0)
- *endptr = any ? (char *)s - 1 : (char *)nptr;
- return acc;
-}
+#include <string.h>\r
+#include <limits.h>\r
+#include <ctype.h>\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+long\r
+strtol(const char *nptr, char **endptr, int base)\r
+{\r
+ const char *s = nptr;\r
+ unsigned long acc;\r
+ int c;\r
+ unsigned long cutoff;\r
+ int neg = 0, any, cutlim;\r
+\r
+ /*\r
+ * Skip white space and pick up leading +/- sign if any.\r
+ * If base is 0, allow 0x for hex and 0 for octal, else\r
+ * assume decimal; if base is already 16, allow 0x.\r
+ */\r
+ do {\r
+ c = *s++;\r
+ } while (isspace(c));\r
+ if (c == '-')\r
+ {\r
+ neg = 1;\r
+ c = *s++;\r
+ }\r
+ else if (c == '+')\r
+ c = *s++;\r
+ if ((base == 0 || base == 16) &&\r
+ c == '0' && (*s == 'x' || *s == 'X'))\r
+ {\r
+ c = s[1];\r
+ s += 2;\r
+ base = 16;\r
+ }\r
+ if (base == 0)\r
+ base = c == '0' ? 8 : 10;\r
+\r
+ /*\r
+ * Compute the cutoff value between legal numbers and illegal\r
+ * numbers. That is the largest legal value, divided by the\r
+ * base. An input number that is greater than this value, if\r
+ * followed by a legal input character, is too big. One that\r
+ * is equal to this value may be valid or not; the limit\r
+ * between valid and invalid numbers is then based on the last\r
+ * digit. For instance, if the range for longs is\r
+ * [-2147483648..2147483647] and the input base is 10,\r
+ * cutoff will be set to 214748364 and cutlim to either\r
+ * 7 (neg==0) or 8 (neg==1), meaning that if we have accumulated\r
+ * a value > 214748364, or equal but the next digit is > 7 (or 8),\r
+ * the number is too big, and we will return a range error.\r
+ *\r
+ * Set any if any `digits' consumed; make it negative to indicate\r
+ * overflow.\r
+ */\r
+ cutoff = neg ? -(unsigned long)LONG_MIN : LONG_MAX;\r
+ cutlim = cutoff % (unsigned long)base;\r
+ cutoff /= (unsigned long)base;\r
+ for (acc = 0, any = 0;; c = *s++)\r
+ {\r
+ if (isdigit(c))\r
+ c -= '0';\r
+ else if (isalpha(c))\r
+ c -= isupper(c) ? 'A' - 10 : 'a' - 10;\r
+ else\r
+ break;\r
+ if (c >= base)\r
+ break;\r
+ if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))\r
+ any = -1;\r
+ else\r
+ {\r
+ any = 1;\r
+ acc *= base;\r
+ acc += c;\r
+ }\r
+ }\r
+ if (any < 0)\r
+ {\r
+ acc = neg ? LONG_MIN : LONG_MAX;\r
+ }\r
+ else if (neg)\r
+ acc = -acc;\r
+ if (endptr != 0)\r
+ *endptr = any ? (char *)s - 1 : (char *)nptr;\r
+ return acc;\r
+}\r
-/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
-#include <ntdll.h>
-
-
-/*
- * Convert a string to an unsigned long integer.
- *
- * Ignores `locale' stuff. Assumes that the upper and lower case
- * alphabets and digits are each contiguous.
- *
- * @implemented
- */
-unsigned long
-strtoul(const char *nptr, char **endptr, int base)
-{
- const char *s = nptr;
- unsigned long acc;
- int c;
- unsigned long cutoff;
- int neg = 0, any, cutlim;
-
- /*
- * See strtol for comments as to the logic used.
- */
- do {
- c = *s++;
- } while (isspace(c));
- if (c == '-')
- {
- neg = 1;
- c = *s++;
- }
- else if (c == '+')
- c = *s++;
- if ((base == 0 || base == 16) &&
- c == '0' && (*s == 'x' || *s == 'X'))
- {
- c = s[1];
- s += 2;
- base = 16;
- }
- if (base == 0)
- base = c == '0' ? 8 : 10;
- cutoff = (unsigned long)ULONG_MAX / (unsigned long)base;
- cutlim = (unsigned long)ULONG_MAX % (unsigned long)base;
- for (acc = 0, any = 0;; c = *s++)
- {
- if (isdigit(c))
- c -= '0';
- else if (isalpha(c))
- c -= isupper(c) ? 'A' - 10 : 'a' - 10;
- else
- break;
- if (c >= base)
- break;
- if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))
- any = -1;
- else {
- any = 1;
- acc *= base;
- acc += c;
- }
- }
- if (any < 0)
- {
- acc = ULONG_MAX;
- }
- else if (neg)
- acc = -acc;
- if (endptr != 0)
- *endptr = any ? (char *)s - 1 : (char *)nptr;
- return acc;
-}
+#include <string.h>\r
+#include <limits.h>\r
+#include <ctype.h>\r
+\r
+/*\r
+ * Convert a string to an unsigned long integer.\r
+ *\r
+ * Ignores `locale' stuff. Assumes that the upper and lower case\r
+ * alphabets and digits are each contiguous.\r
+ *\r
+ * @implemented\r
+ */\r
+unsigned long\r
+strtoul(const char *nptr, char **endptr, int base)\r
+{\r
+ const char *s = nptr;\r
+ unsigned long acc;\r
+ int c;\r
+ unsigned long cutoff;\r
+ int neg = 0, any, cutlim;\r
+\r
+ /*\r
+ * See strtol for comments as to the logic used.\r
+ */\r
+ do {\r
+ c = *s++;\r
+ } while (isspace(c));\r
+ if (c == '-')\r
+ {\r
+ neg = 1;\r
+ c = *s++;\r
+ }\r
+ else if (c == '+')\r
+ c = *s++;\r
+ if ((base == 0 || base == 16) &&\r
+ c == '0' && (*s == 'x' || *s == 'X'))\r
+ {\r
+ c = s[1];\r
+ s += 2;\r
+ base = 16;\r
+ }\r
+ if (base == 0)\r
+ base = c == '0' ? 8 : 10;\r
+ cutoff = (unsigned long)ULONG_MAX / (unsigned long)base;\r
+ cutlim = (unsigned long)ULONG_MAX % (unsigned long)base;\r
+ for (acc = 0, any = 0;; c = *s++)\r
+ {\r
+ if (isdigit(c))\r
+ c -= '0';\r
+ else if (isalpha(c))\r
+ c -= isupper(c) ? 'A' - 10 : 'a' - 10;\r
+ else\r
+ break;\r
+ if (c >= base)\r
+ break;\r
+ if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))\r
+ any = -1;\r
+ else {\r
+ any = 1;\r
+ acc *= base;\r
+ acc += c;\r
+ }\r
+ }\r
+ if (any < 0)\r
+ {\r
+ acc = ULONG_MAX;\r
+ }\r
+ else if (neg)\r
+ acc = -acc;\r
+ if (endptr != 0)\r
+ *endptr = any ? (char *)s - 1 : (char *)nptr;\r
+ return acc;\r
+}\r
-/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
-#include <ntdll.h>
-
-
-/*
- * @implemented
- */
-long
-wcstol(const wchar_t *nptr, wchar_t **endptr, int base)
-{
- const wchar_t *s = nptr;
- unsigned long acc;
- int c;
- unsigned long cutoff;
- int neg = 0, any, cutlim;
-
- /*
- * Skip white space and pick up leading +/- sign if any.
- * If base is 0, allow 0x for hex and 0 for octal, else
- * assume decimal; if base is already 16, allow 0x.
- */
- do {
- c = *s++;
- } while (iswctype(c, _SPACE));
- if (c == '-')
- {
- neg = 1;
- c = *s++;
- }
- else if (c == L'+')
- c = *s++;
- if ((base == 0 || base == 16) &&
- c == L'0' && (*s == L'x' || *s == L'X'))
- {
- c = s[1];
- s += 2;
- base = 16;
- }
- if (base == 0)
- base = c == L'0' ? 8 : 10;
-
- /*
- * Compute the cutoff value between legal numbers and illegal
- * numbers. That is the largest legal value, divided by the
- * base. An input number that is greater than this value, if
- * followed by a legal input character, is too big. One that
- * is equal to this value may be valid or not; the limit
- * between valid and invalid numbers is then based on the last
- * digit. For instance, if the range for longs is
- * [-2147483648..2147483647] and the input base is 10,
- * cutoff will be set to 214748364 and cutlim to either
- * 7 (neg==0) or 8 (neg==1), meaning that if we have accumulated
- * a value > 214748364, or equal but the next digit is > 7 (or 8),
- * the number is too big, and we will return a range error.
- *
- * Set any if any `digits' consumed; make it negative to indicate
- * overflow.
- */
- cutoff = neg ? -(unsigned long)LONG_MIN : LONG_MAX;
- cutlim = cutoff % (unsigned long)base;
- cutoff /= (unsigned long)base;
- for (acc = 0, any = 0;; c = *s++)
- {
- if (iswctype(c, _DIGIT))
- c -= L'0';
- else if (iswctype(c, _ALPHA))
- c -= iswctype(c, _UPPER) ? L'A' - 10 : L'a' - 10;
- else
- break;
- if (c >= base)
- break;
- if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))
- any = -1;
- else
- {
- any = 1;
- acc *= base;
- acc += c;
- }
- }
- if (any < 0)
- {
- acc = neg ? LONG_MIN : LONG_MAX;
- }
- else if (neg)
- acc = -acc;
- if (endptr != 0)
- *endptr = any ? (wchar_t *)s - 1 : (wchar_t *)nptr;
- return acc;
-}
+#include <string.h>\r
+#include <ctype.h>\r
+#include <limits.h>\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+long\r
+wcstol(const wchar_t *nptr, wchar_t **endptr, int base)\r
+{\r
+ const wchar_t *s = nptr;\r
+ unsigned long acc;\r
+ int c;\r
+ unsigned long cutoff;\r
+ int neg = 0, any, cutlim;\r
+\r
+ /*\r
+ * Skip white space and pick up leading +/- sign if any.\r
+ * If base is 0, allow 0x for hex and 0 for octal, else\r
+ * assume decimal; if base is already 16, allow 0x.\r
+ */\r
+ do {\r
+ c = *s++;\r
+ } while (iswctype(c, _SPACE));\r
+ if (c == '-')\r
+ {\r
+ neg = 1;\r
+ c = *s++;\r
+ }\r
+ else if (c == L'+')\r
+ c = *s++;\r
+ if ((base == 0 || base == 16) &&\r
+ c == L'0' && (*s == L'x' || *s == L'X'))\r
+ {\r
+ c = s[1];\r
+ s += 2;\r
+ base = 16;\r
+ }\r
+ if (base == 0)\r
+ base = c == L'0' ? 8 : 10;\r
+\r
+ /*\r
+ * Compute the cutoff value between legal numbers and illegal\r
+ * numbers. That is the largest legal value, divided by the\r
+ * base. An input number that is greater than this value, if\r
+ * followed by a legal input character, is too big. One that\r
+ * is equal to this value may be valid or not; the limit\r
+ * between valid and invalid numbers is then based on the last\r
+ * digit. For instance, if the range for longs is\r
+ * [-2147483648..2147483647] and the input base is 10,\r
+ * cutoff will be set to 214748364 and cutlim to either\r
+ * 7 (neg==0) or 8 (neg==1), meaning that if we have accumulated\r
+ * a value > 214748364, or equal but the next digit is > 7 (or 8),\r
+ * the number is too big, and we will return a range error.\r
+ *\r
+ * Set any if any `digits' consumed; make it negative to indicate\r
+ * overflow.\r
+ */\r
+ cutoff = neg ? -(unsigned long)LONG_MIN : LONG_MAX;\r
+ cutlim = cutoff % (unsigned long)base;\r
+ cutoff /= (unsigned long)base;\r
+ for (acc = 0, any = 0;; c = *s++)\r
+ {\r
+ if (iswctype(c, _DIGIT))\r
+ c -= L'0';\r
+ else if (iswctype(c, _ALPHA))\r
+ c -= iswctype(c, _UPPER) ? L'A' - 10 : L'a' - 10;\r
+ else\r
+ break;\r
+ if (c >= base)\r
+ break;\r
+ if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))\r
+ any = -1;\r
+ else\r
+ {\r
+ any = 1;\r
+ acc *= base;\r
+ acc += c;\r
+ }\r
+ }\r
+ if (any < 0)\r
+ {\r
+ acc = neg ? LONG_MIN : LONG_MAX;\r
+ }\r
+ else if (neg)\r
+ acc = -acc;\r
+ if (endptr != 0)\r
+ *endptr = any ? (wchar_t *)s - 1 : (wchar_t *)nptr;\r
+ return acc;\r
+}\r
-/* $Id$
- *
- * COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS kernel
- * FILE: lib/ntdll/stdlib/wcstombs.c
- * PURPOSE: converts a unicode string to a multi byte string
- */
-
-#include <ntdll.h>
-#define NDEBUG
-#include <debug.h>
-#include <stdlib.h>
-#include <string.h>
-
-/*
- * @implemented
- */
-size_t wcstombs (char *mbstr, const wchar_t *wcstr, size_t count)
-{
- NTSTATUS Status;
- ULONG Size;
- ULONG Length;
-
- Length = wcslen (wcstr);
-
- if (mbstr == NULL)
- {
- RtlUnicodeToMultiByteSize (&Size,
- (wchar_t *)wcstr,
- Length * sizeof(WCHAR));
-
- return (size_t)Size;
- }
-
- Status = RtlUnicodeToMultiByteN (mbstr,
- count,
- &Size,
- (wchar_t *)wcstr,
- Length * sizeof(WCHAR));
- if (!NT_SUCCESS(Status))
- return -1;
-
- return (size_t)Size;
-}
-
-/* EOF */
+#include <windows.h>\r
+#define NTOS_MODE_USER\r
+#define _NTSYSTEM_\r
+#include <ndk/umtypes.h>\r
+#include <ndk/rtlfuncs.h>\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+int wctomb (char *mbchar, wchar_t wchar)\r
+{\r
+ NTSTATUS Status;\r
+ ULONG Size;\r
+\r
+ if (mbchar == NULL)\r
+ return 0;\r
+\r
+ Status = RtlUnicodeToMultiByteN (mbchar,\r
+ 1,\r
+ &Size,\r
+ &wchar,\r
+ sizeof(WCHAR));\r
+ if (!NT_SUCCESS(Status))\r
+ return -1;\r
+\r
+ return (int)Size;\r
+}\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+size_t wcstombs (char *mbstr, const wchar_t *wcstr, size_t count)\r
+{\r
+ NTSTATUS Status;\r
+ ULONG Size;\r
+ ULONG Length;\r
+\r
+ Length = wcslen (wcstr);\r
+\r
+ if (mbstr == NULL)\r
+ {\r
+ RtlUnicodeToMultiByteSize (&Size,\r
+ (wchar_t *)wcstr,\r
+ Length * sizeof(WCHAR));\r
+\r
+ return (size_t)Size;\r
+ }\r
+\r
+ Status = RtlUnicodeToMultiByteN (mbstr,\r
+ count,\r
+ &Size,\r
+ (wchar_t *)wcstr,\r
+ Length * sizeof(WCHAR));\r
+ if (!NT_SUCCESS(Status))\r
+ return -1;\r
+\r
+ return (size_t)Size;\r
+}\r
+\r
+/* EOF */\r
-/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
-#include <ntdll.h>
-
-/*
- * Convert a unicode string to an unsigned long integer.
- *
- * Ignores `locale' stuff. Assumes that the upper and lower case
- * alphabets and digits are each contiguous.
- *
- * @implemented
- */
-unsigned long
-wcstoul(const wchar_t *nptr, wchar_t **endptr, int base)
-{
- const wchar_t *s = nptr;
- unsigned long acc;
- int c;
- unsigned long cutoff;
- int neg = 0, any, cutlim;
-
- /*
- * See strtol for comments as to the logic used.
- */
- do {
- c = *s++;
- } while (iswctype(c, _SPACE));
- if (c == '-')
- {
- neg = 1;
- c = *s++;
- }
- else if (c == L'+')
- c = *s++;
- if ((base == 0 || base == 16) &&
- c == L'0' && (*s == L'x' || *s == L'X'))
- {
- c = s[1];
- s += 2;
- base = 16;
- }
- if (base == 0)
- base = c == L'0' ? 8 : 10;
- cutoff = (unsigned long)ULONG_MAX / (unsigned long)base;
- cutlim = (unsigned long)ULONG_MAX % (unsigned long)base;
- for (acc = 0, any = 0;; c = *s++)
- {
- if (iswctype(c, _DIGIT))
- c -= L'0';
- else if (iswctype(c, _ALPHA))
- c -= iswctype(c, _UPPER) ? L'A' - 10 : L'a' - 10;
- else
- break;
- if (c >= base)
- break;
- if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))
- any = -1;
- else {
- any = 1;
- acc *= base;
- acc += c;
- }
- }
- if (any < 0)
- {
- acc = ULONG_MAX;
- }
- else if (neg)
- acc = -acc;
- if (endptr != 0)
- *endptr = any ? (wchar_t *)s - 1 : (wchar_t *)nptr;
- return acc;
-}
+#include <string.h>\r
+#include <ctype.h>\r
+#include <limits.h>\r
+\r
+\r
+/*\r
+ * Convert a unicode string to an unsigned long integer.\r
+ *\r
+ * Ignores `locale' stuff. Assumes that the upper and lower case\r
+ * alphabets and digits are each contiguous.\r
+ *\r
+ * @implemented\r
+ */\r
+unsigned long\r
+wcstoul(const wchar_t *nptr, wchar_t **endptr, int base)\r
+{\r
+ const wchar_t *s = nptr;\r
+ unsigned long acc;\r
+ int c;\r
+ unsigned long cutoff;\r
+ int neg = 0, any, cutlim;\r
+\r
+ /*\r
+ * See strtol for comments as to the logic used.\r
+ */\r
+ do {\r
+ c = *s++;\r
+ } while (iswctype(c, _SPACE));\r
+ if (c == '-')\r
+ {\r
+ neg = 1;\r
+ c = *s++;\r
+ }\r
+ else if (c == L'+')\r
+ c = *s++;\r
+ if ((base == 0 || base == 16) &&\r
+ c == L'0' && (*s == L'x' || *s == L'X'))\r
+ {\r
+ c = s[1];\r
+ s += 2;\r
+ base = 16;\r
+ }\r
+ if (base == 0)\r
+ base = c == L'0' ? 8 : 10;\r
+ cutoff = (unsigned long)ULONG_MAX / (unsigned long)base;\r
+ cutlim = (unsigned long)ULONG_MAX % (unsigned long)base;\r
+ for (acc = 0, any = 0;; c = *s++)\r
+ {\r
+ if (iswctype(c, _DIGIT))\r
+ c -= L'0';\r
+ else if (iswctype(c, _ALPHA))\r
+ c -= iswctype(c, _UPPER) ? L'A' - 10 : L'a' - 10;\r
+ else\r
+ break;\r
+ if (c >= base)\r
+ break;\r
+ if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))\r
+ any = -1;\r
+ else {\r
+ any = 1;\r
+ acc *= base;\r
+ acc += c;\r
+ }\r
+ }\r
+ if (any < 0)\r
+ {\r
+ acc = ULONG_MAX;\r
+ }\r
+ else if (neg)\r
+ acc = -acc;\r
+ if (endptr != 0)\r
+ *endptr = any ? (wchar_t *)s - 1 : (wchar_t *)nptr;\r
+ return acc;\r
+}\r
-/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
-#include <ntdll.h>
-
-/*
- * @implemented
- */
-int
-_wtoi(const wchar_t *str)
-{
- return (int)wcstol(str, 0, 10);
-}
+#include <string.h>\r
+#include <stdlib.h>\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+int\r
+_wtoi(const wchar_t *str)\r
+{\r
+ return (int)wcstol(str, 0, 10);\r
+}\r
-/* $Id$
- *
- * COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS kernel
- * FILE: lib/ntdll/stdlib/wtoi64.c
- * PURPOSE: converts a unicode string to 64 bit integer
- */
-
-#include <ntdll.h>
-
-/*
- * @implemented
- */
-__int64
-_wtoi64 (const wchar_t *nptr)
-{
- int c;
- __int64 value;
- int sign;
-
- while (iswctype((int)*nptr, _SPACE))
- ++nptr;
-
- c = (int)*nptr++;
- sign = c;
- if (c == L'-' || c == L'+')
- c = (int)*nptr++;
-
- value = 0;
-
- while (iswctype(c, _DIGIT))
- {
- value = 10 * value + (c - L'0');
- c = (int)*nptr++;
- }
-
- if (sign == L'-')
- return -value;
- else
- return value;
-}
-
-/* EOF */
+#include <string.h>\r
+#include <ctype.h>\r
+\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+__int64\r
+_wtoi64 (const wchar_t *nptr)\r
+{\r
+ int c;\r
+ __int64 value;\r
+ int sign;\r
+\r
+ while (iswctype((int)*nptr, _SPACE))\r
+ ++nptr;\r
+\r
+ c = (int)*nptr++;\r
+ sign = c;\r
+ if (c == L'-' || c == L'+')\r
+ c = (int)*nptr++;\r
+\r
+ value = 0;\r
+\r
+ while (iswctype(c, _DIGIT))\r
+ {\r
+ value = 10 * value + (c - L'0');\r
+ c = (int)*nptr++;\r
+ }\r
+\r
+ if (sign == L'-')\r
+ return -value;\r
+ else\r
+ return value;\r
+}\r
+\r
+/* EOF */\r
-/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
-#include <ntdll.h>
-
-/*
- * @implemented
- */
-long
-_wtol(const wchar_t *str)
-{
- return wcstol(str, 0, 10);
-}
+#include <string.h>\r
+#include <stdlib.h>\r
+\r
+/*\r
+ * @implemented\r
+ */\r
+long\r
+_wtol(const wchar_t *str)\r
+{\r
+ return wcstol(str, 0, 10);\r
+}\r
<file>purecall.c</file>
<file>regio.c</file>
<file>sprintf.c</file>
- <file>stdlib.c</file>
<file>strtok.c</file>
<file>swprintf.c</file>
</directory>
projects / reactos.git / commitdiff