c2html: changeset 61:47a5fc33590a

     1.1 --- a/Makefile	Thu Nov 10 18:44:48 2016 +0100
     1.2 +++ b/Makefile	Mon Nov 13 13:52:00 2017 +0100
     1.3 @@ -34,11 +34,6 @@
     1.4  SRC  = frontend.c
     1.5  SRC += c2html.c
     1.6  SRC += highlighter.c
     1.7 -SRC += ucx/allocator.c
     1.8 -SRC += ucx/buffer.c
     1.9 -SRC += ucx/list.c
    1.10 -SRC += ucx/string.c
    1.11 -SRC += ucx/utils.c
    1.12  
    1.13  OBJ = $(SRC:%.c=build/%$(OBJ_EXT))
    1.14

     2.1 --- a/clang.mk	Thu Nov 10 18:44:48 2016 +0100
     2.2 +++ b/clang.mk	Mon Nov 13 13:52:00 2017 +0100
     2.3 @@ -36,5 +36,5 @@
     2.4  CC      = clang
     2.5  CFLAGS  = -O2
     2.6  LD      = clang
     2.7 -LDFLAGS =
     2.8 +LDFLAGS = -lucx
     2.9  OBJ_EXT = .o

     3.1 --- a/gcc.mk	Thu Nov 10 18:44:48 2016 +0100
     3.2 +++ b/gcc.mk	Mon Nov 13 13:52:00 2017 +0100
     3.3 @@ -36,5 +36,5 @@
     3.4  CC      = gcc
     3.5  CFLAGS  = -O2 -std=gnu99
     3.6  LD      = gcc
     3.7 -LDFLAGS =
     3.8 +LDFLAGS = -lucx
     3.9  OBJ_EXT = .o

     4.1 --- a/src/c2html.c	Thu Nov 10 18:44:48 2016 +0100
     4.2 +++ b/src/c2html.c	Mon Nov 13 13:52:00 2017 +0100
     4.3 @@ -29,8 +29,8 @@
     4.4  
     4.5  #include "c2html.h"
     4.6  
     4.7 -#include "ucx/list.h"
     4.8 -#include "ucx/utils.h"
     4.9 +#include <ucx/list.h>
    4.10 +#include <ucx/utils.h>
    4.11  
    4.12  #define try_write(wfnc, str, n, buf, written, maxlen) \
    4.13      {                                              \
    4.14 @@ -99,8 +99,8 @@
    4.15          size_t maxlen, c2html_highlighter_func hltr, int showln) {
    4.16      
    4.17      UcxBuffer *content = ucx_buffer_new(NULL, ibuflen*2, UCX_BUFFER_AUTOEXTEND);
    4.18 -    ucx_stream_copy(inputbuffer, content, rfnc, (write_func) ucx_buffer_write,
    4.19 -            ibuf, ibuflen, (size_t)-1);
    4.20 +    ucx_stream_bcopy(inputbuffer, content, rfnc, (write_func) ucx_buffer_write,
    4.21 +            ibuf, ibuflen);
    4.22  
    4.23      size_t n = c2html_bformatn(content->space, content->size,
    4.24              outputbuffer, wfnc, maxlen, hltr, showln);

     5.1 --- a/src/frontend.c	Thu Nov 10 18:44:48 2016 +0100
     5.2 +++ b/src/frontend.c	Mon Nov 13 13:52:00 2017 +0100
     5.3 @@ -33,7 +33,7 @@
     5.4  #include <string.h>
     5.5  
     5.6  #include "c2html.h"
     5.7 -#include "ucx/utils.h"
     5.8 +#include <ucx/utils.h>
     5.9  
    5.10  #define FILEBUF_SIZE 4096
    5.11  
    5.12 @@ -55,7 +55,7 @@
    5.13          }
    5.14          return 1;
    5.15      }
    5.16 -    ucx_stream_copy(headerfile, fout,
    5.17 +    ucx_stream_bncopy(headerfile, fout,
    5.18              (read_func) fread, (write_func) fwrite,
    5.19              copybuf, copybuflen, (size_t)-1);
    5.20      fclose(headerfile);

     6.1 --- a/src/highlighter.c	Thu Nov 10 18:44:48 2016 +0100
     6.2 +++ b/src/highlighter.c	Mon Nov 13 13:52:00 2017 +0100
     6.3 @@ -33,8 +33,8 @@
     6.4  #include <stdio.h>
     6.5  #include <string.h>
     6.6  #include <ctype.h>
     6.7 -#include "ucx/string.h"
     6.8 -#include "ucx/utils.h"
     6.9 +#include <ucx/string.h>
    6.10 +#include <ucx/utils.h>
    6.11  
    6.12  static void put_htmlescaped(UcxBuffer *dest, char c) {
    6.13      if (c == '>') {

     7.1 --- a/src/highlighter.h	Thu Nov 10 18:44:48 2016 +0100
     7.2 +++ b/src/highlighter.h	Mon Nov 13 13:52:00 2017 +0100
     7.3 @@ -30,7 +30,7 @@
     7.4  #ifndef C2HTML_HIGHLIGHTER_H
     7.5  #define C2HTML_HIGHLIGHTER_H
     7.6  
     7.7 -#include "ucx/buffer.h"
     7.8 +#include <ucx/buffer.h>
     7.9  
    7.10  #ifdef __cplusplus
    7.11  extern "C" {

     8.1 --- a/src/ucx/allocator.c	Thu Nov 10 18:44:48 2016 +0100
     8.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.3 @@ -1,59 +0,0 @@
     8.4 -/*
     8.5 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
     8.6 - *
     8.7 - * Copyright 2015 Olaf Wintermann. All rights reserved.
     8.8 - *
     8.9 - * Redistribution and use in source and binary forms, with or without
    8.10 - * modification, are permitted provided that the following conditions are met:
    8.11 - *
    8.12 - *   1. Redistributions of source code must retain the above copyright
    8.13 - *      notice, this list of conditions and the following disclaimer.
    8.14 - *
    8.15 - *   2. Redistributions in binary form must reproduce the above copyright
    8.16 - *      notice, this list of conditions and the following disclaimer in the
    8.17 - *      documentation and/or other materials provided with the distribution.
    8.18 - *
    8.19 - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    8.20 - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    8.21 - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    8.22 - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
    8.23 - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    8.24 - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    8.25 - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    8.26 - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    8.27 - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    8.28 - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    8.29 - * POSSIBILITY OF SUCH DAMAGE.
    8.30 - */
    8.31 -
    8.32 -#include <stdlib.h>
    8.33 -#include "allocator.h"
    8.34 -
    8.35 -UcxAllocator default_allocator = {
    8.36 -    NULL,
    8.37 -    ucx_default_malloc,
    8.38 -    ucx_default_calloc,
    8.39 -    ucx_default_realloc,
    8.40 -    ucx_default_free
    8.41 -};
    8.42 -
    8.43 -UcxAllocator *ucx_default_allocator() {
    8.44 -    UcxAllocator *allocator = &default_allocator;
    8.45 -    return allocator;
    8.46 -}
    8.47 -
    8.48 -void *ucx_default_malloc(void *ignore, size_t n) {
    8.49 -    return malloc(n);
    8.50 -}
    8.51 -
    8.52 -void *ucx_default_calloc(void *ignore, size_t n, size_t size) {
    8.53 -    return calloc(n, size);
    8.54 -}
    8.55 -
    8.56 -void *ucx_default_realloc(void *ignore, void *data, size_t n) {
    8.57 -    return realloc(data, n);
    8.58 -}
    8.59 -
    8.60 -void ucx_default_free(void *ignore, void *data) {
    8.61 -    free(data);
    8.62 -}

     9.1 --- a/src/ucx/allocator.h	Thu Nov 10 18:44:48 2016 +0100
     9.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     9.3 @@ -1,206 +0,0 @@
     9.4 -/*
     9.5 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
     9.6 - *
     9.7 - * Copyright 2015 Olaf Wintermann. All rights reserved.
     9.8 - *
     9.9 - * Redistribution and use in source and binary forms, with or without
    9.10 - * modification, are permitted provided that the following conditions are met:
    9.11 - *
    9.12 - *   1. Redistributions of source code must retain the above copyright
    9.13 - *      notice, this list of conditions and the following disclaimer.
    9.14 - *
    9.15 - *   2. Redistributions in binary form must reproduce the above copyright
    9.16 - *      notice, this list of conditions and the following disclaimer in the
    9.17 - *      documentation and/or other materials provided with the distribution.
    9.18 - *
    9.19 - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    9.20 - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    9.21 - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    9.22 - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
    9.23 - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    9.24 - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    9.25 - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    9.26 - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    9.27 - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    9.28 - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    9.29 - * POSSIBILITY OF SUCH DAMAGE.
    9.30 - */
    9.31 -/**
    9.32 - * Allocator for custom memory management.
    9.33 - * 
    9.34 - * An UCX allocator consists of a pointer to the memory area / pool and four
    9.35 - * function pointers to memory management functions operating on this memory
    9.36 - * area / pool. These functions shall behave equivalent to the standard libc
    9.37 - * functions <code>malloc(), calloc(), realloc()</code> and <code>free()</code>.
    9.38 - * 
    9.39 - * The signature of the memory management functions is based on the signature
    9.40 - * of the respective libc function but each of them takes the pointer to the
    9.41 - * memory area / pool as first argument.
    9.42 - * 
    9.43 - * As the pointer to the memory area / pool can be arbitrarily chosen, any data
    9.44 - * can be provided to the memory management functions. An UcxMempool is just
    9.45 - * one example.
    9.46 - * 
    9.47 - * @see mempool.h
    9.48 - * @see UcxMap
    9.49 - * 
    9.50 - * @file   allocator.h
    9.51 - * @author Mike Becker
    9.52 - * @author Olaf Wintermann
    9.53 - */
    9.54 -
    9.55 -#ifndef UCX_ALLOCATOR_H
    9.56 -#define	UCX_ALLOCATOR_H
    9.57 -
    9.58 -#include "ucx.h"
    9.59 -
    9.60 -#ifdef	__cplusplus
    9.61 -extern "C" {
    9.62 -#endif
    9.63 -
    9.64 -/**
    9.65 - * A function pointer to the allocators <code>malloc()</code> function.
    9.66 - * @see UcxAllocator
    9.67 - */
    9.68 -typedef void*(*ucx_allocator_malloc)(void *pool, size_t n);
    9.69 -
    9.70 -/**
    9.71 - * A function pointer to the allocators <code>calloc()</code> function.
    9.72 - * @see UcxAllocator
    9.73 - */
    9.74 -typedef void*(*ucx_allocator_calloc)(void *pool, size_t n, size_t size);
    9.75 -
    9.76 -/**
    9.77 - * A function pointer to the allocators <code>realloc()</code> function.
    9.78 - * @see UcxAllocator
    9.79 - */
    9.80 -typedef void*(*ucx_allocator_realloc)(void *pool, void *data, size_t n);
    9.81 -
    9.82 -/**
    9.83 - * A function pointer to the allocators <code>free()</code> function.
    9.84 - * @see UcxAllocator
    9.85 - */
    9.86 -typedef void(*ucx_allocator_free)(void *pool, void *data);
    9.87 -
    9.88 -/**
    9.89 - * UCX allocator data structure containing memory management functions.
    9.90 - */
    9.91 -typedef struct {
    9.92 -    /** Pointer to an area of memory or a complex memory pool.
    9.93 -     * This pointer will be passed to any memory management function as first
    9.94 -     * argument.
    9.95 -     */
    9.96 -    void *pool;
    9.97 -    /**
    9.98 -     * The <code>malloc()</code> function for this allocator.
    9.99 -     */
   9.100 -    ucx_allocator_malloc  malloc;
   9.101 -    /**
   9.102 -     * The <code>calloc()</code> function for this allocator.
   9.103 -     */
   9.104 -    ucx_allocator_calloc  calloc;
   9.105 -    /**
   9.106 -     * The <code>realloc()</code> function for this allocator.
   9.107 -     */
   9.108 -    ucx_allocator_realloc realloc;
   9.109 -    /**
   9.110 -     * The <code>free()</code> function for this allocator.
   9.111 -     */
   9.112 -    ucx_allocator_free    free;
   9.113 -} UcxAllocator;
   9.114 -
   9.115 -/**
   9.116 - * Returns a pointer to the default allocator.
   9.117 - * 
   9.118 - * The default allocator contains wrappers to the standard libc memory
   9.119 - * management functions. Use this function to get a pointer to a globally
   9.120 - * available allocator. You may also define an own UcxAllocator by assigning
   9.121 - * #UCX_ALLOCATOR_DEFAULT to a variable and pass the address of this variable
   9.122 - * to any function that takes an UcxAllocator as argument. Note that using
   9.123 - * this function is the recommended way of passing a default allocator, thus
   9.124 - * it never runs out of scope.
   9.125 - * 
   9.126 - * @return a pointer to the default allocator
   9.127 - * 
   9.128 - * @see UCX_ALLOCATOR_DEFAULT
   9.129 - */
   9.130 -UcxAllocator *ucx_default_allocator();
   9.131 -
   9.132 -/**
   9.133 - * A wrapper for the standard libc <code>malloc()</code> function.
   9.134 - * @param ignore ignored (may be used by allocators for pooled memory)
   9.135 - * @param n argument passed to <code>malloc()</code>
   9.136 - * @return return value of <code>malloc()</code>
   9.137 - */
   9.138 -void *ucx_default_malloc(void *ignore, size_t n);
   9.139 -/**
   9.140 - * A wrapper for the standard libc <code>calloc()</code> function.
   9.141 - * @param ignore ignored (may be used by allocators for pooled memory)
   9.142 - * @param n argument passed to <code>calloc()</code>
   9.143 - * @param size  argument passed to <code>calloc()</code>
   9.144 - * @return return value of <code>calloc()</code>
   9.145 - */
   9.146 -void *ucx_default_calloc(void *ignore, size_t n, size_t size);
   9.147 -/**
   9.148 - * A wrapper for the standard libc <code>realloc()</code> function.
   9.149 - * @param ignore ignored (may be used by allocators for pooled memory)
   9.150 - * @param data argumend passed to <code>realloc()</code>
   9.151 - * @param n argument passed to <code>realloc()</code>
   9.152 - * @return return value of <code>realloc()</code>
   9.153 - */
   9.154 -void *ucx_default_realloc(void *ignore, void *data, size_t n);
   9.155 -/**
   9.156 - * A wrapper for the standard libc <code>free()</code> function.
   9.157 - * @param ignore ignored (may be used by allocators for pooled memory)
   9.158 - * @param data argument passed to <code>free()</code>
   9.159 - */
   9.160 -void ucx_default_free(void *ignore, void *data);
   9.161 -
   9.162 -/**
   9.163 - * Shorthand for calling an allocators malloc function.
   9.164 - * @param allocator the allocator to use
   9.165 - * @param n size of space to allocate
   9.166 - * @return a pointer to the allocated memory area
   9.167 - */
   9.168 -#define almalloc(allocator, n) ((allocator)->malloc((allocator)->pool, n))
   9.169 -
   9.170 -/**
   9.171 - * Shorthand for calling an allocators calloc function.
   9.172 - * @param allocator the allocator to use
   9.173 - * @param n the count of elements the space should be allocated for
   9.174 - * @param size the size of each element
   9.175 - * @return a pointer to the allocated memory area
   9.176 - */
   9.177 -#define alcalloc(allocator, n, size) \
   9.178 -        ((allocator)->calloc((allocator)->pool, n, size))
   9.179 -
   9.180 -/**
   9.181 - * Shorthand for calling an allocators realloc function.
   9.182 - * @param allocator the allocator to use
   9.183 - * @param ptr the pointer to the memory area that shall be reallocated
   9.184 - * @param n the new size of the allocated memory area
   9.185 - * @return a pointer to the reallocated memory area
   9.186 - */
   9.187 -#define alrealloc(allocator, ptr, n) \
   9.188 -        ((allocator)->realloc((allocator)->pool, ptr, n))
   9.189 -
   9.190 -/**
   9.191 - * Shorthand for calling an allocators free function.
   9.192 - * @param allocator the allocator to use
   9.193 - * @param ptr the pointer to the memory area that shall be freed
   9.194 - */
   9.195 -#define alfree(allocator, ptr) ((allocator)->free((allocator)->pool, ptr))
   9.196 -
   9.197 -/**
   9.198 - * Convenient macro for a default allocator <code>struct</code> definition.
   9.199 - */
   9.200 -#define UCX_ALLOCATOR_DEFAULT {NULL, \
   9.201 -        ucx_default_malloc, ucx_default_calloc, ucx_default_realloc, \
   9.202 -        ucx_default_free }
   9.203 -
   9.204 -#ifdef	__cplusplus
   9.205 -}
   9.206 -#endif
   9.207 -
   9.208 -#endif	/* UCX_ALLOCATOR_H */
   9.209 -

    10.1 --- a/src/ucx/buffer.c	Thu Nov 10 18:44:48 2016 +0100
    10.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    10.3 @@ -1,234 +0,0 @@
    10.4 -/*
    10.5 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
    10.6 - *
    10.7 - * Copyright 2015 Olaf Wintermann. All rights reserved.
    10.8 - *
    10.9 - * Redistribution and use in source and binary forms, with or without
   10.10 - * modification, are permitted provided that the following conditions are met:
   10.11 - *
   10.12 - *   1. Redistributions of source code must retain the above copyright
   10.13 - *      notice, this list of conditions and the following disclaimer.
   10.14 - *
   10.15 - *   2. Redistributions in binary form must reproduce the above copyright
   10.16 - *      notice, this list of conditions and the following disclaimer in the
   10.17 - *      documentation and/or other materials provided with the distribution.
   10.18 - *
   10.19 - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   10.20 - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   10.21 - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   10.22 - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
   10.23 - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   10.24 - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   10.25 - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   10.26 - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   10.27 - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   10.28 - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   10.29 - * POSSIBILITY OF SUCH DAMAGE.
   10.30 - */
   10.31 -
   10.32 -#include "buffer.h"
   10.33 -#include <stdarg.h>
   10.34 -#include <stdlib.h>
   10.35 -#include <string.h>
   10.36 -
   10.37 -UcxBuffer *ucx_buffer_new(void *space, size_t capacity, int flags) {
   10.38 -    UcxBuffer *buffer = (UcxBuffer*) malloc(sizeof(UcxBuffer));
   10.39 -    if (buffer) {
   10.40 -        buffer->flags = flags;
   10.41 -        if (!space) {
   10.42 -            buffer->space = (char*)malloc(capacity);
   10.43 -            if (!buffer->space) {
   10.44 -                free(buffer);
   10.45 -                return NULL;
   10.46 -            }
   10.47 -            memset(buffer->space, 0, capacity);
   10.48 -            buffer->flags |= UCX_BUFFER_AUTOFREE;
   10.49 -        } else {
   10.50 -            buffer->space = (char*)space;
   10.51 -        }
   10.52 -        buffer->capacity = capacity;
   10.53 -        buffer->size = 0;
   10.54 -
   10.55 -        buffer->pos = 0;
   10.56 -    }
   10.57 -
   10.58 -    return buffer;
   10.59 -}
   10.60 -
   10.61 -void ucx_buffer_free(UcxBuffer *buffer) {
   10.62 -    if ((buffer->flags & UCX_BUFFER_AUTOFREE) == UCX_BUFFER_AUTOFREE) {
   10.63 -        free(buffer->space);
   10.64 -    }
   10.65 -    free(buffer);
   10.66 -}
   10.67 -
   10.68 -UcxBuffer* ucx_buffer_extract(
   10.69 -        UcxBuffer *src, size_t start, size_t length, int flags) {
   10.70 -    
   10.71 -    if (src->size == 0 || length == 0 || start+length > src->capacity) {
   10.72 -        return NULL;
   10.73 -    }
   10.74 -
   10.75 -    UcxBuffer *dst = (UcxBuffer*) malloc(sizeof(UcxBuffer));
   10.76 -    if (dst) {
   10.77 -        dst->space = (char*)malloc(length);
   10.78 -        if (!dst->space) {
   10.79 -            free(dst);
   10.80 -            return NULL;
   10.81 -        }
   10.82 -        dst->capacity = length;
   10.83 -        dst->size = length;
   10.84 -        dst->flags = flags | UCX_BUFFER_AUTOFREE;
   10.85 -        dst->pos = 0;
   10.86 -        memcpy(dst->space, src->space+start, length);
   10.87 -    }
   10.88 -    return dst;
   10.89 -}
   10.90 -
   10.91 -int ucx_buffer_seek(UcxBuffer *buffer, off_t offset, int whence) {
   10.92 -    size_t npos;
   10.93 -    switch (whence) {
   10.94 -    case SEEK_CUR:
   10.95 -        npos = buffer->pos;
   10.96 -        break;
   10.97 -    case SEEK_END:
   10.98 -        npos = buffer->size;
   10.99 -        break;
  10.100 -    case SEEK_SET:
  10.101 -        npos = 0;
  10.102 -        break;
  10.103 -    default:
  10.104 -        return -1;
  10.105 -    }
  10.106 -
  10.107 -    size_t opos = npos;
  10.108 -    npos += offset;
  10.109 -    
  10.110 -    if ((offset > 0 && npos < opos) || (offset < 0 && npos > opos)) {
  10.111 -        return -1;
  10.112 -    }
  10.113 -    
  10.114 -    if (npos >= buffer->size) {
  10.115 -        return -1;
  10.116 -    } else {
  10.117 -        buffer->pos = npos;
  10.118 -        return 0;
  10.119 -    }
  10.120 -
  10.121 -}
  10.122 -
  10.123 -int ucx_buffer_eof(UcxBuffer *buffer) {
  10.124 -    return buffer->pos >= buffer->size;
  10.125 -}
  10.126 -
  10.127 -int ucx_buffer_extend(UcxBuffer *buffer, size_t len) {
  10.128 -    size_t newcap = buffer->capacity;
  10.129 -    
  10.130 -    if (buffer->capacity + len < buffer->capacity) {
  10.131 -        return -1;
  10.132 -    }
  10.133 -    
  10.134 -    while (buffer->capacity + len > newcap) {
  10.135 -        newcap <<= 1;
  10.136 -        if (newcap < buffer->capacity) {
  10.137 -            return -1;
  10.138 -        }
  10.139 -    }
  10.140 -    
  10.141 -    char *newspace = (char*)realloc(buffer->space, newcap);
  10.142 -    if (newspace) {
  10.143 -        memset(newspace+buffer->size, 0, newcap-buffer->size);
  10.144 -        buffer->space = newspace;
  10.145 -        buffer->capacity = newcap;
  10.146 -    } else {
  10.147 -        return -1;
  10.148 -    }
  10.149 -    
  10.150 -    return 0;
  10.151 -}
  10.152 -
  10.153 -size_t ucx_buffer_write(const void *ptr, size_t size, size_t nitems,
  10.154 -        UcxBuffer *buffer) {
  10.155 -    size_t len = size * nitems;
  10.156 -    size_t required = buffer->pos + len;
  10.157 -    if (buffer->pos > required) {
  10.158 -        return 0;
  10.159 -    }
  10.160 -    
  10.161 -    if (required > buffer->capacity) {
  10.162 -        if ((buffer->flags & UCX_BUFFER_AUTOEXTEND) == UCX_BUFFER_AUTOEXTEND) {
  10.163 -            if (ucx_buffer_extend(buffer, required - buffer->capacity)) {
  10.164 -                return 0;
  10.165 -            }
  10.166 -        } else {
  10.167 -            len = buffer->capacity - buffer->pos;
  10.168 -            if (size > 1) {
  10.169 -                len -= len%size;
  10.170 -            }
  10.171 -        }
  10.172 -    }
  10.173 -    
  10.174 -    if (len == 0) {
  10.175 -        return len;
  10.176 -    }
  10.177 -    
  10.178 -    memcpy(buffer->space + buffer->pos, ptr, len);
  10.179 -    buffer->pos += len;
  10.180 -    if(buffer->pos > buffer->size) {
  10.181 -        buffer->size = buffer->pos;
  10.182 -    }
  10.183 -    
  10.184 -    return len / size;
  10.185 -}
  10.186 -
  10.187 -size_t ucx_buffer_read(void *ptr, size_t size, size_t nitems,
  10.188 -        UcxBuffer *buffer) {
  10.189 -    size_t len = size * nitems;
  10.190 -    if (buffer->pos + len > buffer->size) {
  10.191 -        len = buffer->size - buffer->pos;
  10.192 -        if (size > 1) len -= len%size;
  10.193 -    }
  10.194 -    
  10.195 -    if (len <= 0) {
  10.196 -        return len;
  10.197 -    }
  10.198 -    
  10.199 -    memcpy(ptr, buffer->space + buffer->pos, len);
  10.200 -    buffer->pos += len;
  10.201 -    
  10.202 -    return len / size;
  10.203 -}
  10.204 -
  10.205 -int ucx_buffer_putc(UcxBuffer *buffer, int c) {
  10.206 -    if(buffer->pos >= buffer->capacity) {
  10.207 -        if ((buffer->flags & UCX_BUFFER_AUTOEXTEND) == UCX_BUFFER_AUTOEXTEND) {
  10.208 -            if(ucx_buffer_extend(buffer, 1)) {
  10.209 -                return EOF;
  10.210 -            }
  10.211 -        } else {
  10.212 -            return EOF;
  10.213 -        }
  10.214 -    }
  10.215 -    
  10.216 -    c &= 0xFF;
  10.217 -    buffer->space[buffer->pos] = (char) c;
  10.218 -    buffer->pos++;
  10.219 -    if(buffer->pos > buffer->size) {
  10.220 -        buffer->size = buffer->pos;
  10.221 -    }
  10.222 -    return c;
  10.223 -}
  10.224 -
  10.225 -int ucx_buffer_getc(UcxBuffer *buffer) {
  10.226 -    if (ucx_buffer_eof(buffer)) {
  10.227 -        return EOF;
  10.228 -    } else {
  10.229 -        int c = buffer->space[buffer->pos];
  10.230 -        buffer->pos++;
  10.231 -        return c;
  10.232 -    }
  10.233 -}
  10.234 -
  10.235 -size_t ucx_buffer_puts(UcxBuffer *buffer, char *str) {
  10.236 -    return ucx_buffer_write((const void*)str, 1, strlen(str), buffer);
  10.237 -}

    11.1 --- a/src/ucx/buffer.h	Thu Nov 10 18:44:48 2016 +0100
    11.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    11.3 @@ -1,270 +0,0 @@
    11.4 -/*
    11.5 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
    11.6 - *
    11.7 - * Copyright 2015 Olaf Wintermann. All rights reserved.
    11.8 - *
    11.9 - * Redistribution and use in source and binary forms, with or without
   11.10 - * modification, are permitted provided that the following conditions are met:
   11.11 - *
   11.12 - *   1. Redistributions of source code must retain the above copyright
   11.13 - *      notice, this list of conditions and the following disclaimer.
   11.14 - *
   11.15 - *   2. Redistributions in binary form must reproduce the above copyright
   11.16 - *      notice, this list of conditions and the following disclaimer in the
   11.17 - *      documentation and/or other materials provided with the distribution.
   11.18 - *
   11.19 - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   11.20 - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   11.21 - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   11.22 - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
   11.23 - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   11.24 - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   11.25 - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   11.26 - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   11.27 - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   11.28 - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   11.29 - * POSSIBILITY OF SUCH DAMAGE.
   11.30 - */
   11.31 -
   11.32 -/**
   11.33 - * @file buffer.h
   11.34 - * 
   11.35 - * Advanced buffer implementation.
   11.36 - * 
   11.37 - * Instances of UcxBuffer can be used to read from or to write to like one
   11.38 - * would do with a stream. This allows the use of ucx_stream_copy() to copy
   11.39 - * contents from one buffer to another.
   11.40 - * 
   11.41 - * Some features for convenient use of the buffer
   11.42 - * can be enabled. See the documentation of the macro constants for more
   11.43 - * information.
   11.44 - * 
   11.45 - * @author Mike Becker
   11.46 - * @author Olaf Wintermann
   11.47 - */
   11.48 -
   11.49 -#ifndef UCX_BUFFER_H
   11.50 -#define	UCX_BUFFER_H
   11.51 -
   11.52 -#include "ucx.h"
   11.53 -#include <sys/types.h>
   11.54 -#include <stdio.h>
   11.55 -
   11.56 -#ifdef	__cplusplus
   11.57 -extern "C" {
   11.58 -#endif
   11.59 -
   11.60 -/**
   11.61 - * No buffer features enabled (all flags cleared).
   11.62 - */
   11.63 -#define UCX_BUFFER_DEFAULT      0x00
   11.64 -
   11.65 -/**
   11.66 - * If this flag is enabled, the buffer will automatically free its contents.
   11.67 - */
   11.68 -#define UCX_BUFFER_AUTOFREE     0x01
   11.69 -
   11.70 -/**
   11.71 - * If this flag is enabled, the buffer will automatically extends its capacity.
   11.72 - */
   11.73 -#define UCX_BUFFER_AUTOEXTEND   0x02
   11.74 -
   11.75 -/** UCX Buffer. */
   11.76 -typedef struct {
   11.77 -    /** A pointer to the buffer contents. */
   11.78 -    char *space;
   11.79 -    /** Current position of the buffer. */
   11.80 -    size_t pos;
   11.81 -    /** Current capacity (i.e. maximum size) of the buffer. */
   11.82 -    size_t capacity;
   11.83 -    /** Current size of the buffer content. */
   11.84 -    size_t size;
   11.85 -    /**
   11.86 -     * Flag register for buffer features.
   11.87 -     * @see #UCX_BUFFER_DEFAULT
   11.88 -     * @see #UCX_BUFFER_AUTOFREE
   11.89 -     * @see #UCX_BUFFER_AUTOEXTEND
   11.90 -     */
   11.91 -    int flags;
   11.92 -} UcxBuffer;
   11.93 -
   11.94 -/**
   11.95 - * Creates a new buffer.
   11.96 - * 
   11.97 - * <b>Note:</b> you may provide <code>NULL</code> as argument for
   11.98 - * <code>space</code>. Then this function will allocate the space and enforce
   11.99 - * the #UCX_BUFFER_AUTOFREE flag.
  11.100 - * 
  11.101 - * @param space pointer to the memory area, or <code>NULL</code> to allocate
  11.102 - * new memory
  11.103 - * @param capacity the capacity of the buffer
  11.104 - * @param flags buffer features (see UcxBuffer.flags)
  11.105 - * @return the new buffer
  11.106 - */
  11.107 -UcxBuffer *ucx_buffer_new(void *space, size_t capacity, int flags);
  11.108 -
  11.109 -/**
  11.110 - * Destroys a buffer.
  11.111 - * 
  11.112 - * If the #UCX_BUFFER_AUTOFREE feature is enabled, the contents of the buffer
  11.113 - * are also freed.
  11.114 - * 
  11.115 - * @param buffer the buffer to destroy
  11.116 - */
  11.117 -void ucx_buffer_free(UcxBuffer* buffer);
  11.118 -
  11.119 -/**
  11.120 - * Creates a new buffer and fills it with extracted content from another buffer.
  11.121 - * 
  11.122 - * <b>Note:</b> the #UCX_BUFFER_AUTOFREE feature is enforced for the new buffer.
  11.123 - * 
  11.124 - * @param src the source buffer
  11.125 - * @param start the start position of extraction
  11.126 - * @param length the count of bytes to extract (must not be zero)
  11.127 - * @param flags feature mask for the new buffer
  11.128 - * @return a new buffer containing the extraction
  11.129 - */
  11.130 -UcxBuffer* ucx_buffer_extract(UcxBuffer *src,
  11.131 -        size_t start, size_t length, int flags);
  11.132 -
  11.133 -/**
  11.134 - * A shorthand macro for the full extraction of the buffer.
  11.135 - * 
  11.136 - * @param src the source buffer
  11.137 - * @param flags feature mask for the new buffer
  11.138 - * @return a new buffer with the extracted content
  11.139 - */
  11.140 -#define ucx_buffer_clone(src,flags) \
  11.141 -    ucx_buffer_extract(src, 0, (src)->capacity, flags)
  11.142 -
  11.143 -/**
  11.144 - * Moves the position of the buffer.
  11.145 - * 
  11.146 - * The new position is relative to the <code>whence</code> argument.
  11.147 - *
  11.148 - * SEEK_SET marks the start of the buffer.
  11.149 - * SEEK_CUR marks the current position.
  11.150 - * SEEK_END marks the end of the buffer.
  11.151 - * 
  11.152 - * With an offset of zero, this function sets the buffer position to zero
  11.153 - * (SEEK_SET), the buffer size (SEEK_END) or leaves the buffer position
  11.154 - * unchanged (SEEK_CUR).
  11.155 - * 
  11.156 - * @param buffer
  11.157 - * @param offset position offset relative to <code>whence</code>
  11.158 - * @param whence one of SEEK_SET, SEEK_CUR or SEEK_END
  11.159 - * @return 0 on success, non-zero if the position is invalid
  11.160 - *
  11.161 - */
  11.162 -int ucx_buffer_seek(UcxBuffer *buffer, off_t offset, int whence);
  11.163 -
  11.164 -/**
  11.165 - * Clears the buffer by resetting the position and deleting the data.
  11.166 - * 
  11.167 - * The data is deleted by a zeroing it with call to <code>memset()</code>.
  11.168 - * 
  11.169 - * @param buffer the buffer to be cleared
  11.170 - */
  11.171 -#define ucx_buffer_clear(buffer) memset(buffer->space, 0, buffer->size); \
  11.172 -        buffer->size = 0; buffer->pos = 0;
  11.173 -
  11.174 -/**
  11.175 - * Tests, if the buffer position has exceeded the buffer capacity.
  11.176 - * 
  11.177 - * @param buffer the buffer to test
  11.178 - * @return non-zero, if the current buffer position has exceeded the last
  11.179 - * available byte of the buffer.
  11.180 - */
  11.181 -int ucx_buffer_eof(UcxBuffer *buffer);
  11.182 -
  11.183 -
  11.184 -/**
  11.185 - * Extends the capacity of the buffer.
  11.186 - * 
  11.187 - * <b>Note:</b> The buffer capacity increased by a power of two. I.e.
  11.188 - * the buffer capacity is doubled, as long as it would not hold the current
  11.189 - * content plus the additional required bytes.
  11.190 - * 
  11.191 - * <b>Attention:</b> the argument provided is the number of <i>additional</i>
  11.192 - * bytes the buffer shall hold. It is <b>NOT</b> the total number of bytes the
  11.193 - * buffer shall hold.
  11.194 - * 
  11.195 - * @param buffer the buffer to extend
  11.196 - * @param additional_bytes the number of additional bytes the buffer shall
  11.197 - * <i>at least</i> hold
  11.198 - * @return 0 on success or a non-zero value on failure
  11.199 - */
  11.200 -int ucx_buffer_extend(UcxBuffer *buffer, size_t additional_bytes);
  11.201 -
  11.202 -/**
  11.203 - * Writes data to an UcxBuffer.
  11.204 - * 
  11.205 - * The position of the buffer is increased by the number of bytes written.
  11.206 - * 
  11.207 - * @param ptr a pointer to the memory area containing the bytes to be written
  11.208 - * @param size the length of one element
  11.209 - * @param nitems the element count
  11.210 - * @param buffer the UcxBuffer to write to
  11.211 - * @return the total count of bytes written
  11.212 - */
  11.213 -size_t ucx_buffer_write(const void *ptr, size_t size, size_t nitems,
  11.214 -        UcxBuffer *buffer);
  11.215 -
  11.216 -/**
  11.217 - * Reads data from an UcxBuffer.
  11.218 - * 
  11.219 - * The position of the buffer is increased by the number of bytes read.
  11.220 - * 
  11.221 - * @param ptr a pointer to the memory area where to store the read data
  11.222 - * @param size the length of one element
  11.223 - * @param nitems the element count
  11.224 - * @param buffer the UcxBuffer to read from
  11.225 - * @return the total number of elements read
  11.226 - */
  11.227 -size_t ucx_buffer_read(void *ptr, size_t size, size_t nitems,
  11.228 -        UcxBuffer *buffer);
  11.229 -
  11.230 -/**
  11.231 - * Writes a character to a buffer.
  11.232 - * 
  11.233 - * The least significant byte of the argument is written to the buffer. If the
  11.234 - * end of the buffer is reached and #UCX_BUFFER_AUTOEXTEND feature is enabled,
  11.235 - * the buffer capacity is extended by ucx_buffer_extend(). If the feature is
  11.236 - * disabled or buffer extension fails, <code>EOF</code> is returned.
  11.237 - * 
  11.238 - * On successful write the position of the buffer is increased.
  11.239 - * 
  11.240 - * @param buffer the buffer to write to
  11.241 - * @param c the character to write as <code>int</code> value
  11.242 - * @return the byte that has bean written as <code>int</code> value or
  11.243 - * <code>EOF</code> when the end of the stream is reached and automatic
  11.244 - * extension is not enabled or not possible
  11.245 - */
  11.246 -int ucx_buffer_putc(UcxBuffer *buffer, int c);
  11.247 -
  11.248 -/**
  11.249 - * Gets a character from a buffer.
  11.250 - * 
  11.251 - * The current position of the buffer is increased after a successful read.
  11.252 - * 
  11.253 - * @param buffer the buffer to read from
  11.254 - * @return the character as <code>int</code> value or <code>EOF</code>, if the
  11.255 - * end of the buffer is reached
  11.256 - */
  11.257 -int ucx_buffer_getc(UcxBuffer *buffer);
  11.258 -
  11.259 -/**
  11.260 - * Writes a string to a buffer.
  11.261 - * 
  11.262 - * @param buffer the buffer
  11.263 - * @param str the string
  11.264 - * @return the number of bytes written
  11.265 - */
  11.266 -size_t ucx_buffer_puts(UcxBuffer *buffer, char *str);
  11.267 -
  11.268 -#ifdef	__cplusplus
  11.269 -}
  11.270 -#endif
  11.271 -
  11.272 -#endif	/* UCX_BUFFER_H */
  11.273 -

    12.1 --- a/src/ucx/list.c	Thu Nov 10 18:44:48 2016 +0100
    12.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    12.3 @@ -1,335 +0,0 @@
    12.4 -/*
    12.5 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
    12.6 - *
    12.7 - * Copyright 2015 Olaf Wintermann. All rights reserved.
    12.8 - *
    12.9 - * Redistribution and use in source and binary forms, with or without
   12.10 - * modification, are permitted provided that the following conditions are met:
   12.11 - *
   12.12 - *   1. Redistributions of source code must retain the above copyright
   12.13 - *      notice, this list of conditions and the following disclaimer.
   12.14 - *
   12.15 - *   2. Redistributions in binary form must reproduce the above copyright
   12.16 - *      notice, this list of conditions and the following disclaimer in the
   12.17 - *      documentation and/or other materials provided with the distribution.
   12.18 - *
   12.19 - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   12.20 - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   12.21 - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   12.22 - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
   12.23 - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   12.24 - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   12.25 - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   12.26 - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   12.27 - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   12.28 - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   12.29 - * POSSIBILITY OF SUCH DAMAGE.
   12.30 - */
   12.31 -
   12.32 -#include "list.h"
   12.33 -
   12.34 -UcxList *ucx_list_clone(UcxList *l, copy_func fnc, void *data) {
   12.35 -    return ucx_list_clone_a(ucx_default_allocator(), l, fnc, data);
   12.36 -}
   12.37 -
   12.38 -UcxList *ucx_list_clone_a(UcxAllocator *alloc, UcxList *l,
   12.39 -        copy_func fnc, void *data) {
   12.40 -    UcxList *ret = NULL;
   12.41 -    while (l) {
   12.42 -        if (fnc) {
   12.43 -            ret = ucx_list_append_a(alloc, ret, fnc(l->data, data));
   12.44 -        } else {
   12.45 -            ret = ucx_list_append_a(alloc, ret, l->data);
   12.46 -        }
   12.47 -        l = l->next;
   12.48 -    }
   12.49 -    return ret;
   12.50 -}
   12.51 -
   12.52 -int ucx_list_equals(const UcxList *l1, const UcxList *l2,
   12.53 -        cmp_func fnc, void* data) {
   12.54 -    if (l1 == l2) return 1;
   12.55 -    
   12.56 -    while (l1 != NULL && l2 != NULL) {
   12.57 -        if (fnc == NULL) {
   12.58 -            if (l1->data != l2->data) return 0;
   12.59 -        } else {
   12.60 -            if (fnc(l1->data, l2->data, data) != 0) return 0;
   12.61 -        }
   12.62 -        l1 = l1->next;
   12.63 -        l2 = l2->next;
   12.64 -    }
   12.65 -    
   12.66 -    return (l1 == NULL && l2 == NULL);
   12.67 -}
   12.68 -
   12.69 -void ucx_list_free(UcxList *l) {
   12.70 -    ucx_list_free_a(ucx_default_allocator(), l);
   12.71 -}
   12.72 -
   12.73 -void ucx_list_free_a(UcxAllocator *alloc, UcxList *l) {
   12.74 -    UcxList *e = l, *f;
   12.75 -    while (e != NULL) {
   12.76 -        f = e;
   12.77 -        e = e->next;
   12.78 -        alfree(alloc, f);
   12.79 -    }
   12.80 -}
   12.81 -
   12.82 -void ucx_list_free_content(UcxList* list, ucx_destructor destr) {
   12.83 -    while (list != NULL) {
   12.84 -        destr(list->data);
   12.85 -        list = list->next;
   12.86 -    }
   12.87 -}
   12.88 -
   12.89 -UcxList *ucx_list_append(UcxList *l, void *data)  {
   12.90 -    return ucx_list_append_a(ucx_default_allocator(), l, data);
   12.91 -}
   12.92 -
   12.93 -UcxList *ucx_list_append_a(UcxAllocator *alloc, UcxList *l, void *data)  {
   12.94 -    UcxList *nl = (UcxList*) almalloc(alloc, sizeof(UcxList));
   12.95 -    if (!nl) {
   12.96 -        return NULL;
   12.97 -    }
   12.98 -    
   12.99 -    nl->data = data;
  12.100 -    nl->next = NULL;
  12.101 -    if (l) {
  12.102 -        UcxList *t = ucx_list_last(l);
  12.103 -        t->next = nl;
  12.104 -        nl->prev = t;
  12.105 -        return l;
  12.106 -    } else {
  12.107 -        nl->prev = NULL;
  12.108 -        return nl;
  12.109 -    }
  12.110 -}
  12.111 -
  12.112 -UcxList *ucx_list_prepend(UcxList *l, void *data) {
  12.113 -    return ucx_list_prepend_a(ucx_default_allocator(), l, data);
  12.114 -}
  12.115 -
  12.116 -UcxList *ucx_list_prepend_a(UcxAllocator *alloc, UcxList *l, void *data) {
  12.117 -    UcxList *nl = ucx_list_append_a(alloc, NULL, data);
  12.118 -    if (!nl) {
  12.119 -        return NULL;
  12.120 -    }
  12.121 -    l = ucx_list_first(l);
  12.122 -    
  12.123 -    if (l) {
  12.124 -        nl->next = l;
  12.125 -        l->prev = nl;
  12.126 -    }
  12.127 -    return nl;
  12.128 -}
  12.129 -
  12.130 -UcxList *ucx_list_concat(UcxList *l1, UcxList *l2) {
  12.131 -    if (l1) {
  12.132 -        UcxList *last = ucx_list_last(l1);
  12.133 -        last->next = l2;
  12.134 -        if (l2) {
  12.135 -            l2->prev = last;
  12.136 -        }
  12.137 -        return l1;
  12.138 -    } else {
  12.139 -        return l2;
  12.140 -    }
  12.141 -}
  12.142 -
  12.143 -UcxList *ucx_list_last(const UcxList *l) {
  12.144 -    if (l == NULL) return NULL;
  12.145 -    
  12.146 -    const UcxList *e = l;
  12.147 -    while (e->next != NULL) {
  12.148 -        e = e->next;
  12.149 -    }
  12.150 -    return (UcxList*)e;
  12.151 -}
  12.152 -
  12.153 -ssize_t ucx_list_indexof(const UcxList *list, const UcxList *elem) {
  12.154 -    ssize_t index = 0;
  12.155 -    while (list) {
  12.156 -        if (list == elem) {
  12.157 -            return index;
  12.158 -        }
  12.159 -        list = list->next;
  12.160 -        index++;
  12.161 -    }
  12.162 -    return -1;
  12.163 -}
  12.164 -
  12.165 -UcxList *ucx_list_get(const UcxList *l, size_t index) {
  12.166 -    if (l == NULL) return NULL;
  12.167 -
  12.168 -    const UcxList *e = l;
  12.169 -    while (e->next && index > 0) {
  12.170 -        e = e->next;
  12.171 -        index--;
  12.172 -    }
  12.173 -    
  12.174 -    return (UcxList*)(index == 0 ? e : NULL);
  12.175 -}
  12.176 -
  12.177 -ssize_t ucx_list_find(UcxList *l, void *elem, cmp_func fnc, void *cmpdata) {
  12.178 -    ssize_t index = 0;
  12.179 -    UCX_FOREACH(e, l) {
  12.180 -        if (fnc) {
  12.181 -            if (fnc(elem, e->data, cmpdata) == 0) {
  12.182 -                return index;
  12.183 -            }
  12.184 -        } else {
  12.185 -            if (elem == e->data) {
  12.186 -                return index;
  12.187 -            }
  12.188 -        }
  12.189 -        index++;
  12.190 -    }
  12.191 -    return -1;
  12.192 -}
  12.193 -
  12.194 -int ucx_list_contains(UcxList *l, void *elem, cmp_func fnc, void *cmpdata) {
  12.195 -    return ucx_list_find(l, elem, fnc, cmpdata) > -1;
  12.196 -}
  12.197 -
  12.198 -size_t ucx_list_size(const UcxList *l) {
  12.199 -    if (l == NULL) return 0;
  12.200 -    
  12.201 -    const UcxList *e = l;
  12.202 -    size_t s = 1;
  12.203 -    while (e->next != NULL) {
  12.204 -        e = e->next;
  12.205 -        s++;
  12.206 -    }
  12.207 -
  12.208 -    return s;
  12.209 -}
  12.210 -
  12.211 -static UcxList *ucx_list_sort_merge(int length,
  12.212 -        UcxList* restrict ls, UcxList* restrict le, UcxList* restrict re,
  12.213 -        cmp_func fnc, void* data) {
  12.214 -
  12.215 -    UcxList** sorted = (UcxList**) malloc(sizeof(UcxList*)*length);
  12.216 -    UcxList *rc, *lc;
  12.217 -
  12.218 -    lc = ls; rc = le;
  12.219 -    int n = 0;
  12.220 -    while (lc && lc != le && rc != re) {
  12.221 -        if (fnc(lc->data, rc->data, data) <= 0) {
  12.222 -            sorted[n] = lc;
  12.223 -            lc = lc->next;
  12.224 -        } else {
  12.225 -            sorted[n] = rc;
  12.226 -            rc = rc->next;
  12.227 -        }
  12.228 -        n++;
  12.229 -    }
  12.230 -    while (lc && lc != le) {
  12.231 -        sorted[n] = lc;
  12.232 -        lc = lc->next;
  12.233 -        n++;
  12.234 -    }
  12.235 -    while (rc && rc != re) {
  12.236 -        sorted[n] = rc;
  12.237 -        rc = rc->next;
  12.238 -        n++;
  12.239 -    }
  12.240 -
  12.241 -    // Update pointer
  12.242 -    sorted[0]->prev = NULL;
  12.243 -    for (int i = 0 ; i < length-1 ; i++) {
  12.244 -        sorted[i]->next = sorted[i+1];
  12.245 -        sorted[i+1]->prev = sorted[i];
  12.246 -    }
  12.247 -    sorted[length-1]->next = NULL;
  12.248 -
  12.249 -    UcxList *ret = sorted[0];
  12.250 -    free(sorted);
  12.251 -    return ret;
  12.252 -}
  12.253 -
  12.254 -UcxList *ucx_list_sort(UcxList *l, cmp_func fnc, void *data) {
  12.255 -    if (l == NULL) {
  12.256 -        return NULL;
  12.257 -    }
  12.258 -
  12.259 -    UcxList *lc;
  12.260 -    int ln = 1;
  12.261 -
  12.262 -    UcxList *restrict ls = l, *restrict le, *restrict re;
  12.263 -    
  12.264 -    // check how many elements are already sorted
  12.265 -    lc = ls;
  12.266 -    while (lc->next != NULL && fnc(lc->next->data, lc->data, data) > 0) {
  12.267 -        lc = lc->next;
  12.268 -        ln++;
  12.269 -    }
  12.270 -    le = lc->next;
  12.271 -
  12.272 -    if (le == NULL) {
  12.273 -        return l; // this list is already sorted :)
  12.274 -    } else {
  12.275 -        UcxList *rc;
  12.276 -        int rn = 1;
  12.277 -        rc = le;
  12.278 -        // skip already sorted elements
  12.279 -        while (rc->next != NULL && fnc(rc->next->data, rc->data, data) > 0) {
  12.280 -            rc = rc->next;
  12.281 -            rn++;
  12.282 -        }
  12.283 -        re = rc->next;
  12.284 -
  12.285 -        // {ls,...,le->prev} and {rs,...,re->prev} are sorted - merge them
  12.286 -        UcxList *sorted = ucx_list_sort_merge(ln+rn,
  12.287 -                ls, le, re,
  12.288 -                fnc, data);
  12.289 -        
  12.290 -        // Something left? Sort it!
  12.291 -        size_t remainder_length = ucx_list_size(re);
  12.292 -        if (remainder_length > 0) {
  12.293 -            UcxList *remainder = ucx_list_sort(re, fnc, data);
  12.294 -
  12.295 -            // merge sorted list with (also sorted) remainder
  12.296 -            l = ucx_list_sort_merge(ln+rn+remainder_length,
  12.297 -                    sorted, remainder, NULL, fnc, data);
  12.298 -        } else {
  12.299 -            // no remainder - we've got our sorted list
  12.300 -            l = sorted;
  12.301 -        }
  12.302 -
  12.303 -        return l;
  12.304 -    }
  12.305 -}
  12.306 -
  12.307 -UcxList *ucx_list_first(const UcxList *l) {
  12.308 -    if (!l) {
  12.309 -        return NULL;
  12.310 -    }
  12.311 -    
  12.312 -    const UcxList *e = l;
  12.313 -    while (e->prev) {
  12.314 -        e = e->prev;
  12.315 -    }
  12.316 -    return (UcxList *)e;
  12.317 -}
  12.318 -
  12.319 -UcxList *ucx_list_remove(UcxList *l, UcxList *e) {
  12.320 -    return ucx_list_remove_a(ucx_default_allocator(), l, e);
  12.321 -}
  12.322 -    
  12.323 -UcxList *ucx_list_remove_a(UcxAllocator *alloc, UcxList *l, UcxList *e) {
  12.324 -    if (l == e) {
  12.325 -        l = e->next;
  12.326 -    }
  12.327 -    
  12.328 -    if (e->next) {
  12.329 -        e->next->prev = e->prev;
  12.330 -    }
  12.331 -    
  12.332 -    if (e->prev) {
  12.333 -        e->prev->next = e->next;
  12.334 -    }
  12.335 -    
  12.336 -    alfree(alloc, e);
  12.337 -    return l;
  12.338 -}

    13.1 --- a/src/ucx/list.h	Thu Nov 10 18:44:48 2016 +0100
    13.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    13.3 @@ -1,395 +0,0 @@
    13.4 -/*
    13.5 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
    13.6 - *
    13.7 - * Copyright 2015 Olaf Wintermann. All rights reserved.
    13.8 - *
    13.9 - * Redistribution and use in source and binary forms, with or without
   13.10 - * modification, are permitted provided that the following conditions are met:
   13.11 - *
   13.12 - *   1. Redistributions of source code must retain the above copyright
   13.13 - *      notice, this list of conditions and the following disclaimer.
   13.14 - *
   13.15 - *   2. Redistributions in binary form must reproduce the above copyright
   13.16 - *      notice, this list of conditions and the following disclaimer in the
   13.17 - *      documentation and/or other materials provided with the distribution.
   13.18 - *
   13.19 - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   13.20 - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   13.21 - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   13.22 - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
   13.23 - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   13.24 - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   13.25 - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   13.26 - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   13.27 - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   13.28 - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   13.29 - * POSSIBILITY OF SUCH DAMAGE.
   13.30 - */
   13.31 -/**
   13.32 - * Doubly linked list implementation.
   13.33 - * 
   13.34 - * @file   list.h
   13.35 - * @author Mike Becker
   13.36 - * @author Olaf Wintermann
   13.37 - */
   13.38 -
   13.39 -#ifndef UCX_LIST_H
   13.40 -#define	UCX_LIST_H
   13.41 -
   13.42 -#include "ucx.h"
   13.43 -#include "allocator.h"
   13.44 -
   13.45 -#ifdef	__cplusplus
   13.46 -extern "C" {
   13.47 -#endif
   13.48 -
   13.49 -/**
   13.50 - * Loop statement for UCX lists.
   13.51 - * 
   13.52 - * The first argument is the name of the iteration variable. The scope of
   13.53 - * this variable is limited to the <code>UCX_FOREACH</code> statement.
   13.54 - * 
   13.55 - * The second argument is a pointer to the list. In most cases this will be the
   13.56 - * pointer to the first element of the list, but it may also be an arbitrary
   13.57 - * element of the list. The iteration will then start with that element.
   13.58 - * 
   13.59 - * 
   13.60 - * @param list The first element of the list
   13.61 - * @param elem The variable name of the element
   13.62 - */
   13.63 -#define UCX_FOREACH(elem,list) \
   13.64 -        for (UcxList* elem = list ; elem != NULL ; elem = elem->next)
   13.65 -
   13.66 -/**
   13.67 - * UCX list type.
   13.68 - * @see UcxList
   13.69 - */
   13.70 -typedef struct UcxList UcxList;
   13.71 -
   13.72 -/**
   13.73 - * UCX list structure.
   13.74 - */
   13.75 -struct UcxList {
   13.76 -    /**
   13.77 -     * List element payload.
   13.78 -     */
   13.79 -    void    *data;
   13.80 -    /**
   13.81 -     * Pointer to the next list element or <code>NULL</code>, if this is the
   13.82 -     * last element.
   13.83 -     */
   13.84 -    UcxList *next;
   13.85 -    /**
   13.86 -     * Pointer to the previous list element or <code>NULL</code>, if this is
   13.87 -     * the first element.
   13.88 -     */
   13.89 -    UcxList *prev;
   13.90 -};
   13.91 -
   13.92 -/**
   13.93 - * Creates an element-wise copy of a list.
   13.94 - * 
   13.95 - * This function clones the specified list by creating new list elements and
   13.96 - * copying the data with the specified copy_func(). If no copy_func() is
   13.97 - * specified, a shallow copy is created and the new list will reference the
   13.98 - * same data as the source list.
   13.99 - * 
  13.100 - * @param list the list to copy
  13.101 - * @param cpyfnc a pointer to the function that shall copy an element (may be
  13.102 - * <code>NULL</code>)
  13.103 - * @param data additional data for the copy_func()
  13.104 - * @return a pointer to the copy
  13.105 - */
  13.106 -UcxList *ucx_list_clone(UcxList *list, copy_func cpyfnc, void* data);
  13.107 -
  13.108 -/**
  13.109 - * Creates an element-wise copy of a list using an UcxAllocator.
  13.110 - * 
  13.111 - * See ucx_list_clone() for details.
  13.112 - * 
  13.113 - * Keep in mind, that you might want to pass the allocator as an (part of the)
  13.114 - * argument for the <code>data</code> parameter, if you want the copy_func() to
  13.115 - * make use of the allocator.
  13.116 - * 
  13.117 - * @param allocator the allocator to use
  13.118 - * @param list the list to copy
  13.119 - * @param cpyfnc a pointer to the function that shall copy an element (may be
  13.120 - * <code>NULL</code>)
  13.121 - * @param data additional data for the copy_func()
  13.122 - * @return a pointer to the copy
  13.123 - * @see ucx_list_clone()
  13.124 - */
  13.125 -UcxList *ucx_list_clone_a(UcxAllocator *allocator, UcxList *list,
  13.126 -        copy_func cpyfnc, void* data);
  13.127 -
  13.128 -/**
  13.129 - * Compares two UCX lists element-wise by using a compare function.
  13.130 - * 
  13.131 - * Each element of the two specified lists are compared by using the specified
  13.132 - * compare function and the additional data. The type and content of this
  13.133 - * additional data depends on the cmp_func() used.
  13.134 - * 
  13.135 - * If the list pointers denote elements within a list, the lists are compared
  13.136 - * starting with the denoted elements. Thus any previous elements are not taken
  13.137 - * into account. This might be useful to check, if certain list tails match
  13.138 - * each other.
  13.139 - * 
  13.140 - * @param list1 the first list
  13.141 - * @param list2 the second list
  13.142 - * @param cmpfnc the compare function
  13.143 - * @param data additional data for the compare function
  13.144 - * @return 1, if and only if the two lists equal element-wise, 0 otherwise
  13.145 - */
  13.146 -int ucx_list_equals(const UcxList *list1, const UcxList *list2,
  13.147 -        cmp_func cmpfnc, void* data);
  13.148 -
  13.149 -/**
  13.150 - * Destroys the entire list.
  13.151 - * 
  13.152 - * The members of the list are not automatically freed, so ensure they are
  13.153 - * otherwise referenced or destroyed by ucx_list_free_contents().
  13.154 - * Otherwise, a memory leak is likely to occur.
  13.155 - * 
  13.156 - * <b>Caution:</b> the argument <b>MUST</b> denote an entire list (i.e. a call
  13.157 - * to ucx_list_first() on the argument must return the argument itself)
  13.158 - * 
  13.159 - * @param list the list to free
  13.160 - * @see ucx_list_free_contents()
  13.161 - */
  13.162 -void ucx_list_free(UcxList *list);
  13.163 -
  13.164 -/**
  13.165 - * Destroys the entire list using an UcxAllocator.
  13.166 - * 
  13.167 - * See ucx_list_free() for details.
  13.168 - * 
  13.169 - * @param allocator the allocator to use
  13.170 - * @param list the list to free
  13.171 - * @see ucx_list_free()
  13.172 - */
  13.173 -void ucx_list_free_a(UcxAllocator *allocator, UcxList *list);
  13.174 -
  13.175 -/**
  13.176 - * Destroys the contents of the specified list by calling the specified
  13.177 - * destructor on each of them.
  13.178 - * 
  13.179 - * Note, that the contents are not usable afterwards and the list should be
  13.180 - * destroyed with ucx_list_free().
  13.181 - * 
  13.182 - * @param list the list for which the contents shall be freed
  13.183 - * @param destr the destructor function (e.g. stdlib free())
  13.184 - * @see ucx_list_free()
  13.185 - */
  13.186 -void ucx_list_free_content(UcxList* list, ucx_destructor destr);
  13.187 -
  13.188 -
  13.189 -/**
  13.190 - * Inserts an element at the end of the list.
  13.191 - * 
  13.192 - * This is generally an O(n) operation, as the end of the list is retrieved with
  13.193 - * ucx_list_last().
  13.194 - * 
  13.195 - * @param list the list where to append the data, or <code>NULL</code> to
  13.196 - * create a new list
  13.197 - * @param data the data to insert
  13.198 - * @return <code>list</code>, if it is not <code>NULL</code> or a pointer to
  13.199 - * the newly created list otherwise
  13.200 - */
  13.201 -UcxList *ucx_list_append(UcxList *list, void *data);
  13.202 -
  13.203 -/**
  13.204 - * Inserts an element at the end of the list using an UcxAllocator.
  13.205 - * 
  13.206 - * See ucx_list_append() for details.
  13.207 - * 
  13.208 - * @param allocator the allocator to use
  13.209 - * @param list the list where to append the data, or <code>NULL</code> to
  13.210 - * create a new list
  13.211 - * @param data the data to insert
  13.212 - * @return <code>list</code>, if it is not <code>NULL</code> or a pointer to
  13.213 - * the newly created list otherwise
  13.214 - * @see ucx_list_append()
  13.215 - */
  13.216 -UcxList *ucx_list_append_a(UcxAllocator *allocator, UcxList *list, void *data);
  13.217 -
  13.218 -/**
  13.219 - * Inserts an element at the beginning of the list.
  13.220 - * 
  13.221 - * You <i>should</i> overwrite the old list pointer by calling
  13.222 - * <code>mylist = ucx_list_prepend(mylist, mydata);</code>. However, you may
  13.223 - * also perform successive calls of ucx_list_prepend() on the same list pointer,
  13.224 - * as this function always searchs for the head of the list with
  13.225 - * ucx_list_first().
  13.226 - * 
  13.227 - * @param list the list where to insert the data or <code>NULL</code> to create
  13.228 - * a new list
  13.229 - * @param data the data to insert
  13.230 - * @return a pointer to the new list head
  13.231 - */
  13.232 -UcxList *ucx_list_prepend(UcxList *list, void *data);
  13.233 -
  13.234 -/**
  13.235 - * Inserts an element at the beginning of the list using an UcxAllocator.
  13.236 - * 
  13.237 - * See ucx_list_prepend() for details.
  13.238 - * 
  13.239 - * @param allocator the allocator to use
  13.240 - * @param list the list where to insert the data or <code>NULL</code> to create
  13.241 - * a new list
  13.242 - * @param data the data to insert
  13.243 - * @return a pointer to the new list head
  13.244 - * @see ucx_list_prepend()
  13.245 - */
  13.246 -UcxList *ucx_list_prepend_a(UcxAllocator *allocator, UcxList *list, void *data);
  13.247 -
  13.248 -/**
  13.249 - * Concatenates two lists.
  13.250 - * 
  13.251 - * Either of the two arguments may be <code>NULL</code>.
  13.252 - * 
  13.253 - * This function modifies the references to the next/previous element of
  13.254 - * the last/first element of <code>list1</code>/<code>
  13.255 - * list2</code>.
  13.256 - * 
  13.257 - * @param list1 first list
  13.258 - * @param list2 second list
  13.259 - * @return if <code>list1</code> is <code>NULL</code>, <code>list2</code> is
  13.260 - * returned, otherwise <code>list1</code> is returned
  13.261 - */
  13.262 -UcxList *ucx_list_concat(UcxList *list1, UcxList *list2);
  13.263 -
  13.264 -/**
  13.265 - * Returns the first element of a list.
  13.266 - * 
  13.267 - * If the argument is the list pointer, it is directly returned. Otherwise
  13.268 - * this function traverses to the first element of the list and returns the
  13.269 - * list pointer.
  13.270 - * 
  13.271 - * @param elem one element of the list
  13.272 - * @return the first element of the list, the specified element is a member of
  13.273 - */
  13.274 -UcxList *ucx_list_first(const UcxList *elem);
  13.275 -
  13.276 -/**
  13.277 - * Returns the last element of a list.
  13.278 - * 
  13.279 - * If the argument has no successor, it is the last element and therefore
  13.280 - * directly returned. Otherwise this function traverses to the last element of
  13.281 - * the list and returns it.
  13.282 - * 
  13.283 - * @param elem one element of the list
  13.284 - * @return the last element of the list, the specified element is a member of
  13.285 - */
  13.286 -UcxList *ucx_list_last(const UcxList *elem);
  13.287 -
  13.288 -/**
  13.289 - * Returns the list element at the specified index.
  13.290 - * 
  13.291 - * @param list the list to retrieve the element from
  13.292 - * @param index index of the element to return
  13.293 - * @return the element at the specified index or <code>NULL</code>, if the
  13.294 - * index is greater than the list size
  13.295 - */
  13.296 -UcxList *ucx_list_get(const UcxList *list, size_t index);
  13.297 -
  13.298 -/**
  13.299 - * Returns the index of an element.
  13.300 - * 
  13.301 - * @param list the list where to search for the element
  13.302 - * @param elem the element to find
  13.303 - * @return the index of the element or -1 if the list does not contain the
  13.304 - * element
  13.305 - */
  13.306 -ssize_t ucx_list_indexof(const UcxList *list, const UcxList *elem);
  13.307 -
  13.308 -/**
  13.309 - * Returns the element count of the list.
  13.310 - * 
  13.311 - * @param list the list whose elements are counted
  13.312 - * @return the element count
  13.313 - */
  13.314 -size_t ucx_list_size(const UcxList *list);
  13.315 -
  13.316 -/**
  13.317 - * Returns the index of an element containing the specified data.
  13.318 - *
  13.319 - * This function uses a cmp_func() to compare the data of each list element
  13.320 - * with the specified data. If no cmp_func is provided, the pointers are
  13.321 - * compared.
  13.322 - * 
  13.323 - * If the list contains the data more than once, the index of the first
  13.324 - * occurrence is returned.
  13.325 - *  
  13.326 - * @param list the list where to search for the data
  13.327 - * @param elem the element data
  13.328 - * @param cmpfnc the compare function
  13.329 - * @param data additional data for the compare function
  13.330 - * @return the index of the element containing the specified data or -1 if the
  13.331 - * data is not found in this list
  13.332 - */
  13.333 -ssize_t ucx_list_find(UcxList *list, void *elem, cmp_func cmpfnc, void *data);
  13.334 -
  13.335 -/**
  13.336 - * Checks, if a list contains a specific element.
  13.337 - * 
  13.338 - * An element is found, if ucx_list_find() returns a value greater than -1.
  13.339 - * 
  13.340 - * @param list the list where to search for the data
  13.341 - * @param elem the element data
  13.342 - * @param cmpfnc the compare function
  13.343 - * @param data additional data for the compare function
  13.344 - * @return 1, if and only if the list contains the specified element data
  13.345 - * @see ucx_list_find()
  13.346 - */
  13.347 -int ucx_list_contains(UcxList *list, void *elem, cmp_func cmpfnc, void *data);
  13.348 -
  13.349 -/**
  13.350 - * Sorts an UcxList with natural merge sort.
  13.351 - * 
  13.352 - * This function uses O(n) additional temporary memory for merge operations
  13.353 - * that is automatically freed after each merge.
  13.354 - * 
  13.355 - * As the head of the list might change, you <b>MUST</b> call this function
  13.356 - * as follows: <code>mylist = ucx_list_sort(mylist, mycmpfnc, mydata);</code>.
  13.357 - * 
  13.358 - * @param list the list to sort
  13.359 - * @param cmpfnc the function that shall be used to compare the element data
  13.360 - * @param data additional data for the cmp_func()
  13.361 - * @return the sorted list
  13.362 - */
  13.363 -UcxList *ucx_list_sort(UcxList *list, cmp_func cmpfnc, void *data);
  13.364 -
  13.365 -/**
  13.366 - * Removes an element from the list.
  13.367 - * 
  13.368 - * If the first element is removed, the list pointer changes. So it is
  13.369 - * <i>highly recommended</i> to <i>always</i> update the pointer by calling
  13.370 - * <code>mylist = ucx_list_remove(mylist, myelem);</code>.
  13.371 - * 
  13.372 - * @param list the list from which the element shall be removed
  13.373 - * @param element the element to remove
  13.374 - * @return returns the updated list pointer or <code>NULL</code>, if the list
  13.375 - * is now empty
  13.376 - */
  13.377 -UcxList *ucx_list_remove(UcxList *list, UcxList *element);
  13.378 -
  13.379 -/**
  13.380 - * Removes an element from the list using an UcxAllocator.
  13.381 - * 
  13.382 - * See ucx_list_remove() for details.
  13.383 - * 
  13.384 - * @param allocator the allocator to use
  13.385 - * @param list the list from which the element shall be removed
  13.386 - * @param element the element to remove
  13.387 - * @return returns the updated list pointer or <code>NULL</code>, if the list
  13.388 - * @see ucx_list_remove()
  13.389 - */
  13.390 -UcxList *ucx_list_remove_a(UcxAllocator *allocator, UcxList *list,
  13.391 -        UcxList *element);
  13.392 -
  13.393 -#ifdef	__cplusplus
  13.394 -}
  13.395 -#endif
  13.396 -
  13.397 -#endif	/* UCX_LIST_H */
  13.398 -

    14.1 --- a/src/ucx/string.c	Thu Nov 10 18:44:48 2016 +0100
    14.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    14.3 @@ -1,381 +0,0 @@
    14.4 -/*
    14.5 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
    14.6 - *
    14.7 - * Copyright 2015 Olaf Wintermann. All rights reserved.
    14.8 - *
    14.9 - * Redistribution and use in source and binary forms, with or without
   14.10 - * modification, are permitted provided that the following conditions are met:
   14.11 - *
   14.12 - *   1. Redistributions of source code must retain the above copyright
   14.13 - *      notice, this list of conditions and the following disclaimer.
   14.14 - *
   14.15 - *   2. Redistributions in binary form must reproduce the above copyright
   14.16 - *      notice, this list of conditions and the following disclaimer in the
   14.17 - *      documentation and/or other materials provided with the distribution.
   14.18 - *
   14.19 - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   14.20 - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   14.21 - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   14.22 - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
   14.23 - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   14.24 - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   14.25 - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   14.26 - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   14.27 - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   14.28 - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   14.29 - * POSSIBILITY OF SUCH DAMAGE.
   14.30 - */
   14.31 -
   14.32 -#include <stdlib.h>
   14.33 -#include <string.h>
   14.34 -#include <stdarg.h>
   14.35 -#include <ctype.h>
   14.36 -
   14.37 -#include "string.h"
   14.38 -#include "allocator.h"
   14.39 -
   14.40 -sstr_t sstr(char *cstring) {
   14.41 -    sstr_t string;
   14.42 -    string.ptr = cstring;
   14.43 -    string.length = strlen(cstring);
   14.44 -    return string;
   14.45 -}
   14.46 -
   14.47 -sstr_t sstrn(char *cstring, size_t length) {
   14.48 -    sstr_t string;
   14.49 -    string.ptr = cstring;
   14.50 -    string.length = length;
   14.51 -    return string;
   14.52 -}
   14.53 -
   14.54 -size_t sstrnlen(size_t n, sstr_t s, ...) {
   14.55 -    va_list ap;
   14.56 -    size_t size = s.length;
   14.57 -    va_start(ap, s);
   14.58 -
   14.59 -    for (size_t i = 1 ; i < n ; i++) {
   14.60 -        sstr_t str = va_arg(ap, sstr_t);
   14.61 -        size += str.length;
   14.62 -    }
   14.63 -    va_end(ap);
   14.64 -
   14.65 -    return size;
   14.66 -}
   14.67 -
   14.68 -static sstr_t sstrvcat_a(
   14.69 -        UcxAllocator *a,
   14.70 -        size_t count,
   14.71 -        sstr_t s1,
   14.72 -        sstr_t s2,
   14.73 -        va_list ap) {
   14.74 -    sstr_t str;
   14.75 -    str.ptr = NULL;
   14.76 -    str.length = 0;
   14.77 -    if(count < 2) {
   14.78 -        return str;
   14.79 -    }
   14.80 -    
   14.81 -    sstr_t *strings = (sstr_t*) calloc(count, sizeof(sstr_t));
   14.82 -    if(!strings) {
   14.83 -        return str;
   14.84 -    }
   14.85 -    
   14.86 -    // get all args and overall length
   14.87 -    strings[0] = s1;
   14.88 -    strings[1] = s2;
   14.89 -    size_t strlen = s1.length + s2.length;
   14.90 -    for (size_t i=2;i<count;i++) {
   14.91 -        sstr_t s = va_arg (ap, sstr_t);
   14.92 -        strings[i] = s;
   14.93 -        strlen += s.length;
   14.94 -    }
   14.95 -    
   14.96 -    // create new string
   14.97 -    str.ptr = (char*) almalloc(a, strlen + 1);
   14.98 -    str.length = strlen;
   14.99 -    if(!str.ptr) {
  14.100 -        free(strings);
  14.101 -        str.length = 0;
  14.102 -        return str;
  14.103 -    }
  14.104 -    
  14.105 -    // concatenate strings
  14.106 -    size_t pos = 0;
  14.107 -    for (size_t i=0;i<count;i++) {
  14.108 -        sstr_t s = strings[i];
  14.109 -        memcpy(str.ptr + pos, s.ptr, s.length);
  14.110 -        pos += s.length;
  14.111 -    }
  14.112 -    
  14.113 -    str.ptr[str.length] = '\0';
  14.114 -    
  14.115 -    free(strings);
  14.116 -    
  14.117 -    return str;
  14.118 -}
  14.119 -
  14.120 -sstr_t sstrcat(size_t count, sstr_t s1, sstr_t s2, ...) {
  14.121 -    va_list ap;
  14.122 -    va_start(ap, s2);
  14.123 -    sstr_t s = sstrvcat_a(ucx_default_allocator(), count, s1, s2, ap);
  14.124 -    va_end(ap);
  14.125 -    return s;
  14.126 -}
  14.127 -
  14.128 -sstr_t sstrcat_a(UcxAllocator *a, size_t count, sstr_t s1, sstr_t s2, ...) {
  14.129 -    va_list ap;
  14.130 -    va_start(ap, s2);
  14.131 -    sstr_t s = sstrvcat_a(a, count, s1, s2, ap);
  14.132 -    va_end(ap);
  14.133 -    return s;
  14.134 -}
  14.135 -
  14.136 -sstr_t sstrsubs(sstr_t s, size_t start) {
  14.137 -    return sstrsubsl (s, start, s.length-start);
  14.138 -}
  14.139 -
  14.140 -sstr_t sstrsubsl(sstr_t s, size_t start, size_t length) {
  14.141 -    sstr_t new_sstr;
  14.142 -    if (start >= s.length) {
  14.143 -        new_sstr.ptr = NULL;
  14.144 -        new_sstr.length = 0;
  14.145 -    } else {
  14.146 -        if (length > s.length-start) {
  14.147 -            length = s.length-start;
  14.148 -        }
  14.149 -        new_sstr.ptr = &s.ptr[start];
  14.150 -        new_sstr.length = length;
  14.151 -    }
  14.152 -    return new_sstr;
  14.153 -}
  14.154 -
  14.155 -sstr_t sstrchr(sstr_t s, int c) {
  14.156 -    for(size_t i=0;i<s.length;i++) {
  14.157 -        if(s.ptr[i] == c) {
  14.158 -            return sstrsubs(s, i);
  14.159 -        }
  14.160 -    }
  14.161 -    sstr_t n;
  14.162 -    n.ptr = NULL;
  14.163 -    n.length = 0;
  14.164 -    return n;
  14.165 -}
  14.166 -
  14.167 -sstr_t sstrrchr(sstr_t s, int c) {
  14.168 -    if (s.length > 0) {
  14.169 -        for(size_t i=s.length;i>0;i--) {
  14.170 -            if(s.ptr[i-1] == c) {
  14.171 -                return sstrsubs(s, i-1);
  14.172 -            }
  14.173 -        }
  14.174 -    }
  14.175 -    sstr_t n;
  14.176 -    n.ptr = NULL;
  14.177 -    n.length = 0;
  14.178 -    return n;
  14.179 -}
  14.180 -
  14.181 -sstr_t sstrstr(sstr_t string, sstr_t match) {
  14.182 -    if (match.length == 0) {
  14.183 -        return string;
  14.184 -    }
  14.185 -    
  14.186 -    for (size_t i = 0 ; i < string.length ; i++) {
  14.187 -        sstr_t substr = sstrsubs(string, i);
  14.188 -        if (sstrprefix(substr, match)) {
  14.189 -            return substr;
  14.190 -        }
  14.191 -    }
  14.192 -    
  14.193 -    sstr_t emptystr;
  14.194 -    emptystr.length = 0;
  14.195 -    emptystr.ptr = NULL;
  14.196 -    return emptystr;
  14.197 -}
  14.198 -
  14.199 -sstr_t* sstrsplit(sstr_t s, sstr_t d, ssize_t *n) {
  14.200 -    return sstrsplit_a(ucx_default_allocator(), s, d, n);
  14.201 -}
  14.202 -
  14.203 -sstr_t* sstrsplit_a(UcxAllocator *allocator, sstr_t s, sstr_t d, ssize_t *n) {
  14.204 -    if (s.length == 0 || d.length == 0) {
  14.205 -        *n = -1;
  14.206 -        return NULL;
  14.207 -    }
  14.208 -
  14.209 -    sstr_t* result;
  14.210 -    ssize_t nmax = *n;
  14.211 -    *n = 1;
  14.212 -
  14.213 -    /* special case: exact match - no processing needed */
  14.214 -    if (sstrcmp(s, d) == 0) {
  14.215 -        *n = 0;
  14.216 -        return NULL;
  14.217 -    }
  14.218 -    sstr_t sv = sstrdup(s);
  14.219 -    if (sv.length == 0) {
  14.220 -        *n = -2;
  14.221 -        return NULL;
  14.222 -    }
  14.223 -
  14.224 -    for (size_t i = 0 ; i < s.length ; i++) {
  14.225 -        sstr_t substr = sstrsubs(sv, i);
  14.226 -        if (sstrprefix(substr, d)) {
  14.227 -            (*n)++;
  14.228 -            for (size_t j = 0 ; j < d.length ; j++) {
  14.229 -                sv.ptr[i+j] = 0;
  14.230 -            }
  14.231 -            i += d.length - 1; // -1, because the loop will do a i++
  14.232 -        }
  14.233 -        if ((*n) == nmax) break;
  14.234 -    }
  14.235 -    result = (sstr_t*) almalloc(allocator, sizeof(sstr_t)*(*n));
  14.236 -
  14.237 -    if (result) {
  14.238 -        char *pptr = sv.ptr;
  14.239 -        for (ssize_t i = 0 ; i < *n ; i++) {
  14.240 -            size_t l = strlen(pptr);
  14.241 -            char* ptr = (char*) almalloc(allocator, l + 1);
  14.242 -            if (ptr) {
  14.243 -                memcpy(ptr, pptr, l);
  14.244 -                ptr[l] = 0;
  14.245 -
  14.246 -                result[i] = sstrn(ptr, l);
  14.247 -                pptr += l + d.length;
  14.248 -            } else {
  14.249 -                for (ssize_t j = i-1 ; j >= 0 ; j--) {
  14.250 -                    alfree(allocator, result[j].ptr);
  14.251 -                }
  14.252 -                alfree(allocator, result);
  14.253 -                *n = -2;
  14.254 -                break;
  14.255 -            }
  14.256 -        }
  14.257 -    } else {
  14.258 -        *n = -2;
  14.259 -    }
  14.260 -    
  14.261 -    free(sv.ptr);
  14.262 -
  14.263 -    return result;
  14.264 -}
  14.265 -
  14.266 -int sstrcmp(sstr_t s1, sstr_t s2) {
  14.267 -    if (s1.length == s2.length) {
  14.268 -        return memcmp(s1.ptr, s2.ptr, s1.length);
  14.269 -    } else if (s1.length > s2.length) {
  14.270 -        return 1;
  14.271 -    } else {
  14.272 -        return -1;
  14.273 -    }
  14.274 -}
  14.275 -
  14.276 -int sstrcasecmp(sstr_t s1, sstr_t s2) {
  14.277 -    if (s1.length == s2.length) {
  14.278 -#ifdef _WIN32
  14.279 -        return _strnicmp(s1.ptr, s2.ptr, s1.length);
  14.280 -#else
  14.281 -        return strncasecmp(s1.ptr, s2.ptr, s1.length);
  14.282 -#endif
  14.283 -    } else if (s1.length > s2.length) {
  14.284 -        return 1;
  14.285 -    } else {
  14.286 -        return -1;
  14.287 -    }
  14.288 -}
  14.289 -
  14.290 -sstr_t sstrdup(sstr_t s) {
  14.291 -    return sstrdup_a(ucx_default_allocator(), s);
  14.292 -}
  14.293 -
  14.294 -sstr_t sstrdup_a(UcxAllocator *allocator, sstr_t s) {
  14.295 -    sstr_t newstring;
  14.296 -    newstring.ptr = (char*)almalloc(allocator, s.length + 1);
  14.297 -    if (newstring.ptr) {
  14.298 -        newstring.length = s.length;
  14.299 -        newstring.ptr[newstring.length] = 0;
  14.300 -        
  14.301 -        memcpy(newstring.ptr, s.ptr, s.length);
  14.302 -    } else {
  14.303 -        newstring.length = 0;
  14.304 -    }
  14.305 -    
  14.306 -    return newstring;
  14.307 -}
  14.308 -
  14.309 -sstr_t sstrtrim(sstr_t string) {
  14.310 -    sstr_t newstr = string;
  14.311 -    
  14.312 -    while (newstr.length > 0 && isspace(*newstr.ptr)) {
  14.313 -        newstr.ptr++;
  14.314 -        newstr.length--;
  14.315 -    }
  14.316 -    while (newstr.length > 0 && isspace(newstr.ptr[newstr.length-1])) {
  14.317 -        newstr.length--;
  14.318 -    }
  14.319 -    
  14.320 -    return newstr;
  14.321 -}
  14.322 -
  14.323 -int sstrprefix(sstr_t string, sstr_t prefix) {
  14.324 -    if (string.length == 0) {
  14.325 -        return prefix.length == 0;
  14.326 -    }
  14.327 -    if (prefix.length == 0) {
  14.328 -        return 1;
  14.329 -    }
  14.330 -    
  14.331 -    if (prefix.length > string.length) {
  14.332 -        return 0;
  14.333 -    } else {
  14.334 -        return memcmp(string.ptr, prefix.ptr, prefix.length) == 0;
  14.335 -    }
  14.336 -}
  14.337 -
  14.338 -int sstrsuffix(sstr_t string, sstr_t suffix) {
  14.339 -    if (string.length == 0) {
  14.340 -        return suffix.length == 0;
  14.341 -    }
  14.342 -    if (suffix.length == 0) {
  14.343 -        return 1;
  14.344 -    }
  14.345 -    
  14.346 -    if (suffix.length > string.length) {
  14.347 -        return 0;
  14.348 -    } else {
  14.349 -        return memcmp(string.ptr+string.length-suffix.length,
  14.350 -            suffix.ptr, suffix.length) == 0;
  14.351 -    }
  14.352 -}
  14.353 -
  14.354 -sstr_t sstrlower(sstr_t string) {
  14.355 -    sstr_t ret = sstrdup(string);
  14.356 -    for (size_t i = 0; i < ret.length ; i++) {
  14.357 -        ret.ptr[i] = tolower(ret.ptr[i]);
  14.358 -    }
  14.359 -    return ret;
  14.360 -}
  14.361 -
  14.362 -sstr_t sstrlower_a(UcxAllocator *allocator, sstr_t string) {
  14.363 -    sstr_t ret = sstrdup_a(allocator, string);
  14.364 -    for (size_t i = 0; i < ret.length ; i++) {
  14.365 -        ret.ptr[i] = tolower(ret.ptr[i]);
  14.366 -    }
  14.367 -    return ret;
  14.368 -}
  14.369 -
  14.370 -sstr_t sstrupper(sstr_t string) {
  14.371 -    sstr_t ret = sstrdup(string);
  14.372 -    for (size_t i = 0; i < ret.length ; i++) {
  14.373 -        ret.ptr[i] = toupper(ret.ptr[i]);
  14.374 -    }
  14.375 -    return ret;
  14.376 -}
  14.377 -
  14.378 -sstr_t sstrupper_a(UcxAllocator *allocator, sstr_t string) {
  14.379 -    sstr_t ret = sstrdup_a(allocator, string);
  14.380 -    for (size_t i = 0; i < ret.length ; i++) {
  14.381 -        ret.ptr[i] = toupper(ret.ptr[i]);
  14.382 -    }
  14.383 -    return ret;
  14.384 -}

    15.1 --- a/src/ucx/string.h	Thu Nov 10 18:44:48 2016 +0100
    15.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    15.3 @@ -1,457 +0,0 @@
    15.4 -/*
    15.5 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
    15.6 - *
    15.7 - * Copyright 2015 Olaf Wintermann. All rights reserved.
    15.8 - *
    15.9 - * Redistribution and use in source and binary forms, with or without
   15.10 - * modification, are permitted provided that the following conditions are met:
   15.11 - *
   15.12 - *   1. Redistributions of source code must retain the above copyright
   15.13 - *      notice, this list of conditions and the following disclaimer.
   15.14 - *
   15.15 - *   2. Redistributions in binary form must reproduce the above copyright
   15.16 - *      notice, this list of conditions and the following disclaimer in the
   15.17 - *      documentation and/or other materials provided with the distribution.
   15.18 - *
   15.19 - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   15.20 - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   15.21 - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   15.22 - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
   15.23 - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   15.24 - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   15.25 - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   15.26 - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   15.27 - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   15.28 - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   15.29 - * POSSIBILITY OF SUCH DAMAGE.
   15.30 - */
   15.31 -/**
   15.32 - * Bounded string implementation.
   15.33 - * 
   15.34 - * The UCX strings (<code>sstr_t</code>) provide an alternative to C strings.
   15.35 - * The main difference to C strings is, that <code>sstr_t</code> does <b>not
   15.36 - * need to be <code>NULL</code>-terminated</b>. Instead the length is stored
   15.37 - * within the structure.
   15.38 - * 
   15.39 - * When using <code>sstr_t</code>, developers must be full aware of what type
   15.40 - * of string (<code>NULL</code>-terminated) or not) they are using, when 
   15.41 - * accessing the <code>char* ptr</code> directly.
   15.42 - * 
   15.43 - * The UCX string module provides some common string functions, known from
   15.44 - * standard libc, working with <code>sstr_t</code>.
   15.45 - * 
   15.46 - * @file   string.h
   15.47 - * @author Mike Becker
   15.48 - * @author Olaf Wintermann
   15.49 - */
   15.50 -
   15.51 -#ifndef UCX_STRING_H
   15.52 -#define	UCX_STRING_H
   15.53 -
   15.54 -#include "ucx.h"
   15.55 -#include "allocator.h"
   15.56 -#include <stddef.h>
   15.57 -
   15.58 -/** Shortcut for a <code>sstr_t struct</code> literal. */
   15.59 -#define ST(s) { (char*)s, sizeof(s)-1 }
   15.60 -
   15.61 -/** Shortcut for the conversion of a C string to a <code>sstr_t</code>. */
   15.62 -#define S(s) sstrn((char*)s, sizeof(s)-1)
   15.63 -
   15.64 -#ifdef	__cplusplus
   15.65 -extern "C" {
   15.66 -#endif
   15.67 -
   15.68 -/**
   15.69 - * The UCX string structure.
   15.70 - */
   15.71 -typedef struct {
   15.72 -   /** A reference to the string (<b>not necessarily  <code>NULL</code>
   15.73 -    * -terminated</b>) */
   15.74 -    char   *ptr;
   15.75 -    /** The length of the string */
   15.76 -    size_t length;
   15.77 -} sstr_t;
   15.78 -
   15.79 -/**
   15.80 - * Creates a new sstr_t based on a C string.
   15.81 - * 
   15.82 - * The length is implicitly inferred by using a call to <code>strlen()</code>.
   15.83 - *
   15.84 - * <b>Note:</b> the sstr_t will hold a <i>reference</i> to the C string. If you
   15.85 - * do want a copy, use sstrdup() on the return value of this function.
   15.86 - * 
   15.87 - * @param cstring the C string to wrap
   15.88 - * @return a new sstr_t containing the C string
   15.89 - * 
   15.90 - * @see sstrn()
   15.91 - */
   15.92 -sstr_t sstr(char *cstring);
   15.93 -
   15.94 -/**
   15.95 - * Creates a new sstr_t of the specified length based on a C string.
   15.96 - *
   15.97 - * <b>Note:</b> the sstr_t will hold a <i>reference</i> to the C string. If you
   15.98 - * do want a copy, use sstrdup() on the return value of this function.
   15.99 - * 
  15.100 - * @param cstring  the C string to wrap
  15.101 - * @param length   the length of the string
  15.102 - * @return a new sstr_t containing the C string
  15.103 - * 
  15.104 - * @see sstr()
  15.105 - * @see S()
  15.106 - */
  15.107 -sstr_t sstrn(char *cstring, size_t length);
  15.108 -
  15.109 -
  15.110 -/**
  15.111 - * Returns the cumulated length of all specified strings.
  15.112 - *
  15.113 - * At least one string must be specified.
  15.114 - * 
  15.115 - * <b>Attention:</b> if the count argument does not match the count of the
  15.116 - * specified strings, the behavior is undefined.
  15.117 - *
  15.118 - * @param count    the total number of specified strings (so at least 1)
  15.119 - * @param string   the first string
  15.120 - * @param ...      all other strings
  15.121 - * @return the cumulated length of all strings
  15.122 - */
  15.123 -size_t sstrnlen(size_t count, sstr_t string, ...);
  15.124 -
  15.125 -/**
  15.126 - * Concatenates two or more strings.
  15.127 - * 
  15.128 - * The resulting string will be allocated by standard <code>malloc()</code>. 
  15.129 - * So developers <b>MUST</b> pass the sstr_t.ptr to <code>free()</code>.
  15.130 - * 
  15.131 - * The sstr_t.ptr of the return value will <i>always</i> be <code>NULL</code>-
  15.132 - * terminated.
  15.133 - *
  15.134 - * @param count   the total number of strings to concatenate
  15.135 - * @param s1      first string
  15.136 - * @param s2      second string
  15.137 - * @param ...     all remaining strings
  15.138 - * @return the concatenated string
  15.139 - */
  15.140 -sstr_t sstrcat(size_t count, sstr_t s1, sstr_t s2, ...);
  15.141 -
  15.142 -/**
  15.143 - * Concatenates two or more strings using an UcxAllocator.
  15.144 - * 
  15.145 - * See sstrcat() for details.
  15.146 - *
  15.147 - * @param a       the allocator to use
  15.148 - * @param count   the total number of strings to concatenate
  15.149 - * @param s1      first string
  15.150 - * @param s2      second string
  15.151 - * @param ...     all remaining strings
  15.152 - * @return the concatenated string
  15.153 - */
  15.154 -sstr_t sstrcat_a(UcxAllocator *a, size_t count, sstr_t s1, sstr_t s2, ...);
  15.155 -
  15.156 -
  15.157 -/**
  15.158 - * Returns a substring starting at the specified location.
  15.159 - * 
  15.160 - * <b>Attention:</b> the new string references the same memory area as the
  15.161 - * input string and will <b>NOT</b> be <code>NULL</code>-terminated.
  15.162 - * Use sstrdup() to get a copy.
  15.163 - * 
  15.164 - * @param string input string
  15.165 - * @param start  start location of the substring
  15.166 - * @return a substring of <code>string</code> starting at <code>start</code>
  15.167 - * 
  15.168 - * @see sstrsubsl()
  15.169 - * @see sstrchr()
  15.170 - */
  15.171 -sstr_t sstrsubs(sstr_t string, size_t start);
  15.172 -
  15.173 -/**
  15.174 - * Returns a substring with a maximum length starting at the specified location.
  15.175 - * 
  15.176 - * <b>Attention:</b> the new string references the same memory area as the
  15.177 - * input string and will <b>NOT</b> be <code>NULL</code>-terminated.
  15.178 - * Use sstrdup() to get a copy.
  15.179 - * 
  15.180 - * @param string input string
  15.181 - * @param start  start location of the substring
  15.182 - * @param length the maximum length of the substring
  15.183 - * @return a substring of <code>string</code> starting at <code>start</code>
  15.184 - * with a maximum length of <code>length</code>
  15.185 - * 
  15.186 - * @see sstrsubs()
  15.187 - * @see sstrchr()
  15.188 - */
  15.189 -sstr_t sstrsubsl(sstr_t string, size_t start, size_t length);
  15.190 -
  15.191 -/**
  15.192 - * Returns a substring starting at the location of the first occurrence of the
  15.193 - * specified character.
  15.194 - * 
  15.195 - * If the string does not contain the character, an empty string is returned.
  15.196 - * 
  15.197 - * @param string the string where to locate the character
  15.198 - * @param chr    the character to locate
  15.199 - * @return       a substring starting at the first location of <code>chr</code>
  15.200 - * 
  15.201 - * @see sstrsubs()
  15.202 - */
  15.203 -sstr_t sstrchr(sstr_t string, int chr);
  15.204 -
  15.205 -/**
  15.206 - * Returns a substring starting at the location of the last occurrence of the
  15.207 - * specified character.
  15.208 - * 
  15.209 - * If the string does not contain the character, an empty string is returned.
  15.210 - * 
  15.211 - * @param string the string where to locate the character
  15.212 - * @param chr    the character to locate
  15.213 - * @return       a substring starting at the last location of <code>chr</code>
  15.214 - * 
  15.215 - * @see sstrsubs()
  15.216 - */
  15.217 -sstr_t sstrrchr(sstr_t string, int chr);
  15.218 -
  15.219 -/**
  15.220 - * Returns a substring starting at the location of the first occurrence of the
  15.221 - * specified string.
  15.222 - * 
  15.223 - * If the string does not contain the other string, an empty string is returned.
  15.224 - * 
  15.225 - * If <code>match</code> is an empty string, the complete <code>string</code> is
  15.226 - * returned.
  15.227 - * 
  15.228 - * @param string the string to be scanned
  15.229 - * @param match  string containing the sequence of characters to match
  15.230 - * @return       a substring starting at the first occurrence of
  15.231 - *               <code>match</code>, or an empty string, if the sequence is not
  15.232 - *               present in <code>string</code>
  15.233 - */
  15.234 -sstr_t sstrstr(sstr_t string, sstr_t match);
  15.235 -
  15.236 -/**
  15.237 - * Splits a string into parts by using a delimiter string.
  15.238 - * 
  15.239 - * This function will return <code>NULL</code>, if one of the following happens:
  15.240 - * <ul>
  15.241 - *   <li>the string length is zero</li>
  15.242 - *   <li>the delimeter length is zero</li>
  15.243 - *   <li>the string equals the delimeter</li>
  15.244 - *   <li>memory allocation fails</li>
  15.245 - * </ul>
  15.246 - * 
  15.247 - * The integer referenced by <code>count</code> is used as input and determines
  15.248 - * the maximum size of the resulting array, i.e. the maximum count of splits to
  15.249 - * perform + 1.
  15.250 - * 
  15.251 - * The integer referenced by <code>count</code> is also used as output and is
  15.252 - * set to
  15.253 - * <ul>
  15.254 - *   <li>-2, on memory allocation errors</li>
  15.255 - *   <li>-1, if either the string or the delimiter is an empty string</li>
  15.256 - *   <li>0, if the string equals the delimiter</li>
  15.257 - *   <li>1, if the string does not contain the delimiter</li>
  15.258 - *   <li>the count of array items, otherwise</li>
  15.259 - * </ul>
  15.260 - * 
  15.261 - * If the string starts with the delimiter, the first item of the resulting
  15.262 - * array will be an empty string.
  15.263 - * 
  15.264 - * If the string ends with the delimiter and the maximum list size is not
  15.265 - * exceeded, the last array item will be an empty string.
  15.266 - * 
  15.267 - * <b>Attention:</b> The array pointer <b>AND</b> all sstr_t.ptr of the array
  15.268 - * items must be manually passed to <code>free()</code>. Use sstrsplit_a() with
  15.269 - * an allocator to managed memory, to avoid this.
  15.270 - *
  15.271 - * @param string the string to split
  15.272 - * @param delim  the delimiter string
  15.273 - * @param count  IN: the maximum size of the resulting array (0 = no limit),
  15.274 - *               OUT: the actual size of the array
  15.275 - * @return a sstr_t array containing the split strings or
  15.276 - *         <code>NULL</code> on error
  15.277 - * 
  15.278 - * @see sstrsplit_a()
  15.279 - */
  15.280 -sstr_t* sstrsplit(sstr_t string, sstr_t delim, ssize_t *count);
  15.281 -
  15.282 -/**
  15.283 - * Performing sstrsplit() using an UcxAllocator.
  15.284 - * 
  15.285 - * <i>Read the description of sstrsplit() for details.</i>
  15.286 - * 
  15.287 - * The memory for the sstr_t.ptr pointers of the array items and the memory for
  15.288 - * the sstr_t array itself are allocated by using the UcxAllocator.malloc()
  15.289 - * function.
  15.290 - * 
  15.291 - * <b>Note:</b> the allocator is not used for memory that is freed within the
  15.292 - * same call of this function (locally scoped variables).
  15.293 - * 
  15.294 - * @param allocator the UcxAllocator used for allocating memory
  15.295 - * @param string the string to split
  15.296 - * @param delim  the delimiter string
  15.297 - * @param count  IN: the maximum size of the resulting array (0 = no limit),
  15.298 - *               OUT: the actual size of the array
  15.299 - * @return a sstr_t array containing the split strings or
  15.300 - *         <code>NULL</code> on error
  15.301 - * 
  15.302 - * @see sstrsplit()
  15.303 - */
  15.304 -sstr_t* sstrsplit_a(UcxAllocator *allocator, sstr_t string, sstr_t delim,
  15.305 -        ssize_t *count);
  15.306 -
  15.307 -/**
  15.308 - * Compares two UCX strings with standard <code>memcmp()</code>.
  15.309 - * 
  15.310 - * At first it compares the sstr_t.length attribute of the two strings. The
  15.311 - * <code>memcmp()</code> function is called, if and only if the lengths match.
  15.312 - * 
  15.313 - * @param s1 the first string
  15.314 - * @param s2 the second string
  15.315 - * @return -1, if the length of s1 is less than the length of s2 or 1, if the 
  15.316 - * length of s1 is greater than the length of s2 or the result of
  15.317 - * <code>memcmp()</code> otherwise (i.e. 0 if the strings match)
  15.318 - */
  15.319 -int sstrcmp(sstr_t s1, sstr_t s2);
  15.320 -
  15.321 -/**
  15.322 - * Compares two UCX strings ignoring the case.
  15.323 - * 
  15.324 - * At first it compares the sstr_t.length attribute of the two strings. If and
  15.325 - * only if the lengths match, both strings are compared char by char ignoring
  15.326 - * the case.
  15.327 - * 
  15.328 - * @param s1 the first string
  15.329 - * @param s2 the second string
  15.330 - * @return -1, if the length of s1 is less than the length of s2 or 1, if the 
  15.331 - * length of s1 is greater than the length of s2 or the difference between the
  15.332 - * first two differing characters otherwise (i.e. 0 if the strings match and
  15.333 - * no characters differ)
  15.334 - */
  15.335 -int sstrcasecmp(sstr_t s1, sstr_t s2);
  15.336 -
  15.337 -/**
  15.338 - * Creates a duplicate of the specified string.
  15.339 - * 
  15.340 - * The new sstr_t will contain a copy allocated by standard
  15.341 - * <code>malloc()</code>. So developers <b>MUST</b> pass the sstr_t.ptr to
  15.342 - * <code>free()</code>.
  15.343 - * 
  15.344 - * The sstr_t.ptr of the return value will <i>always</i> be <code>NULL</code>-
  15.345 - * terminated.
  15.346 - * 
  15.347 - * @param string the string to duplicate
  15.348 - * @return a duplicate of the string
  15.349 - * @see sstrdup_a()
  15.350 - */
  15.351 -sstr_t sstrdup(sstr_t string);
  15.352 -
  15.353 -/**
  15.354 - * Creates a duplicate of the specified string using an UcxAllocator.
  15.355 - * 
  15.356 - * The new sstr_t will contain a copy allocated by the allocators
  15.357 - * ucx_allocator_malloc function. So it is implementation depended, whether the
  15.358 - * returned sstr_t.ptr pointer must be passed to the allocators
  15.359 - * ucx_allocator_free function manually.
  15.360 - * 
  15.361 - * The sstr_t.ptr of the return value will <i>always</i> be <code>NULL</code>-
  15.362 - * terminated.
  15.363 - * 
  15.364 - * @param allocator a valid instance of an UcxAllocator
  15.365 - * @param string the string to duplicate
  15.366 - * @return a duplicate of the string
  15.367 - * @see sstrdup()
  15.368 - */
  15.369 -sstr_t sstrdup_a(UcxAllocator *allocator, sstr_t string);
  15.370 -
  15.371 -/**
  15.372 - * Omits leading and trailing spaces.
  15.373 - * 
  15.374 - * This function returns a new sstr_t containing a trimmed version of the
  15.375 - * specified string.
  15.376 - * 
  15.377 - * <b>Note:</b> the new sstr_t references the same memory, thus you
  15.378 - * <b>MUST NOT</b> pass the sstr_t.ptr of the return value to
  15.379 - * <code>free()</code>. It is also highly recommended to avoid assignments like
  15.380 - * <code>mystr = sstrtrim(mystr);</code> as you lose the reference to the
  15.381 - * source string. Assignments of this type are only permitted, if the
  15.382 - * sstr_t.ptr of the source string does not need to be freed or if another
  15.383 - * reference to the source string exists.
  15.384 - * 
  15.385 - * @param string the string that shall be trimmed
  15.386 - * @return a new sstr_t containing the trimmed string
  15.387 - */
  15.388 -sstr_t sstrtrim(sstr_t string);
  15.389 -
  15.390 -/**
  15.391 - * Checks, if a string has a specific prefix.
  15.392 - * @param string the string to check
  15.393 - * @param prefix the prefix the string should have
  15.394 - * @return 1, if and only if the string has the specified prefix, 0 otherwise
  15.395 - */
  15.396 -int sstrprefix(sstr_t string, sstr_t prefix);
  15.397 -
  15.398 -/**
  15.399 - * Checks, if a string has a specific suffix.
  15.400 - * @param string the string to check
  15.401 - * @param suffix the suffix the string should have
  15.402 - * @return 1, if and only if the string has the specified suffix, 0 otherwise
  15.403 - */
  15.404 -int sstrsuffix(sstr_t string, sstr_t suffix);
  15.405 -
  15.406 -/**
  15.407 - * Returns a lower case version of a string.
  15.408 - * 
  15.409 - * This function creates a duplicate of the input string, first. See the
  15.410 - * documentation of sstrdup() for the implications.
  15.411 - * 
  15.412 - * @param string the input string
  15.413 - * @return the resulting lower case string
  15.414 - * @see sstrdup()
  15.415 - */
  15.416 -sstr_t sstrlower(sstr_t string);
  15.417 -
  15.418 -/**
  15.419 - * Returns a lower case version of a string.
  15.420 - * 
  15.421 - * This function creates a duplicate of the input string, first. See the
  15.422 - * documentation of sstrdup_a() for the implications.
  15.423 - * 
  15.424 - * @param allocator the allocator used for duplicating the string
  15.425 - * @param string the input string
  15.426 - * @return the resulting lower case string
  15.427 - * @see sstrdup_a()
  15.428 - */
  15.429 -sstr_t sstrlower_a(UcxAllocator *allocator, sstr_t string);
  15.430 -
  15.431 -/**
  15.432 - * Returns a upper case version of a string.
  15.433 - * 
  15.434 - * This function creates a duplicate of the input string, first. See the
  15.435 - * documentation of sstrdup() for the implications.
  15.436 - * 
  15.437 - * @param string the input string
  15.438 - * @return the resulting upper case string
  15.439 - * @see sstrdup()
  15.440 - */
  15.441 -sstr_t sstrupper(sstr_t string);
  15.442 -
  15.443 -/**
  15.444 - * Returns a upper case version of a string.
  15.445 - * 
  15.446 - * This function creates a duplicate of the input string, first. See the
  15.447 - * documentation of sstrdup_a() for the implications.
  15.448 - * 
  15.449 - * @param allocator the allocator used for duplicating the string
  15.450 - * @param string the input string
  15.451 - * @return the resulting upper case string
  15.452 - * @see sstrdup_a()
  15.453 - */
  15.454 -sstr_t sstrupper_a(UcxAllocator *allocator, sstr_t string);
  15.455 -
  15.456 -#ifdef	__cplusplus
  15.457 -}
  15.458 -#endif
  15.459 -
  15.460 -#endif	/* UCX_STRING_H */

    16.1 --- a/src/ucx/ucx.h	Thu Nov 10 18:44:48 2016 +0100
    16.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    16.3 @@ -1,138 +0,0 @@
    16.4 -/*
    16.5 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
    16.6 - *
    16.7 - * Copyright 2015 Olaf Wintermann. All rights reserved.
    16.8 - *
    16.9 - * Redistribution and use in source and binary forms, with or without
   16.10 - * modification, are permitted provided that the following conditions are met:
   16.11 - *
   16.12 - *   1. Redistributions of source code must retain the above copyright
   16.13 - *      notice, this list of conditions and the following disclaimer.
   16.14 - *
   16.15 - *   2. Redistributions in binary form must reproduce the above copyright
   16.16 - *      notice, this list of conditions and the following disclaimer in the
   16.17 - *      documentation and/or other materials provided with the distribution.
   16.18 - *
   16.19 - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   16.20 - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   16.21 - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   16.22 - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
   16.23 - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   16.24 - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   16.25 - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   16.26 - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   16.27 - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   16.28 - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   16.29 - * POSSIBILITY OF SUCH DAMAGE.
   16.30 - */
   16.31 -/**
   16.32 - * Main UCX Header providing most common definitions.
   16.33 - * 
   16.34 - * @file   ucx.h
   16.35 - * @author Mike Becker
   16.36 - * @author Olaf Wintermann
   16.37 - */
   16.38 -
   16.39 -#ifndef UCX_H
   16.40 -#define	UCX_H
   16.41 -
   16.42 -/** Major UCX version as integer constant. */
   16.43 -#define UCX_VERSION_MAJOR   0
   16.44 -
   16.45 -/** Minor UCX version as integer constant. */
   16.46 -#define UCX_VERSION_MINOR   9
   16.47 -
   16.48 -/** The UCX version in format [major].[minor] */
   16.49 -#define UCX_VERSION UCX_VERSION_MAJOR.UCX_VERSION_MINOR
   16.50 -
   16.51 -#include <stdlib.h>
   16.52 -
   16.53 -#ifdef _WIN32
   16.54 -#if !(defined __ssize_t_defined || defined _SSIZE_T_)
   16.55 -#include <BaseTsd.h>
   16.56 -typedef SSIZE_T ssize_t;
   16.57 -#define __ssize_t_defined
   16.58 -#define _SSIZE_T_
   16.59 -#endif /* __ssize_t_defined and _SSIZE_T */
   16.60 -#else /* !_WIN32 */
   16.61 -#include <sys/types.h>
   16.62 -#endif /* _WIN32 */
   16.63 -
   16.64 -#ifdef	__cplusplus
   16.65 -#ifndef _Bool
   16.66 -#define _Bool bool
   16.67 -#define restrict
   16.68 -#endif
   16.69 -/** Use C naming even when compiling with C++.  */
   16.70 -#define UCX_EXTERN extern "C"
   16.71 -extern "C" {
   16.72 -#else
   16.73 -/** Pointless in C. */
   16.74 -#define UCX_EXTERN
   16.75 -#endif
   16.76 -    
   16.77 -
   16.78 -/**
   16.79 - * A function pointer to a destructor function.
   16.80 - * @see ucx_mempool_setdestr()
   16.81 - * @see ucx_mempool_regdestr()
   16.82 - */
   16.83 -typedef void(*ucx_destructor)(void*);
   16.84 -
   16.85 -/**
   16.86 - * Function pointer to a compare function.
   16.87 - * 
   16.88 - * The compare function shall take three arguments: the two values that shall be
   16.89 - * compared and optional additional data.
   16.90 - * The function shall then return -1 if the first argument is less than the
   16.91 - * second argument, 1 if the first argument is greater than the second argument
   16.92 - * and 0 if both arguments are equal. If the third argument is
   16.93 - * <code>NULL</code>, it shall be ignored.
   16.94 - */
   16.95 -typedef int(*cmp_func)(void*,void*,void*);
   16.96 -
   16.97 -/**
   16.98 - * Function pointer to a copy function.
   16.99 - * 
  16.100 - * The copy function shall create a copy of the first argument and may use
  16.101 - * additional data provided by the second argument. If the second argument is
  16.102 - * <code>NULL</code>, it shall be ignored.
  16.103 -
  16.104 - * <b>Attention:</b> if pointers returned by functions of this type may be
  16.105 - * passed to <code>free()</code> depends on the implementation of the
  16.106 - * respective <code>copy_func</code>.
  16.107 - */
  16.108 -typedef void*(*copy_func)(void*,void*);
  16.109 -
  16.110 -/**
  16.111 - * Function pointer to a write function.
  16.112 - * 
  16.113 - * The signature of the write function shall be compatible to the signature
  16.114 - * of standard <code>fwrite</code>, though it may use arbitrary data types for
  16.115 - * source and destination.
  16.116 - * 
  16.117 - * The arguments shall contain (in ascending order): a pointer to the source,
  16.118 - * the length of one element, the element count and a pointer to the
  16.119 - * destination.
  16.120 - */
  16.121 -typedef size_t(*write_func)(const void*, size_t, size_t, void*);
  16.122 -
  16.123 -/**
  16.124 - * Function pointer to a read function.
  16.125 - * 
  16.126 - * The signature of the read function shall be compatible to the signature
  16.127 - * of standard <code>fread</code>, though it may use arbitrary data types for
  16.128 - * source and destination.
  16.129 - * 
  16.130 - * The arguments shall contain (in ascending order): a pointer to the
  16.131 - * destination, the length of one element, the element count and a pointer to
  16.132 - * the source.
  16.133 - */
  16.134 -typedef size_t(*read_func)(void*, size_t, size_t, void*);
  16.135 -
  16.136 -#ifdef	__cplusplus
  16.137 -}
  16.138 -#endif
  16.139 -
  16.140 -#endif	/* UCX_H */
  16.141 -

    17.1 --- a/src/ucx/utils.c	Thu Nov 10 18:44:48 2016 +0100
    17.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    17.3 @@ -1,259 +0,0 @@
    17.4 -/*
    17.5 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
    17.6 - *
    17.7 - * Copyright 2015 Olaf Wintermann. All rights reserved.
    17.8 - *
    17.9 - * Redistribution and use in source and binary forms, with or without
   17.10 - * modification, are permitted provided that the following conditions are met:
   17.11 - *
   17.12 - *   1. Redistributions of source code must retain the above copyright
   17.13 - *      notice, this list of conditions and the following disclaimer.
   17.14 - *
   17.15 - *   2. Redistributions in binary form must reproduce the above copyright
   17.16 - *      notice, this list of conditions and the following disclaimer in the
   17.17 - *      documentation and/or other materials provided with the distribution.
   17.18 - *
   17.19 - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   17.20 - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   17.21 - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   17.22 - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
   17.23 - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   17.24 - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   17.25 - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   17.26 - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   17.27 - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   17.28 - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   17.29 - * POSSIBILITY OF SUCH DAMAGE.
   17.30 - */
   17.31 -
   17.32 -#include "utils.h"
   17.33 -#include <math.h>
   17.34 -#include <stdio.h>
   17.35 -#include <limits.h>
   17.36 -#include <errno.h>
   17.37 -
   17.38 -/* COPY FUCNTIONS */
   17.39 -void* ucx_strcpy(void* s, void* data) {
   17.40 -    char *str = (char*) s;
   17.41 -    size_t n = 1+strlen(str);
   17.42 -    char *cpy = (char*) malloc(n);
   17.43 -    memcpy(cpy, str, n);
   17.44 -    return cpy;
   17.45 -}
   17.46 -
   17.47 -void* ucx_memcpy(void* m, void* n) {
   17.48 -    size_t k = *((size_t*)n);
   17.49 -    void *cpy = malloc(k);
   17.50 -    memcpy(cpy, m, k);
   17.51 -    return cpy;
   17.52 -}
   17.53 -
   17.54 -size_t ucx_stream_copy(void *src, void *dest, read_func readfnc,
   17.55 -        write_func writefnc, char* buf, size_t bufsize, size_t n) {
   17.56 -    if(n == 0 || bufsize == 0) {
   17.57 -        return 0;
   17.58 -    }
   17.59 -    
   17.60 -    char *lbuf;    
   17.61 -    size_t ncp = 0;
   17.62 -    
   17.63 -    if(buf) {
   17.64 -        lbuf = buf;
   17.65 -    } else {
   17.66 -        lbuf = (char*)malloc(bufsize);
   17.67 -        if(lbuf == NULL) {
   17.68 -            return 0;
   17.69 -        }
   17.70 -    }
   17.71 -    
   17.72 -    size_t r;
   17.73 -    size_t rn = bufsize > n ? n : bufsize;
   17.74 -    while((r = readfnc(lbuf, 1, rn, src)) != 0) {
   17.75 -        r = writefnc(lbuf, 1, r, dest);
   17.76 -        ncp += r;
   17.77 -        n -= r;
   17.78 -        rn = bufsize > n ? n : bufsize;
   17.79 -        if(r == 0 || n == 0) {
   17.80 -            break;
   17.81 -        }
   17.82 -    }
   17.83 -    
   17.84 -    if (lbuf != buf) {
   17.85 -        free(lbuf);
   17.86 -    }
   17.87 -    
   17.88 -    return ncp;
   17.89 -}
   17.90 -
   17.91 -/* COMPARE FUNCTIONS */
   17.92 -
   17.93 -int ucx_strcmp(void *s1, void *s2, void *data) {
   17.94 -    return strcmp((char*)s1, (char*)s2);
   17.95 -}
   17.96 -
   17.97 -int ucx_strncmp(void *s1, void *s2, void *n) {
   17.98 -    return strncmp((char*)s1, (char*)s2, *((size_t*) n));
   17.99 -}
  17.100 -
  17.101 -int ucx_intcmp(void *i1, void *i2, void *data) {
  17.102 -   int a = *((int*) i1);
  17.103 -   int b = *((int*) i2);
  17.104 -   if (a == b) {
  17.105 -       return 0;
  17.106 -   } else {
  17.107 -       return a < b ? -1 : 1;
  17.108 -   }
  17.109 -}
  17.110 -
  17.111 -int ucx_floatcmp(void *f1, void *f2, void *epsilon) {
  17.112 -   float a = *((float*) f1);
  17.113 -   float b = *((float*) f2);
  17.114 -   float e = !epsilon ? 1e-6f : *((float*)epsilon);
  17.115 -   if (fabsf(a - b) < e) {
  17.116 -       return 0;
  17.117 -   } else {
  17.118 -       return a < b ? -1 : 1;
  17.119 -   }
  17.120 -}
  17.121 -
  17.122 -int ucx_doublecmp(void *d1, void *d2, void *epsilon) {
  17.123 -   double a = *((float*) d1);
  17.124 -   double b = *((float*) d2);
  17.125 -   double e = !epsilon ? 1e-14 : *((double*)epsilon);
  17.126 -   if (fabs(a - b) < e) {
  17.127 -       return 0;
  17.128 -   } else {
  17.129 -       return a < b ? -1 : 1;
  17.130 -   }
  17.131 -}
  17.132 -
  17.133 -int ucx_ptrcmp(void *ptr1, void *ptr2, void *data) {
  17.134 -    intptr_t p1 = (intptr_t) ptr1;
  17.135 -    intptr_t p2 = (intptr_t) ptr2;
  17.136 -    if (p1 == p2) {
  17.137 -        return 0;
  17.138 -    } else {
  17.139 -        return p1  < p2 ? -1 : 1;
  17.140 -    }
  17.141 -}
  17.142 -
  17.143 -int ucx_memcmp(void *ptr1, void *ptr2, void *n) {
  17.144 -    return memcmp(ptr1, ptr2, *((size_t*)n));
  17.145 -}
  17.146 -
  17.147 -/* PRINTF FUNCTIONS */
  17.148 -
  17.149 -#ifdef va_copy
  17.150 -#define UCX_PRINTF_BUFSIZE 256
  17.151 -#else
  17.152 -#pragma message("WARNING: C99 va_copy macro not supported by this platform" \
  17.153 -                " - limiting ucx_*printf to 2 KiB")
  17.154 -#define UCX_PRINTF_BUFSIZE 0x800
  17.155 -#endif
  17.156 -
  17.157 -int ucx_fprintf(void *stream, write_func wfc, const char *fmt, ...) {
  17.158 -    int ret;
  17.159 -    va_list ap;
  17.160 -    va_start(ap, fmt);
  17.161 -    ret = ucx_vfprintf(stream, wfc, fmt, ap);
  17.162 -    va_end(ap);
  17.163 -    return ret;
  17.164 -}
  17.165 -
  17.166 -int ucx_vfprintf(void *stream, write_func wfc, const char *fmt, va_list ap) {
  17.167 -    char buf[UCX_PRINTF_BUFSIZE];
  17.168 -#ifdef va_copy
  17.169 -    va_list ap2;
  17.170 -    va_copy(ap2, ap);
  17.171 -    int ret = vsnprintf(buf, UCX_PRINTF_BUFSIZE, fmt, ap);
  17.172 -    if (ret < 0) {
  17.173 -        return ret;
  17.174 -    } else if (ret < UCX_PRINTF_BUFSIZE) {
  17.175 -        return (int)wfc(buf, 1, ret, stream);
  17.176 -    } else {
  17.177 -        if (ret == INT_MAX) {
  17.178 -            errno = ENOMEM;
  17.179 -            return -1;
  17.180 -        }
  17.181 -        
  17.182 -        int len = ret + 1;
  17.183 -        char *newbuf = (char*)malloc(len);
  17.184 -        if (!newbuf) {
  17.185 -            return -1;
  17.186 -        }
  17.187 -        
  17.188 -        ret = vsnprintf(newbuf, len, fmt, ap2);
  17.189 -        if (ret > 0) {
  17.190 -            ret = (int)wfc(newbuf, 1, ret, stream);
  17.191 -        }
  17.192 -        free(newbuf);
  17.193 -    }
  17.194 -    return ret;
  17.195 -#else
  17.196 -    int ret = vsnprintf(buf, UCX_PRINTF_BUFSIZE, fmt, ap);
  17.197 -    if (ret < 0) {
  17.198 -        return ret;
  17.199 -    } else if (ret < UCX_PRINTF_BUFSIZE) {
  17.200 -        return (int)wfc(buf, 1, ret, stream);
  17.201 -    } else {
  17.202 -        errno = ENOMEM;
  17.203 -        return -1;
  17.204 -    }
  17.205 -#endif
  17.206 -}
  17.207 -
  17.208 -sstr_t ucx_asprintf(UcxAllocator *allocator, const char *fmt, ...) {
  17.209 -    va_list ap;
  17.210 -    sstr_t ret;
  17.211 -    va_start(ap, fmt);
  17.212 -    ret = ucx_vasprintf(allocator, fmt, ap);
  17.213 -    va_end(ap);
  17.214 -    return ret;
  17.215 -}
  17.216 -
  17.217 -sstr_t ucx_vasprintf(UcxAllocator *a, const char *fmt, va_list ap) {
  17.218 -    sstr_t s;
  17.219 -    s.ptr = NULL;
  17.220 -    s.length = 0;
  17.221 -    char buf[UCX_PRINTF_BUFSIZE];
  17.222 -#ifdef va_copy
  17.223 -    va_list ap2;
  17.224 -    va_copy(ap2, ap);
  17.225 -    int ret = vsnprintf(buf, UCX_PRINTF_BUFSIZE, fmt, ap);
  17.226 -    if (ret > 0 && ret < UCX_PRINTF_BUFSIZE) {
  17.227 -        s.ptr = (char*)almalloc(a, ret + 1);
  17.228 -        if (s.ptr) {
  17.229 -            s.length = (size_t)ret;
  17.230 -            memcpy(s.ptr, buf, ret);
  17.231 -            s.ptr[s.length] = '\0';
  17.232 -        }
  17.233 -    } else if (ret == INT_MAX) {
  17.234 -        errno = ENOMEM;
  17.235 -    } else  {
  17.236 -        int len = ret + 1;
  17.237 -        s.ptr = (char*)almalloc(a, len);
  17.238 -        if (s.ptr) {
  17.239 -            ret = vsnprintf(s.ptr, len, fmt, ap2);
  17.240 -            if (ret < 0) {
  17.241 -                free(s.ptr);
  17.242 -                s.ptr = NULL;
  17.243 -            } else {
  17.244 -                s.length = (size_t)ret;
  17.245 -            }
  17.246 -        }
  17.247 -    }
  17.248 -#else
  17.249 -    int ret = vsnprintf(buf, UCX_PRINTF_BUFSIZE, fmt, ap);
  17.250 -    if (ret > 0 && ret < UCX_PRINTF_BUFSIZE) {
  17.251 -        s.ptr = (char*)almalloc(a, ret + 1);
  17.252 -        if (s.ptr) {
  17.253 -            s.length = (size_t)ret;
  17.254 -            memcpy(s.ptr, buf, ret);
  17.255 -            s.ptr[s.length] = '\0';
  17.256 -        }
  17.257 -    } else {
  17.258 -        errno = ENOMEM;
  17.259 -    }
  17.260 -#endif
  17.261 -    return s;
  17.262 -}

    18.1 --- a/src/ucx/utils.h	Thu Nov 10 18:44:48 2016 +0100
    18.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    18.3 @@ -1,254 +0,0 @@
    18.4 -/*
    18.5 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
    18.6 - *
    18.7 - * Copyright 2015 Olaf Wintermann. All rights reserved.
    18.8 - *
    18.9 - * Redistribution and use in source and binary forms, with or without
   18.10 - * modification, are permitted provided that the following conditions are met:
   18.11 - *
   18.12 - *   1. Redistributions of source code must retain the above copyright
   18.13 - *      notice, this list of conditions and the following disclaimer.
   18.14 - *
   18.15 - *   2. Redistributions in binary form must reproduce the above copyright
   18.16 - *      notice, this list of conditions and the following disclaimer in the
   18.17 - *      documentation and/or other materials provided with the distribution.
   18.18 - *
   18.19 - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   18.20 - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   18.21 - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   18.22 - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
   18.23 - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   18.24 - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   18.25 - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   18.26 - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   18.27 - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   18.28 - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   18.29 - * POSSIBILITY OF SUCH DAMAGE.
   18.30 - */
   18.31 -
   18.32 -/**
   18.33 - * @file utils.h
   18.34 - * 
   18.35 - * Compare, copy and printf functions.
   18.36 - * 
   18.37 - * @author Mike Becker
   18.38 - * @author Olaf Wintermann
   18.39 - */
   18.40 -
   18.41 -#ifndef UCX_UTILS_H
   18.42 -#define UCX_UTILS_H
   18.43 -
   18.44 -#ifdef __cplusplus
   18.45 -extern "C" {
   18.46 -#endif
   18.47 -
   18.48 -#include "ucx.h"
   18.49 -#include "string.h"
   18.50 -#include "allocator.h"
   18.51 -#include <inttypes.h>
   18.52 -#include <string.h>
   18.53 -#include <stdarg.h>
   18.54 -
   18.55 -/**
   18.56 - * Copies a string.
   18.57 - * @param s the string to copy
   18.58 - * @param data omitted
   18.59 - * @return a pointer to a copy of s1 that can be passed to free(void*)
   18.60 - */
   18.61 -void *ucx_strcpy(void *s, void *data);
   18.62 -
   18.63 -/**
   18.64 - * Copies a memory area.
   18.65 - * @param m a pointer to the memory area
   18.66 - * @param n a pointer to the size_t containing the size of the memory area
   18.67 - * @return a pointer to a copy of the specified memory area that can
   18.68 - * be passed to free(void*)
   18.69 - */
   18.70 -void *ucx_memcpy(void *m, void *n);
   18.71 -
   18.72 -
   18.73 -/**
   18.74 - * Reads data from a stream and writes it to another stream.
   18.75 - * 
   18.76 - * @param src the source stream
   18.77 - * @param dest the destination stream
   18.78 - * @param rfnc the read function
   18.79 - * @param wfnc the write function
   18.80 - * @param buf a pointer to the copy buffer or <code>NULL</code> if a buffer
   18.81 - * shall be implicitly created on the heap
   18.82 - * @param bufsize the size of the copy buffer - if <code>NULL</code> was
   18.83 - * provided for <code>buf</code>, this is the size of the buffer that shall be
   18.84 - * implicitly created
   18.85 - * @param n the maximum number of bytes that shall be copied
   18.86 - * @return the total number of bytes copied
   18.87 -  */
   18.88 -size_t ucx_stream_copy(void *src, void *dest, read_func rfnc, write_func wfnc,
   18.89 -        char* buf, size_t bufsize, size_t n);
   18.90 -
   18.91 -/**
   18.92 - * Shorthand for ucx_stream_copy using the default copy buffer.
   18.93 - * 
   18.94 - * @param src the source stream
   18.95 - * @param dest the destination stream
   18.96 - * @param rfnc the read function
   18.97 - * @param wfnc the write function
   18.98 - * @return total number of bytes copied
   18.99 - */
  18.100 -#define ucx_stream_hcopy(src,dest,rfnc,wfnc) ucx_stream_copy(\
  18.101 -        src, dest, (read_func)rfnc, (write_func)wfnc, NULL, 0x100, (size_t)-1)
  18.102 -
  18.103 -/**
  18.104 - * Shorthand for ucx_stream_copy using the default copy buffer and a copy limit.
  18.105 - * 
  18.106 - * @param src the source stream
  18.107 - * @param dest the destination stream
  18.108 - * @param rfnc the read function
  18.109 - * @param wfnc the write function
  18.110 - * @param n maximum number of bytes that shall be copied
  18.111 - * @return total number of bytes copied
  18.112 - */
  18.113 -#define ucx_stream_ncopy(src,dest,rfnc,wfnc, n) ucx_stream_copy(\
  18.114 -        src, dest, (read_func)rfnc, (write_func)wfnc, NULL, 0x100, n)
  18.115 -
  18.116 -/**
  18.117 - * Wraps the strcmp function.
  18.118 - * @param s1 string one
  18.119 - * @param s2 string two
  18.120 - * @param data omitted
  18.121 - * @return the result of strcmp(s1, s2)
  18.122 - */
  18.123 -int ucx_strcmp(void *s1, void *s2, void *data);
  18.124 -
  18.125 -/**
  18.126 - * Wraps the strncmp function.
  18.127 - * @param s1 string one
  18.128 - * @param s2 string two
  18.129 - * @param n a pointer to the size_t containing the third strncmp parameter
  18.130 - * @return the result of strncmp(s1, s2, *n)
  18.131 - */
  18.132 -int ucx_strncmp(void *s1, void *s2, void *n);
  18.133 -
  18.134 -/**
  18.135 - * Compares two integers of type int.
  18.136 - * @param i1 pointer to integer one
  18.137 - * @param i2 pointer to integer two
  18.138 - * @param data omitted
  18.139 - * @return -1, if *i1 is less than *i2, 0 if both are equal,
  18.140 - * 1 if *i1 is greater than *i2
  18.141 - */
  18.142 -int ucx_intcmp(void *i1, void *i2, void *data);
  18.143 -
  18.144 -/**
  18.145 - * Compares two real numbers of type float.
  18.146 - * @param f1 pointer to float one
  18.147 - * @param f2 pointer to float two
  18.148 - * @param data if provided: a pointer to precision (default: 1e-6f)
  18.149 - * @return -1, if *f1 is less than *f2, 0 if both are equal,
  18.150 - * 1 if *f1 is greater than *f2
  18.151 - */
  18.152 -
  18.153 -int ucx_floatcmp(void *f1, void *f2, void *data);
  18.154 -
  18.155 -/**
  18.156 - * Compares two real numbers of type double.
  18.157 - * @param d1 pointer to double one
  18.158 - * @param d2 pointer to double two
  18.159 - * @param data if provided: a pointer to precision (default: 1e-14)
  18.160 - * @return -1, if *d1 is less than *d2, 0 if both are equal,
  18.161 - * 1 if *d1 is greater than *d2
  18.162 - */
  18.163 -int ucx_doublecmp(void *d1, void *d2, void *data);
  18.164 -
  18.165 -/**
  18.166 - * Compares two pointers.
  18.167 - * @param ptr1 pointer one
  18.168 - * @param ptr2 pointer two
  18.169 - * @param data omitted
  18.170 - * @return -1 if ptr1 is less than ptr2, 0 if both are equal,
  18.171 - * 1 if ptr1 is greater than ptr2
  18.172 - */
  18.173 -int ucx_ptrcmp(void *ptr1, void *ptr2, void *data);
  18.174 -
  18.175 -/**
  18.176 - * Compares two memory areas.
  18.177 - * @param ptr1 pointer one
  18.178 - * @param ptr2 pointer two
  18.179 - * @param n a pointer to the size_t containing the third parameter for memcmp
  18.180 - * @return the result of memcmp(ptr1, ptr2, *n)
  18.181 - */
  18.182 -int ucx_memcmp(void *ptr1, void *ptr2, void *n);
  18.183 -
  18.184 -/**
  18.185 - * A <code>printf()</code> like function which writes the output to a stream by
  18.186 - * using a write_func().
  18.187 - * @param stream the stream the data is written to
  18.188 - * @param wfc the write function
  18.189 - * @param fmt format string
  18.190 - * @param ... additional arguments
  18.191 - * @return the total number of bytes written
  18.192 - */
  18.193 -int ucx_fprintf(void *stream, write_func wfc, const char *fmt, ...);
  18.194 -
  18.195 -/**
  18.196 - * <code>va_list</code> version of ucx_fprintf().
  18.197 - * @param stream the stream the data is written to
  18.198 - * @param wfc the write function
  18.199 - * @param fmt format string
  18.200 - * @param ap argument list
  18.201 - * @return the total number of bytes written
  18.202 - * @see ucx_fprintf()
  18.203 - */
  18.204 -int ucx_vfprintf(void *stream, write_func wfc, const char *fmt, va_list ap);
  18.205 -
  18.206 -/**
  18.207 - * A <code>printf()</code> like function which allocates space for a sstr_t
  18.208 - * the result is written to.
  18.209 - * 
  18.210 - * <b>Attention</b>: The sstr_t data is allocated with the allocators
  18.211 - * ucx_allocator_malloc() function. So it is implementation dependent, if
  18.212 - * the returned sstr_t.ptr pointer must be passed to the allocators
  18.213 - * ucx_allocator_free() function manually.
  18.214 - * 
  18.215 - * <b>Note</b>: The sstr_t.ptr of the return value will <i>always</i> be
  18.216 - * <code>NULL</code>-terminated.
  18.217 - * 
  18.218 - * @param allocator the UcxAllocator used for allocating the result sstr_t
  18.219 - * @param fmt format string
  18.220 - * @param ... additional arguments
  18.221 - * @return a sstr_t containing the formatted string
  18.222 - */
  18.223 -sstr_t ucx_asprintf(UcxAllocator *allocator, const char *fmt, ...);
  18.224 -
  18.225 -/** Shortcut for ucx_asprintf() with default allocator. */
  18.226 -#define ucx_sprintf(fmt, ...) \
  18.227 -    ucx_asprintf(ucx_default_allocator(), fmt, __VA_ARGS__)
  18.228 -
  18.229 -/**
  18.230 - * <code>va_list</code> version of ucx_asprintf().
  18.231 - * 
  18.232 - * @param allocator the UcxAllocator used for allocating the result sstr_t
  18.233 - * @param fmt format string
  18.234 - * @param ap argument list
  18.235 - * @return a sstr_t containing the formatted string
  18.236 - * @see ucx_asprintf()
  18.237 - */
  18.238 -sstr_t ucx_vasprintf(UcxAllocator *allocator, const char *fmt, va_list ap);
  18.239 -
  18.240 -/**
  18.241 - * A <code>printf()</code> like function which writes the output to an
  18.242 - * UcxBuffer.
  18.243 - * 
  18.244 - * @param buffer the buffer the data is written to
  18.245 - * @param ... format string and additional arguments
  18.246 - * @return the total number of bytes written
  18.247 - * @see ucx_fprintf()
  18.248 - */
  18.249 -#define ucx_bprintf(buffer, ...) ucx_fprintf((UcxBuffer*)buffer, \
  18.250 -        (write_func)ucx_buffer_write, __VA_ARGS__)
  18.251 -
  18.252 -#ifdef __cplusplus
  18.253 -}
  18.254 -#endif
  18.255 -
  18.256 -#endif /* UCX_UTILS_H */
  18.257 -

Makefile		file \| annotate \| diff \| comparison \| revisions
clang.mk		file \| annotate \| diff \| comparison \| revisions
gcc.mk		file \| annotate \| diff \| comparison \| revisions
src/c2html.c		file \| annotate \| diff \| comparison \| revisions
src/frontend.c		file \| annotate \| diff \| comparison \| revisions
src/highlighter.c		file \| annotate \| diff \| comparison \| revisions
src/highlighter.h		file \| annotate \| diff \| comparison \| revisions
src/ucx/allocator.c		file \| annotate \| diff \| comparison \| revisions
src/ucx/allocator.h		file \| annotate \| diff \| comparison \| revisions
src/ucx/buffer.c		file \| annotate \| diff \| comparison \| revisions
src/ucx/buffer.h		file \| annotate \| diff \| comparison \| revisions
src/ucx/list.c		file \| annotate \| diff \| comparison \| revisions
src/ucx/list.h		file \| annotate \| diff \| comparison \| revisions
src/ucx/string.c		file \| annotate \| diff \| comparison \| revisions
src/ucx/string.h		file \| annotate \| diff \| comparison \| revisions
src/ucx/ucx.h		file \| annotate \| diff \| comparison \| revisions
src/ucx/utils.c		file \| annotate \| diff \| comparison \| revisions
src/ucx/utils.h		file \| annotate \| diff \| comparison \| revisions

Mercurial > hg > c2html / changeset

changeset

ucx is now used as external library