Código
/*** *wcscat.c - contains wcscat() and wcscpy() * * Copyright (c) 1985-1993, Microsoft Corporation. All rights reserved. * *Purpose: * wcscat() appends one wchar_t string onto another. * wcscpy() copies one wchar_t string into another. * * wcscat() concatenates (appends) a copy of the source string to the * end of the destination string, returning the destination string. * Strings are wide-character strings. * * wcscpy() copies the source string to the spot pointed to be * the destination string, returning the destination string. * Strings are wide-character strings. * *******************************************************************************/ #include <string.h> /*** *wchar_t *wcscat(dst, src) - concatenate (append) one wchar_t string to another * *Purpose: * Concatenates src onto the end of dest. Assumes enough * space in dest. * *Entry: * wchar_t *dst - wchar_t string to which "src" is to be appended * const wchar_t *src - wchar_t string to be appended to the end of "dst" * *Exit: * The address of "dst" * *Exceptions: * *******************************************************************************/ wchar_t * dst, const wchar_t * src ) { wchar_t * cp = dst; while( *cp ) cp++; /* find end of dst */ while( *cp++ = *src++ ) ; /* Copy src to end of dst */ return( dst ); /* return dst */ } /*** *wchar_t *wcscpy(dst, src) - copy one wchar_t string over another * *Purpose: * Copies the wchar_t string src into the spot specified by * dest; assumes enough room. * *Entry: * wchar_t * dst - wchar_t string over which "src" is to be copied * const wchar_t * src - wchar_t string to be copied over "dst" * *Exit: * The address of "dst" * *Exceptions: *******************************************************************************/ { wchar_t * cp = dst; while( *cp++ = *src++ ) ; /* Copy src over dst */ return( dst ); }
Código
/*** *wcschr.c - search a wchar_t string for a given wchar_t character * * Copyright (c) 1985-1993, Microsoft Corporation. All rights reserved. * *Purpose: * defines wcschr() - search a wchar_t string for a wchar_t character * *******************************************************************************/ #include <string.h> /*** *wchar_t *wcschr(string, c) - search a string for a wchar_t character * *Purpose: * Searches a wchar_t string for a given wchar_t character, * which may be the null character L'\0'. * *Entry: * wchar_t *string - wchar_t string to search in * wchar_t c - wchar_t character to search for * *Exit: * returns pointer to the first occurence of c in string * returns NULL if c does not occur in string * *Exceptions: * *******************************************************************************/ const wchar_t * string, wchar_t ch ) { while (*string && *string != (wchar_t)ch) string++; if (*string == (wchar_t)ch) return((wchar_t *)string); return(NULL); }
Código
/*** *wcscmp.c - routine to compare two wchar_t strings (for equal, less, or greater) * * Copyright (c) 1985-1993, Microsoft Corporation. All rights reserved. * *Purpose: * Compares two wide-character strings, determining their lexical order. * *******************************************************************************/ #include <string.h> /*** *wcscmp - compare two wchar_t strings, * returning less than, equal to, or greater than * *Purpose: * wcscmp compares two wide-character strings and returns an integer * to indicate whether the first is less than the second, the two are * equal, or whether the first is greater than the second. * * Comparison is done wchar_t by wchar_t on an UNSIGNED basis, which is to * say that Null wchar_t(0) is less than any other character. * *Entry: * const wchar_t * src - string for left-hand side of comparison * const wchar_t * dst - string for right-hand side of comparison * *Exit: * returns -1 if src < dst * returns 0 if src == dst * returns +1 if src > dst * *Exceptions: * *******************************************************************************/ const wchar_t * src, const wchar_t * dst ) { int ret = 0 ; while( ! (ret = (int)(*src - *dst)) && *dst) ++src, ++dst; if ( ret < 0 ) ret = -1 ; else if ( ret > 0 ) ret = 1 ; return( ret ); }
Código
/*** *wcslen.c - contains wcslen() routine * * Copyright (c) 1985-1993, Microsoft Corporation. All rights reserved. * *Purpose: * wcslen returns the length of a null-terminated wide-character string, * not including the null wchar_t itself. * *******************************************************************************/ #include <string.h> /*** *wcslen - return the length of a null-terminated wide-character string * *Purpose: * Finds the length in wchar_t's of the given string, not including * the final null wchar_t (wide-characters). * *Entry: * const wchar_t * wcs - string whose length is to be computed * *Exit: * length of the string "wcs", exclusive of the final null wchar_t * *Exceptions: * *******************************************************************************/ const wchar_t * wcs ) { const wchar_t *eos = wcs; while( *eos++ ) ; return( (size_t)(eos - wcs - 1) ); }
Código
/*** *wcsncpy.c - copy at most n characters of wide-character string * * Copyright (c) 1985-1993, Microsoft Corporation. All rights reserved. * *Purpose: * defines wcsncpy() - copy at most n characters of wchar_t string * *******************************************************************************/ #include <string.h> /*** *wchar_t *wcsncpy(dest, source, count) - copy at most n wide characters * *Purpose: * Copies count characters from the source string to the * destination. If count is less than the length of source, * NO NULL CHARACTER is put onto the end of the copied string. * If count is greater than the length of sources, dest is padded * with null characters to length count (wide-characters). * * *Entry: * wchar_t *dest - pointer to destination * wchar_t *source - source string for copy * size_t count - max number of characters to copy * *Exit: * returns dest * *Exceptions: * *******************************************************************************/ wchar_t * dest, const wchar_t * source, size_t count ) { wchar_t *start = dest; while (count && (*dest++ = *source++)) /* copy string */ count--; if (count) /* pad out with zeroes */ while (--count) *dest++ = L'\0'; return(start); }
Código
/*** *wcspbrk.c - scans wide character string for a character from control string * * Copyright (c) 1985-1993, Microsoft Corporation. All rights reserved. * *Purpose: * defines wcspbrk()- returns pointer to the first wide-character in * a wide-character string in the control string. * *******************************************************************************/ #include <string.h> /*** *wchar_t *wcspbrk(string, control) - scans string for a character from control * *Purpose: * Returns pointer to the first wide-character in * a wide-character string in the control string. * *Entry: * wchar_t *string - string to search in * wchar_t *control - string containing characters to search for * *Exit: * returns a pointer to the first character from control found * in string. * returns NULL if string and control have no characters in common. * *Exceptions: * *******************************************************************************/ const wchar_t * string, const wchar_t * control ) { wchar_t *wcset; /* 1st char in control string stops search */ while (*string) { for (wcset = (wchar_t *) control; *wcset; wcset++) { if (*wcset == *string) { return (wchar_t *) string; } } string++; } return NULL; }
Código
/*** *wcsrchr.c - find last occurrence of wchar_t character in wide string * * Copyright (c) 1985-1993, Microsoft Corporation. All rights reserved. * *Purpose: * defines wcsrchr() - find the last occurrence of a given character * in a string (wide-characters). * *******************************************************************************/ #include <string.h> /*** *wchar_t *wcsrchr(string, ch) - find last occurrence of ch in wide string * *Purpose: * Finds the last occurrence of ch in string. The terminating * null character is used as part of the search (wide-characters). * *Entry: * wchar_t *string - string to search in * wchar_t ch - character to search for * *Exit: * returns a pointer to the last occurrence of ch in the given * string * returns NULL if ch does not occurr in the string * *Exceptions: * *******************************************************************************/ const wchar_t * string, wchar_t ch ) { wchar_t *start = (wchar_t *)string; while (*string++) /* find end of string */ ; /* search towards front */ while (--string != start && *string != (wchar_t)ch) ; if (*string == (wchar_t)ch) /* wchar_t found ? */ return( (wchar_t *)string ); return(NULL); }
Código
/*** *wcsrev.c - reverse a wide-character string in place * * Copyright (c) 1985-1993, Microsoft Corporation. All rights reserved. * *Purpose: * defines _wcsrev() - reverse a wchar_t string in place (not including * L'\0' character) * *******************************************************************************/ #include <string.h> /*** *wchar_t *_wcsrev(string) - reverse a wide-character string in place * *Purpose: * Reverses the order of characters in the string. The terminating * null character remains in place (wide-characters). * *Entry: * wchar_t *string - string to reverse * *Exit: * returns string - now with reversed characters * *Exceptions: * *******************************************************************************/ wchar_t * __cdecl _wcsrev ( wchar_t * string ) { wchar_t *start = string; wchar_t *left = string; wchar_t ch; while (*string++) /* find end of string */ ; string -= 2; while (left < string) { ch = *left; *left++ = *string; *string-- = ch; } return(start); }
Código
/*** *wcsspn.c - find length of initial substring of chars from a control string * (wide-character strings) * * Copyright (c) 1985-1993, Microsoft Corporation. All rights reserved. * *Purpose: * defines wcsspn() - finds the length of the initial substring of * a string consisting entirely of characters from a control string * (wide-character strings). * *******************************************************************************/ #include <string.h> /*** *int wcsspn(string, control) - find init substring of control chars * *Purpose: * Finds the index of the first character in string that does belong * to the set of characters specified by control. This is * equivalent to the length of the initial substring of string that * consists entirely of characters from control. The L'\0' character * that terminates control is not considered in the matching process * (wide-character strings). * *Entry: * wchar_t *string - string to search * wchar_t *control - string containing characters not to search for * *Exit: * returns index of first wchar_t in string not in control * *Exceptions: * *******************************************************************************/ const wchar_t * string, const wchar_t * control ) { wchar_t *str = (wchar_t *) string; wchar_t *ctl; /* 1st char not in control string stops search */ while (*str) { for (ctl = (wchar_t *)control; *ctl != *str; ctl++) { if (*ctl == (wchar_t)0) { /* * reached end of control string without finding a match */ return str - string; } } str++; } /* * The whole string consisted of characters from control */ return str - string; }
Código
/*** *wcsstr.c - search for one wide-character string inside another * * Copyright (c) 1985-1993, Microsoft Corporation. All rights reserved. * *Purpose: * defines wcsstr() - search for one wchar_t string inside another * *******************************************************************************/ #include <string.h> /*** *wchar_t *wcsstr(string1, string2) - search for string2 in string1 * (wide strings) * *Purpose: * finds the first occurrence of string2 in string1 (wide strings) * *Entry: * wchar_t *string1 - string to search in * wchar_t *string2 - string to search for * *Exit: * returns a pointer to the first occurrence of string2 in * string1, or NULL if string2 does not occur in string1 * *Uses: * *Exceptions: * *******************************************************************************/ const wchar_t * wcs1, const wchar_t * wcs2 ) { wchar_t *cp = (wchar_t *) wcs1; wchar_t *s1, *s2; while (*cp) { s1 = cp; s2 = (wchar_t *) wcs2; while ( *s1 && *s2 && !(*s1-*s2) ) s1++, s2++; if (!*s2) return(cp); cp++; } return(NULL); }
Código
/*** *wcstok.c - tokenize a wide-character string with given delimiters * * Copyright (c) 1989-1993, Microsoft Corporation. All rights reserved. * *Purpose: * defines wcstok() - breaks wide-character string into series of token * via repeated calls. * *******************************************************************************/ #include "headers.hxx" #ifndef X_STRING_H_ #define X_STRING_H_ #include <string.h> #endif /*** *wchar_t *wcstok(string, control) - tokenize string with delimiter in control * (wide-characters) * *Purpose: * wcstok considers the string to consist of a sequence of zero or more * text tokens separated by spans of one or more control chars. the first * call, with string specified, returns a pointer to the first wchar_t of * the first token, and will write a null wchar_t into string immediately * following the returned token. subsequent calls with zero for the first * argument (string) will work thru the string until no tokens remain. the * control string may be different from call to call. when no tokens remain * in string a NULL pointer is returned. remember the control chars with a * bit map, one bit per wchar_t. the null wchar_t is always a control char * (wide-characters). * *Entry: * wchar_t *string - wchar_t string to tokenize, or NULL to get next token * wchar_t *control - wchar_t string of characters to use as delimiters * *Exit: * returns pointer to first token in string, or if string * was NULL, to next token * returns NULL when no more tokens remain. * *Uses: * *Exceptions: * *******************************************************************************/ wchar_t * string, const wchar_t * control ) { wchar_t *token; const wchar_t *ctl; THREADSTATE *pts = GetThreadState(); /* If string==NULL, continue with previous string */ if (!string) string = pts->wtoken; /* Find beginning of token (skip over leading delimiters). Note that * there is no token iff this loop sets string to point to the terminal * null (*string == '\0') */ while (*string) { for (ctl=control; *ctl && *ctl != *string; ctl++) ; if (!*ctl) break; string++; } token = string; /* Find the end of the token. If it is not the end of the string, * put a null there. */ for ( ; *string ; string++ ) { for (ctl=control; *ctl && *ctl != *string; ctl++) ; if (*ctl) { *string++ = '\0'; break; } } /* Update nextoken (or the corresponding field in the per-thread data * structure */ pts->wtoken = string; /* Determine if a token has been found. */ if ( token == string ) return NULL; else return token; }
Código
/*** *wcstol.c - Contains C runtimes wcstol and wcstoul * * Copyright (c) 1989-1993, Microsoft Corporation. All rights reserved. * *Purpose: * wcstol - convert wchar_t string to long signed integer * wcstoul - convert wchar_t string to long unsigned integer * *******************************************************************************/ #include "headers.hxx" #ifndef X_STDLIB_H_ #define X_STDLIB_H_ #include <stdlib.h> #endif #ifndef X_LIMITS_H_ #define X_LIMITS_H_ #include <limits.h> #endif #ifndef X_CTYPE_H_ #define X_CTYPE_H_ #include <ctype.h> #endif /*** *wcstol, wcstoul(nptr,endptr,ibase) - Convert ascii string to long un/signed * int. * *Purpose: * Convert an ascii string to a long 32-bit value. The base * used for the caculations is supplied by the caller. The base * must be in the range 0, 2-36. If a base of 0 is supplied, the * ascii string must be examined to determine the base of the * number: * (a) First char = '0', second char = 'x' or 'X', * use base 16. * (b) First char = '0', use base 8 * (c) First char in range '1' - '9', use base 10. * * If the 'endptr' value is non-NULL, then wcstol/wcstoul places * a pointer to the terminating character in this value. * See ANSI standard for details * *Entry: * nptr == NEAR/FAR pointer to the start of string. * endptr == NEAR/FAR pointer to the end of the string. * ibase == integer base to use for the calculations. * * string format: [whitespace] [sign] [0] [x] [digits/letters] * *Exit: * Good return: * result * * Overflow return: * wcstol -- LONG_MAX or LONG_MIN * wcstoul -- ULONG_MAX * wcstol/wcstoul -- errno == ERANGE * * No digits or bad base return: * 0 * endptr = nptr* * *Exceptions: * None. *******************************************************************************/ /* flag values */ #define FL_UNSIGNED 1 /* wcstoul called */ #define FL_NEG 2 /* negative sign found */ #define FL_OVERFLOW 4 /* overflow occured */ #define FL_READDIGIT 8 /* we've read at least one correct digit */ #pragma warning (disable: 4305) #pragma warning (disable: 4306) static unsigned long __cdecl wcstoxl ( const wchar_t *nptr, wchar_t **endptr, int ibase, int flags ) { const wchar_t *p; wchar_t c; unsigned long number; unsigned digval; unsigned long maxval; p = nptr; /* p is our scanning pointer */ number = 0; /* start with zero */ c = *p++; /* read char */ while (_istspace(c)) c = *p++; /* skip whitespace */ if (c == '-') { flags |= FL_NEG; /* remember minus sign */ c = *p++; } else if (c == '+') c = *p++; /* skip sign */ if (ibase < 0 || ibase == 1 || ibase > 36) { /* bad base! */ if (endptr) /* store beginning of string in endptr */ *endptr = (wchar_t *)nptr; return 0L; /* return 0 */ } else if (ibase == 0) { /* determine base free-lance, based on first two chars of string */ if (c != L'0') ibase = 10; else if (*p == L'x' || *p == L'X') ibase = 16; else ibase = 8; } if (ibase == 16) { /* we might have 0x in front of number; remove if there */ if (c == L'0' && (*p == L'x' || *p == L'X')) { ++p; c = *p++; /* advance past prefix */ } } /* if our number exceeds this, we will overflow on multiply */ maxval = ULONG_MAX / ibase; for (;;) { /* exit in middle of loop */ /* convert c to value */ if (_istdigit(c)) digval = c - L'0'; else if (_istalpha(c)) digval = (TCHAR)CharUpper((LPTSTR)c) - L'A' + 10; else break; if (digval >= (unsigned)ibase) break; /* exit loop if bad digit found */ /* record the fact we have read one digit */ flags |= FL_READDIGIT; /* we now need to compute number = number * base + digval, but we need to know if overflow occured. This requires a tricky pre-check. */ if (number < maxval || (number == maxval && (unsigned long)digval <= ULONG_MAX % ibase)) { /* we won't overflow, go ahead and multiply */ number = number * ibase + digval; } else { /* we would have overflowed -- set the overflow flag */ flags |= FL_OVERFLOW; } c = *p++; /* read next digit */ } --p; /* point to place that stopped scan */ if (!(flags & FL_READDIGIT)) { /* no number there; return 0 and point to beginning of string */ if (endptr) /* store beginning of string in endptr later on */ p = nptr; number = 0L; /* return 0 */ } else if ( (flags & FL_OVERFLOW) || ( !(flags & FL_UNSIGNED) && ( ( (flags & FL_NEG) && (number > -LONG_MIN) ) || ( !(flags & FL_NEG) && (number > LONG_MAX) ) ) ) ) { /* overflow or signed overflow occurred */ //errno = ERANGE; if ( flags & FL_UNSIGNED ) number = ULONG_MAX; else if ( flags & FL_NEG ) number = (unsigned long)(-LONG_MIN); else number = LONG_MAX; } if (endptr != NULL) /* store pointer to char that stopped the scan */ *endptr = (wchar_t *)p; if (flags & FL_NEG) /* negate result if there was a neg sign */ number = (unsigned long)(-(long)number); return number; /* done. */ } #pragma warning (default: 4305) #pragma warning (default: 4306) const wchar_t *nptr, wchar_t **endptr, int ibase ) { return (long) wcstoxl(nptr, endptr, ibase, 0); } const wchar_t *nptr, wchar_t **endptr, int ibase ) { return wcstoxl(nptr, endptr, ibase, FL_UNSIGNED); }
B#