Changeset 1379291 in serd


Ignore:
Timestamp:
07/30/17 11:24:37 (3 weeks ago)
Author:
David Robillard <d@…>
Branches:
serd1
Children:
a26622b
Parents:
30379f4
git-author:
David Robillard <d@…> (03/15/16 20:37:09)
git-committer:
David Robillard <d@…> (07/30/17 11:24:37)
Message:

Remove useless character counting

Files:
9 edited

Legend:

Unmodified
Added
Removed
  • NEWS

    r30379f4 r1379291  
    44  * Add serd_node_new_relative_uri() 
    55  * Fix construction and comparison of URIs with UTF-8 characters 
     6  * Remove useless character counting 
    67  * Report I/O errors with message and return appropriate status code 
    78  * Report missing statement separator errors 
  • serd/serd.h

    r30379f4 r1379291  
    218218    const uint8_t* buf;      /**< Value string */ 
    219219    size_t         n_bytes;  /**< Size in bytes (not including null) */ 
    220     size_t         n_chars;  /**< Length in characters (not including null)*/ 
    221220    SerdNodeFlags  flags;    /**< Node flags (e.g. string properties) */ 
    222221    SerdType       type;     /**< Node type */ 
     
    297296/** 
    298297   Measure a UTF-8 string. 
    299    @return Length of `str` in characters (except NULL). 
     298   @return Length of `str` in bytes. 
    300299   @param str A null-terminated UTF-8 string. 
    301    @param n_bytes (Output) Set to the size of `str` in bytes (except NULL). 
    302300   @param flags (Output) Set to the applicable flags. 
    303301*/ 
    304302SERD_API 
    305303size_t 
    306 serd_strlen(const uint8_t* str, size_t* n_bytes, SerdNodeFlags* flags); 
     304serd_strlen(const uint8_t* str, SerdNodeFlags* flags); 
    307305 
    308306/** 
     
    446444*/ 
    447445 
    448 static const SerdNode SERD_NODE_NULL = { NULL, 0, 0, 0, SERD_NOTHING }; 
     446static const SerdNode SERD_NODE_NULL = { NULL, 0, 0, SERD_NOTHING }; 
    449447 
    450448/** 
  • src/env.c

    r902d171 r1379291  
    246246        const size_t len = prefix.len + suffix.len; 
    247247        uint8_t*     buf = (uint8_t*)malloc(len + 1); 
    248         SerdNode     ret = { buf, len, 0, 0, SERD_URI }; 
    249         snprintf((char*)buf, len + 1, "%s%s", prefix.buf, suffix.buf); 
    250         ret.n_chars = serd_strlen(buf, NULL, NULL); 
     248        SerdNode     ret = { buf, len, 0, SERD_URI }; 
     249        snprintf((char*)buf, ret.n_bytes + 1, "%s%s", prefix.buf, suffix.buf); 
    251250        return ret; 
    252251    } 
  • src/node.c

    r30379f4 r1379291  
    4040    } 
    4141 
    42     uint32_t     flags       = 0; 
    43     size_t       buf_n_bytes = 0; 
    44     const size_t buf_n_chars = serd_strlen(str, &buf_n_bytes, &flags); 
    45     SerdNode ret = { str, buf_n_bytes, buf_n_chars, flags, type }; 
     42    uint32_t       flags   = 0; 
     43    const size_t   n_bytes = serd_strlen(str, &flags); 
     44    const SerdNode ret     = { str, n_bytes, flags, type }; 
    4645    return ret; 
    4746} 
     
    5554    } 
    5655 
    57     uint32_t     flags       = 0; 
    58     size_t       buf_n_bytes = 0; 
    59     const size_t buf_n_chars = serd_substrlen(str, len, &buf_n_bytes, &flags); 
    60     assert(buf_n_bytes <= len); 
    61     SerdNode ret = { str, buf_n_bytes, buf_n_chars, flags, type }; 
     56    uint32_t       flags   = 0; 
     57    const size_t   n_bytes = serd_substrlen(str, len, &flags); 
     58    const SerdNode ret     = { str, n_bytes, flags, type }; 
    6259    return ret; 
    6360} 
     
    8582        || (a->type == b->type 
    8683            && a->n_bytes == b->n_bytes 
    87             && a->n_chars == b->n_chars 
    8884            && ((a->buf == b->buf) || !memcmp((const char*)a->buf, 
    8985                                              (const char*)b->buf, 
     
    218214    const size_t len        = serd_uri_string_length(&abs_uri); 
    219215    uint8_t*     buf        = (uint8_t*)malloc(len + 1); 
    220     SerdNode     node       = { buf, 0, 0, 0, SERD_URI }; 
     216    SerdNode     node       = { buf, len, 0, SERD_URI }; 
    221217    uint8_t*     ptr        = buf; 
    222218    const size_t actual_len = serd_uri_serialise(&abs_uri, string_sink, &ptr); 
     
    224220    buf[actual_len] = '\0'; 
    225221    node.n_bytes    = actual_len; 
    226     node.n_chars    = serd_strlen(buf, NULL, NULL); 
    227222 
    228223    if (out) { 
     
    243238    const size_t base_len = serd_uri_string_length(base); 
    244239    uint8_t*     buf        = (uint8_t*)malloc(uri_len + base_len + 1); 
    245     SerdNode     node       = { buf, 0, 0, 0, SERD_URI }; 
     240    SerdNode     node       = { buf, 0, 0, SERD_URI }; 
    246241    uint8_t*     ptr        = buf; 
    247242    const size_t actual_len = serd_uri_serialise_relative( 
     
    250245    buf[actual_len] = '\0'; 
    251246    node.n_bytes    = actual_len; 
    252     node.n_chars    = serd_strlen(buf, NULL, NULL); 
    253247 
    254248    if (out) { 
     
    277271    const unsigned int_digits = serd_digits(abs_d); 
    278272    char*          buf        = (char*)calloc(int_digits + frac_digits + 3, 1); 
    279     SerdNode       node       = { (const uint8_t*)buf, 0, 0, 0, SERD_LITERAL }; 
     273    SerdNode       node       = { (const uint8_t*)buf, 0, 0, SERD_LITERAL }; 
    280274    const double   int_part   = floor(abs_d); 
    281275 
     
    300294    if (frac_part < DBL_EPSILON) { 
    301295        *s++ = '0'; 
    302         node.n_bytes = node.n_chars = (s - buf); 
     296        node.n_bytes = (s - buf); 
    303297    } else { 
    304298        uint64_t frac = frac_part * pow(10.0, (int)frac_digits) + 0.5; 
     
    309303        for (; i < frac_digits - 1 && !(frac % 10); ++i, --s, frac /= 10) {} 
    310304 
    311         node.n_bytes = node.n_chars = (s - buf) + 1; 
     305        node.n_bytes = (s - buf) + 1; 
    312306 
    313307        // Write digits from last trailing zero to decimal point 
     
    328322    const unsigned digits = serd_digits(abs_i); 
    329323    char*          buf    = (char*)calloc(digits + 2, 1); 
    330     SerdNode       node   = { (const uint8_t*)buf, 0, 0, 0, SERD_LITERAL }; 
     324    SerdNode       node   = { (const uint8_t*)buf, 0, 0, SERD_LITERAL }; 
    331325 
    332326    // Point s to the end 
     
    337331    } 
    338332 
    339     node.n_bytes = node.n_chars = (s - buf) + 1; 
     333    node.n_bytes = (s - buf) + 1; 
    340334 
    341335    // Write integer part (right to left) 
     
    374368    const size_t len  = ((size + 2) / 3) * 4 + (wrap_lines ? (size / 57) : 0); 
    375369    uint8_t*     str  = (uint8_t*)calloc(1, len + 2); 
    376     SerdNode     node = { str, len, len, 0, SERD_LITERAL }; 
     370    SerdNode     node = { str, len, 0, SERD_LITERAL }; 
    377371    for (size_t i = 0, j = 0; i < size; i += 3, j += 4) { 
    378372        uint8_t in[4] = { 0, 0, 0, 0 }; 
  • src/reader.c

    r1cd3218 r1379291  
    180180 
    181181    SerdNode* const node = (SerdNode*)mem; 
    182     node->n_bytes = node->n_chars = n_bytes; 
     182    node->n_bytes = n_bytes; 
    183183    node->flags   = 0; 
    184184    node->type    = type; 
     
    220220    SerdNode* const node = (SerdNode*)(reader->stack.buf + ref); 
    221221    ++node->n_bytes; 
    222     if (!(c & 0x80)) {  // Starts with 0 bit, start of new character 
    223         ++node->n_chars; 
    224     } 
    225222    *(s - 1) = c; 
    226223    *s       = '\0'; 
     
    11211118    SerdNode*   node   = deref(reader, ref); 
    11221119    const char* prefix = reader->bprefix ? (const char*)reader->bprefix : ""; 
    1123     node->n_bytes = node->n_chars = snprintf( 
     1120    node->n_bytes = snprintf( 
    11241121        (char*)node->buf, buf_size, "%sb%u", prefix, reader->next_id++); 
    11251122} 
  • src/serd_internal.h

    rf15d475 r1379291  
    331331 
    332332size_t 
    333 serd_substrlen(const uint8_t* str, 
    334                const size_t   len, 
    335                size_t*        n_bytes, 
    336                SerdNodeFlags* flags); 
     333serd_substrlen(const uint8_t* str, const size_t len, SerdNodeFlags* flags); 
    337334 
    338335static inline uint32_t 
  • src/string.c

    r4d535bb r1379291  
    5252serd_substrlen(const uint8_t* const str, 
    5353               const size_t         len, 
    54                size_t* const        n_bytes, 
    5554               SerdNodeFlags* const flags) 
    5655{ 
    57     size_t        n_chars = 0; 
    58     size_t        i       = 0; 
    59     SerdNodeFlags f       = 0; 
     56    size_t        i = 0; 
     57    SerdNodeFlags f = 0; 
    6058    for (; i < len && str[i]; ++i) { 
    6159        if ((str[i] & 0xC0) != 0x80) {  // Start of new character 
    62             ++n_chars; 
    6360            serd_update_flags(str[i], &f); 
    6461        } 
    65     } 
    66     if (n_bytes) { 
    67         *n_bytes = i; 
    6862    } 
    6963    if (flags) { 
    7064        *flags = f; 
    7165    } 
    72     return n_chars; 
     66    return i; 
    7367} 
    7468 
    7569SERD_API 
    7670size_t 
    77 serd_strlen(const uint8_t* str, size_t* n_bytes, SerdNodeFlags* flags) 
     71serd_strlen(const uint8_t* str, SerdNodeFlags* flags) 
    7872{ 
    79     size_t        n_chars = 0; 
    80     size_t        i       = 0; 
    81     SerdNodeFlags f       = 0; 
    82     for (; str[i]; ++i) { 
    83         if ((str[i] & 0xC0) != 0x80) {  // Start of new character 
    84             ++n_chars; 
    85             serd_update_flags(str[i], &f); 
     73    if (flags) { 
     74        size_t i = 0; 
     75        for (; str[i]; ++i) { 
     76            if ((str[i] & 0xC0) != 0x80) {  // Start of new character 
     77                serd_update_flags(str[i], flags); 
     78            } 
    8679        } 
     80        return i; 
    8781    } 
    88     if (n_bytes) { 
    89         *n_bytes = i; 
    90     } 
    91     if (flags) { 
    92         *flags = f; 
    93     } 
    94     return n_chars; 
     82    return strlen((const char*)str); 
    9583} 
    9684 
  • src/writer.c

    r30379f4 r1379291  
    3232 
    3333static const WriteContext WRITE_CONTEXT_NULL = { 
    34     { 0, 0, 0, 0, SERD_NOTHING }, 
    35     { 0, 0, 0, 0, SERD_NOTHING }, 
    36     { 0, 0, 0, 0, SERD_NOTHING } 
     34    { 0, 0, 0, SERD_NOTHING }, 
     35    { 0, 0, 0, SERD_NOTHING }, 
     36    { 0, 0, 0, SERD_NOTHING } 
    3737}; 
    3838 
     
    160160        dst->buf = (uint8_t*)realloc((char*)dst->buf, src->n_bytes + 1); 
    161161        dst->n_bytes = src->n_bytes; 
    162         dst->n_chars = src->n_chars; 
    163162        dst->flags   = src->flags; 
    164163        dst->type    = src->type; 
  • tests/serd_test.c

    r30379f4 r1379291  
    173173        } 
    174174        const size_t len = node.buf ? strlen((const char*)node.buf) : 0; 
    175         if (node.n_bytes != len || node.n_chars != len) { 
    176             return failure("Length %zu,%zu != %zu\n", 
    177                            node.n_bytes, node.n_chars, len); 
     175        if (node.n_bytes != len) { 
     176            return failure("Length %zu != %zu\n", node.n_bytes, len); 
    178177        } 
    179178        serd_node_free(&node); 
     
    197196        } 
    198197        const size_t len = strlen((const char*)node.buf); 
    199         if (node.n_bytes != len || node.n_chars != len) { 
    200             return failure("Length %zu,%zu != %zu\n", 
    201                            node.n_bytes, node.n_chars, len); 
     198        if (node.n_bytes != len) { 
     199            return failure("Length %zu != %zu\n", node.n_bytes, len); 
    202200        } 
    203201        serd_node_free(&node); 
     
    213211        SerdNode blob = serd_node_new_blob(data, size, size % 5); 
    214212 
    215         if (blob.n_bytes != blob.n_chars) { 
    216             return failure("Blob %zu bytes != %zu chars\n", 
    217                            blob.n_bytes, blob.n_chars); 
    218         } 
    219  
    220213        size_t   out_size; 
    221214        uint8_t* out = (uint8_t*)serd_base64_decode( 
     
    240233    const uint8_t str[] = { '"', '5', 0xE2, 0x82, 0xAC, '"', '\n', 0 }; 
    241234 
    242     size_t        n_bytes; 
    243235    SerdNodeFlags flags; 
    244     size_t        len = serd_strlen(str, &n_bytes, &flags); 
    245     if (len != 5 || n_bytes != 7 
    246         || flags != (SERD_HAS_QUOTE|SERD_HAS_NEWLINE)) { 
    247         return failure("Bad serd_strlen(%s) len=%zu n_bytes=%zu flags=%u\n", 
    248                 str, len, n_bytes, flags); 
    249     } 
    250     len = serd_strlen(str, NULL, &flags); 
    251     if (len != 5) { 
    252         return failure("Bad serd_strlen(%s) len=%zu flags=%u\n", 
    253                 str, len, flags); 
     236    size_t        n_bytes = serd_strlen(str, &flags); 
     237    if (n_bytes != 7 || flags != (SERD_HAS_QUOTE|SERD_HAS_NEWLINE)) { 
     238        return failure("Bad serd_strlen(%s) n_bytes=%zu flags=%u\n", 
     239                str, n_bytes, flags); 
    254240    } 
    255241 
     
    356342 
    357343    SerdNode node = serd_node_from_string(SERD_LITERAL, (const uint8_t*)"hello\""); 
    358     if (node.n_bytes != 6 || node.n_chars != 6 || node.flags != SERD_HAS_QUOTE 
     344    if (node.n_bytes != 6 || node.flags != SERD_HAS_QUOTE 
    359345        || strcmp((const char*)node.buf, "hello\"")) { 
    360         return failure("Bad node %s %zu %zu %d %d\n", 
    361                 node.buf, node.n_bytes, node.n_chars, node.flags, node.type); 
     346        return failure("Bad node %s %zu %d %d\n", 
     347                node.buf, node.n_bytes, node.flags, node.type); 
    362348    } 
    363349 
     
    370356 
    371357    SerdNode empty = serd_node_from_substring(SERD_LITERAL, NULL, 32); 
    372     if (empty.buf || empty.n_bytes || empty.n_chars || empty.flags || empty.type) { 
     358    if (empty.buf || empty.n_bytes || empty.flags || empty.type) { 
    373359        return failure("Successfully created node from NULL substring\n"); 
    374360    } 
    375361 
    376362    SerdNode a_b = serd_node_from_substring(SERD_LITERAL, USTR("a\"bc"), 3); 
    377     if (a_b.n_bytes != 3 || a_b.n_chars != 3 || a_b.flags != SERD_HAS_QUOTE 
     363    if (a_b.n_bytes != 3 || a_b.flags != SERD_HAS_QUOTE 
    378364        || strncmp((const char*)a_b.buf, "a\"b", 3)) { 
    379         return failure("Bad node %s %zu %zu %d %d\n", 
    380                        a_b.buf, a_b.n_bytes, a_b.n_chars, a_b.flags, a_b.type); 
     365        return failure("Bad node %s %zu %d %d\n", 
     366                       a_b.buf, a_b.n_bytes, a_b.flags, a_b.type); 
    381367    } 
    382368 
    383369    a_b = serd_node_from_substring(SERD_LITERAL, USTR("a\"bc"), 10); 
    384     if (a_b.n_bytes != 4 || a_b.n_chars != 4 || a_b.flags != SERD_HAS_QUOTE 
     370    if (a_b.n_bytes != 4 || a_b.flags != SERD_HAS_QUOTE 
    385371        || strncmp((const char*)a_b.buf, "a\"bc", 4)) { 
    386         return failure("Bad node %s %zu %zu %d %d\n", 
    387                        a_b.buf, a_b.n_bytes, a_b.n_chars, a_b.flags, a_b.type); 
     372        return failure("Bad node %s %zu %d %d\n", 
     373                       a_b.buf, a_b.n_bytes, a_b.flags, a_b.type); 
    388374    } 
    389375 
Note: See TracChangeset for help on using the changeset viewer.