ucx: src/buffer.c@77021e06b1a8

     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     buffer->allocator = allocator;

    43     buffer->flags = flags;

    44     if (!space) {

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

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

    47             return 1;

    48         }

    49         buffer->flags |= CX_BUFFER_FREE_CONTENTS;

    50     } else {

    51         buffer->bytes = space;

    52     }

    53     buffer->capacity = capacity;

    54     buffer->size = 0;

    55     buffer->pos = 0;

    57     buffer->flush_func = NULL;

    58     buffer->flush_target = NULL;

    59     buffer->flush_blkmax = 0;

    60     buffer->flush_blksize = 4096;

    61     buffer->flush_threshold = SIZE_MAX;

    63     return 0;

    64 }

    66 void cxBufferDestroy(CxBuffer *buffer) {

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

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

    69     }

    70 }

    72 int cxBufferSeek(

    73         CxBuffer *buffer,

    74         off_t offset,

    75         int whence

    76 ) {

    77     size_t npos;

    78     switch (whence) {

    79         case SEEK_CUR:

    80             npos = buffer->pos;

    81             break;

    82         case SEEK_END:

    83             npos = buffer->size;

    84             break;

    85         case SEEK_SET:

    86             npos = 0;

    87             break;

    88         default:

    89             return -1;

    90     }

    92     size_t opos = npos;

    93     npos += offset;

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

    96         return -1;

    97     }

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

   100         return -1;

   101     } else {

   102         buffer->pos = npos;

   103         return 0;

   104     }

   106 }

   108 void cxBufferClear(CxBuffer *buffer) {

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

   110     buffer->size = 0;

   111     buffer->pos = 0;

   112 }

   114 int cxBufferEof(CxBuffer const *buffer) {

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

   116 }

   118 int cxBufferMinimumCapacity(

   119         CxBuffer *buffer,

   120         size_t newcap

   121 ) {

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

   123         return 0;

   124     }

   126     if (cxReallocate(buffer->allocator,

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

   128         buffer->capacity = newcap;

   129         return 0;

   130     } else {

   131         return -1;

   132     }

   133 }

   135 /**

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

   137  *

   138  * @param buffer the buffer containing the config

   139  * @param space the data to flush

   140  * @param size the element size

   141  * @param nitems the number of items

   142  * @return the number of items flushed

   143  */

   144 static size_t cx_buffer_write_flush_helper(

   145         CxBuffer *buffer,

   146         unsigned char const *space,

   147         size_t size,

   148         size_t nitems

   149 ) {

   150     size_t pos = 0;

   151     size_t remaining = nitems;

   152     size_t max_items = buffer->flush_blksize / size;

   153     while (remaining > 0) {

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

   155         size_t flushed = buffer->flush_func(

   156                 space + pos,

   157                 size, items,

   158                 buffer->flush_target);

   159         if (flushed > 0) {

   160             pos += (flushed * size);

   161             remaining -= flushed;

   162         } else {

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

   164             break;

   165         }

   166     }

   167     return nitems - remaining;

   168 }

   170 size_t cxBufferWrite(

   171         void const *ptr,

   172         size_t size,

   173         size_t nitems,

   174         CxBuffer *buffer

   175 ) {

   176     // optimize for easy case

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

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

   179         buffer->pos += nitems;

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

   181             buffer->size = buffer->pos;

   182         }

   183         return nitems;

   184     }

   186     size_t len;

   187     size_t nitems_out = nitems;

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

   189         return 0;

   190     }

   191     size_t required = buffer->pos + len;

   192     if (buffer->pos > required) {

   193         return 0;

   194     }

   196     bool perform_flush = false;

   197     if (required > buffer->capacity) {

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

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

   200                 perform_flush = true;

   201             } else {

   202                 if (cxBufferMinimumCapacity(buffer, required)) {

   203                     return 0;

   204                 }

   205             }

   206         } else {

   207             if (buffer->flush_blkmax > 0) {

   208                 perform_flush = true;

   209             } else {

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

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

   212                 if (size > 1) {

   213                     len -= len % size;

   214                 }

   215                 nitems_out = len / size;

   216             }

   217         }

   218     }

   220     if (len == 0) {

   221         return len;

   222     }

   224     if (perform_flush) {

   225         size_t flush_max;

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

   227             return 0;

   228         }

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

   230                            ? buffer->pos

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

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

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

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

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

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

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

   240             if (items_flush > 0) {

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

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

   243             }

   244             items_keep = nitems - items_flush;

   245             if (items_keep > 0) {

   246                 // try again with the remaining stuff

   247                 unsigned char const *new_ptr = ptr;

   248                 new_ptr += items_flush * size;

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

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

   251             } else {

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

   253                 return nitems;

   254             }

   255         } else if (flush_pos == 0) {

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

   257             return 0;

   258         } else {

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

   260             cxBufferShiftLeft(buffer, flush_pos);

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

   262         }

   263     } else {

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

   265         buffer->pos += len;

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

   267             buffer->size = buffer->pos;

   268         }

   269         return nitems_out;

   270     }

   272 }

   274 int cxBufferPut(

   275         CxBuffer *buffer,

   276         int c

   277 ) {

   278     c &= 0xFF;

   279     unsigned char const ch = c;

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

   281         return c;

   282     } else {

   283         return EOF;

   284     }

   285 }

   287 size_t cxBufferPutString(

   288         CxBuffer *buffer,

   289         const char *str

   290 ) {

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

   292 }

   294 size_t cxBufferRead(

   295         void *ptr,

   296         size_t size,

   297         size_t nitems,

   298         CxBuffer *buffer

   299 ) {

   300     size_t len;

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

   302         return 0;

   303     }

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

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

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

   307     }

   309     if (len <= 0) {

   310         return len;

   311     }

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

   314     buffer->pos += len;

   316     return len / size;

   317 }

   319 int cxBufferGet(CxBuffer *buffer) {

   320     if (cxBufferEof(buffer)) {

   321         return EOF;

   322     } else {

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

   324         buffer->pos++;

   325         return c;

   326     }

   327 }

   329 int cxBufferShiftLeft(

   330         CxBuffer *buffer,

   331         size_t shift

   332 ) {

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

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

   335     } else {

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

   337         buffer->size -= shift;

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

   340             buffer->pos -= shift;

   341         } else {

   342             buffer->pos = 0;

   343         }

   344     }

   345     return 0;

   346 }

   348 int cxBufferShiftRight(

   349         CxBuffer *buffer,

   350         size_t shift

   351 ) {

   352     size_t req_capacity = buffer->size + shift;

   353     size_t movebytes;

   355     // auto extend buffer, if required and enabled

   356     if (buffer->capacity < req_capacity) {

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

   358             if (cxBufferMinimumCapacity(buffer, req_capacity)) {

   359                 return 1;

   360             }

   361             movebytes = buffer->size;

   362         } else {

   363             movebytes = buffer->capacity - shift;

   364         }

   365     } else {

   366         movebytes = buffer->size;

   367     }

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

   370     buffer->size = shift + movebytes;

   372     buffer->pos += shift;

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

   374         buffer->pos = buffer->size;

   375     }

   377     return 0;

   378 }

   380 int cxBufferShift(

   381         CxBuffer *buffer,

   382         off_t shift

   383 ) {

   384     if (shift < 0) {

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

   386     } else if (shift > 0) {

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

   388     } else {

   389         return 0;

   390     }

   391 }

Mercurial > hg > ucx / file revision

src/buffer.c@77021e06b1a8

src/buffer.c