← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/pbms/src/cslib/CSStrUtil.cc

  • Committer: Barry.Leslie at PrimeBase
  • Date: 2010-10-18 21:21:20 UTC
  • mto: This revision was merged to the branch mainline in revision 1871.
  • Revision ID: barry.leslie@primebase.com-20101018212120-dqukgtkwhb1imt1o
Merged changes from lp:pbms. These changes should remove any danger
of longjmp() clobbering local variables.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/pbms/src/cslib/CSStrUtil.cc
29
29
#include "CSConfig.h"
30
30
#include <inttypes.h>
31
31
 
 
32
#include <stdlib.h>
32
33
#include <stdio.h>
33
34
#include <string.h>
34
35
#include <ctype.h>
35
36
 
 
37
#ifndef OS_WINDOWS
 
38
#include <fnmatch.h>
 
39
#endif
 
40
 
36
41
#include "CSDefs.h"
37
42
#include "CSStrUtil.h"
38
43
#include "CSMemory.h"
39
44
#include "CSGlobal.h"
40
45
 
 
46
const char *cs_version()
 
47
{
 
48
        static char version[124];
 
49
        
 
50
        if (!version[0]) {
 
51
                snprintf(version, 124, "%s(Built %s %s)", VERSION, __DATE__, __TIME__);
 
52
        }
 
53
        
 
54
        return version;
 
55
}
 
56
 
41
57
void cs_strcpy(size_t size, char *to, const char *from, size_t len)
42
58
{
43
59
        if (size > 0) {
59
75
        }
60
76
}
61
77
 
 
78
/* This function adds '...' to the end of the string.
 
79
 * if it does not fit!
 
80
 */
 
81
void cs_strcpy_dottt(size_t size, char *d, const char *s, size_t len)
 
82
{
 
83
        if (len+1 <= size) {
 
84
                cs_strcpy(size, d, s, len);
 
85
                return;
 
86
        }
 
87
        if (size < 5) {
 
88
                /* Silly, but anyway... */
 
89
                cs_strcpy(size, d, "...");
 
90
                return;
 
91
        }
 
92
        memcpy(d, s, size-4);
 
93
        memcpy(d+size-4, "...", 3);
 
94
        d[size-1] = 0;
 
95
}
 
96
 
62
97
void cs_strcpy_left(size_t size, char *to, const char *from, char ch)
63
98
{
64
99
        if (size > 0) {
174
209
                cs_strcat(size, buffer, ")");
175
210
}
176
211
 
 
212
int cs_path_depth(const char *path)
 
213
{
 
214
        int count = 0;
 
215
        while (*path) {
 
216
                if (IS_DIR_CHAR(*path))
 
217
                        count++;
 
218
 
 
219
                path++;
 
220
        }
 
221
        return count;
 
222
}
 
223
 
 
224
static const char *find_wildcard(const char *pattern)
 
225
{
 
226
        bool escaped = false;
 
227
        while (*pattern) {
 
228
                if ((*pattern == '*' || *pattern == '?' ) && !escaped)
 
229
                        return pattern;
 
230
                        
 
231
                if (*pattern == '\\')
 
232
                        escaped = !escaped;
 
233
                else
 
234
                        escaped = false;
 
235
                        
 
236
                pattern++;
 
237
        }
 
238
        
 
239
        return NULL;
 
240
}
 
241
 
 
242
// Check if the path contains any variable components.
 
243
bool cs_fixed_pattern(const char *str)
 
244
{
 
245
        return (find_wildcard(str) == NULL);
 
246
}
 
247
 
 
248
#ifdef OS_WINDOWS
 
249
bool cs_match_patern(const char *pattern, const char *str, bool ignore_case)
 
250
{
 
251
        bool escaped = false;
 
252
        
 
253
        while (*pattern && *str) {
 
254
                if ((*pattern == '*' || *pattern == '?' ) && !escaped) {
 
255
                        if (*pattern == '?') {
 
256
                                pattern++;
 
257
                                str++;  
 
258
                                continue;                       
 
259
                        }
 
260
                        
 
261
                        while (*pattern == '*' || *pattern == '?' ) pattern++; // eat the pattern matching characters.
 
262
                        
 
263
                        if (!*pattern) // A * at the end of the pattern matches everything.
 
264
                                return true;
 
265
                                
 
266
                        // This is where it gets complicted.
 
267
                        
 
268
                        coming soon!
 
269
                        
 
270
                }
 
271
                                        
 
272
                if (*pattern == '\\')
 
273
                        escaped = !escaped;
 
274
                else
 
275
                        escaped = false;
 
276
                        
 
277
                if (escaped)
 
278
                        pattern++;
 
279
                else {
 
280
                        if (ignore_case) {
 
281
                                if (toupper(*pattern) != toupper(*str))
 
282
                                        return false;
 
283
                        } else if (*pattern != *str)
 
284
                                return false;
 
285
                        pattern++;
 
286
                        str++;                          
 
287
                }
 
288
                
 
289
        }
 
290
        
 
291
        return ((!*pattern) && (!*str));
 
292
}
 
293
#else
 
294
bool cs_match_patern(const char *pattern, const char *str, bool ignore_case)
 
295
{
 
296
        return (fnmatch(pattern, str, (ignore_case)?FNM_CASEFOLD:0) == 0);
 
297
}
 
298
#endif
 
299
 
177
300
/* This function returns "" if the path ends with a dir char */
178
301
char *cs_last_name_of_path(const char *path, int count)
179
302
{
202
325
}
203
326
 
204
327
/* This function returns the last name component, even if the path ends with a dir char */
205
 
char *cs_last_directory_of_path(char *path)
 
328
char *cs_last_directory_of_path(const char *path)
206
329
{
207
330
        size_t  length;
208
 
        char    *ptr;
 
331
        const char      *ptr;
209
332
 
210
333
        length = strlen(path);
211
334
        if (!length)
212
 
                return(path);
 
335
                return((char *)path);
213
336
        ptr = path + length - 1;
214
337
        if (IS_DIR_CHAR(*ptr))
215
338
                ptr--;
216
339
        while (ptr != path && !IS_DIR_CHAR(*ptr)) ptr--;
217
340
        if (IS_DIR_CHAR(*ptr)) ptr++;
218
 
        return(ptr);
 
341
        return((char *)ptr);
219
342
}
220
343
 
221
344
const char *cs_find_extension(const char *file_name)
402
525
                return NULL;
403
526
 
404
527
        str = (char *) cs_malloc(len + 1);
 
528
 
 
529
        // Allow for allocation of an oversized buffer.
 
530
        size_t str_len = strlen(in_str);
 
531
        if (len > str_len)
 
532
                len = str_len;
 
533
                
405
534
        memcpy(str, in_str, len);
406
535
        str[len] = 0;
407
536
        return str;
418
547
        return *cstr || !*w_cstr;
419
548
}
420
549
 
 
550
bool cs_ends_with(const char *cstr, const char *w_cstr)
 
551
{
 
552
        size_t          len = strlen(cstr);
 
553
        size_t          w_len = strlen(w_cstr);
 
554
        const char      *ptr = cstr + len - 1;
 
555
        const char      *w_ptr = w_cstr + w_len - 1;
 
556
        
 
557
        if (w_len > len)
 
558
                return false;
 
559
 
 
560
        if (w_len == 0)
 
561
                return false;
 
562
 
 
563
        while (w_ptr >= w_cstr) {
 
564
                if (*w_ptr != *ptr)
 
565
                        return false;
 
566
                w_ptr--;
 
567
                ptr--;
 
568
        }
 
569
 
 
570
        return true;
 
571
}
 
572
 
421
573
void cs_replace_string(size_t size, char *into, const char ch, const char *str)
422
574
{
423
575
        char *ptr;
469
621
        return value;
470
622
}
471
623
 
472
 
int64_t cs_byte_size_to_int8(const char *ptr)
 
624
int64_t cs_byte_size_to_int8(const char *ptr, bool *invalid)
473
625
{
474
 
        char    number[101], *num_ptr;
 
626
        char    *end_ptr;
475
627
        int64_t size;
476
628
 
 
629
        if (invalid)
 
630
                *invalid = false;
 
631
 
477
632
        while (*ptr && isspace(*ptr))
478
633
                ptr++;
479
634
 
480
 
        num_ptr = number;
481
 
        while (*ptr && isdigit(*ptr)) {
482
 
                if (num_ptr < number+100) {
483
 
                        *num_ptr = *ptr;
484
 
                        num_ptr++;
485
 
                }
486
 
                ptr++;
487
 
        }
488
 
        *num_ptr = 0;
489
 
        size = cs_str_to_int8(number, NULL);
490
 
 
 
635
        if (!isdigit(*ptr) && *ptr != '.')
 
636
                goto failed;
 
637
 
 
638
        size = (int64_t) strtod(ptr, &end_ptr);
 
639
 
 
640
        ptr = end_ptr;
491
641
        while (*ptr && isspace(*ptr))
492
642
                ptr++;
493
643
        
494
644
        switch (toupper(*ptr)) {
 
645
                case 'P':
 
646
                        size *= (int64_t) 1024;
 
647
                case 'T':
 
648
                        size *= (int64_t) 1024;
495
649
                case 'G':
496
 
                        size *= 1024LL * 1024LL * 1024LL;
497
 
                        break;
 
650
                        size *= (int64_t) 1024;
498
651
                case 'M':
499
 
                        size *= 1024LL * 1024LL;
500
 
                        break;
 
652
                        size *= (int64_t) 1024;
501
653
                case 'K':
502
 
                        size *= 1024LL;
503
 
                        break;
504
 
        }
505
 
        
506
 
        return size;
507
 
}
508
 
 
509
 
 
510
 
/*--------------------------------------------------------------------------------------------------*/
511
 
size_t cs_hex_to_bin(size_t size, void *bin, size_t len, const char *hex)
512
 
{       
513
 
        unsigned char *bin_ptr, *hex_ptr, c, val;
514
 
        size_t result = 0;
515
 
 
516
 
        if (len %2)  /* The hex string must be an even number of bytes. */
517
 
                len--;
518
 
                
519
 
        if (len > (2 *size)) {
520
 
                len = 2 * size;
521
 
        } 
522
 
                        
523
 
        bin_ptr = (unsigned char *) bin;        
524
 
        hex_ptr = (unsigned char *) hex;        
525
 
 
526
 
        
527
 
        for (; len > 0; len--, hex_ptr++) {
528
 
                c = *hex_ptr;
529
 
                if ((c >= '0') && (c <= '9')) {
530
 
                        val = c - '0';
531
 
                }
532
 
                else {
533
 
                        c = toupper(c);
534
 
                        if ((c >= 'A') && (c <= 'F')) {
535
 
                                val = c - 'A' + 10;
536
 
                        }
537
 
                        else
538
 
                                return(result);
539
 
                }
540
 
                
541
 
                if ( len & 0X01) {
542
 
                        *bin_ptr += val;
543
 
                        bin_ptr++;
544
 
                        result++;
545
 
                }
546
 
                else {
547
 
                        *bin_ptr = val << 4;
548
 
                }
549
 
        }
550
 
        
551
 
        return(result);
552
 
}
553
 
        
554
 
/*--------------------------------------------------------------------------------------------------*/
555
 
size_t cs_bin_to_hex(size_t size, char *hex, size_t len, const void *bin)
556
 
{
557
 
        static uint16_t hex_table[256], initialized = 0;
558
 
        uint16_t *hex_ptr = (uint16_t *)hex;
559
 
        unsigned char *bin_ptr = (unsigned char *)bin;
560
 
        size_t  result = 0;
561
 
 
562
 
        /* init the hex table if required */
563
 
        if (!initialized) {
564
 
                char buf[20];
565
 
                int i;
566
 
                for ( i=0; i < 256; i++) {
567
 
                        snprintf(buf, 20,"%X", i + 256);
568
 
                        memcpy(&(hex_table[i]), buf +1, 2);
569
 
                }
570
 
                
571
 
                initialized = 1;
572
 
        }
573
 
        /*----------------------------------*/  
574
 
 
575
 
        if (size < len *2) {
576
 
                len = size/2;
577
 
        }
578
 
                
579
 
        result = len *2;
580
 
                
581
 
        hex_ptr += len -1;
582
 
        bin_ptr += len -1;
583
 
        for (; len != 0; len--, hex_ptr--, bin_ptr--) {
584
 
                memcpy(hex_ptr, hex_table + *bin_ptr, 2);
585
 
        }
586
 
        
587
 
        // If there is room null terminate the hex string.
588
 
        if (size > result)
589
 
                hex[result] = 0;
590
 
                
591
 
        return(result);
 
654
                        size *= (int64_t) 1024;
 
655
                        ptr++;
 
656
                        break;
 
657
                case '\0':
 
658
                        break;
 
659
                default:
 
660
                        goto failed;
 
661
        }
 
662
        
 
663
        if (toupper(*ptr) == 'B')
 
664
                ptr++;
 
665
 
 
666
        while (*ptr && isspace(*ptr))
 
667
                ptr++;
 
668
 
 
669
        if (*ptr)
 
670
                goto failed;
 
671
 
 
672
        return (int64_t) size;
 
673
 
 
674
        failed:
 
675
        if (invalid)
 
676
                *invalid = true;
 
677
        return 0;
 
678
}
 
679
 
 
680
 
 
681
static uint32_t cs_hex_value(char ch)
 
682
{
 
683
        u_char uch = (u_char) ch;
 
684
 
 
685
        if (uch >= '0' && uch <= '9')
 
686
                return uch - '0';
 
687
        if (uch >= 'A' && uch <= 'F')
 
688
                return uch - 'A' + 10; 
 
689
        if (uch >= 'a' && uch <= 'f')
 
690
                return uch - 'a' + 10;
 
691
        return 0;
 
692
}
 
693
 
 
694
size_t cs_hex_to_bin(size_t size, void *v_bin, size_t len, const char *hex)
 
695
{
 
696
        size_t  tot_size = size;
 
697
        uint32_t        val = 0;
 
698
        size_t  shift = 0;
 
699
        u_char *bin = (u_char *) v_bin;
 
700
 
 
701
        if (len & 1)
 
702
                shift = 1;
 
703
        for (size_t i=shift; i<len+shift && size > 0; i++) {
 
704
                if (i & 1) {
 
705
                        val = val | cs_hex_value(*hex);
 
706
                        *bin = val;
 
707
                        bin++;
 
708
                        size--;
 
709
                }
 
710
                else
 
711
                        val = cs_hex_value(*hex) << 4;
 
712
                hex++;
 
713
        }
 
714
        return tot_size - size;
 
715
}
 
716
 
 
717
size_t cs_hex_to_bin(size_t size, void *bin, const char *hex)
 
718
{
 
719
        return cs_hex_to_bin(size, bin, strlen(hex), hex);
 
720
}
 
721
 
 
722
#define HEX_DIGIT(x)    ((x) <= 9 ? '0' + (x) : 'A' + ((x) - 10))
 
723
 
 
724
void cs_bin_to_hex(size_t size, char *hex, size_t len, const void *v_bin)
 
725
{
 
726
        const u_char *bin = (u_char *) v_bin;
 
727
        if (size == 0)
 
728
                return;
 
729
        size--;
 
730
        for (size_t i=0; i<len && size > 0; i++) {
 
731
                *hex = HEX_DIGIT(*bin >> 4);
 
732
                hex++;
 
733
                size--;
 
734
                if (size == 0)
 
735
                        break;
 
736
                *hex = HEX_DIGIT(*bin & 0x0F);
 
737
                hex++;
 
738
                size--;
 
739
                bin++;
 
740
        }
 
741
        *hex = 0;
592
742
}       
593
743
 
594
744
void cs_strToUpper(char *ptr)
607
757
        }
608
758
}
609
759
 
 
760
/*
 
761
 * Return failed if this is not a valid number.
 
762
 */
 
763
bool cs_str_to_value(const char *ptr, uint32_t *value, uint8_t base)
 
764
{
 
765
        char *endptr;
 
766
 
 
767
        *value = strtoul(ptr, &endptr, base);
 
768
        return *endptr ? false : true;
 
769
}
 
770
 
 
771