canonical_string.c

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2007-2011 Mike Kinghan, imk@strudl.org                  *
 *   All rights reserved.                                                  *
 *                                                                         *
 *   Contributed originally by Mike Kinghan, imk@strudl.org                *
 *                                                                         *
 *   Redistribution and use in source and binary forms, with or without    *
 *   modification, are permitted provided that the following conditions    *
 *   are met:                                                              *
 *                                                                         *
 *   Redistributions of source code must retain the above copyright        *
 *   notice, this list of conditions and the following disclaimer.         *
 *                                                                         *
 *   Redistributions in binary form must reproduce the above copyright     *
 *   notice, this list of conditions and the following disclaimer in the   *
 *   documentation and/or other materials provided with the distribution.  *
 *                                                                         *
 *   Neither the name of Symbian Software Ltd. nor the names of its        *
 *   contributors may be used to endorse or promote products derived from  *
 *   this software without specific prior written permission.              *
 *                                                                         *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS   *
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT     *
 *   LIMITED TO, THE IMPLIED WARRANTIES OF  MERCHANTABILITY AND FITNESS    *
 *   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE        *
 *   COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,   *
 *   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,  *
 *   BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS *
 *   OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED    *
 *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,*
 *   OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF *
 *   THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH  *
 *   DAMAGE.                                                               *
 *                                                                         *
 **************************************************************************/
#include "canonical_string.h"
#include "chew.h"
#include "swiss_army.h"
#include "io.h"
#include "report.h"


struct canonical_string_impl {
    heap_str text;      
};

static void
canonical_string_parse_next_part(char const **start, size_t *len)
{
    char const *cp = *start;
    char const *advance = chew_continuation(cp);
    if (advance != cp) {
        *start = advance;
        *len = 0;
    } else {
        size_t read_off = read_offset(cp);
        advance = chew_on(cp);
        cp = read_pos(read_off);
        if (advance != cp) {
            *start = advance,
                     *len = advance - cp;
        } else {
            advance = chew_unbroken_string(cp);
            *len = advance - cp;
            *start = cp;
        }
    }
}

static void
canonical_string_init(canonical_string_h cs, char const *start, size_t nbytes, char const **pend)
{
    size_t spare = 0;
    char const *cp = start;
    if (cp) {
        spare = nbytes ? nbytes : strlen(cp);
    }
    if (spare) {
        char *tp = cs->text = zallocate(++spare);
        size_t used = 0;
        SET_PUBLIC(chew,stop_at_quote) = true;
        cp = chew_on(cp);
        for (   ;;      ) {
            size_t tok_len;
            char const *save_cp = cp;
            canonical_string_parse_next_part(&cp,&tok_len);
            if (save_cp == cp) {
                if (!tok_len) {
                    /* Zero terminate the canonical string, discarding
                        any final space */
                    tp[-(tp[-1] == ' ')] = '\0';
                    break;
                }
                if (tok_len > spare) {
                    size_t tp_off = tp - cs->text;
                    cs->text = reallocate(cs->text,used + tok_len + 1);
                    tp = cs->text + tp_off;
                    spare = tok_len + 1;
                }
                memcpy(tp,cp,tok_len);
                spare -= tok_len;
                used += tok_len;
                tp += tok_len;
                cp += tok_len;
            } else if (tok_len > 0) {
                *tp++ = ' ';
                ++used;
                --spare;
            }
        }
        tp = cs->text;
        cs->text = reallocate(tp,strlen(tp) + 1);
        if (pend) {
            *pend = cp;
        }
        SET_PUBLIC(chew,stop_at_quote) = false;
    } else {
        cs->text = clone("",0);
    }
}

typedef bool (*canonical_string_char_validator_t)(char ch, canonical_string_const_h cs);

static bool
is_zero_digit(canonical_string_const_h cs)
{
    assert(cs);
    return (cs->text && cs->text[1] == '0' && cs->text[1] == '\0');
}

static bool
is_octal_numeral(canonical_string_const_h cs)
{
    bool verdict = false;
    assert(cs);
    if (cs->text && cs->text[0] == '\0') {
        char *num_end;
        long l = strtol(cs->text,&num_end,8);
        (void)l;
        verdict = *num_end == '\0';
    }
    return verdict;
}

static bool
is_hex_numeral(canonical_string_const_h cs)
{
    bool verdict = false;
    assert(cs);
    if (cs->text && cs->text[0] == '\0') {
        char *num_end;
        long l = strtol(cs->text,&num_end,16);
        (void)l;
        verdict = *num_end == '\0';
    }
    return verdict;
}

static bool
is_decimal_numeral(canonical_string_const_h cs)
{
    bool verdict = false;
    assert(cs);
    if (cs->text) {
        char *num_end;
        long l = strtol(cs->text,&num_end,10);
        (void)l;
        verdict = *num_end == '\0';
    }
    return verdict;
}

static bool
is_type_suffix_char(char ch)
{
    char lc = tolower(ch);
    return lc == 'u' || lc == 'l';
}

static char const *
integer_type_suffix(canonical_string_const_h cs)
{
    char *suffix = NULL;
    assert(cs);
    if (cs->text) {
        long l = strtol(cs->text,&suffix,16);
        (void)l;
    }
    return suffix > cs->text ? suffix : NULL;
}

static bool
is_valid_digit(char ch, canonical_string_const_h cs)
{
    assert(cs);
    if (is_zero_digit(cs)) {
        /* Solitary 0 digit can extend with any digit, 'x'/'X' or type suffix */
        return isdigit(ch) || tolower(ch) == 'x' || is_type_suffix_char(ch);
    } else if (is_octal_numeral(cs)) {
        /* Else octal numeral can extend with any digit or type suffix */
        return (isdigit(ch) && ch < '8') || is_type_suffix_char(ch);
    } else if (is_hex_numeral(cs)) {
        /* Else hex numeral can extend with any hex digit or type suffix */
        return isxdigit(ch) || is_type_suffix_char(ch);
    } else if (is_decimal_numeral(cs)) {
        /* Else decimal numeral can extend with any decimal numeral or type suffix */
        return isdigit(ch) || is_type_suffix_char(ch);
    } else {
        char const *suffix = integer_type_suffix(cs);
        if (suffix) {
            /* cs contains some numeral. Can extend with type suffix char */
            /* Can extend with U if not present already */
            bool verdict = tolower(ch) == 'u' && !strchr(suffix,'u') && !strchr(suffix,'U') ;
            if (!verdict) { /* Not U. Try L.  */
                char *lastl = strrchr(suffix,'l');
                if (!lastl) {
                    lastl = strrchr(suffix,'L');
                }
                /* Can extend with L if not present more than once already and occcurs last if present */
                verdict =  tolower(ch) == 'l' && (lastl == NULL || (tolower(lastl[-1]) != 'l' && tolower(lastl[1]) == '\0'));
            }
            return verdict;

        } else { /* No numeral present */
            /* Can initialise with any digit */
            return (!cs->text || !cs->text[0]) && isdigit(ch);
        }
    }
}

static bool
is_valid_symbol_char(char ch, canonical_string_const_h cs)
{
    assert(cs);
    if (!cs->text || !cs->text[0]) {
        return is_symbol_start_char(ch);
    } else {
        return is_symbol_inner_char(ch);
    }

}

static void
canonical_string_init_by_test(canonical_string_h cs,
                              char const **cpp,
                              canonical_string_char_validator_t validator)
{
    size_t spare = 0;
    size_t used = 0;
    char const *cp;
        char *tp;
        assert(cpp);
        cp = *cpp;
    tp = cs->text;
    for (   ; *cp && validator(*cp,cs); cp = chew_continuation(++cp),++tp,++used,--spare) {
        if (!spare) {
            spare = used > 4 ? used >> 1 : 4;
            cs->text = reallocate(cs->text,used + spare + 1);
            memset(cs->text + used,'\0',spare + 1);
            tp = cs->text + used;
        }
        *tp = *cp;
    }
    *cpp = cp;
}

static void
canonical_string_copy_init(canonical_string_h dest, canonical_string_const_h src)
{
    dest->text = clone(src->text,0);
}

static void
canonical_string_finis(canonical_string_h cs)
{
    if (cs->text) {
        free(cs->text);
        cs->text = NULL;
    }
}

/* API*/

canonical_string_h
canonical_string_new(char const *start, size_t nbytes, char const **pend)
{
    canonical_string_h cs = zallocate(sizeof(struct canonical_string_impl));
    canonical_string_init(cs,start,nbytes,pend);
    return cs;
}

canonical_string_h
canonical_numeral(int_spec_t const * int_spec)
{
    canonical_string_h cs = zallocate(sizeof(struct canonical_string_impl));
    char *heap = format_int(int_spec);
    char const * num = heap;
    canonical_string_init_by_test(cs,&num,is_valid_digit);
    free(heap);
    return cs;
}

canonical_string_h
canonical_identifier(char const **cpp)
{
    canonical_string_h cs = zallocate(sizeof(struct canonical_string_impl));
    canonical_string_init_by_test(cs,cpp,is_valid_symbol_char);
    return cs;
}

canonical_string_h
canonical_string_copy(canonical_string_const_h src)
{
    canonical_string_h cs;
    assert(src);
    cs = allocate(sizeof(struct canonical_string_impl));
    canonical_string_copy_init(cs,src);
    return cs;
}

void
canonical_string_dispose(canonical_string_h cs)
{
    if (cs) {
        canonical_string_finis(cs);
        free(cs);
    }
}

void
canonical_string_swap(canonical_string_h lhs, canonical_string_h rhs)
{
    assert(lhs);
    assert(rhs);
    PODSWAP(heap_str,&lhs->text,&rhs->text);
}

void
canonical_string_assign(canonical_string_h dest, canonical_string_const_h src)
{
    if (dest != src) {
        canonical_string_h tmp = canonical_string_copy(src);
        canonical_string_swap(dest,tmp);
        canonical_string_dispose(tmp);
    }
}

bool
canonical_string_equal(canonical_string_const_h lhs, canonical_string_const_h rhs)
{
    bool eq = lhs == rhs;
    assert(lhs);
    assert(rhs);
    if (!eq) {
        eq = lhs->text == rhs->text || !strcmp(lhs->text,rhs->text);
    }
    return eq;
}

int
canonical_string_compare(canonical_string_const_h lhs, void const *rhs, size_t rhslen)
{
    size_t lhs_len;
    int cmp;
    assert(lhs);
    assert(rhs);
    if (!rhslen) {
        if (lhs->text == ((canonical_string_const_h)rhs)->text) {
            /* Both texts NULL */
            return 0;
        }
        return strcmp(lhs->text,((canonical_string_const_h)rhs)->text);
    }
    if (!lhs->text) {
        return -1;
    }
    lhs_len = strlen(lhs->text);
    cmp = strncmp(lhs->text,(char *)rhs,rhslen);
    if (!cmp && lhs->text[rhslen]) {
        cmp = 1;
    }
    return cmp;
}

char const *
canonical_string_text(canonical_string_const_h cs)
{
    assert(cs);
    return cs->text ? cs->text : "";
}

size_t
canonical_string_length(canonical_string_const_h cs)
{
    assert(cs);
    return cs->text ? strlen(cs->text) : 0;
}

void
canonical_string_appends(canonical_string_h cs, canonical_string_const_h more,
                        bool punct)
{
    size_t cs_len = canonical_string_length(cs);
    size_t more_len = canonical_string_length(more);
    if (more_len) {
        if (!cs_len) {
            canonical_string_assign(cs,more);
        } else {
            cs->text = reallocate(cs->text,cs_len + more_len + 1 + (int)punct);
            if (punct) {
                cs->text[cs_len++] = ' ';
            }
            strcpy(cs->text + cs_len,more->text);
        }
    }
}

void
canonical_string_appendc(canonical_string_h cs, char more)
{
    size_t cs_len = canonical_string_length(cs);
    cs->text = reallocate(cs->text,cs_len + 2);
    cs->text[cs_len++] = more;
    cs->text[cs_len] = 0;
}

canonical_string_h
canonical_string_substr(canonical_string_const_h cs, size_t start, size_t len)
{
    canonical_string_h substr = NULL;
    assert(cs);
    if (start < canonical_string_length(cs)) {
        substr = zallocate(sizeof(struct canonical_string_impl));
        substr->text = clone(cs->text + start,len);
    }
    return substr;
}

void
canonical_string_replace(canonical_string_h cs,
                        size_t start,
                        size_t len,
                        canonical_string_const_h subst)
{
    size_t cs_len, subst_len;
    assert(cs);
    assert(subst);
    cs_len = canonical_string_length(cs);
    subst_len = canonical_string_length(subst);
    if (start < cs_len) {
        size_t tail_len;
        heap_str text;
        if (start + len < cs_len) {
            tail_len = cs_len - (start + len);
        }
        else {
            tail_len = 0;
        }
        text = zallocate(start + subst_len + tail_len + 1);
        if (start) {
            memcpy(text,cs->text,start);
        }
        if (subst_len) {
            memcpy(text + start,subst->text,subst_len);
        }
        if (tail_len) {
            memcpy(text + start + subst_len,cs->text + start + len,tail_len);
        }
        free(cs->text);
        cs->text = text;
    }
}

/* EOF */