rxvt-unicode/src/strings.C

/*--------------------------------*-C-*---------------------------------*
 * File:        strings.c
 *----------------------------------------------------------------------*
 * $Id: strings.C,v 1.2 2003/11/24 17:31:28 pcg Exp $
 *
 * All portions of code are copyright by their respective author/s.
 * Copyright (c) 1997-2001 Geoff Wing <gcw@pobox.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *----------------------------------------------------------------------*/

#include "../config.h"          /* NECESSARY */
#include "rxvt.h"               /* NECESSARY */
#include "strings.intpro"       /* PROTOS for internal routines */

#ifndef NO_STRINGS
/*----------------------------------------------------------------------*/
/*
 * a replacement for strcasecmp() to avoid linking an entire library.
 * Mark Olesen added this in 2.15 but for which OS & library? - Geoff Wing
 */
int
strcasecmp(const char *s1, const char *s2)
{
    for ( ; tolower(*s1) == tolower(*s2); s1++, s2++)
        if (!*s1)
            return 0;
    return (int)(tolower(*s1) - tolower(*s2));
}

int
strncasecmp(const char *s1, const char *s2, size_t n)
{
    for ( ; n-- && (tolower(*s1) == tolower(*s2)); s1++, s2++)
        if (!*s1)
            return 0;
    if (n == 0)
        return 0;
    return (int)(tolower(*s1) - tolower(*s2));
}

char           *
strcpy(char *d, const char *s)
{
    char          *r = d;

    for ( ; (*r++ = *s++) != '\0'; ) ;
    return d;
}

char           *
strncpy(char *d, const char *s, size_t len)
{
    char          *r = d;

    if (len)
        for ( ; len; len--)
            if ((*r++ = *s++) == '\0') {
                for ( ; --len; )
                    *r++ = '\0';
                break;
            }
    return d;
}

int
strcmp(const char *s1, const char *s2)
{
    for ( ; (*s1 == *s2++); )
        if (*s1++ == '\0')
            return 0;
    return (int) ((unsigned char) *s1 - (unsigned char) *--s2);
}

int
strncmp(const char *s1, const char *s2, size_t len)
{
    if (len) {
        for ( ; len-- && (*s1++ == *s2++); ) ;
        if (++len)
            return (int) ((unsigned char) *--s1 - (unsigned char) *--s2);
    }
    return 0;
}

char           *
strcat(char *s1, const char *s2)
{
    char           *r = s1;

    if (*r != '\0')
        for ( ; *++r != '\0'; ) ;
    for ( ; (*r++ = *s2++) != '\0'; ) ;

    return s1;
}

char           *
strncat(char *s1, const char *s2, size_t len)
{
    char           *r = s1;

    if (*r != '\0')
        for ( ; *++r != '\0'; ) ;
    for ( ; len-- && ((*r++ = *s2++) != '\0'); ) ;
    *r = '\0';

    return s1;
}

size_t
strlen(const char *s)
{
    size_t         len = 0;

    for ( ; *s++ != '\0'; len++) ;
    return len;
}

char           *
strdup(const char *s)
{
    size_t         len = STRLEN(s) + 1;
    char          *c;

    if ((c = malloc(len)) != NULL)
        MEMCPY(c, s, len);
    return c;
}

char           *
index(const char *s, int c)
{
    return STRCHR(s, c);
}

char           *
strchr(const char *s, int c)
{
    char          *p = NULL;

    for (;;) {
        if (*s == (char)c) {
            p = (char *)s;
            break;
        }
        if (*s++ == '\0')
            break;
    }
    return p;

}

char           *
rindex(const char *s, int c)
{
    return STRRCHR(s, c);
}

char           *
strrchr(const char *s, int c)
{
    char          *p = NULL;

    for (;;) {
        if (*s == (char)c)
            p = (char *)s;
        if (*s++ == '\0')
            break;
    }
    return p;
}

void           *
memcpy(void *s1, const void *s2, size_t len)
{
    /* has extra stack and time but less code space */
    return MEMMOVE(s1, s2, len);
}

/*--------------------------------------------------------------------------*
 * Possibly faster memmove() by Geoff Wing <mason@primenet.com.au>
 *--------------------------------------------------------------------------*/
void           *
memmove(void *d, const void *s, size_t len)
{
    u_intp_t        i;
    unsigned char  *dst = (unsigned char *)d;
    const unsigned char *src = (const unsigned char *)s;

    if (len && d != s) {
        if ((u_intp_t)d < (u_intp_t)s) {
        /* forwards */
            i = (-(u_intp_t)dst) & (SIZEOF_INT_P - 1);
            if (len >= 16 && i == ((-(u_intp_t)src) & (SIZEOF_INT_P - 1))) {
            /* speed up since src & dst are offset correctly */
                len -= (size_t)i;
                for ( ; i--; )
                    *dst++ = *src++;
                for (i = (u_intp_t)(len / SIZEOF_INT_P); i--; )
                    *((u_intp_t *)dst)++ = *((const u_intp_t *)src)++;
                len &= (SIZEOF_INT_P - 1);
            }
            for ( ; len--; )
                *dst++ = *src++;
        } else {
        /* backwards */
            dst += len;
            src += len;
            i = ((u_intp_t)dst) & (SIZEOF_INT_P - 1);
            if (len >= 16 && i == (((u_intp_t)src) & (SIZEOF_INT_P - 1))) {
            /* speed up since src & dst are offset correctly */
                len -= (size_t)i;
                for ( ; i--; )
                    *--dst = *--src;
                for (i = (u_intp_t)(len / SIZEOF_INT_P); i--; )
                    *--((u_intp_t *)dst) = *--((const u_intp_t *)src);
                len &= (SIZEOF_INT_P - 1);
            }
            for ( ; len--; )
                *--dst = *--src;
        }
    }
    return d;
}

/*--------------------------------------------------------------------------*
 * Possibly faster memset() by Geoff Wing <mason@primenet.com.au>
 * presumptions:
 *   1) intp_t write the best
 *   2) SIZEOF_INT_P == power of 2
 *--------------------------------------------------------------------------*/

void
bzero(void *b, size_t len)
{
    MEMSET(b, 0, len);
}

void           *
memset(void *p, int c1, size_t len)
{
    u_intp_t        i, val;
    unsigned char   c = (unsigned char) c1;
    unsigned char  *lp = (unsigned char *) p;

    if (len) {
        if (len >= 16) { /* < 16 probably not worth all the calculations */
/* write out preceding characters so we align on an integer boundary */
            if ((i = ((-(u_intp_t)p) & (SIZEOF_INT_P - 1)))) {
                len -= (size_t)i;
                for (; i--;)
                    *lp++ = c;
            }

/* do the fast writing */
            val = (c << 8) + c;
#if SIZEOF_INT_P >= 4
            val |= (val << 16);
#endif
#if SIZEOF_INT_P >= 8
            val |= (val << 32);
#endif
#if SIZEOF_INT_P == 16
            val |= (val << 64);
#endif
            for (i = (u_intp_t)(len / SIZEOF_INT_P); i--;)
                *((u_intp_t *)lp)++ = val;
            len &= (SIZEOF_INT_P - 1);
        }
/* write trailing characters */
        for (; len--;)
            *lp++ = c;
    }
    return p;
}
#endif
/*----------------------- end-of-file (C source) -----------------------*/
Revision:	1.3
Committed:	Sat Jan 31 00:20:21 2004 UTC (20 years, 3 months ago) by pcg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	before_astyle
Changes since 1.2:	+1 -19 lines
Log Message:	* empty log message *
#	Content
1	/---------------------------------C----------------------------------
2	* File: strings.c
3	----------------------------------------------------------------------
4	* $Id: strings.C,v 1.2 2003/11/24 17:31:28 pcg Exp $
5	*
6	* All portions of code are copyright by their respective author/s.
7	* Copyright (c) 1997-2001 Geoff Wing <gcw@pobox.com>
8	*
9	* This program is free software; you can redistribute it and/or modify
10	* it under the terms of the GNU General Public License as published by
11	* the Free Software Foundation; either version 2 of the License, or
12	* (at your option) any later version.
13	*
14	* This program is distributed in the hope that it will be useful,
15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17	* GNU General Public License for more details.
18	*
19	* You should have received a copy of the GNU General Public License
20	* along with this program; if not, write to the Free Software
21	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22	----------------------------------------------------------------------/
23
24	#include "../config.h" /* NECESSARY */
25	#include "rxvt.h" /* NECESSARY */
26	#include "strings.intpro" /* PROTOS for internal routines */
27
28	#ifndef NO_STRINGS
29	/----------------------------------------------------------------------/
30	/*
31	* a replacement for strcasecmp() to avoid linking an entire library.
32	* Mark Olesen added this in 2.15 but for which OS & library? - Geoff Wing
33	*/
34	int
35	strcasecmp(const char s1, const char s2)
36	{
37	for ( ; tolower(s1) == tolower(s2); s1++, s2++)
38	if (!*s1)
39	return 0;
40	return (int)(tolower(s1) - tolower(s2));
41	}
42
43	int
44	strncasecmp(const char s1, const char s2, size_t n)
45	{
46	for ( ; n-- && (tolower(s1) == tolower(s2)); s1++, s2++)
47	if (!*s1)
48	return 0;
49	if (n == 0)
50	return 0;
51	return (int)(tolower(s1) - tolower(s2));
52	}
53
54	char *
55	strcpy(char d, const char s)
56	{
57	char *r = d;
58
59	for ( ; (r++ = s++) != '\0'; ) ;
60	return d;
61	}
62
63	char *
64	strncpy(char d, const char s, size_t len)
65	{
66	char *r = d;
67
68	if (len)
69	for ( ; len; len--)
70	if ((r++ = s++) == '\0') {
71	for ( ; --len; )
72	*r++ = '\0';
73	break;
74	}
75	return d;
76	}
77
78	int
79	strcmp(const char s1, const char s2)
80	{
81	for ( ; (s1 == s2++); )
82	if (*s1++ == '\0')
83	return 0;
84	return (int) ((unsigned char) s1 - (unsigned char) --s2);
85	}
86
87	int
88	strncmp(const char s1, const char s2, size_t len)
89	{
90	if (len) {
91	for ( ; len-- && (s1++ == s2++); ) ;
92	if (++len)
93	return (int) ((unsigned char) --s1 - (unsigned char) --s2);
94	}
95	return 0;
96	}
97
98	char *
99	strcat(char s1, const char s2)
100	{
101	char *r = s1;
102
103	if (*r != '\0')
104	for ( ; *++r != '\0'; ) ;
105	for ( ; (r++ = s2++) != '\0'; ) ;
106
107	return s1;
108	}
109
110	char *
111	strncat(char s1, const char s2, size_t len)
112	{
113	char *r = s1;
114
115	if (*r != '\0')
116	for ( ; *++r != '\0'; ) ;
117	for ( ; len-- && ((r++ = s2++) != '\0'); ) ;
118	*r = '\0';
119
120	return s1;
121	}
122
123	size_t
124	strlen(const char *s)
125	{
126	size_t len = 0;
127
128	for ( ; *s++ != '\0'; len++) ;
129	return len;
130	}
131
132	char *
133	strdup(const char *s)
134	{
135	size_t len = STRLEN(s) + 1;
136	char *c;
137
138	if ((c = malloc(len)) != NULL)
139	MEMCPY(c, s, len);
140	return c;
141	}
142
143	char *
144	index(const char *s, int c)
145	{
146	return STRCHR(s, c);
147	}
148
149	char *
150	strchr(const char *s, int c)
151	{
152	char *p = NULL;
153
154	for (;;) {
155	if (*s == (char)c) {
156	p = (char *)s;
157	break;
158	}
159	if (*s++ == '\0')
160	break;
161	}
162	return p;
163
164	}
165
166	char *
167	rindex(const char *s, int c)
168	{
169	return STRRCHR(s, c);
170	}
171
172	char *
173	strrchr(const char *s, int c)
174	{
175	char *p = NULL;
176
177	for (;;) {
178	if (*s == (char)c)
179	p = (char *)s;
180	if (*s++ == '\0')
181	break;
182	}
183	return p;
184	}
185
186	void *
187	memcpy(void s1, const void s2, size_t len)
188	{
189	/* has extra stack and time but less code space */
190	return MEMMOVE(s1, s2, len);
191	}
192
193	/--------------------------------------------------------------------------
194	* Possibly faster memmove() by Geoff Wing <mason@primenet.com.au>
195	--------------------------------------------------------------------------/
196	void *
197	memmove(void d, const void s, size_t len)
198	{
199	u_intp_t i;
200	unsigned char dst = (unsigned char )d;
201	const unsigned char src = (const unsigned char )s;
202
203	if (len && d != s) {
204	if ((u_intp_t)d < (u_intp_t)s) {
205	/* forwards */
206	i = (-(u_intp_t)dst) & (SIZEOF_INT_P - 1);
207	if (len >= 16 && i == ((-(u_intp_t)src) & (SIZEOF_INT_P - 1))) {
208	/* speed up since src & dst are offset correctly */
209	len -= (size_t)i;
210	for ( ; i--; )
211	dst++ = src++;
212	for (i = (u_intp_t)(len / SIZEOF_INT_P); i--; )
213	((u_intp_t )dst)++ = ((const u_intp_t )src)++;
214	len &= (SIZEOF_INT_P - 1);
215	}
216	for ( ; len--; )
217	dst++ = src++;
218	} else {
219	/* backwards */
220	dst += len;
221	src += len;
222	i = ((u_intp_t)dst) & (SIZEOF_INT_P - 1);
223	if (len >= 16 && i == (((u_intp_t)src) & (SIZEOF_INT_P - 1))) {
224	/* speed up since src & dst are offset correctly */
225	len -= (size_t)i;
226	for ( ; i--; )
227	--dst = --src;
228	for (i = (u_intp_t)(len / SIZEOF_INT_P); i--; )
229	--((u_intp_t )dst) = --((const u_intp_t )src);
230	len &= (SIZEOF_INT_P - 1);
231	}
232	for ( ; len--; )
233	--dst = --src;
234	}
235	}
236	return d;
237	}
238
239	/--------------------------------------------------------------------------
240	* Possibly faster memset() by Geoff Wing <mason@primenet.com.au>
241	* presumptions:
242	* 1) intp_t write the best
243	* 2) SIZEOF_INT_P == power of 2
244	--------------------------------------------------------------------------/
245
246	void
247	bzero(void *b, size_t len)
248	{
249	MEMSET(b, 0, len);
250	}
251
252	void *
253	memset(void *p, int c1, size_t len)
254	{
255	u_intp_t i, val;
256	unsigned char c = (unsigned char) c1;
257	unsigned char lp = (unsigned char ) p;
258
259	if (len) {
260	if (len >= 16) { /* < 16 probably not worth all the calculations */
261	/* write out preceding characters so we align on an integer boundary */
262	if ((i = ((-(u_intp_t)p) & (SIZEOF_INT_P - 1)))) {
263	len -= (size_t)i;
264	for (; i--;)
265	*lp++ = c;
266	}
267
268	/* do the fast writing */
269	val = (c << 8) + c;
270	#if SIZEOF_INT_P >= 4
271	val \|= (val << 16);
272	#endif
273	#if SIZEOF_INT_P >= 8
274	val \|= (val << 32);
275	#endif
276	#if SIZEOF_INT_P == 16
277	val \|= (val << 64);
278	#endif
279	for (i = (u_intp_t)(len / SIZEOF_INT_P); i--;)
280	((u_intp_t )lp)++ = val;
281	len &= (SIZEOF_INT_P - 1);
282	}
283	/* write trailing characters */
284	for (; len--;)
285	*lp++ = c;
286	}
287	return p;
288	}
289	#endif
290	/----------------------- end-of-file (C source) -----------------------/