ucx: ucx/buffer.c@fb07a0ab9a17

     1 #include "buffer.h"

     2 #include <stdarg.h>

     3 #include <stdlib.h>

     4 #include <string.h>

     6 struct UcxBuffer {

     7     void *space;

     8     off_t pos;

     9     size_t length;

    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->length = length;

    30         buffer->pos = 0;

    31     }

    33     return buffer;

    34 }

    36 void ucx_buffer_free(UcxBuffer *buffer) {

    37     if ((buffer->flags & UCX_BUFFER_AUTOFREE) > 0) {

    38         free(buffer->space);

    39     }

    40     free(buffer);

    41 }

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

    44     off_t npos;

    45     switch (whence) {

    46     case SEEK_SET:

    47         npos = 0;

    48         break;

    49     case SEEK_CUR:

    50         npos = buffer->pos;

    51         break;

    52     case SEEK_END:

    53         npos = strlen(buffer->space);

    54         break;

    55     }

    57     npos += offset;

    59     if (npos < 0 || npos > buffer->length) {

    60         return -1;

    61     } else {

    62         buffer->pos = npos;

    63         return 0;

    64     }

    66 }

    68 int ucx_buffer_eof(UcxBuffer *buffer) {

    69     return buffer->pos >= buffer->length;

    70 }

    72 size_t ucx_buffer_tell(UcxBuffer *buffer) {

    73     return buffer->pos;

    74 }

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

    77     size_t len;

    78     if (b->pos + s*n > b->length) {

    79         len = b->length - b->pos;

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

    81     } else {

    82         len = s*n;

    83     }

    85     if (len == 0) {

    86         return 0;

    87     }

    89     if (read) {

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

    91     } else {

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

    93     }

    94     b->pos += len;

    96     return len;

    97 }

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

   100     if (ucx_buffer_eof(buffer)) {

   101         return EOF;

   102     } else {

   103         c &= 0xFF;

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

   105         buffer->pos++;

   106         return c;

   107     }

   108 }

   110 int ucx_buffer_getc(UcxBuffer *buffer) {

   111     if (ucx_buffer_eof(buffer)) {

   112         return EOF;

   113     } else {

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

   115         buffer->pos++;

   116         return c;

   117     }

   118 }

Mercurial > hg > ucx / file revision