ucx: src/buffer.c@60fb6aec157d

     1 /*

     2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

     3  *

     4  * Copyright 2021 Mike Becker, Olaf Wintermann All rights reserved.

     5  *

     6  * Redistribution and use in source and binary forms, with or without

     7  * modification, are permitted provided that the following conditions are met:

     8  *

     9  *   1. Redistributions of source code must retain the above copyright

    10  *      notice, this list of conditions and the following disclaimer.

    11  *

    12  *   2. Redistributions in binary form must reproduce the above copyright

    13  *      notice, this list of conditions and the following disclaimer in the

    14  *      documentation and/or other materials provided with the distribution.

    15  *

    16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

    17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

    19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

    20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

    21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

    22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

    23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

    24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

    25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

    26  * POSSIBILITY OF SUCH DAMAGE.

    27  */

    29 #include "cx/buffer.h"

    30 #include "cx/utils.h"

    32 #include <stdio.h>

    33 #include <string.h>

    35 int cxBufferInit(

    36         CxBuffer *buffer,

    37         void *space,

    38         size_t capacity,

    39         CxAllocator const *allocator,

    40         int flags

    41 ) {

    42     if (allocator == NULL) allocator = cxDefaultAllocator;

    43     buffer->allocator = allocator;

    44     buffer->flags = flags;

    45     if (!space) {

    46         buffer->bytes = cxMalloc(allocator, capacity);

    47         if (buffer->bytes == NULL) {

    48             return 1;

    49         }

    50         buffer->flags |= CX_BUFFER_FREE_CONTENTS;

    51     } else {

    52         buffer->bytes = space;

    53     }

    54     buffer->capacity = capacity;

    55     buffer->size = 0;

    56     buffer->pos = 0;

    58     buffer->flush_func = NULL;

    59     buffer->flush_target = NULL;

    60     buffer->flush_blkmax = 0;

    61     buffer->flush_blksize = 4096;

    62     buffer->flush_threshold = SIZE_MAX;

    64     return 0;

    65 }

    67 void cxBufferDestroy(CxBuffer *buffer) {

    68     if ((buffer->flags & CX_BUFFER_FREE_CONTENTS) == CX_BUFFER_FREE_CONTENTS) {

    69         cxFree(buffer->allocator, buffer->bytes);

    70     }

    71 }

    73 int cxBufferSeek(

    74         CxBuffer *buffer,

    75         off_t offset,

    76         int whence

    77 ) {

    78     size_t npos;

    79     switch (whence) {

    80         case SEEK_CUR:

    81             npos = buffer->pos;

    82             break;

    83         case SEEK_END:

    84             npos = buffer->size;

    85             break;

    86         case SEEK_SET:

    87             npos = 0;

    88             break;

    89         default:

    90             return -1;

    91     }

    93     size_t opos = npos;

    94     npos += offset;

    96     if ((offset > 0 && npos < opos) || (offset < 0 && npos > opos)) {

    97         return -1;

    98     }

   100     if (npos >= buffer->size) {

   101         return -1;

   102     } else {

   103         buffer->pos = npos;

   104         return 0;

   105     }

   107 }

   109 void cxBufferClear(CxBuffer *buffer) {

   110     memset(buffer->bytes, 0, buffer->size);

   111     buffer->size = 0;

   112     buffer->pos = 0;

   113 }

   115 int cxBufferEof(CxBuffer const *buffer) {

   116     return buffer->pos >= buffer->size;

   117 }

   119 int cxBufferMinimumCapacity(

   120         CxBuffer *buffer,

   121         size_t newcap

   122 ) {

   123     if (newcap <= buffer->capacity) {

   124         return 0;

   125     }

   127     if (cxReallocate(buffer->allocator,

   128                      (void **) &buffer->bytes, newcap) == 0) {

   129         buffer->capacity = newcap;

   130         return 0;

   131     } else {

   132         return -1;

   133     }

   134 }

   136 /**

   137  * Helps flushing data to the flush target of a buffer.

   138  *

   139  * @param buffer the buffer containing the config

   140  * @param space the data to flush

   141  * @param size the element size

   142  * @param nitems the number of items

   143  * @return the number of items flushed

   144  */

   145 static size_t cx_buffer_write_flush_helper(

   146         CxBuffer *buffer,

   147         unsigned char const *space,

   148         size_t size,

   149         size_t nitems

   150 ) {

   151     size_t pos = 0;

   152     size_t remaining = nitems;

   153     size_t max_items = buffer->flush_blksize / size;

   154     while (remaining > 0) {

   155         size_t items = remaining > max_items ? max_items : remaining;

   156         size_t flushed = buffer->flush_func(

   157                 space + pos,

   158                 size, items,

   159                 buffer->flush_target);

   160         if (flushed > 0) {

   161             pos += (flushed * size);

   162             remaining -= flushed;

   163         } else {

   164             // if no bytes can be flushed out anymore, we give up

   165             break;

   166         }

   167     }

   168     return nitems - remaining;

   169 }

   171 size_t cxBufferWrite(

   172         void const *ptr,

   173         size_t size,

   174         size_t nitems,

   175         CxBuffer *buffer

   176 ) {

   177     // optimize for easy case

   178     if (size == 1 && (buffer->capacity - buffer->pos) >= nitems) {

   179         memcpy(buffer->bytes + buffer->pos, ptr, nitems);

   180         buffer->pos += nitems;

   181         if (buffer->pos > buffer->size) {

   182             buffer->size = buffer->pos;

   183         }

   184         return nitems;

   185     }

   187     size_t len;

   188     size_t nitems_out = nitems;

   189     if (cx_szmul(size, nitems, &len)) {

   190         return 0;

   191     }

   192     size_t required = buffer->pos + len;

   193     if (buffer->pos > required) {

   194         return 0;

   195     }

   197     bool perform_flush = false;

   198     if (required > buffer->capacity) {

   199         if ((buffer->flags & CX_BUFFER_AUTO_EXTEND) == CX_BUFFER_AUTO_EXTEND && required) {

   200             if (buffer->flush_blkmax > 0 && required > buffer->flush_threshold) {

   201                 perform_flush = true;

   202             } else {

   203                 if (cxBufferMinimumCapacity(buffer, required)) {

   204                     return 0;

   205                 }

   206             }

   207         } else {

   208             if (buffer->flush_blkmax > 0) {

   209                 perform_flush = true;

   210             } else {

   211                 // truncate data to be written, if we can neither extend nor flush

   212                 len = buffer->capacity - buffer->pos;

   213                 if (size > 1) {

   214                     len -= len % size;

   215                 }

   216                 nitems_out = len / size;

   217             }

   218         }

   219     }

   221     if (len == 0) {

   222         return len;

   223     }

   225     if (perform_flush) {

   226         size_t flush_max;

   227         if (cx_szmul(buffer->flush_blkmax, buffer->flush_blksize, &flush_max)) {

   228             return 0;

   229         }

   230         size_t flush_pos = buffer->flush_func == NULL || buffer->flush_target == NULL

   231                            ? buffer->pos

   232                            : cx_buffer_write_flush_helper(buffer, buffer->bytes, 1, buffer->pos);

   233         if (flush_pos == buffer->pos) {

   234             // entire buffer has been flushed, we can reset

   235             buffer->size = buffer->pos = 0;

   237             size_t items_flush; // how many items can also be directly flushed

   238             size_t items_keep; // how many items have to be written to the buffer

   240             items_flush = flush_max >= required ? nitems : (flush_max - flush_pos) / size;

   241             if (items_flush > 0) {

   242                 items_flush = cx_buffer_write_flush_helper(buffer, ptr, size, items_flush / size);

   243                 // in case we could not flush everything, keep the rest

   244             }

   245             items_keep = nitems - items_flush;

   246             if (items_keep > 0) {

   247                 // try again with the remaining stuff

   248                 unsigned char const *new_ptr = ptr;

   249                 new_ptr += items_flush * size;

   250                 // report the directly flushed items as written plus the remaining stuff

   251                 return items_flush + cxBufferWrite(new_ptr, size, items_keep, buffer);

   252             } else {

   253                 // all items have been flushed - report them as written

   254                 return nitems;

   255             }

   256         } else if (flush_pos == 0) {

   257             // nothing could be flushed at all, we immediately give up without writing any data

   258             return 0;

   259         } else {

   260             // we were partially successful, we shift left and try again

   261             cxBufferShiftLeft(buffer, flush_pos);

   262             return cxBufferWrite(ptr, size, nitems, buffer);

   263         }

   264     } else {

   265         memcpy(buffer->bytes + buffer->pos, ptr, len);

   266         buffer->pos += len;

   267         if (buffer->pos > buffer->size) {

   268             buffer->size = buffer->pos;

   269         }

   270         return nitems_out;

   271     }

   273 }

   275 int cxBufferPut(

   276         CxBuffer *buffer,

   277         int c

   278 ) {

   279     c &= 0xFF;

   280     unsigned char const ch = c;

   281     if (cxBufferWrite(&ch, 1, 1, buffer) == 1) {

   282         return c;

   283     } else {

   284         return EOF;

   285     }

   286 }

   288 size_t cxBufferPutString(

   289         CxBuffer *buffer,

   290         const char *str

   291 ) {

   292     return cxBufferWrite(str, 1, strlen(str), buffer);

   293 }

   295 size_t cxBufferRead(

   296         void *ptr,

   297         size_t size,

   298         size_t nitems,

   299         CxBuffer *buffer

   300 ) {

   301     size_t len;

   302     if (cx_szmul(size, nitems, &len)) {

   303         return 0;

   304     }

   305     if (buffer->pos + len > buffer->size) {

   306         len = buffer->size - buffer->pos;

   307         if (size > 1) len -= len % size;

   308     }

   310     if (len <= 0) {

   311         return len;

   312     }

   314     memcpy(ptr, buffer->bytes + buffer->pos, len);

   315     buffer->pos += len;

   317     return len / size;

   318 }

   320 int cxBufferGet(CxBuffer *buffer) {

   321     if (cxBufferEof(buffer)) {

   322         return EOF;

   323     } else {

   324         int c = buffer->bytes[buffer->pos];

   325         buffer->pos++;

   326         return c;

   327     }

   328 }

   330 int cxBufferShiftLeft(

   331         CxBuffer *buffer,

   332         size_t shift

   333 ) {

   334     if (shift >= buffer->size) {

   335         buffer->pos = buffer->size = 0;

   336     } else {

   337         memmove(buffer->bytes, buffer->bytes + shift, buffer->size - shift);

   338         buffer->size -= shift;

   340         if (buffer->pos >= shift) {

   341             buffer->pos -= shift;

   342         } else {

   343             buffer->pos = 0;

   344         }

   345     }

   346     return 0;

   347 }

   349 int cxBufferShiftRight(

   350         CxBuffer *buffer,

   351         size_t shift

   352 ) {

   353     size_t req_capacity = buffer->size + shift;

   354     size_t movebytes;

   356     // auto extend buffer, if required and enabled

   357     if (buffer->capacity < req_capacity) {

   358         if ((buffer->flags & CX_BUFFER_AUTO_EXTEND) == CX_BUFFER_AUTO_EXTEND) {

   359             if (cxBufferMinimumCapacity(buffer, req_capacity)) {

   360                 return 1;

   361             }

   362             movebytes = buffer->size;

   363         } else {

   364             movebytes = buffer->capacity - shift;

   365         }

   366     } else {

   367         movebytes = buffer->size;

   368     }

   370     memmove(buffer->bytes + shift, buffer->bytes, movebytes);

   371     buffer->size = shift + movebytes;

   373     buffer->pos += shift;

   374     if (buffer->pos > buffer->size) {

   375         buffer->pos = buffer->size;

   376     }

   378     return 0;

   379 }

   381 int cxBufferShift(

   382         CxBuffer *buffer,

   383         off_t shift

   384 ) {

   385     if (shift < 0) {

   386         return cxBufferShiftLeft(buffer, (size_t) (-shift));

   387     } else if (shift > 0) {

   388         return cxBufferShiftRight(buffer, (size_t) shift);

   389     } else {

   390         return 0;

   391     }

   392 }

Mercurial > hg > ucx / file revision

src/buffer.c@60fb6aec157d

src/buffer.c