ucx: ucx/buffer.c@6814aea8462d

     1 #include "buffer.h"

     2 #include <stdarg.h>

     3 #include <stdlib.h>

     4 #include <string.h>

     6 struct UcxBuffer {

     7     void *space;

     8     size_t pos;

     9     size_t size;

    10     int flags;

    11 };

    13 UcxBuffer *ucx_buffer_new(void *space, size_t length, int flags) {

    14     UcxBuffer *buffer = (UcxBuffer*) malloc(sizeof(UcxBuffer));

    15     if (buffer) {

    16         buffer->flags = flags;

    17         if (!space) {

    18             buffer->space = malloc(length);

    19             if (!buffer->space) {

    20                 free(buffer);

    21                 return NULL;

    22             }

    23             memset(buffer->space, 0, length);

    24             buffer->flags |= UCX_BUFFER_AUTOFREE;

    25         } else {

    26             buffer->space = space;

    27         }

    28         buffer->size = length;

    30         buffer->pos = 0;

    31     }

    33     return buffer;

    34 }

    36 void ucx_buffer_free(UcxBuffer *buffer) {

    37     if (ucx_buffer_testflags(buffer, UCX_BUFFER_AUTOFREE)) {

    38         free(buffer->space);

    39     }

    40     free(buffer);

    41 }

    43 UcxBuffer *ucx_buffer_extract(

    44         UcxBuffer *src, size_t start, size_t length, int flags) {

    45     if (length == 0) {

    46         length = src->size - start;

    47     }

    48     if (start+length > src->size) {

    49         return NULL;

    50     }

    52     UcxBuffer *dst = (UcxBuffer*) malloc(sizeof(UcxBuffer));

    53     if (dst) {

    54         dst->space = malloc(length);

    55         if (!dst->space) {

    56             free(dst);

    57             return NULL;

    58         }

    59         dst->size = length;

    60         dst->flags = flags | UCX_BUFFER_AUTOFREE;

    61         dst->pos = 0;

    62         memcpy(dst->space, (char*)src->space+start, length);

    63     }

    64     return dst;

    65 }

    67 int ucx_buffer_seek(UcxBuffer *buffer, off_t offset, int whence) {

    68     off_t npos;

    69     switch (whence) {

    70     case SEEK_SET:

    71         npos = 0;

    72         break;

    73     case SEEK_CUR:

    74         npos = buffer->pos;

    75         break;

    76     case SEEK_END:

    77         npos = strlen(buffer->space);

    78         break;

    79     }

    81     npos += offset;

    83     if (npos < 0 || npos > buffer->size) {

    84         return -1;

    85     } else {

    86         buffer->pos = npos;

    87         return 0;

    88     }

    90 }

    92 int ucx_buffer_eof(UcxBuffer *buffer) {

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

    94 }

    96 size_t ucx_buffer_tell(UcxBuffer *buffer) {

    97     return buffer->pos;

    98 }

   100 size_t ucx_buffer_size(UcxBuffer *buffer) {

   101     return buffer->size;

   102 }

   104 int ucx_buffer_testflags(UcxBuffer *buffer, int flags) {

   105     return (buffer->flags & flags) == flags;

   106 }

   108 size_t ucx_bufio(void* d, size_t s, size_t n, UcxBuffer *b, _Bool read) {

   109     size_t len;

   110     if (b->pos + s*n > b->size) {

   111         len = b->size - b->pos;

   112         if (s > 1) len -= len%s;

   113     } else {

   114         len = s*n;

   115     }

   117     if (len == 0) {

   118         return 0;

   119     }

   121     if (read) {

   122         memcpy(d, (char*)b->space+b->pos, len);

   123     } else {

   124         memcpy((char*)b->space+b->pos, d, len);

   125     }

   126     b->pos += len;

   128     return len;

   129 }

   131 int ucx_buffer_putc(UcxBuffer *buffer, int c) {

   132     if (ucx_buffer_eof(buffer)) {

   133         return EOF;

   134     } else {

   135         c &= 0xFF;

   136         ((char*)(buffer->space))[buffer->pos] = (char) c;

   137         buffer->pos++;

   138         return c;

   139     }

   140 }

   142 int ucx_buffer_getc(UcxBuffer *buffer) {

   143     if (ucx_buffer_eof(buffer)) {

   144         return EOF;

   145     } else {

   146         int c = ((char*)(buffer->space))[buffer->pos];

   147         buffer->pos++;

   148         return c;

   149     }

   150 }

Mercurial > hg > ucx / file revision