ucx: src/buffer.c@7b9114030ca4

     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 <stdlib.h>

    33 #include <stdio.h>

    34 #include <string.h>

    35 #include <stdint.h>

    37 int cxBufferInit(

    38         CxBuffer *buffer,

    39         void *space,

    40         size_t capacity,

    41         CxAllocator const *allocator,

    42         int flags

    43 ) {

    44     buffer->allocator = allocator;

    45     buffer->flags = flags;

    46     if (!space) {

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

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

    49             return 1;

    50         }

    51         buffer->flags |= CX_BUFFER_FREE_CONTENTS;

    52     } else {

    53         buffer->bytes = space;

    54     }

    55     buffer->capacity = capacity;

    56     buffer->size = 0;

    57     buffer->pos = 0;

    59     buffer->flush_func = NULL;

    60     buffer->flush_target = NULL;

    61     buffer->flush_blkmax = 0;

    62     buffer->flush_blksize = 4096;

    63     buffer->flush_threshold = SIZE_MAX;

    65     return 0;

    66 }

    68 void cxBufferDestroy(CxBuffer *buffer) {

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

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

    71     }

    72 }

    74 int cxBufferSeek(

    75         CxBuffer *buffer,

    76         off_t offset,

    77         int whence

    78 ) {

    79     size_t npos;

    80     switch (whence) {

    81         case SEEK_CUR:

    82             npos = buffer->pos;

    83             break;

    84         case SEEK_END:

    85             npos = buffer->size;

    86             break;

    87         case SEEK_SET:

    88             npos = 0;

    89             break;

    90         default:

    91             return -1;

    92     }

    94     size_t opos = npos;

    95     npos += offset;

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

    98         return -1;

    99     }

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

   102         return -1;

   103     } else {

   104         buffer->pos = npos;

   105         return 0;

   106     }

   108 }

   110 void cxBufferClear(CxBuffer *buffer) {

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

   112     buffer->size = 0;

   113     buffer->pos = 0;

   114 }

   116 int cxBufferEof(CxBuffer const *buffer) {

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

   118 }

   120 int cxBufferMinimumCapacity(

   121         CxBuffer *buffer,

   122         size_t newcap

   123 ) {

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

   125         return 0;

   126     }

   128     if (cxReallocate(buffer->allocator,

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

   130         buffer->capacity = newcap;

   131         return 0;

   132     } else {

   133         return -1;

   134     }

   135 }

   137 size_t cxBufferWrite(

   138         void const *ptr,

   139         size_t size,

   140         size_t nitems,

   141         CxBuffer *buffer

   142 ) {

   143     // optimize for easy case

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

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

   146         buffer->pos += nitems;

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

   148             buffer->size = buffer->pos;

   149         }

   150         return nitems;

   151     }

   153     size_t len;

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

   155         return 0;

   156     }

   157     size_t required = buffer->pos + len;

   158     if (buffer->pos > required) {

   159         return 0;

   160     }

   162     bool perform_flush = false;

   163     if (required > buffer->capacity) {

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

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

   166                 perform_flush = true;

   167             } else {

   168                 if (cxBufferMinimumCapacity(buffer, required)) {

   169                     return 0;

   170                 }

   171             }

   172         } else {

   173             if (buffer->flush_blkmax > 0) {

   174                 perform_flush = true;

   175             } else {

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

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

   178                 if (size > 1) {

   179                     len -= len % size;

   180                 }

   181                 nitems = len / size;

   182             }

   183         }

   184     }

   186     if (len == 0) {

   187         return len;

   188     }

   190     if (perform_flush) {

   191         // TODO: implement flushing

   192         // (1) determine how many bytes to flush (use flushmax = blkmax * blksize)

   193         // (2) if len is larger than the number computed in (1) we need more flush cycles, compute how many

   194         // (3) determine how many bytes from the buffer shall be flushed

   195         // (4) if something remains in the buffer, shift the buffer to the left

   196         // (4a) if buffer was shifted, append the new data to the buffer

   197         // (4b) if the buffer was flushed entirely AND the new data also fits into flushmax,

   198         //      directly write the new data to the flush sink

   199         return 0; // remove this after implementation

   200     } else {

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

   202         buffer->pos += len;

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

   204             buffer->size = buffer->pos;

   205         }

   206     }

   208     return nitems;

   209 }

   211 int cxBufferPut(

   212         CxBuffer *buffer,

   213         int c

   214 ) {

   215     c &= 0xFF;

   216     unsigned char const ch = c;

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

   218         return c;

   219     } else {

   220         return EOF;

   221     }

   222 }

   224 size_t cxBufferPutString(

   225         CxBuffer *buffer,

   226         const char *str

   227 ) {

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

   229 }

   231 size_t cxBufferRead(

   232         void *ptr,

   233         size_t size,

   234         size_t nitems,

   235         CxBuffer *buffer

   236 ) {

   237     size_t len;

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

   239         return 0;

   240     }

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

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

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

   244     }

   246     if (len <= 0) {

   247         return len;

   248     }

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

   251     buffer->pos += len;

   253     return len / size;

   254 }

   256 int cxBufferGet(CxBuffer *buffer) {

   257     if (cxBufferEof(buffer)) {

   258         return EOF;

   259     } else {

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

   261         buffer->pos++;

   262         return c;

   263     }

   264 }

   266 int cxBufferShiftLeft(

   267         CxBuffer *buffer,

   268         size_t shift

   269 ) {

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

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

   272     } else {

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

   274         buffer->size -= shift;

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

   277             buffer->pos -= shift;

   278         } else {

   279             buffer->pos = 0;

   280         }

   281     }

   282     return 0;

   283 }

   285 int cxBufferShiftRight(

   286         CxBuffer *buffer,

   287         size_t shift

   288 ) {

   289     size_t req_capacity = buffer->size + shift;

   290     size_t movebytes;

   292     // auto extend buffer, if required and enabled

   293     if (buffer->capacity < req_capacity) {

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

   295             if (cxBufferMinimumCapacity(buffer, req_capacity)) {

   296                 return 1;

   297             }

   298             movebytes = buffer->size;

   299         } else {

   300             movebytes = buffer->capacity - shift;

   301         }

   302     } else {

   303         movebytes = buffer->size;

   304     }

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

   307     buffer->size = shift + movebytes;

   309     buffer->pos += shift;

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

   311         buffer->pos = buffer->size;

   312     }

   314     return 0;

   315 }

   317 int cxBufferShift(

   318         CxBuffer *buffer,

   319         off_t shift

   320 ) {

   321     if (shift < 0) {

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

   323     } else if (shift > 0) {

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

   325     } else {

   326         return 0;

   327     }

   328 }

Mercurial > hg > ucx / file revision

src/buffer.c@7b9114030ca4

src/buffer.c