Changeset a26622b in serd


Ignore:
Timestamp:
07/31/17 00:37:56 (3 weeks ago)
Author:
David Robillard <d@…>
Branches:
serd1
Children:
af0beac
Parents:
1379291
git-author:
David Robillard <d@…> (03/16/16 13:21:20)
git-committer:
David Robillard <d@…> (07/31/17 00:37:56)
Message:

Use char* for strings in public API

The constant casting just makes user code a mess, for no benefit.

Files:
12 edited

Legend:

Unmodified
Added
Removed
  • NEWS

    r1379291 ra26622b  
    44  * Add serd_node_new_relative_uri() 
    55  * Fix construction and comparison of URIs with UTF-8 characters 
     6  * Use char* for strings in public API 
    67  * Remove useless character counting 
    78  * Report I/O errors with message and return appropriate status code 
  • serd/serd.h

    r1379291 ra26622b  
    216216*/ 
    217217typedef struct { 
    218     const uint8_t* buf;      /**< Value string */ 
     218    const char*    buf;      /**< Value string */ 
    219219    size_t         n_bytes;  /**< Size in bytes (not including null) */ 
    220220    SerdNodeFlags  flags;    /**< Node flags (e.g. string properties) */ 
     
    226226*/ 
    227227typedef struct { 
    228     const uint8_t* buf;  /**< Start of chunk */ 
    229     size_t         len;  /**< Length of chunk in bytes */ 
     228    const char* buf;  /**< Start of chunk */ 
     229    size_t      len;  /**< Length of chunk in bytes */ 
    230230} SerdChunk; 
    231231 
     
    242242*/ 
    243243typedef struct { 
    244     SerdStatus     status;    /**< Error code */ 
    245     const uint8_t* filename;  /**< File where error was encountered, or NULL */ 
    246     unsigned       line;      /**< Line where error was encountered, or 0 */ 
    247     unsigned       col;       /**< Column where error was encountered */ 
    248     const char*    fmt;       /**< Message format string (printf style) */ 
    249     va_list*       args;      /**< Arguments for fmt */ 
     244    SerdStatus  status;    /**< Error code */ 
     245    const char* filename;  /**< File where error was encountered, or NULL */ 
     246    unsigned    line;      /**< Line where error was encountered, or 0 */ 
     247    unsigned    col;       /**< Column where error was encountered */ 
     248    const char* fmt;       /**< Message format string (printf style) */ 
     249    va_list*    args;      /**< Arguments for fmt */ 
    250250} SerdError; 
    251251 
     
    291291*/ 
    292292SERD_API 
    293 const uint8_t* 
     293const char* 
    294294serd_strerror(SerdStatus status); 
    295295 
     
    302302SERD_API 
    303303size_t 
    304 serd_strlen(const uint8_t* str, SerdNodeFlags* flags); 
     304serd_strlen(const char* str, SerdNodeFlags* flags); 
    305305 
    306306/** 
     
    327327SERD_API 
    328328void* 
    329 serd_base64_decode(const uint8_t* str, size_t len, size_t* size); 
     329serd_base64_decode(const char* str, size_t len, size_t* size); 
    330330 
    331331/** 
     
    347347*/ 
    348348SERD_API 
    349 const uint8_t* 
    350 serd_uri_to_path(const uint8_t* uri); 
     349const char* 
     350serd_uri_to_path(const char* uri); 
    351351 
    352352/** 
     
    359359*/ 
    360360SERD_API 
    361 uint8_t* 
    362 serd_file_uri_parse(const uint8_t* uri, uint8_t** hostname); 
     361char* 
     362serd_file_uri_parse(const char* uri, char** hostname); 
    363363 
    364364/** 
     
    367367SERD_API 
    368368bool 
    369 serd_uri_string_has_scheme(const uint8_t* utf8); 
     369serd_uri_string_has_scheme(const char* utf8); 
    370370 
    371371/** 
     
    374374SERD_API 
    375375SerdStatus 
    376 serd_uri_parse(const uint8_t* utf8, SerdURI* out); 
     376serd_uri_parse(const char* utf8, SerdURI* out); 
    377377 
    378378/** 
     
    453453SERD_API 
    454454SerdNode 
    455 serd_node_from_string(SerdType type, const uint8_t* str); 
     455serd_node_from_string(SerdType type, const char* str); 
    456456 
    457457/** 
     
    463463SERD_API 
    464464SerdNode 
    465 serd_node_from_substring(SerdType type, const uint8_t* str, size_t len); 
     465serd_node_from_substring(SerdType type, const char* str, size_t len); 
    466466 
    467467/** 
     
    495495SERD_API 
    496496SerdNode 
    497 serd_node_new_uri_from_string(const uint8_t* str, 
     497serd_node_new_uri_from_string(const char*    str, 
    498498                              const SerdURI* base, 
    499499                              SerdURI*       out); 
     
    511511SERD_API 
    512512SerdNode 
    513 serd_node_new_file_uri(const uint8_t* path, 
    514                        const uint8_t* hostname, 
    515                        SerdURI*       out, 
    516                        bool           escape); 
     513serd_node_new_file_uri(const char* path, 
     514                       const char* hostname, 
     515                       SerdURI*    out, 
     516                       bool        escape); 
    517517 
    518518/** 
     
    704704SERD_API 
    705705SerdStatus 
    706 serd_env_set_prefix_from_strings(SerdEnv*       env, 
    707                                  const uint8_t* name, 
    708                                  const uint8_t* uri); 
     706serd_env_set_prefix_from_strings(SerdEnv*    env, 
     707                                 const char* name, 
     708                                 const char* uri); 
    709709 
    710710/** 
     
    805805SERD_API 
    806806void 
    807 serd_reader_add_blank_prefix(SerdReader*    reader, 
    808                              const uint8_t* prefix); 
     807serd_reader_add_blank_prefix(SerdReader* reader, 
     808                             const char* prefix); 
    809809 
    810810/** 
     
    825825SERD_API 
    826826SerdStatus 
    827 serd_reader_read_file(SerdReader*    reader, 
    828                       const uint8_t* uri); 
     827serd_reader_read_file(SerdReader* reader, 
     828                      const char* uri); 
    829829 
    830830/** 
     
    838838SERD_API 
    839839SerdStatus 
    840 serd_reader_start_stream(SerdReader*    reader, 
    841                          FILE*          file, 
    842                          const uint8_t* name, 
    843                          bool           bulk); 
     840serd_reader_start_stream(SerdReader* me, 
     841                         FILE*       file, 
     842                         const char* name, 
     843                         bool        bulk); 
    844844 
    845845/** 
     
    855855                                SerdStreamErrorFunc error_func, 
    856856                                void*               stream, 
    857                                 const uint8_t*      name, 
     857                                const char*         name, 
    858858                                size_t              page_size); 
    859859 
     
    882882SERD_API 
    883883SerdStatus 
    884 serd_reader_read_file_handle(SerdReader*    reader, 
    885                              FILE*          file, 
    886                              const uint8_t* name); 
     884serd_reader_read_file_handle(SerdReader* reader, 
     885                             FILE*       file, 
     886                             const char* name); 
    887887 
    888888/** 
     
    895895                        SerdStreamErrorFunc error, 
    896896                        void*               stream, 
    897                         const uint8_t*      name, 
     897                        const char*         name, 
    898898                        size_t              page_size); 
    899899 
     
    903903SERD_API 
    904904SerdStatus 
    905 serd_reader_read_string(SerdReader* reader, const uint8_t* utf8); 
     905serd_reader_read_string(SerdReader* reader, const char* utf8); 
    906906 
    907907/** 
     
    973973*/ 
    974974SERD_API 
    975 uint8_t* 
     975char* 
    976976serd_buffer_sink_finish(SerdBuffer* stream); 
    977977 
     
    993993SERD_API 
    994994void 
    995 serd_writer_chop_blank_prefix(SerdWriter*    writer, 
    996                               const uint8_t* prefix); 
     995serd_writer_chop_blank_prefix(SerdWriter* writer, 
     996                              const char* prefix); 
    997997 
    998998/** 
  • src/byte_source.c

    r4024103 ra26622b  
    4848 
    4949    if (page_size > 1) { 
    50         source->file_buf = (uint8_t*)serd_bufalloc(page_size); 
     50        source->file_buf = (char*)serd_bufalloc(page_size); 
    5151        source->read_buf = source->file_buf; 
    5252        memset(source->file_buf, '\0', page_size); 
     
    7373 
    7474SerdStatus 
    75 serd_byte_source_open_string(SerdByteSource* source, const uint8_t* utf8) 
     75serd_byte_source_open_string(SerdByteSource* source, const char* utf8) 
    7676{ 
    7777    memset(source, '\0', sizeof(*source)); 
  • src/env.c

    r1379291 ra26622b  
    9393static inline SerdPrefix* 
    9494serd_env_find(const SerdEnv* env, 
    95               const uint8_t* name, 
     95              const char*    name, 
    9696              size_t         name_len) 
    9797{ 
     
    151151SERD_API 
    152152SerdStatus 
    153 serd_env_set_prefix_from_strings(SerdEnv*       env, 
    154                                  const uint8_t* name, 
    155                                  const uint8_t* uri) 
     153serd_env_set_prefix_from_strings(SerdEnv*    env, 
     154                                 const char* name, 
     155                                 const char* uri) 
    156156{ 
    157157    const SerdNode name_node = serd_node_from_string(SERD_LITERAL, name); 
     
    162162 
    163163static inline bool 
    164 is_nameChar(const uint8_t c) 
     164is_nameChar(const char c) 
    165165{ 
    166166    return is_alpha(c) || is_digit(c) || c == '_'; 
     
    172172*/ 
    173173static inline bool 
    174 is_name(const uint8_t* buf, size_t len) 
     174is_name(const char* buf, size_t len) 
    175175{ 
    176176    for (size_t i = 0; i < len; ++i) { 
     
    214214                SerdChunk*      uri_suffix) 
    215215{ 
    216     const uint8_t* const colon = (const uint8_t*)memchr( 
     216    const char* const colon = (const char*)memchr( 
    217217        curie->buf, ':', curie->n_bytes + 1); 
    218218    if (!colon) { 
     
    245245        } 
    246246        const size_t len = prefix.len + suffix.len; 
    247         uint8_t*     buf = (uint8_t*)malloc(len + 1); 
     247        char*        buf = (char*)malloc(len + 1); 
    248248        SerdNode     ret = { buf, len, 0, SERD_URI }; 
    249249        snprintf((char*)buf, ret.n_bytes + 1, "%s%s", prefix.buf, suffix.buf); 
  • src/node.c

    r1379291 ra26622b  
    3434SERD_API 
    3535SerdNode 
    36 serd_node_from_string(SerdType type, const uint8_t* str) 
     36serd_node_from_string(SerdType type, const char* str) 
    3737{ 
    3838    if (!str) { 
     
    4848SERD_API 
    4949SerdNode 
    50 serd_node_from_substring(SerdType type, const uint8_t* str, const size_t len) 
     50serd_node_from_substring(SerdType type, const char* str, const size_t len) 
    5151{ 
    5252    if (!str) { 
     
    6969 
    7070    SerdNode copy = *node; 
    71     uint8_t* buf  = (uint8_t*)malloc(copy.n_bytes + 1); 
     71    char* buf  = (char*)malloc(copy.n_bytes + 1); 
    7272    memcpy(buf, node->buf, copy.n_bytes + 1); 
    7373    copy.buf = buf; 
     
    107107string_sink(const void* buf, size_t len, void* stream) 
    108108{ 
    109     uint8_t** ptr = (uint8_t**)stream; 
     109    char** ptr = (char**)stream; 
    110110    memcpy(*ptr, buf, len); 
    111111    *ptr += len; 
     
    126126SERD_API 
    127127SerdNode 
    128 serd_node_new_uri_from_string(const uint8_t* str, 
     128serd_node_new_uri_from_string(const char*    str, 
    129129                              const SerdURI* base, 
    130130                              SerdURI*       out) 
     
    141141 
    142142static inline bool 
    143 is_uri_path_char(const uint8_t c) 
     143is_uri_path_char(const char c) 
    144144{ 
    145145    if (is_alpha(c) || is_digit(c)) { 
     
    161161SERD_API 
    162162SerdNode 
    163 serd_node_new_file_uri(const uint8_t* path, 
    164                        const uint8_t* hostname, 
    165                        SerdURI*       out, 
    166                        bool           escape) 
     163serd_node_new_file_uri(const char* path, 
     164                       const char* hostname, 
     165                       SerdURI*    out, 
     166                       bool        escape) 
    167167{ 
    168168    const size_t path_len     = strlen((const char*)path); 
     
    170170    const bool   evil         = is_windows_path(path); 
    171171    size_t       uri_len      = 0; 
    172     uint8_t*     uri          = NULL; 
     172    char*        uri          = NULL; 
    173173 
    174174    if (path[0] == '/' || is_windows_path(path)) { 
    175175        uri_len = strlen("file://") + hostname_len + evil; 
    176         uri = (uint8_t*)malloc(uri_len + 1); 
     176        uri = (char*)malloc(uri_len + 1); 
    177177        snprintf((char*)uri, uri_len + 1, "file://%s%s", 
    178178                 hostname ? (const char*)hostname : "", 
     
    213213 
    214214    const size_t len        = serd_uri_string_length(&abs_uri); 
    215     uint8_t*     buf        = (uint8_t*)malloc(len + 1); 
     215    char*        buf        = (char*)malloc(len + 1); 
    216216    SerdNode     node       = { buf, len, 0, SERD_URI }; 
    217     uint8_t*     ptr        = buf; 
     217    char*        ptr        = buf; 
    218218    const size_t actual_len = serd_uri_serialise(&abs_uri, string_sink, &ptr); 
    219219 
     
    235235                           SerdURI*       out) 
    236236{ 
    237     const size_t uri_len  = serd_uri_string_length(uri); 
    238     const size_t base_len = serd_uri_string_length(base); 
    239     uint8_t*     buf        = (uint8_t*)malloc(uri_len + base_len + 1); 
     237    const size_t uri_len    = serd_uri_string_length(uri); 
     238    const size_t base_len   = serd_uri_string_length(base); 
     239    char*        buf        = (char*)malloc(uri_len + base_len + 1); 
    240240    SerdNode     node       = { buf, 0, 0, SERD_URI }; 
    241     uint8_t*     ptr        = buf; 
     241    char*        ptr        = buf; 
    242242    const size_t actual_len = serd_uri_serialise_relative( 
    243243        uri, base, root, string_sink, &ptr); 
     
    271271    const unsigned int_digits = serd_digits(abs_d); 
    272272    char*          buf        = (char*)calloc(int_digits + frac_digits + 3, 1); 
    273     SerdNode       node       = { (const uint8_t*)buf, 0, 0, SERD_LITERAL }; 
     273    SerdNode       node       = { buf, 0, 0, SERD_LITERAL }; 
    274274    const double   int_part   = floor(abs_d); 
    275275 
     
    322322    const unsigned digits = serd_digits(abs_i); 
    323323    char*          buf    = (char*)calloc(digits + 2, 1); 
    324     SerdNode       node   = { (const uint8_t*)buf, 0, 0, SERD_LITERAL }; 
     324    SerdNode       node   = { (const char*)buf, 0, 0, SERD_LITERAL }; 
    325325 
    326326    // Point s to the end 
     
    368368    const size_t len  = ((size + 2) / 3) * 4 + (wrap_lines ? (size / 57) : 0); 
    369369    uint8_t*     str  = (uint8_t*)calloc(1, len + 2); 
    370     SerdNode     node = { str, len, 0, SERD_LITERAL }; 
     370    SerdNode     node = { (const char*)str, len, 0, SERD_LITERAL }; 
    371371    for (size_t i = 0, j = 0; i < size; i += 3, j += 4) { 
    372372        uint8_t in[4] = { 0, 0, 0, 0 }; 
     
    389389{ 
    390390    if (node && node->buf) { 
    391         free((uint8_t*)node->buf); 
     391        free((char*)node->buf); 
    392392        node->buf = NULL; 
    393393    } 
  • src/reader.c

    r1379291 ra26622b  
    4040 
    4141typedef struct { 
    42     const uint8_t* filename; 
    43     unsigned       line; 
    44     unsigned       col; 
     42    const char* filename; 
     43    unsigned    line; 
     44    unsigned    col; 
    4545} Cursor; 
    46  
    47 typedef uint32_t uchar; 
    4846 
    4947/* Reference to a node in the stack (we can not use pointers since the 
     
    8179    Cursor            cur; 
    8280    SerdStatus        status; 
    83     uint8_t*          buf; 
    84     uint8_t*          bprefix; 
     81    char*             buf; 
     82    char*             bprefix; 
    8583    size_t            bprefix_len; 
    8684    bool              strict;     ///< True iff strict parsing 
     
    167165    bool bad = false; 
    168166    for (unsigned i = 0; i < n; ++i) { 
    169         bad |= eat_byte_check(reader, ((const uint8_t*)str)[i]); 
     167        bad |= eat_byte_check(reader, str[i]); 
    170168    } 
    171169    return bad; 
     
    176174                 SerdType type, const char* str, size_t n_bytes) 
    177175{ 
    178     void* mem = serd_stack_push_aligned( 
     176    char* mem = serd_stack_push_aligned( 
    179177        &reader->stack, sizeof(SerdNode) + maxlen + 1, sizeof(SerdNode)); 
    180178 
     
    185183    node->buf     = NULL; 
    186184 
    187     uint8_t* buf = (uint8_t*)(node + 1); 
     185    char* buf = (char*)(node + 1); 
    188186    memcpy(buf, str, n_bytes + 1); 
    189187 
     
    191189    reader->allocs = realloc( 
    192190        reader->allocs, sizeof(reader->allocs) * (++reader->n_allocs)); 
    193     reader->allocs[reader->n_allocs - 1] = ((uint8_t*)mem - reader->stack.buf); 
     191    reader->allocs[reader->n_allocs - 1] = (mem - reader->stack.buf); 
    194192#endif 
    195     return (uint8_t*)node - reader->stack.buf; 
     193    return (char*)node - reader->stack.buf; 
    196194} 
    197195 
     
    207205    if (ref) { 
    208206        SerdNode* node = (SerdNode*)(reader->stack.buf + ref); 
    209         node->buf = (uint8_t*)node + sizeof(SerdNode); 
     207        node->buf = (char*)node + sizeof(SerdNode); 
    210208        return node; 
    211209    } 
     
    217215{ 
    218216    SERD_STACK_ASSERT_TOP(reader, ref); 
    219     uint8_t* const  s    = serd_stack_push(&reader->stack, 1); 
     217    char* const     s    = serd_stack_push(&reader->stack, 1); 
    220218    SerdNode* const node = (SerdNode*)(reader->stack.buf + ref); 
    221219    ++node->n_bytes; 
     
    242240#endif 
    243241        SerdNode* const node = deref(reader, ref); 
    244         uint8_t* const  top  = reader->stack.buf + reader->stack.size; 
    245         serd_stack_pop_aligned(&reader->stack, top - (uint8_t*)node); 
     242        char* const     top  = reader->stack.buf + reader->stack.size; 
     243        serd_stack_pop_aligned(&reader->stack, top - (char*)node); 
    246244    } 
    247245    return 0; 
     
    10701068    eat_byte_check(reader, ':'); 
    10711069    Ref ref = push_node(reader, SERD_BLANK, 
    1072                         reader->bprefix ? (char*)reader->bprefix : "", 
     1070                        reader->bprefix ? reader->bprefix : "", 
    10731071                        reader->bprefix_len); 
    10741072 
     
    11171115{ 
    11181116    SerdNode*   node   = deref(reader, ref); 
    1119     const char* prefix = reader->bprefix ? (const char*)reader->bprefix : ""; 
     1117    const char* prefix = reader->bprefix ? reader->bprefix : ""; 
    11201118    node->n_bytes = snprintf( 
    11211119        (char*)node->buf, buf_size, "%sb%u", prefix, reader->next_id++); 
     
    18061804SERD_API 
    18071805void 
    1808 serd_reader_add_blank_prefix(SerdReader*    reader, 
    1809                              const uint8_t* prefix) 
     1806serd_reader_add_blank_prefix(SerdReader* reader, 
     1807                             const char* prefix) 
    18101808{ 
    18111809    free(reader->bprefix); 
     
    18131811    reader->bprefix     = NULL; 
    18141812    if (prefix) { 
    1815         reader->bprefix_len = strlen((const char*)prefix); 
    1816         reader->bprefix     = (uint8_t*)malloc(reader->bprefix_len + 1); 
     1813        reader->bprefix_len = strlen(prefix); 
     1814        reader->bprefix     = (char*)malloc(reader->bprefix_len + 1); 
    18171815        memcpy(reader->bprefix, prefix, reader->bprefix_len + 1); 
    18181816    } 
     
    18301828SERD_API 
    18311829SerdStatus 
    1832 serd_reader_read_file(SerdReader*    reader, 
    1833                       const uint8_t* uri) 
    1834 { 
    1835     uint8_t* const path = serd_file_uri_parse(uri, NULL); 
     1830serd_reader_read_file(SerdReader* reader, 
     1831                      const char* uri) 
     1832{ 
     1833    char* const path = serd_file_uri_parse(uri, NULL); 
    18361834    if (!path) { 
    18371835        return SERD_ERR_BAD_ARG; 
    18381836    } 
    18391837 
    1840     FILE* fd = serd_fopen((const char*)path, "r"); 
     1838    FILE* fd = serd_fopen(path, "r"); 
    18411839    if (!fd) { 
    18421840        free(path); 
     
    18671865SERD_API 
    18681866SerdStatus 
    1869 serd_reader_start_stream(SerdReader*    reader, 
    1870                          FILE*          file, 
    1871                          const uint8_t* name, 
    1872                          bool           bulk) 
     1867serd_reader_start_stream(SerdReader* reader, 
     1868                         FILE*       file, 
     1869                         const char* name, 
     1870                         bool        bulk) 
    18731871{ 
    18741872    return serd_reader_start_source_stream( 
     
    18871885                                SerdStreamErrorFunc error_func, 
    18881886                                void*               stream, 
    1889                                 const uint8_t*      name, 
     1887                                const char*         name, 
    18901888                                size_t              page_size) 
    18911889{ 
     
    19391937SERD_API 
    19401938SerdStatus 
    1941 serd_reader_read_file_handle(SerdReader*    reader, 
    1942                              FILE*          file, 
    1943                              const uint8_t* name) 
     1939serd_reader_read_file_handle(SerdReader* reader, 
     1940                             FILE*       file, 
     1941                             const char* name) 
    19441942{ 
    19451943    return serd_reader_read_source( 
     
    19541952                        SerdStreamErrorFunc error, 
    19551953                        void*               stream, 
    1956                         const uint8_t*      name, 
     1954                        const char*         name, 
    19571955                        size_t              page_size) 
    19581956{ 
     
    19731971SERD_API 
    19741972SerdStatus 
    1975 serd_reader_read_string(SerdReader* reader, const uint8_t* utf8) 
    1976 { 
    1977     const Cursor cur = { (const uint8_t*)"(string)", 1, 1 }; 
     1973serd_reader_read_string(SerdReader* reader, const char* utf8) 
     1974{ 
     1975    const Cursor cur = { "(string)", 1, 1 }; 
    19781976 
    19791977    serd_byte_source_open_string(&reader->source, utf8); 
  • src/serd_internal.h

    r1379291 ra26622b  
    7676    void*               stream;       ///< Stream (e.g. FILE) 
    7777    size_t              page_size;    ///< Number of bytes to read at a time 
    78     uint8_t*            file_buf;     ///< Buffer iff reading pages from a file 
    79     const uint8_t*      read_buf;     ///< Pointer to file_buf or read_byte 
     78    char*               file_buf;     ///< Buffer iff reading pages from a file 
     79    const char*         read_buf;     ///< Pointer to file_buf or read_byte 
    8080    size_t              read_head;    ///< Offset into read_buf 
    81     uint8_t             read_byte;    ///< 1-byte 'buffer' used when not paging 
     81    char                read_byte;    ///< 1-byte 'buffer' used when not paging 
    8282    bool                from_stream;  ///< True iff reading from `stream` 
    8383    bool                prepared;     ///< True iff prepared for reading 
     
    9090 
    9191SerdStatus 
    92 serd_byte_source_open_string(SerdByteSource* source, const uint8_t* utf8); 
     92serd_byte_source_open_string(SerdByteSource* source, const char* utf8); 
    9393 
    9494SerdStatus 
     
    119119/** A dynamic stack in memory. */ 
    120120typedef struct { 
    121     uint8_t* buf;       ///< Stack memory 
     121    char*    buf;       ///< Stack memory 
    122122    size_t   buf_size;  ///< Allocated size of buf (>= size) 
    123123    size_t   size;      ///< Conceptual size of stack in buf 
     
    131131{ 
    132132    SerdStack stack; 
    133     stack.buf       = (uint8_t*)malloc(size); 
     133    stack.buf       = (char*)malloc(size); 
    134134    stack.buf_size  = size; 
    135135    stack.size      = SERD_STACK_BOTTOM; 
     
    152152} 
    153153 
    154 static inline uint8_t* 
     154static inline char* 
    155155serd_stack_push(SerdStack* stack, size_t n_bytes) 
    156156{ 
     
    158158    if (stack->buf_size < new_size) { 
    159159        stack->buf_size *= 2; 
    160         stack->buf = (uint8_t*)realloc(stack->buf, stack->buf_size); 
    161     } 
    162     uint8_t* const ret = (stack->buf + stack->size); 
     160        stack->buf = (char*)realloc(stack->buf, stack->buf_size); 
     161    } 
     162    char* const ret = (stack->buf + stack->size); 
    163163    stack->size = new_size; 
    164164    return ret; 
     
    209209    SerdSink sink; 
    210210    void*    stream; 
    211     uint8_t* buf; 
     211    char*    buf; 
    212212    size_t   size; 
    213213    size_t   block_size; 
     
    223223    bsink.block_size = block_size; 
    224224    bsink.buf        = ((block_size > 1) 
    225                         ? (uint8_t*)serd_bufalloc(block_size) 
     225                        ? (char*)serd_bufalloc(block_size) 
    226226                        : NULL); 
    227227    return bsink; 
     
    262262        memcpy(bsink->buf + bsink->size, buf, n); 
    263263        bsink->size += n; 
    264         buf          = (const uint8_t*)buf + n; 
     264        buf          = (const char*)buf + n; 
    265265        len         -= n; 
    266266 
     
    278278/** Return true if `c` lies within [`min`...`max`] (inclusive) */ 
    279279static inline bool 
    280 in_range(const uint8_t c, const uint8_t min, const uint8_t max) 
     280in_range(const char c, const char min, const char max) 
    281281{ 
    282282    return (c >= min && c <= max); 
     
    285285/** RFC2234: ALPHA := %x41-5A / %x61-7A  ; A-Z / a-z */ 
    286286static inline bool 
    287 is_alpha(const uint8_t c) 
     287is_alpha(const char c) 
    288288{ 
    289289    return in_range(c, 'A', 'Z') || in_range(c, 'a', 'z'); 
     
    292292/** RFC2234: DIGIT ::= %x30-39  ; 0-9 */ 
    293293static inline bool 
    294 is_digit(const uint8_t c) 
     294is_digit(const char c) 
    295295{ 
    296296    return in_range(c, '0', '9'); 
     
    316316 
    317317static inline bool 
    318 is_base64(const uint8_t c) 
     318is_base64(const char c) 
    319319{ 
    320320    return is_alpha(c) || is_digit(c) || c == '+' || c == '/' || c == '='; 
     
    322322 
    323323static inline bool 
    324 is_windows_path(const uint8_t* path) 
     324is_windows_path(const char* path) 
    325325{ 
    326326    return is_alpha(path[0]) && (path[1] == ':' || path[1] == '|') 
     
    331331 
    332332size_t 
    333 serd_substrlen(const uint8_t* str, const size_t len, SerdNodeFlags* flags); 
     333serd_substrlen(const char* str, const size_t len, SerdNodeFlags* flags); 
    334334 
    335335static inline uint32_t 
     
    393393} 
    394394 
    395 static inline uint8_t 
     395static inline char 
    396396uri_path_at(const SerdURI* uri, size_t i) 
    397397{ 
  • src/serdi.c

    r571dcd5 ra26622b  
    9898    } 
    9999 
    100     FILE*          in_fd         = NULL; 
    101     SerdSyntax     input_syntax  = SERD_TURTLE; 
    102     SerdSyntax     output_syntax = SERD_NTRIPLES; 
    103     bool           from_file     = true; 
    104     bool           bulk_read     = true; 
    105     bool           bulk_write    = false; 
    106     bool           full_uris     = false; 
    107     bool           lax           = false; 
    108     bool           quiet         = false; 
    109     const uint8_t* in_name       = NULL; 
    110     const uint8_t* add_prefix    = NULL; 
    111     const uint8_t* chop_prefix   = NULL; 
    112     const uint8_t* root_uri      = NULL; 
    113     int            a             = 1; 
     100    FILE*       in_fd         = NULL; 
     101    SerdSyntax  input_syntax  = SERD_TURTLE; 
     102    SerdSyntax  output_syntax = SERD_NTRIPLES; 
     103    bool        from_file     = true; 
     104    bool        bulk_read     = true; 
     105    bool        bulk_write    = false; 
     106    bool        full_uris     = false; 
     107    bool        lax           = false; 
     108    bool        quiet         = false; 
     109    const char* in_name       = NULL; 
     110    const char* add_prefix    = NULL; 
     111    const char* chop_prefix   = NULL; 
     112    const char* root_uri      = NULL; 
     113    int         a             = 1; 
    114114    for (; a < argc && argv[a][0] == '-'; ++a) { 
    115115        if (argv[a][1] == '\0') { 
    116             in_name = (const uint8_t*)"(stdin)"; 
     116            in_name = (const char*)"(stdin)"; 
    117117            in_fd   = stdin; 
    118118            break; 
     
    132132            return print_version(); 
    133133        } else if (argv[a][1] == 's') { 
    134             in_name = (const uint8_t*)"(string)"; 
     134            in_name = (const char*)"(string)"; 
    135135            from_file = false; 
    136136            ++a; 
     
    152152                return missing_arg(argv[0], 'p'); 
    153153            } 
    154             add_prefix = (const uint8_t*)argv[a]; 
     154            add_prefix = (const char*)argv[a]; 
    155155        } else if (argv[a][1] == 'c') { 
    156156            if (++a == argc) { 
    157157                return missing_arg(argv[0], 'c'); 
    158158            } 
    159             chop_prefix = (const uint8_t*)argv[a]; 
     159            chop_prefix = (const char*)argv[a]; 
    160160        } else if (argv[a][1] == 'r') { 
    161161            if (++a == argc) { 
    162162                return missing_arg(argv[0], 'r'); 
    163163            } 
    164             root_uri = (const uint8_t*)argv[a]; 
     164            root_uri = (const char*)argv[a]; 
    165165        } else { 
    166166            SERDI_ERRORF("invalid option -- '%s'\n", argv[a] + 1); 
     
    174174    } 
    175175 
    176     const uint8_t* input = (const uint8_t*)argv[a++]; 
     176    const char* input = (const char*)argv[a++]; 
    177177    if (from_file) { 
    178178        in_name = in_name ? in_name : input; 
     
    189189    if (a < argc) {  // Base URI given on command line 
    190190        base = serd_node_new_uri_from_string( 
    191             (const uint8_t*)argv[a], NULL, &base_uri); 
     191            (const char*)argv[a], NULL, &base_uri); 
    192192    } else if (from_file && in_fd != stdin) {  // Use input file URI 
    193193        base = serd_node_new_file_uri(input, NULL, &base_uri, true); 
  • src/string.c

    r1379291 ra26622b  
    2020 
    2121SERD_API 
    22 const uint8_t* 
    23 serd_strerror(SerdStatus status) 
     22const char* 
     23serd_strerror(SerdStatus st) 
    2424{ 
    25     switch (status) { 
    26     case SERD_SUCCESS:        return (const uint8_t*)"Success"; 
    27     case SERD_FAILURE:        return (const uint8_t*)"Non-fatal failure"; 
    28     case SERD_ERR_UNKNOWN:    return (const uint8_t*)"Unknown error"; 
    29     case SERD_ERR_BAD_SYNTAX: return (const uint8_t*)"Invalid syntax"; 
    30     case SERD_ERR_BAD_ARG:    return (const uint8_t*)"Invalid argument"; 
    31     case SERD_ERR_NOT_FOUND:  return (const uint8_t*)"Not found"; 
    32     case SERD_ERR_ID_CLASH:   return (const uint8_t*)"Blank node ID clash"; 
    33     case SERD_ERR_BAD_CURIE:  return (const uint8_t*)"Invalid CURIE"; 
    34     case SERD_ERR_INTERNAL:   return (const uint8_t*)"Internal error"; 
     25    switch (st) { 
     26    case SERD_SUCCESS:        return "Success"; 
     27    case SERD_FAILURE:        return "Non-fatal failure"; 
     28    case SERD_ERR_UNKNOWN:    return "Unknown error"; 
     29    case SERD_ERR_BAD_SYNTAX: return "Invalid syntax"; 
     30    case SERD_ERR_BAD_ARG:    return "Invalid argument"; 
     31    case SERD_ERR_NOT_FOUND:  return "Not found"; 
     32    case SERD_ERR_ID_CLASH:   return "Blank node ID clash"; 
     33    case SERD_ERR_BAD_CURIE:  return "Invalid CURIE"; 
     34    case SERD_ERR_INTERNAL:   return "Internal error"; 
    3535    } 
    36     return (const uint8_t*)"Unknown error";  // never reached 
     36    return "Unknown error";  // never reached 
    3737} 
    3838 
     
    5050 
    5151size_t 
    52 serd_substrlen(const uint8_t* const str, 
     52serd_substrlen(const char* const    str, 
    5353               const size_t         len, 
    5454               SerdNodeFlags* const flags) 
     
    6969SERD_API 
    7070size_t 
    71 serd_strlen(const uint8_t* str, SerdNodeFlags* flags) 
     71serd_strlen(const char* str, SerdNodeFlags* flags) 
    7272{ 
    7373    if (flags) { 
     
    167167SERD_API 
    168168void* 
    169 serd_base64_decode(const uint8_t* str, size_t len, size_t* size) 
     169serd_base64_decode(const char* str, size_t len, size_t* size) 
    170170{ 
     171    const uint8_t* ustr = (const uint8_t*)str; 
     172 
    171173    void* buf = malloc((len * 3) / 4 + 2); 
    172174    *size = 0; 
     
    175177        size_t  n_in = 0; 
    176178        for (; i < len && n_in < 4; ++n_in) { 
    177             for (; i < len && !is_base64(str[i]); ++i) {}  // Skip junk 
    178             in[n_in] = str[i++]; 
     179            for (; i < len && !is_base64(ustr[i]); ++i) {}  // Skip junk 
     180            in[n_in] = ustr[i++]; 
    179181        } 
    180182        if (n_in > 1) { 
  • src/uri.c

    r30379f4 ra26622b  
    2323 
    2424SERD_API 
    25 const uint8_t* 
    26 serd_uri_to_path(const uint8_t* uri) 
    27 { 
    28     const uint8_t* path = uri; 
     25const char* 
     26serd_uri_to_path(const char* uri) 
     27{ 
     28    const char* path = uri; 
    2929    if (!is_windows_path(uri) && serd_uri_string_has_scheme(uri)) { 
    3030        if (strncmp((const char*)uri, "file:", 5)) { 
     
    4747 
    4848SERD_API 
    49 uint8_t* 
    50 serd_file_uri_parse(const uint8_t* uri, uint8_t** hostname) 
    51 { 
    52     const uint8_t* path = uri; 
     49char* 
     50serd_file_uri_parse(const char* uri, char** hostname) 
     51{ 
     52    const char* path = uri; 
    5353    if (hostname) { 
    5454        *hostname = NULL; 
    5555    } 
    5656    if (!strncmp((const char*)uri, "file://", 7)) { 
    57         const uint8_t* auth = uri + 7; 
     57        const char* auth = uri + 7; 
    5858        if (*auth == '/') {  // No hostname 
    5959            path = auth; 
    6060        } else {  // Has hostname 
    61             if (!(path = (const uint8_t*)strchr((const char*)auth, '/'))) { 
     61            if (!(path = (const char*)strchr((const char*)auth, '/'))) { 
    6262                return NULL; 
    6363            } 
    6464            if (hostname) { 
    65                 *hostname = (uint8_t*)calloc(1, path - auth + 1); 
     65                *hostname = (char*)calloc(1, path - auth + 1); 
    6666                memcpy(*hostname, auth, path - auth); 
    6767            } 
     
    7474 
    7575    SerdBuffer buffer = { NULL, 0 }; 
    76     for (const uint8_t* s = path; *s; ++s) { 
     76    for (const char* s = path; *s; ++s) { 
    7777        if (*s == '%') { 
    7878            if (*(s + 1) == '%') { 
     
    8080                ++s; 
    8181            } else if (is_hexdig(*(s + 1)) && is_hexdig(*(s + 2))) { 
    82                 const uint8_t code[3] = { *(s + 1), *(s + 2), 0 }; 
     82                const char code[3] = { *(s + 1), *(s + 2), 0 }; 
    8383                uint32_t num; 
    8484                sscanf((const char*)code, "%X", &num); 
    85                 const uint8_t c = num; 
     85                const char c = num; 
    8686                serd_buffer_sink(&c, 1, &buffer); 
    8787                s += 2; 
     
    9898SERD_API 
    9999bool 
    100 serd_uri_string_has_scheme(const uint8_t* utf8) 
     100serd_uri_string_has_scheme(const char* utf8) 
    101101{ 
    102102    // RFC3986: scheme ::= ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) 
     
    105105    } 
    106106 
    107     for (uint8_t c; (c = *++utf8) != '\0';) { 
     107    for (char c; (c = *++utf8) != '\0';) { 
    108108        if (!is_uri_scheme_char(c)) { 
    109109            return false; 
     
    138138SERD_API 
    139139SerdStatus 
    140 serd_uri_parse(const uint8_t* utf8, SerdURI* out) 
     140serd_uri_parse(const char* utf8, SerdURI* out) 
    141141{ 
    142142    *out = SERD_URI_NULL; 
    143143 
    144     const uint8_t* ptr = utf8; 
     144    const char* ptr = utf8; 
    145145 
    146146    /* See http://tools.ietf.org/html/rfc3986#section-3 
     
    150150    /* S3.1: scheme ::= ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) */ 
    151151    if (is_alpha(*ptr)) { 
    152         for (uint8_t c = *++ptr; true; c = *++ptr) { 
     152        for (char c = *++ptr; true; c = *++ptr) { 
    153153            switch (c) { 
    154154            case '\0': case '/': case '?': case '#': 
     
    177177        ptr += 2; 
    178178        out->authority.buf = ptr; 
    179         for (uint8_t c; (c = *ptr) != '\0'; ++ptr) { 
     179        for (char c; (c = *ptr) != '\0'; ++ptr) { 
    180180            switch (c) { 
    181181            case '/': goto path; 
     
    200200    out->path.buf = ptr; 
    201201    out->path.len = 0; 
    202     for (uint8_t c; (c = *ptr) != '\0'; ++ptr) { 
     202    for (char c; (c = *ptr) != '\0'; ++ptr) { 
    203203        switch (c) { 
    204204        case '?': goto query; 
     
    216216    if (*ptr == '?') { 
    217217        out->query.buf = ++ptr; 
    218         for (uint8_t c; (c = *ptr) != '\0'; ++ptr) { 
     218        for (char c; (c = *ptr) != '\0'; ++ptr) { 
    219219            switch (c) { 
    220220            case '#': 
     
    254254   @return A pointer to the new start of `path` 
    255255*/ 
    256 static const uint8_t* 
    257 remove_dot_segments(const uint8_t* path, size_t len, size_t* up) 
    258 { 
    259     const uint8_t*       begin = path; 
    260     const uint8_t* const end   = path + len; 
     256static const char* 
     257remove_dot_segments(const char* path, size_t len, size_t* up) 
     258{ 
     259    const char*       begin = path; 
     260    const char* const end   = path + len; 
    261261 
    262262    *up = 0; 
     
    318318merge(SerdChunk* base, SerdChunk* path) 
    319319{ 
    320     size_t         up; 
    321     const uint8_t* begin = remove_dot_segments(path->buf, path->len, &up); 
    322     const uint8_t* end   = path->buf + path->len; 
     320    size_t      up; 
     321    const char* begin = remove_dot_segments(path->buf, path->len, &up); 
     322    const char* end   = path->buf + path->len; 
    323323 
    324324    if (base->len) { 
    325325        // Find the up'th last slash 
    326         const uint8_t* base_last = (base->buf + base->len - 1); 
     326        const char* base_last = (base->buf + base->len - 1); 
    327327        ++up; 
    328328        do { 
  • src/writer.c

    r1379291 ra26622b  
    158158{ 
    159159    if (src) { 
    160         dst->buf = (uint8_t*)realloc((char*)dst->buf, src->n_bytes + 1); 
     160        dst->buf = (char*)realloc((char*)dst->buf, src->n_bytes + 1); 
    161161        dst->n_bytes = src->n_bytes; 
    162162        dst->flags   = src->flags; 
     
    219219 
    220220static size_t 
    221 write_uri(SerdWriter* writer, const uint8_t* utf8, size_t n_bytes) 
     221write_uri(SerdWriter* writer, const char* utf8, size_t n_bytes) 
    222222{ 
    223223    size_t len = 0; 
     
    238238        // Write UTF-8 character 
    239239        size_t size = 0; 
    240         len += write_character(writer, utf8 + i, &size); 
     240        len += write_character(writer, (const uint8_t*)utf8 + i, &size); 
    241241        i   += size; 
    242242        if (size == 0) { 
     
    250250 
    251251static bool 
    252 lname_must_escape(const uint8_t c) 
     252lname_must_escape(const char c) 
    253253{ 
    254254    /* This arbitrary list of characters, most of which have nothing to do with 
     
    271271 
    272272static size_t 
    273 write_lname(SerdWriter* writer, const uint8_t* utf8, size_t n_bytes) 
     273write_lname(SerdWriter* writer, const char* utf8, size_t n_bytes) 
    274274{ 
    275275    size_t len = 0; 
     
    297297static size_t 
    298298write_text(SerdWriter* writer, TextContext ctx, 
    299            const uint8_t* utf8, size_t n_bytes) 
     299           const char* utf8, size_t n_bytes) 
    300300{ 
    301301    size_t len = 0; 
     
    350350 
    351351        size_t size = 0; 
    352         len += write_character(writer, utf8 + i - 1, &size); 
     352        len += write_character(writer, (const uint8_t*)utf8 + i - 1, &size); 
     353 
    353354        if (size == 0) { 
    354355            // Corrupt input, write replacement char and scan to next start 
     
    365366uri_sink(const void* buf, size_t len, void* stream) 
    366367{ 
    367     return write_uri((SerdWriter*)stream, (const uint8_t*)buf, len); 
     368    return write_uri((SerdWriter*)stream, (const char*)buf, len); 
    368369} 
    369370 
     
    884885SERD_API 
    885886void 
    886 serd_writer_chop_blank_prefix(SerdWriter*    writer, 
    887                               const uint8_t* prefix) 
     887serd_writer_chop_blank_prefix(SerdWriter* writer, 
     888                              const char* prefix) 
    888889{ 
    889890    free(writer->bprefix); 
     
    998999 
    9991000SERD_API 
    1000 uint8_t* 
     1001char* 
    10011002serd_buffer_sink_finish(SerdBuffer* stream) 
    10021003{ 
    10031004    serd_buffer_sink("", 1, stream); 
    1004     return (uint8_t*)stream->buf; 
    1005 } 
     1005    return (char*)stream->buf; 
     1006} 
  • tests/serd_test.c

    r1379291 ra26622b  
    2323 
    2424#include "serd/serd.h" 
    25  
    26 #define USTR(s) ((const uint8_t*)(s)) 
    2725 
    2826#ifndef INFINITY 
     
    9997    } 
    10098 
    101     SerdNode node = serd_node_new_file_uri( 
    102         USTR(path), USTR(hostname), 0, escape); 
    103  
    104     uint8_t* out_hostname = NULL; 
    105     uint8_t* out_path     = serd_file_uri_parse(node.buf, &out_hostname); 
     99    SerdNode node         = serd_node_new_file_uri(path, hostname, 0, escape); 
     100    char*    out_hostname = NULL; 
     101    char*    out_path     = serd_file_uri_parse(node.buf, &out_hostname); 
    106102    int      ret          = 0; 
    107103    if (strcmp((const char*)node.buf, expected_uri)) { 
     
    166162        SerdNode   node = serd_node_new_decimal(dbl_test_nums[i], 8); 
    167163        const bool pass = (node.buf && dbl_test_strs[i]) 
    168             ? !strcmp((const char*)node.buf, (const char*)dbl_test_strs[i]) 
    169             : ((const char*)node.buf == dbl_test_strs[i]); 
     164            ? !strcmp(node.buf, dbl_test_strs[i]) 
     165            : (node.buf == dbl_test_strs[i]); 
    170166        if (!pass) { 
    171167            return failure("Serialised `%s' != %s\n", 
    172168                           node.buf, dbl_test_strs[i]); 
    173169        } 
    174         const size_t len = node.buf ? strlen((const char*)node.buf) : 0; 
     170        const size_t len = node.buf ? strlen(node.buf) : 0; 
    175171        if (node.n_bytes != len) { 
    176172            return failure("Length %zu != %zu\n", node.n_bytes, len); 
     
    191187    for (unsigned i = 0; i < sizeof(int_test_nums) / sizeof(double); ++i) { 
    192188        SerdNode node = serd_node_new_integer(int_test_nums[i]); 
    193         if (strcmp((const char*)node.buf, (const char*)int_test_strs[i])) { 
     189        if (strcmp(node.buf, int_test_strs[i])) { 
    194190            return failure("Serialised `%s' != %s\n", 
    195191                           node.buf, int_test_strs[i]); 
    196192        } 
    197         const size_t len = strlen((const char*)node.buf); 
     193        const size_t len = strlen(node.buf); 
    198194        if (node.n_bytes != len) { 
    199195            return failure("Length %zu != %zu\n", node.n_bytes, len); 
     
    234230 
    235231    SerdNodeFlags flags; 
    236     size_t        n_bytes = serd_strlen(str, &flags); 
     232    size_t        n_bytes = serd_strlen((const char*)str, &flags); 
    237233    if (n_bytes != 7 || flags != (SERD_HAS_QUOTE|SERD_HAS_NEWLINE)) { 
    238234        return failure("Bad serd_strlen(%s) n_bytes=%zu flags=%u\n", 
     
    242238    // Test serd_strerror 
    243239 
    244     const uint8_t* msg = NULL; 
    245     if (strcmp((const char*)(msg = serd_strerror(SERD_SUCCESS)), "Success")) { 
     240    const char* msg = NULL; 
     241    if (strcmp((msg = serd_strerror(SERD_SUCCESS)), "Success")) { 
    246242        return failure("Bad message `%s' for SERD_SUCCESS\n", msg); 
    247243    } 
    248244    for (int i = SERD_FAILURE; i <= SERD_ERR_INTERNAL; ++i) { 
    249245        msg = serd_strerror((SerdStatus)i); 
    250         if (!strcmp((const char*)msg, "Success")) { 
     246        if (!strcmp(msg, "Success")) { 
    251247            return failure("Bad message `%s' for (SerdStatus)%d\n", msg, i); 
    252248        } 
     
    256252    // Test serd_uri_to_path 
    257253 
    258     const uint8_t* uri = (const uint8_t*)"file:///home/user/foo.ttl"; 
    259     if (strcmp((const char*)serd_uri_to_path(uri), "/home/user/foo.ttl")) { 
     254    const char* uri = "file:///home/user/foo.ttl"; 
     255    if (strcmp(serd_uri_to_path(uri), "/home/user/foo.ttl")) { 
    260256        return failure("Bad path %s for %s\n", serd_uri_to_path(uri), uri); 
    261257    } 
    262     uri = (const uint8_t*)"file://localhost/home/user/foo.ttl"; 
    263     if (strcmp((const char*)serd_uri_to_path(uri), "/home/user/foo.ttl")) { 
     258    uri = "file://localhost/home/user/foo.ttl"; 
     259    if (strcmp(serd_uri_to_path(uri), "/home/user/foo.ttl")) { 
    264260        return failure("Bad path %s for %s\n", serd_uri_to_path(uri), uri); 
    265261    } 
    266     uri = (const uint8_t*)"file:illegal/file/uri"; 
     262    uri = "file:illegal/file/uri"; 
    267263    if (serd_uri_to_path(uri)) { 
    268264        return failure("Converted invalid URI `%s' to path `%s'\n", 
    269265                uri, serd_uri_to_path(uri)); 
    270266    } 
    271     uri = (const uint8_t*)"file:///c:/awful/system"; 
    272     if (strcmp((const char*)serd_uri_to_path(uri), "c:/awful/system")) { 
     267    uri = "file:///c:/awful/system"; 
     268    if (strcmp(serd_uri_to_path(uri), "c:/awful/system")) { 
    273269        return failure("Bad path %s for %s\n", serd_uri_to_path(uri), uri); 
    274270    } 
    275     uri = (const uint8_t*)"file:///c:awful/system"; 
    276     if (strcmp((const char*)serd_uri_to_path(uri), "/c:awful/system")) { 
     271    uri = "file:///c:awful/system"; 
     272    if (strcmp(serd_uri_to_path(uri), "/c:awful/system")) { 
    277273        return failure("Bad path %s for %s\n", serd_uri_to_path(uri), uri); 
    278274    } 
    279     uri = (const uint8_t*)"file:///0/1"; 
    280     if (strcmp((const char*)serd_uri_to_path(uri), "/0/1")) { 
     275    uri = "file:///0/1"; 
     276    if (strcmp(serd_uri_to_path(uri), "/0/1")) { 
    281277        return failure("Bad path %s for %s\n", serd_uri_to_path(uri), uri); 
    282278    } 
    283     uri = (const uint8_t*)"C:\\Windows\\Sucks"; 
    284     if (strcmp((const char*)serd_uri_to_path(uri), "C:\\Windows\\Sucks")) { 
     279    uri = "C:\\Windows\\Sucks"; 
     280    if (strcmp(serd_uri_to_path(uri), "C:\\Windows\\Sucks")) { 
    285281        return failure("Bad path %s for %s\n", serd_uri_to_path(uri), uri); 
    286282    } 
    287     uri = (const uint8_t*)"C|/Windows/Sucks"; 
    288     if (strcmp((const char*)serd_uri_to_path(uri), "C|/Windows/Sucks")) { 
     283    uri = "C|/Windows/Sucks"; 
     284    if (strcmp(serd_uri_to_path(uri), "C|/Windows/Sucks")) { 
    289285        return failure("Bad path %s for %s\n", serd_uri_to_path(uri), uri); 
    290286    } 
     
    308304    } 
    309305 
    310     // Test tolerance of parsing junk URI escapes 
    311  
    312     uint8_t* out_path = serd_file_uri_parse(USTR("file:///foo/%0Xbar"), NULL); 
    313     if (strcmp((const char*)out_path, "/foo/bar")) { 
     306    char* out_path = serd_file_uri_parse("file://host/foo/%0Xbar", NULL); 
     307    if (strcmp(out_path, "/foo/bar")) { 
    314308        return failure("bad tolerance of junk escape: `%s'\n", out_path); 
    315309    } 
     
    319313 
    320314    const uint8_t replacement_char_str[] = { 0xEF, 0xBF, 0xBD, 0 }; 
    321     SerdNode lhs = serd_node_from_string(SERD_LITERAL, replacement_char_str); 
    322     SerdNode rhs = serd_node_from_string(SERD_LITERAL, USTR("123")); 
     315    SerdNode lhs = serd_node_from_string(SERD_LITERAL, (const char*)replacement_char_str); 
     316    SerdNode rhs = serd_node_from_string(SERD_LITERAL, "123"); 
    323317    if (serd_node_equals(&lhs, &rhs)) { 
    324318        return failure("%s == %s\n", lhs.buf, rhs.buf); 
    325319    } 
    326320 
    327     SerdNode qnode = serd_node_from_string(SERD_CURIE, USTR("foo:bar")); 
     321    SerdNode qnode = serd_node_from_string(SERD_CURIE, "foo:bar"); 
    328322    if (serd_node_equals(&lhs, &qnode)) { 
    329323        return failure("%s == %s\n", lhs.buf, qnode.buf); 
     
    341335    // Test serd_node_from_string 
    342336 
    343     SerdNode node = serd_node_from_string(SERD_LITERAL, (const uint8_t*)"hello\""); 
     337    SerdNode node = serd_node_from_string(SERD_LITERAL, "hello\""); 
    344338    if (node.n_bytes != 6 || node.flags != SERD_HAS_QUOTE 
    345         || strcmp((const char*)node.buf, "hello\"")) { 
     339        || strcmp(node.buf, "hello\"")) { 
    346340        return failure("Bad node %s %zu %d %d\n", 
    347341                node.buf, node.n_bytes, node.flags, node.type); 
     
    360354    } 
    361355 
    362     SerdNode a_b = serd_node_from_substring(SERD_LITERAL, USTR("a\"bc"), 3); 
     356    SerdNode a_b = serd_node_from_substring(SERD_LITERAL, "a\"bc", 3); 
    363357    if (a_b.n_bytes != 3 || a_b.flags != SERD_HAS_QUOTE 
    364358        || strncmp((const char*)a_b.buf, "a\"b", 3)) { 
     
    367361    } 
    368362 
    369     a_b = serd_node_from_substring(SERD_LITERAL, USTR("a\"bc"), 10); 
     363    a_b = serd_node_from_substring(SERD_LITERAL, "a\"bc", 10); 
    370364    if (a_b.n_bytes != 4 || a_b.flags != SERD_HAS_QUOTE 
    371365        || strncmp((const char*)a_b.buf, "a\"bc", 4)) { 
     
    382376 
    383377    SerdURI base_uri; 
    384     SerdNode base = serd_node_new_uri_from_string(USTR("http://example.org/"), 
     378    SerdNode base = serd_node_new_uri_from_string("http://example.org/", 
    385379                                                  NULL, &base_uri); 
    386380    SerdNode nil = serd_node_new_uri_from_string(NULL, &base_uri, NULL); 
    387     SerdNode nil2 = serd_node_new_uri_from_string(USTR(""), &base_uri, NULL); 
    388     if (nil.type != SERD_URI || strcmp((const char*)nil.buf, (const char*)base.buf) || 
    389         nil2.type != SERD_URI || strcmp((const char*)nil2.buf, (const char*)base.buf)) { 
     381    SerdNode nil2 = serd_node_new_uri_from_string("", &base_uri, NULL); 
     382    if (nil.type != SERD_URI || strcmp(nil.buf, base.buf) || 
     383        nil2.type != SERD_URI || strcmp(nil2.buf, base.buf)) { 
    390384        return failure("URI %s != base %s\n", nil.buf, base.buf); 
    391385    } 
     
    394388 
    395389    // Test serd_node_new_relative_uri 
    396     SerdNode abs = serd_node_from_string(SERD_URI, USTR("http://example.org/foo/bar")); 
     390    SerdNode abs = serd_node_from_string(SERD_URI, "http://example.org/foo/bar"); 
    397391    SerdURI  abs_uri; 
    398392    serd_uri_parse(abs.buf, &abs_uri); 
     
    409403    // Test SerdEnv 
    410404 
    411     SerdNode u   = serd_node_from_string(SERD_URI, USTR("http://example.org/foo")); 
    412     SerdNode b   = serd_node_from_string(SERD_CURIE, USTR("invalid")); 
    413     SerdNode c   = serd_node_from_string(SERD_CURIE, USTR("eg.2:b")); 
     405    SerdNode u   = serd_node_from_string(SERD_URI, "http://example.org/foo"); 
     406    SerdNode b   = serd_node_from_string(SERD_CURIE, "invalid"); 
     407    SerdNode c   = serd_node_from_string(SERD_CURIE, "eg.2:b"); 
    414408    SerdEnv* env = serd_env_new(NULL); 
    415     serd_env_set_prefix_from_strings(env, USTR("eg.2"), USTR("http://example.org/")); 
     409    serd_env_set_prefix_from_strings(env, "eg.2", "http://example.org/"); 
    416410 
    417411    if (!serd_env_set_base_uri(env, NULL)) { 
     
    438432 
    439433    SerdNode xu = serd_env_expand_node(env, &u); 
    440     if (strcmp((const char*)xu.buf, "http://example.org/foo")) { 
     434    if (strcmp(xu.buf, "http://example.org/foo")) { 
    441435        return failure("Expanded %s to %s\n", c.buf, xu.buf); 
    442436    } 
    443437    serd_node_free(&xu); 
    444438 
    445     SerdNode badpre = serd_node_from_string(SERD_CURIE, USTR("hm:what")); 
     439    SerdNode badpre = serd_node_from_string(SERD_CURIE, "hm:what"); 
    446440    SerdNode xbadpre = serd_env_expand_node(env, &badpre); 
    447441    if (!serd_node_equals(&xbadpre, &SERD_NODE_NULL)) { 
     
    450444 
    451445    SerdNode xc = serd_env_expand_node(env, &c); 
    452     if (strcmp((const char*)xc.buf, "http://example.org/b")) { 
     446    if (strcmp(xc.buf, "http://example.org/b")) { 
    453447        return failure("Expanded %s to %s\n", c.buf, xc.buf); 
    454448    } 
     
    459453    } 
    460454 
    461     const SerdNode lit = serd_node_from_string(SERD_LITERAL, USTR("hello")); 
     455    const SerdNode lit = serd_node_from_string(SERD_LITERAL, "hello"); 
    462456    if (!serd_env_set_prefix(env, &b, &lit)) { 
    463457        return failure("Set prefix to literal\n"); 
     
    465459 
    466460    int n_prefixes = 0; 
    467     serd_env_set_prefix_from_strings(env, USTR("eg.2"), USTR("http://example.org/")); 
     461    serd_env_set_prefix_from_strings(env, "eg.2", "http://example.org/"); 
    468462    serd_env_foreach(env, count_prefixes, &n_prefixes); 
    469463    if (n_prefixes != 1) { 
     
    471465    } 
    472466 
    473     SerdNode shorter_uri = serd_node_from_string(SERD_URI, USTR("urn:foo")); 
     467    SerdNode shorter_uri = serd_node_from_string(SERD_URI, "urn:foo"); 
    474468    SerdNode prefix_name; 
    475469    if (serd_env_qualify(env, &shorter_uri, &prefix_name, &suffix)) { 
     
    491485    } 
    492486 
    493     serd_writer_chop_blank_prefix(writer, USTR("tmp")); 
     487    serd_writer_chop_blank_prefix(writer, "tmp"); 
    494488    serd_writer_chop_blank_prefix(writer, NULL); 
    495489 
     
    504498    } 
    505499 
    506     uint8_t buf[] = { 0x80, 0, 0, 0, 0 }; 
    507     SerdNode s = serd_node_from_string(SERD_URI, USTR("")); 
    508     SerdNode p = serd_node_from_string(SERD_URI, USTR("http://example.org/pred")); 
    509     SerdNode o = serd_node_from_string(SERD_LITERAL, buf); 
     500    uint8_t buf[] = { 0xEF, 0xBF, 0xBD, 0 }; 
     501    SerdNode s = serd_node_from_string(SERD_URI, ""); 
     502    SerdNode p = serd_node_from_string(SERD_URI, "http://example.org/pred"); 
     503    SerdNode o = serd_node_from_string(SERD_LITERAL, (char*)buf); 
    510504 
    511505    // Write 3 invalid statements (should write nothing) 
     
    528522    } 
    529523 
    530     const SerdNode t = serd_node_from_string(SERD_URI, USTR("urn:Type")); 
    531     const SerdNode l = serd_node_from_string(SERD_LITERAL, USTR("en")); 
     524    const SerdNode t = serd_node_from_string(SERD_URI, "urn:Type"); 
     525    const SerdNode l = serd_node_from_string(SERD_LITERAL, "en"); 
    532526    const SerdNode* good[][5] = { { &s, &p, &o, NULL, NULL }, 
    533527                                  { &s, &p, &o, &SERD_NODE_NULL, &SERD_NODE_NULL }, 
     
    549543 
    550544    // Write statements with bad UTF-8 (should be replaced) 
    551     const uint8_t bad_str[] = { 0xFF, 0x90, 'h', 'i', 0 }; 
    552     SerdNode      bad_lit   = serd_node_from_string(SERD_LITERAL, bad_str); 
    553     SerdNode      bad_uri   = serd_node_from_string(SERD_URI, bad_str); 
     545    const char bad_str[] = { (char)0xFF, (char)0x90, 'h', 'i', 0 }; 
     546    SerdNode   bad_lit   = serd_node_from_string(SERD_LITERAL, bad_str); 
     547    SerdNode   bad_uri   = serd_node_from_string(SERD_URI, bad_str); 
    554548    if (serd_writer_write_statement(writer, 0, NULL, 
    555549                                    &s, &p, &bad_lit, NULL, NULL)) { 
     
    561555 
    562556    // Write 1 valid statement 
    563     o = serd_node_from_string(SERD_LITERAL, USTR("hello")); 
     557    o = serd_node_from_string(SERD_LITERAL, "hello"); 
    564558    if (serd_writer_write_statement(writer, 0, NULL, 
    565559                                    &s, &p, &o, NULL, NULL)) { 
     
    574568        SERD_TURTLE, (SerdStyle)0, env, NULL, serd_buffer_sink, &buffer); 
    575569 
    576     o = serd_node_from_string(SERD_URI, USTR("http://example.org/base")); 
     570    o = serd_node_from_string(SERD_URI, "http://example.org/base"); 
    577571    if (serd_writer_set_base_uri(writer, &o)) { 
    578572        return failure("Failed to write to chunk sink\n"); 
     
    580574 
    581575    serd_writer_free(writer); 
    582     uint8_t* out = serd_buffer_sink_finish(&buffer); 
    583  
    584     if (strcmp((const char*)out, "@base <http://example.org/base> .\n")) { 
     576    char* out = serd_buffer_sink_finish(&buffer); 
     577 
     578    if (strcmp(out, "@base <http://example.org/base> .\n")) { 
    585579        return failure("Incorrect buffer output:\n%s\n", buffer.buf); 
    586580    } 
     
    602596    } 
    603597 
    604     SerdNode g = serd_node_from_string(SERD_URI, USTR("http://example.org/")); 
     598    SerdNode g = serd_node_from_string(SERD_URI, "http://example.org/"); 
    605599    serd_reader_set_default_graph(reader, &g); 
    606     serd_reader_add_blank_prefix(reader, USTR("tmp")); 
     600    serd_reader_add_blank_prefix(reader, "tmp"); 
    607601    serd_reader_add_blank_prefix(reader, NULL); 
    608602 
    609     if (!serd_reader_read_file(reader, USTR("http://notafile"))) { 
     603    if (!serd_reader_read_file(reader, "http://notafile")) { 
    610604        return failure("Apparently read an http URI\n"); 
    611     } else if (!serd_reader_read_file(reader, USTR("file:///better/not/exist"))) { 
     605    } else if (!serd_reader_read_file(reader, "file:///better/not/exist")) { 
    612606        return failure("Apparently read a non-existent file\n"); 
    613     } else if (!serd_reader_read_file(reader, USTR("file://"))) { 
     607    } else if (!serd_reader_read_file(reader, "file://")) { 
    614608        return failure("Apparently read a file with no path\n"); 
    615609    } 
    616610 
    617     const SerdStatus st = serd_reader_read_file(reader, USTR(path)); 
     611    const SerdStatus st = serd_reader_read_file(reader, path); 
    618612    if (st) { 
    619613        return failure("Error reading file (%s)\n", serd_strerror(st)); 
     
    621615        return failure("Bad statement count %d\n", rt->n_statements); 
    622616    } else if (!rt->graph || !rt->graph->buf || 
    623                strcmp((const char*)rt->graph->buf, "http://example.org/")) { 
     617               strcmp(rt->graph->buf, "http://example.org/")) { 
    624618        return failure("Bad graph %p\n", rt->graph); 
    625619    } 
    626620 
    627     if (!serd_reader_read_string(reader, USTR("This isn't Turtle at all."))) { 
     621    if (!serd_reader_read_string(reader, "This isn't Turtle at all.")) { 
    628622        return failure("Parsed invalid string successfully.\n"); 
    629623    } 
Note: See TracChangeset for help on using the changeset viewer.