ucx: ucx/buffer.c@1d3500806565

     1 #include "buffer.h"

     2 #include <stdarg.h>

     3 #include <stdlib.h>

     4 #include <string.h>

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

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

     8     if (buffer) {

     9         buffer->flags = flags;

    10         if (!space) {

    11             buffer->space = malloc(length);

    12             if (!buffer->space) {

    13                 free(buffer);

    14                 return NULL;

    15             }

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

    17             buffer->flags |= UCX_BUFFER_AUTOFREE;

    18         } else {

    19             buffer->space = space;

    20         }

    21         buffer->size = length;

    23         buffer->pos = 0;

    24     }

    26     return buffer;

    27 }

    29 void ucx_buffer_free(UcxBuffer *buffer) {

    30     if ((buffer->flags & UCX_BUFFER_AUTOFREE) == UCX_BUFFER_AUTOFREE) {

    31         free(buffer->space);

    32     }

    33     free(buffer);

    34 }

    36 UcxBuffer *ucx_buffer_extract(

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

    38     if (length == 0) {

    39         length = src->size - start;

    40     }

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

    42         return NULL;

    43     }

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

    46     if (dst) {

    47         dst->space = malloc(length);

    48         if (!dst->space) {

    49             free(dst);

    50             return NULL;

    51         }

    52         dst->size = length;

    53         dst->flags = flags | UCX_BUFFER_AUTOFREE;

    54         dst->pos = 0;

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

    56     }

    57     return dst;

    58 }

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

    61     off_t npos;

    62     switch (whence) {

    63     case SEEK_SET:

    64         npos = 0;

    65         break;

    66     case SEEK_CUR:

    67         npos = buffer->pos;

    68         break;

    69     case SEEK_END:

    70         npos = strlen(buffer->space);

    71         break;

    72     }

    74     npos += offset;

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

    77         return -1;

    78     } else {

    79         buffer->pos = npos;

    80         return 0;

    81     }

    83 }

    85 int ucx_buffer_eof(UcxBuffer *buffer) {

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

    87 }

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

    90     size_t len;

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

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

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

    94     } else {

    95         len = s*n;

    96     }

    98     if (len == 0) {

    99         return 0;

   100     }

   102     if (read) {

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

   104     } else {

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

   106     }

   107     b->pos += len;

   109     return len;

   110 }

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

   113     if (ucx_buffer_eof(buffer)) {

   114         return EOF;

   115     } else {

   116         c &= 0xFF;

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

   118         buffer->pos++;

   119         return c;

   120     }

   121 }

   123 int ucx_buffer_getc(UcxBuffer *buffer) {

   124     if (ucx_buffer_eof(buffer)) {

   125         return EOF;

   126     } else {

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

   128         buffer->pos++;

   129         return c;

   130     }

   131 }

Mercurial > hg > ucx / file revision