| 0,0 → 1,359 |
|---|
| /**************************************************************************** |
| * |
| * Open Watcom Project |
| * |
| * Portions Copyright (c) 1983-2002 Sybase, Inc. All Rights Reserved. |
| * |
| * ======================================================================== |
| * |
| * This file contains Original Code and/or Modifications of Original |
| * Code as defined in and that are subject to the Sybase Open Watcom |
| * Public License version 1.0 (the 'License'). You may not use this file |
| * except in compliance with the License. BY USING THIS FILE YOU AGREE TO |
| * ALL TERMS AND CONDITIONS OF THE LICENSE. A copy of the License is |
| * provided with the Original Code and Modifications, and is also |
| * available at www.sybase.com/developer/opensource. |
| * |
| * The Original Code and all software distributed under the License are |
| * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER |
| * EXPRESS OR IMPLIED, AND SYBASE AND ALL CONTRIBUTORS HEREBY DISCLAIM |
| * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR |
| * NON-INFRINGEMENT. Please see the License for the specific language |
| * governing rights and limitations under the License. |
| * |
| * ======================================================================== |
| * |
| * Description: RISC oriented string functions designed to access memory |
| * as aligned 32- or 64-bit words whenever possible. |
| * |
| ****************************************************************************/ |
| |
| |
| #ifndef _RISCSTR_H_INCLUDED |
| #define _RISCSTR_H_INCLUDED |
| |
| |
| /* |
| * Determine if we're building RISC versions of string/memory routines. |
| */ |
| |
| #if defined(__AXP__) || defined(__PPC__) |
| #define __RISCSTR__ |
| #endif |
| |
| #ifdef __RISCSTR__ /* do nothing if not RISC target */ |
| |
| |
| #include "variety.h" |
| #include "widechar.h" |
| #include <string.h> |
| #include <wchar.h> |
| #include "watcom.h" |
| |
| |
| /* |
| * Choose between 32- and 64-bit words. |
| */ |
| |
| #define USE_INT64 0 /* no 64-bit stuff for now */ |
| |
| #ifndef USE_INT64 |
| #ifdef __AXP__ |
| #define USE_INT64 1 |
| #else |
| #define USE_INT64 0 |
| #endif |
| #endif |
| |
| #if USE_INT64 |
| #define INT __int64 |
| #define UINT unsigned __int64 |
| #else |
| #define INT int |
| #define UINT uint_32 |
| #endif |
| |
| #define BYTES_PER_WORD ( sizeof( UINT ) ) |
| #define INT_SIZE ( BYTES_PER_WORD * 8 ) |
| #define CHARS_PER_WORD ( BYTES_PER_WORD / CHARSIZE ) |
| |
| #define MOD_BYTES_PER_WORD(__n) ( (__n) & (BYTES_PER_WORD-1) ) |
| |
| |
| |
| /* |
| * Macros to mask off a single character. |
| */ |
| |
| #if USE_INT64 |
| #define BYTE1 ( _riscdata->byteMasks[0].val ) |
| #define BYTE2 ( _riscdata->byteMasks[1].val ) |
| #define BYTE3 ( _riscdata->byteMasks[2].val ) |
| #define BYTE4 ( _riscdata->byteMasks[3].val ) |
| #define BYTE5 ( _riscdata->byteMasks[4].val ) |
| #define BYTE6 ( _riscdata->byteMasks[5].val ) |
| #define BYTE7 ( _riscdata->byteMasks[6].val ) |
| #define BYTE8 ( _riscdata->byteMasks[7].val ) |
| #else |
| #define BYTE1 ( 0x000000FF ) |
| #define BYTE2 ( 0x0000FF00 ) |
| #define BYTE3 ( 0x00FF0000 ) |
| #define BYTE4 ( 0xFF000000 ) |
| #endif |
| |
| #ifdef __WIDECHAR__ |
| #define CHR1MASK ( BYTE1 | BYTE2 ) |
| #define CHR2MASK ( BYTE3 | BYTE4 ) |
| #else |
| #define CHR1MASK ( BYTE1 ) |
| #define CHR2MASK ( BYTE2 ) |
| #define CHR3MASK ( BYTE3 ) |
| #define CHR4MASK ( BYTE4 ) |
| #endif |
| |
| |
| #ifdef __WIDECHAR__ |
| #define CHR1(__w) ( (__w) & CHR1MASK ) |
| #define CHR2(__w) ( (__w) & CHR2MASK ) |
| #else |
| #define CHR1(__w) ( (__w) & BYTE1 ) |
| #define CHR2(__w) ( (__w) & BYTE2 ) |
| #define CHR3(__w) ( (__w) & BYTE3 ) |
| #define CHR4(__w) ( (__w) & BYTE4 ) |
| #if USE_INT64 |
| #define CHR5(__w) ( (__w) & BYTE5 ) |
| #define CHR6(__w) ( (__w) & BYTE6 ) |
| #define CHR7(__w) ( (__w) & BYTE7 ) |
| #define CHR8(__w) ( (__w) & BYTE8 ) |
| #endif |
| #endif |
| |
| |
| |
| /* |
| * Macros for extracting the first characters in a word. |
| */ |
| |
| #if USE_INT64 |
| #define FRONT_BYTES(__n) ( _riscdata->frontCharsMasks[(__n)].val ) |
| #define FRONT_CHRS(__w,__o) ( (__w) & FRONT_BYTES_riscdata[(__o)].val ) |
| #else |
| // extern UINT __FRONT_BYTES[]; |
| // #define FRONT_BYTES __FRONT_BYTES |
| #define FRONT_BYTES ( _riscdata->frontCharsMasks ) |
| #define FRONT_CHRS(__w,__o) ( (__w) & FRONT_BYTES[(__o)] ) |
| #endif |
| |
| |
| |
| /* |
| * Macros for ignoring the first characters in a word. |
| */ |
| |
| #if USE_INT64 |
| #define SKIP_CHRS_MASKS(__n) ( _riscdata->skipCharsMasks[(__n)].val ) |
| #define SKIP_CHRS(__w,__o) ( (__w) & SKIP_CHRS_MASKS(__o) ) |
| #else |
| // extern UINT __SKIP_CHRS_MASKS[]; |
| // #define SKIP_CHRS_MASKS __SKIP_CHRS_MASKS |
| #define SKIP_CHRS_MASKS(__n) ( _riscdata->skipCharsMasks[(__n)] ) |
| #define SKIP_CHRS(__w,__o) ( (__w) & SKIP_CHRS_MASKS(__o) ) |
| #endif |
| |
| |
| |
| /* |
| * Macros for checking if a word contains a null byte. |
| */ |
| |
| #if USE_INT64 |
| #define SUB_M ( _riscdata->_01Mask.val ) |
| #define NIL_M ( _riscdata->_80Mask.val ) |
| #define SUB_MASK(__n) ( _riscdata->subMasks[(__n)].val ) |
| #else |
| #ifdef __WIDECHAR__ |
| #define SUB_M ( 0x00010001 ) |
| #define NIL_M ( 0x80008000 ) |
| #else |
| #define SUB_M ( 0x01010101 ) |
| #define NIL_M ( 0x80808080 ) |
| #endif |
| // extern UINT __SubMask[]; |
| // #define SUB_MASK __SubMask |
| #define SUB_MASK(__n) ( _riscdata->subMasks[(__n)] ) |
| #endif |
| |
| #define GOT_NIL(__w) ( ( (~(__w)) & ((__w) - SUB_M) ) & NIL_M ) |
| |
| #ifdef __WIDECHAR__ |
| #define OFFSET_GOT_NIL(__w,__o) ( ( (~(__w)) & ((__w) - SUB_MASK((__o)/CHARSIZE)) ) & NIL_M ) |
| #else |
| #define OFFSET_GOT_NIL(__w,__o) ( ( (~(__w)) & ((__w) - SUB_MASK(__o)) ) & NIL_M ) |
| #endif |
| |
| |
| |
| /* |
| * Some handy pointer manipulation macros. |
| */ |
| |
| #define ROUND(__p) ( (UINT*) ( (UINT)(__p) & (-sizeof(UINT)) ) ) |
| |
| #define OFFSET(__p) ( ((unsigned int)(__p)) & (sizeof(UINT)-1) ) |
| |
| |
| |
| /* |
| * Macros for uppercase and lowercase stuff. |
| */ |
| |
| #ifdef __WIDECHAR__ |
| #define CHR1_A ( 0x00000041 ) |
| #define CHR2_A ( 0x00410000 ) |
| |
| #define CHR1_Z ( 0x0000005A ) |
| #define CHR2_Z ( 0x005A0000 ) |
| |
| #define CHR1_A2a(s) ( s | 0x00000020 ) |
| #define CHR2_A2a(s) ( s | 0x00200000 ) |
| #else |
| #define CHR1_A ( 0x00000041 ) |
| #define CHR2_A ( 0x00004100 ) |
| #define CHR3_A ( 0x00410000 ) |
| #define CHR4_A ( 0x41000000 ) |
| |
| #define CHR1_Z ( 0x0000005A ) |
| #define CHR2_Z ( 0x00005A00 ) |
| #define CHR3_Z ( 0x005A0000 ) |
| #define CHR4_Z ( 0x5A000000 ) |
| |
| #define CHR1_A2a(s) ( s | 0x00000020 ) |
| #define CHR2_A2a(s) ( s | 0x00002000 ) |
| #define CHR3_A2a(s) ( s | 0x00200000 ) |
| #define CHR4_A2a(s) ( s | 0x20000000 ) |
| #endif |
| |
| #ifdef __WIDECHAR__ |
| #define TO_LOW_CHR1(s) ( ( (s>=CHR1_A) && (s<=CHR1_Z) ) ? CHR1_A2a(s) : s ) |
| #define TO_LOW_CHR2(s) ( ( (s>=CHR2_A) && (s<=CHR2_Z) ) ? CHR2_A2a(s) : s ) |
| #else |
| #define TO_LOW_CHR1(s) ( ( (s>=CHR1_A) && (s<=CHR1_Z) ) ? CHR1_A2a(s) : s ) |
| #define TO_LOW_CHR2(s) ( ( (s>=CHR2_A) && (s<=CHR2_Z) ) ? CHR2_A2a(s) : s ) |
| #define TO_LOW_CHR3(s) ( ( (s>=CHR3_A) && (s<=CHR3_Z) ) ? CHR3_A2a(s) : s ) |
| #define TO_LOW_CHR4(s) ( ( (s>=CHR4_A) && (s<=CHR4_Z) ) ? CHR4_A2a(s) : s ) |
| #endif |
| |
| |
| #ifdef __WIDECHAR__ |
| #define CHR1_a ( 0x00000061 ) |
| #define CHR2_a ( 0x00610000 ) |
| |
| #define CHR1_z ( 0x0000007A ) |
| #define CHR2_z ( 0x007A0000 ) |
| |
| #define CHR1_a2A(s) ( s & 0x000000DF ) |
| #define CHR2_a2A(s) ( s & 0x00DF0000 ) |
| #else |
| #define CHR1_a ( 0x00000061 ) |
| #define CHR2_a ( 0x00006100 ) |
| #define CHR3_a ( 0x00610000 ) |
| #define CHR4_a ( 0x61000000 ) |
| |
| #define CHR1_z ( 0x0000007A ) |
| #define CHR2_z ( 0x00007A00 ) |
| #define CHR3_z ( 0x007A0000 ) |
| #define CHR4_z ( 0x7A000000 ) |
| |
| #define CHR1_a2A(s) ( s & 0x000000DF ) |
| #define CHR2_a2A(s) ( s & 0x0000DF00 ) |
| #define CHR3_a2A(s) ( s & 0x00DF0000 ) |
| #define CHR4_a2A(s) ( s & 0xDF000000 ) |
| #endif |
| |
| #ifdef __WIDECHAR__ |
| #define TO_UPR_CHR1(s) ( ( (s>=CHR1_a) && (s<=CHR1_z) ) ? CHR1_a2A(s) : s ) |
| #define TO_UPR_CHR2(s) ( ( (s>=CHR2_a) && (s<=CHR2_z) ) ? CHR2_a2A(s) : s ) |
| #else |
| #define TO_UPR_CHR1(s) ( ( (s>=CHR1_a) && (s<=CHR1_z) ) ? CHR1_a2A(s) : s ) |
| #define TO_UPR_CHR2(s) ( ( (s>=CHR2_a) && (s<=CHR2_z) ) ? CHR2_a2A(s) : s ) |
| #define TO_UPR_CHR3(s) ( ( (s>=CHR3_a) && (s<=CHR3_z) ) ? CHR3_a2A(s) : s ) |
| #define TO_UPR_CHR4(s) ( ( (s>=CHR4_a) && (s<=CHR4_z) ) ? CHR4_a2A(s) : s ) |
| #endif |
| |
| |
| |
| /* |
| * Tweak characters within a word. |
| */ |
| |
| #ifdef __WIDECHAR__ |
| #define REVERSE_CHARS(__w) ( (CHR1(__w)<<16) | (CHR2(__w)>>16) ) |
| #else |
| #define REVERSE_CHARS(__w) ( (CHR1(__w)<<24) | (CHR2(__w)<<8) | \ |
| (CHR3(__w)>>8) | (CHR4(__w)>>24) ) |
| #endif |
| |
| #define SWAP_BYTES(__w) ( (((__w)&BYTE1)<<8) | (((__w)&BYTE2)>>8) | \ |
| (((__w)&BYTE3)<<8) | (((__w)&BYTE4)>>8) ) |
| |
| |
| |
| /* |
| * Data used by the RISC string functions. |
| */ |
| |
| struct __F_NAME(__RISC_StrData,__wRISC_StrData) { |
| #if USE_INT64 |
| unsigned_64 byteMasks[8]; |
| unsigned_64 frontCharsMasks[8]; |
| unsigned_64 skipCharsMasks[8]; |
| unsigned_64 _01Mask; |
| unsigned_64 _80Mask; |
| unsigned_64 subMasks[8]; |
| #else |
| #ifdef __WIDECHAR__ |
| uint_32 frontCharsMasks[2]; |
| uint_32 skipCharsMasks[2]; |
| uint_32 subMasks[2]; |
| #else |
| uint_32 frontCharsMasks[4]; |
| uint_32 skipCharsMasks[4]; |
| uint_32 subMasks[4]; |
| #endif |
| #endif |
| }; |
| |
| |
| #ifdef __WIDECHAR__ |
| extern struct __wRISC_StrData __wRISC_StringData; |
| #define RISC_DATA_LOCALREF struct __wRISC_StrData *_riscdata = &__wRISC_StringData |
| #else |
| extern struct __RISC_StrData __RISC_StringData; |
| #define RISC_DATA_LOCALREF struct __RISC_StrData *_riscdata = &__RISC_StringData |
| #endif |
| |
| |
| |
| /* |
| * Prototype functions called by the RISC-oriented string functions. |
| */ |
| |
| _WCRTLINK extern wchar_t * __simple_wcschr( const wchar_t *str, wint_t ch ); |
| _WCRTLINK extern int __simple_wcscmp( const wchar_t *s1, const wchar_t *s2 ); |
| _WCRTLINK extern wchar_t * __simple_wcscpy( wchar_t *dest, const wchar_t *src ); |
| _WCRTLINK extern int __simple__wcsicmp( const wchar_t *s1, const wchar_t *s2 ); |
| _WCRTLINK extern size_t __simple_wcslen( const wchar_t *str ); |
| _WCRTLINK extern wchar_t * __simple__wcslwr( wchar_t *str ); |
| _WCRTLINK extern int __simple_wcsncmp( const wchar_t *s1, const wchar_t *s2, size_t n ); |
| _WCRTLINK extern wchar_t * __simple_wcsncpy( wchar_t *dest, const wchar_t *src, size_t n ); |
| _WCRTLINK extern int __simple__wcsnicmp( const wchar_t *s1, const wchar_t *s2, size_t n ); |
| _WCRTLINK extern wchar_t * __simple__wcsnset( wchar_t *str, int ch, size_t n ); |
| _WCRTLINK extern wchar_t * __simple_wcsrchr( const wchar_t *str, wint_t ch ); |
| _WCRTLINK extern wchar_t * __simple__wcsset( wchar_t *str, wchar_t ch ); |
| _WCRTLINK extern wchar_t * __simple__wcsupr( wchar_t *str ); |
| |
| |
| #endif /* #ifdef __RISCSTR__ */ |
| |
| #endif |