Rev

Rev 2230 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | SVN | Bug Tracker

Rev 2230 Rev 2398
Line 5... Line 5...
5
##
5
##
6
##  Copyleft (c) 2003 - 2015
6
##  Copyleft (c) 2003 - 2015
7
##  This code is provided under the CeCill-C license agreement.
7
##  This code is provided under the CeCill-C license agreement.
8
######################################################################
8
######################################################################
9
*********************************************************************/
9
*********************************************************************/
-
 
10
#define _CRT_SECURE_NO_WARNINGS
10
#include "cstr.h"
11
#include "cstr.h"
11
#include <string.h>
12
#include <string.h>
12
#include <stdio.h>
13
#include <stdio.h>
13
#include <stdarg.h>
14
#include <stdarg.h>
14
#include <stdlib.h>
15
#include <stdlib.h>
-
 
16
#include <ctype.h>
15
17
16
int    cstrlen(const char * str)
18
int    cstrlen(const char * str)
17
{
19
{
18
        return str ? strlen(str) : 0;
20
        return str ? strlen(str) : 0;
-
 
21
}
-
 
22
int    cstrnlen(const char * str, int maxsize)
-
 
23
{
-
 
24
        int len = str ? strlen(str) : 0;
-
 
25
        return  len > maxsize ? maxsize : len;
-
 
26
}
-
 
27
-
 
28
char*  cstrend(const char * str)
-
 
29
{
-
 
30
        return (char*)(str ? str + strlen(str) : NULL);
-
 
31
}
-
 
32
-
 
33
int cstrequal(const char * s1, const char * s2)
-
 
34
{
-
 
35
        return (s1 == s2) || (s1 && s2 && 0 == strcmp(s1, s2));
-
 
36
}
-
 
37
-
 
38
char* cstrisprefix(const char * str, const char * prefix)
-
 
39
{
-
 
40
        int len;
-
 
41
        if (str == prefix){
-
 
42
                return (char*)(str ? str + strlen(str) : NULL);
-
 
43
        }
-
 
44
        if (str == NULL || prefix == NULL || 0 == *prefix){
-
 
45
                return (char*)str;
-
 
46
        }
-
 
47
        len = strlen(prefix);
-
 
48
        if (0 == memcmp(str, prefix, len)){
-
 
49
                return ((char*)str) + len;
-
 
50
        }
-
 
51
        return NULL;
19
}
52
}
20
53
21
char * cstrcpy(char * dst, const char * src)
54
char * cstrcpy(char * dst, const char * src)
22
{
55
{
23
        if(!dst) return (char*)0;
56
        if(!dst) return (char*)0;
Line 40... Line 73...
40
        unsigned int len = 0;
73
        unsigned int len = 0;
41
        if(src && ms > 0){
74
        if (src && ms > 0){
42
                len = strlen(src);
75
                len = strlen(src);
43
                if(len > ms){
76
                if (len > ms){
44
                        len = ms;
77
                        len = ms;
-
 
78
                }
45
                        if(len){
79
                if (len){
46
                                memcpy(dst, src, len);
80
                        memcpy(dst, src, len);
47
                        }
-
 
48
                }
81
                }
49
        }
82
        }
50
        dst[len]=0;
83
        dst[len] = 0;
51
        return dst + len;
84
        return dst + len;
-
 
85
}
-
 
86
-
 
87
char * cmemcpy(char * dst, const char * src, int length)
-
 
88
{
-
 
89
        if (!dst) return (char*)0;
-
 
90
        if (length){
-
 
91
                if (src){
-
 
92
                        memcpy(dst, src, length);
-
 
93
                }
-
 
94
                else{
-
 
95
                        memset(dst, 0, length);
-
 
96
                }
-
 
97
        }
-
 
98
        dst[length] = 0;
-
 
99
        return dst + length;
52
}
100
}
53
101
54
/* copy up to maxsize characters from src to dst and return pointer to the next byte after the end */
102
/* copy up to maxsize characters from src to dst and return pointer to the next byte after the end */
55
char * cvstrncpy(char * dst, int maxsize, const char * ptr, ...)
103
char * cvstrncpy(char * dst, int maxsize, const char * ptr, ...)
56
{
104
{
Line 139... Line 187...
139
                *p = 0;
187
                *p = 0;
140
        }
188
        }
141
        return dst;
189
        return dst;
142
}
190
}
143
191
144
char * cstrnload(char * dst, int max_size, const char * path)
192
char * cstrnload(char * dst, int max_size, const pchar_t * path)
145
{
193
{
146
        FILE * f = fopen(path, "rb");
194
        FILE * f = pchar_fopen(path, _PCH("rb"));
147
        unsigned long len;
195
        unsigned long len, rl;
148
        unsigned long ms = max_size;
196
        unsigned long ms = max_size;
149
        if (!f) return NULL;
197
        if (!f) return NULL;
150
        fseek(f, 0, SEEK_END);
198
        fseek(f, 0, SEEK_END);
151
        len = ftell(f);
199
        len = ftell(f);
152
        fseek(f, 0, SEEK_SET);
200
        fseek(f, 0, SEEK_SET);
153
        if (len > ms) len = ms;
201
        if (len > ms) len = ms;
154
        ms = fread(dst, 1, len, f);
202
        rl = fread(dst, 1, len, f);
155
        fclose(f);
203
        fclose(f);
156
        if ((int)ms < 0){
204
        if ((int)rl < 0){
157
                return NULL;
205
                return NULL;
158
        }
206
        }
159
        dst[len] = 0;
207
        if (len < ms)dst[len] = 0;
160
        return dst + len;
208
        return dst + len;
161
}
209
}
162
210
163
char * cstraload(char ** p, const char * path)
211
char * cstraload(char ** p, const pchar_t * path)
164
{
212
{
165
        char * ret = NULL;
213
        char * ret = NULL;
166
        FILE * f = fopen(path, "rb");
214
        FILE * f = pchar_fopen(path, _PCH("rb"));
167
        int len;
215
        int len;
168
        if (f){
216
        if (f){
169
                fseek(f, 0, SEEK_END);
217
                fseek(f, 0, SEEK_END);
170
                len = ftell(f);
218
                len = ftell(f);
171
                fseek(f, 0, SEEK_SET);
219
                fseek(f, 0, SEEK_SET);
Line 186... Line 234...
186
                fclose(f);
234
                fclose(f);
187
        }
235
        }
188
        return ret;
236
        return ret;
189
}
237
}
190
238
191
const char * cstrlastpathelement(const char * str)
239
const pchar_t * cstrlastpathelement(const pchar_t * str)
192
{
240
{
193
        const char * p = strrchr(str, '/');
241
        const pchar_t * p = pchar_rchr(str, '/');
-
 
242
#ifdef WIN32
194
        const char * p2 = strrchr(str, '/');
243
        const pchar_t * p2 = pchar_rchr(str, '\\');
195
        if(p<p2)p=p2;
244
        if(p<p2)p=p2;
-
 
245
#endif
196
        else if(p == NULL) p = str;
246
        else if(p == NULL) p = str;
197
        return p;
247
        return p;
-
 
248
}
-
 
249
-
 
250
pchar_t * cstrpathextension(const pchar_t * str)
-
 
251
{
-
 
252
        const pchar_t * p;
-
 
253
        if (str){
-
 
254
                p = pchar_rchr(str, '.');
-
 
255
                if (!p) p = str + pchar_len(str);
-
 
256
        }
-
 
257
        else{
-
 
258
                p = str;
-
 
259
        }
-
 
260
        return (pchar_t*)p;
198
}
261
}
199
262
200
char * cstr_hex2bin(char * bin, int blen, const char * hex, int hlen)
263
char * cstr_hex2bin(char * bin, int blen, const char * hex, int hlen)
201
{
264
{
202
        // check
265
        // check
Line 204... Line 267...
204
        const char * e = hex+hlen;
267
        const char * e = hex+hlen;
205
        char * b = bin;
268
        char * b = bin;
206
        int n = 0;
269
        int n = 0;
207
        while (h<e){
270
        while (h<e){
208
                char ch = *h++;
271
                char ch = *h++;
209
                if (ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n') continue;
272
                if (isspace((int)(ch))) continue;
210
                if (ch >= '0' && ch <= '9') continue;
273
                if (ch >= '0' && ch <= '9') continue;
211
                if (ch >= 'A' && ch <= 'F') continue;
274
                if (ch >= 'A' && ch <= 'F') continue;
212
                if (ch >= 'a' && ch <= 'f') continue;
275
                if (ch >= 'a' && ch <= 'f') continue;
213
                return NULL;
276
                return NULL;
214
        }
277
        }
Line 233... Line 296...
233
                *b++ = (ch1 << 4);
296
                *b++ = (ch1 << 4);
234
                n = 0;
297
                n = 0;
235
        }
298
        }
236
        return b;
299
        return b;
237
}
300
}
-
 
301
238
static const char* _hexDigits = "0123456789ABCDEF";
302
static const char* _hexDigits = "0123456789ABCDEF";
239
char * cstr_bin2hex(char * hex, int hlen, const char * bin, int blen)
303
char * cstr_bin2hex(char * hex, int hlen, const char * bin, int blen)
240
{
304
{
241
        const unsigned char *b, *e;
305
        const unsigned char *b, *e;
242
        char * s;
306
        char * s;
Line 252... Line 316...
252
                *(--s) = _hexDigits[(*e) & 0xF];
316
                *(--s) = _hexDigits[(*e) & 0xF];
253
                *(--s) = _hexDigits[(*e) >> 4];
317
                *(--s) = _hexDigits[(*e) >> 4];
254
        }
318
        }
255
        return hex + blen * 2;
319
        return hex + blen * 2;
256
}
320
}
-
 
321
-
 
322
int cstr_write(const char * const p, char ** const ptr, const char * const end, int * const error);
-
 
323
int cstr_read(char * const p, const char ** const ptr, const char * const end, int * const error);
-
 
324
-
 
325
int cstrn_write(const char * const p, int length, char ** const ptr, const char * const end, int * const error);
-
 
326
int cstrn_read(char * const p, int length, const char ** const ptr, const char * const end, int * const error);