rxvt-unicode/src/strings.C

/*--------------------------------*-C-*---------------------------------*
 * File:        strings.c
 *----------------------------------------------------------------------*
 * $Id: strings.C,v 1.1 2003/11/18 14:22:18 root 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
 */
/* EXTPROTO */
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));
}

/* EXTPROTO */
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));
}

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

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

/* EXTPROTO */
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;
}

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

/* EXTPROTO */
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;
}

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

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

    return s1;
}

/* EXTPROTO */
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;
}

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

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

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

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

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

/* EXTPROTO */
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;

}

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

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

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

/* EXTPROTO */
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>
 *--------------------------------------------------------------------------*/
/* EXTPROTO */
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
 *--------------------------------------------------------------------------*/

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

/* EXTPROTO */
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.1
Committed:	Mon Nov 24 17:28:08 2003 UTC (20 years, 6 months ago) by pcg
Content type:	text/plain
Branch:	MAIN
Log Message:	* empty log message *
#	Content
1	/---------------------------------C----------------------------------
2	* File: strings.c
3	----------------------------------------------------------------------
4	* $Id: strings.C,v 1.1 2003/11/18 14:22:18 root 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	/* EXTPROTO */
35	int
36	strcasecmp(const char s1, const char s2)
37	{
38	for ( ; tolower(s1) == tolower(s2); s1++, s2++)
39	if (!*s1)
40	return 0;
41	return (int)(tolower(s1) - tolower(s2));
42	}
43
44	/* EXTPROTO */
45	int
46	strncasecmp(const char s1, const char s2, size_t n)
47	{
48	for ( ; n-- && (tolower(s1) == tolower(s2)); s1++, s2++)
49	if (!*s1)
50	return 0;
51	if (n == 0)
52	return 0;
53	return (int)(tolower(s1) - tolower(s2));
54	}
55
56	/* EXTPROTO */
57	char *
58	strcpy(char d, const char s)
59	{
60	char *r = d;
61
62	for ( ; (r++ = s++) != '\0'; ) ;
63	return d;
64	}
65
66	/* EXTPROTO */
67	char *
68	strncpy(char d, const char s, size_t len)
69	{
70	char *r = d;
71
72	if (len)
73	for ( ; len; len--)
74	if ((r++ = s++) == '\0') {
75	for ( ; --len; )
76	*r++ = '\0';
77	break;
78	}
79	return d;
80	}
81
82	/* EXTPROTO */
83	int
84	strcmp(const char s1, const char s2)
85	{
86	for ( ; (s1 == s2++); )
87	if (*s1++ == '\0')
88	return 0;
89	return (int) ((unsigned char) s1 - (unsigned char) --s2);
90	}
91
92	/* EXTPROTO */
93	int
94	strncmp(const char s1, const char s2, size_t len)
95	{
96	if (len) {
97	for ( ; len-- && (s1++ == s2++); ) ;
98	if (++len)
99	return (int) ((unsigned char) --s1 - (unsigned char) --s2);
100	}
101	return 0;
102	}
103
104	/* EXTPROTO */
105	char *
106	strcat(char s1, const char s2)
107	{
108	char *r = s1;
109
110	if (*r != '\0')
111	for ( ; *++r != '\0'; ) ;
112	for ( ; (r++ = s2++) != '\0'; ) ;
113
114	return s1;
115	}
116
117	/* EXTPROTO */
118	char *
119	strncat(char s1, const char s2, size_t len)
120	{
121	char *r = s1;
122
123	if (*r != '\0')
124	for ( ; *++r != '\0'; ) ;
125	for ( ; len-- && ((r++ = s2++) != '\0'); ) ;
126	*r = '\0';
127
128	return s1;
129	}
130
131	/* EXTPROTO */
132	size_t
133	strlen(const char *s)
134	{
135	size_t len = 0;
136
137	for ( ; *s++ != '\0'; len++) ;
138	return len;
139	}
140
141	/* EXTPROTO */
142	char *
143	strdup(const char *s)
144	{
145	size_t len = STRLEN(s) + 1;
146	char *c;
147
148	if ((c = malloc(len)) != NULL)
149	MEMCPY(c, s, len);
150	return c;
151	}
152
153	/* EXTPROTO */
154	char *
155	index(const char *s, int c)
156	{
157	return STRCHR(s, c);
158	}
159
160	/* EXTPROTO */
161	char *
162	strchr(const char *s, int c)
163	{
164	char *p = NULL;
165
166	for (;;) {
167	if (*s == (char)c) {
168	p = (char *)s;
169	break;
170	}
171	if (*s++ == '\0')
172	break;
173	}
174	return p;
175
176	}
177
178	/* EXTPROTO */
179	char *
180	rindex(const char *s, int c)
181	{
182	return STRRCHR(s, c);
183	}
184
185	/* EXTPROTO */
186	char *
187	strrchr(const char *s, int c)
188	{
189	char *p = NULL;
190
191	for (;;) {
192	if (*s == (char)c)
193	p = (char *)s;
194	if (*s++ == '\0')
195	break;
196	}
197	return p;
198	}
199
200	/* EXTPROTO */
201	void *
202	memcpy(void s1, const void s2, size_t len)
203	{
204	/* has extra stack and time but less code space */
205	return MEMMOVE(s1, s2, len);
206	}
207
208	/--------------------------------------------------------------------------
209	* Possibly faster memmove() by Geoff Wing <mason@primenet.com.au>
210	--------------------------------------------------------------------------/
211	/* EXTPROTO */
212	void *
213	memmove(void d, const void s, size_t len)
214	{
215	u_intp_t i;
216	unsigned char dst = (unsigned char )d;
217	const unsigned char src = (const unsigned char )s;
218
219	if (len && d != s) {
220	if ((u_intp_t)d < (u_intp_t)s) {
221	/* forwards */
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	} else {
235	/* backwards */
236	dst += len;
237	src += len;
238	i = ((u_intp_t)dst) & (SIZEOF_INT_P - 1);
239	if (len >= 16 && i == (((u_intp_t)src) & (SIZEOF_INT_P - 1))) {
240	/* speed up since src & dst are offset correctly */
241	len -= (size_t)i;
242	for ( ; i--; )
243	--dst = --src;
244	for (i = (u_intp_t)(len / SIZEOF_INT_P); i--; )
245	--((u_intp_t )dst) = --((const u_intp_t )src);
246	len &= (SIZEOF_INT_P - 1);
247	}
248	for ( ; len--; )
249	--dst = --src;
250	}
251	}
252	return d;
253	}
254
255	/--------------------------------------------------------------------------
256	* Possibly faster memset() by Geoff Wing <mason@primenet.com.au>
257	* presumptions:
258	* 1) intp_t write the best
259	* 2) SIZEOF_INT_P == power of 2
260	--------------------------------------------------------------------------/
261
262	/* EXTPROTO */
263	void
264	bzero(void *b, size_t len)
265	{
266	MEMSET(b, 0, len);
267	}
268
269	/* EXTPROTO */
270	void *
271	memset(void *p, int c1, size_t len)
272	{
273	u_intp_t i, val;
274	unsigned char c = (unsigned char) c1;
275	unsigned char lp = (unsigned char ) p;
276
277	if (len) {
278	if (len >= 16) { /* < 16 probably not worth all the calculations */
279	/* write out preceding characters so we align on an integer boundary */
280	if ((i = ((-(u_intp_t)p) & (SIZEOF_INT_P - 1)))) {
281	len -= (size_t)i;
282	for (; i--;)
283	*lp++ = c;
284	}
285
286	/* do the fast writing */
287	val = (c << 8) + c;
288	#if SIZEOF_INT_P >= 4
289	val \|= (val << 16);
290	#endif
291	#if SIZEOF_INT_P >= 8
292	val \|= (val << 32);
293	#endif
294	#if SIZEOF_INT_P == 16
295	val \|= (val << 64);
296	#endif
297	for (i = (u_intp_t)(len / SIZEOF_INT_P); i--;)
298	((u_intp_t )lp)++ = val;
299	len &= (SIZEOF_INT_P - 1);
300	}
301	/* write trailing characters */
302	for (; len--;)
303	*lp++ = c;
304	}
305	return p;
306	}
307	#endif
308	/----------------------- end-of-file (C source) -----------------------/