Return to buffer.c CVS log

Up to [local] / src / usr.bin / tmux

Annotation of src/usr.bin/tmux/buffer.c, Revision 1.3

1.3     ! nicm        1: /* $OpenBSD: buffer.c,v 1.2 2009/06/25 06:05:47 nicm Exp $ */
1.1       nicm        2:
                      3: /*
                      4:  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
                      5:  *
                      6:  * Permission to use, copy, modify, and distribute this software for any
                      7:  * purpose with or without fee is hereby granted, provided that the above
                      8:  * copyright notice and this permission notice appear in all copies.
                      9:  *
                     10:  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
                     11:  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
                     12:  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
                     13:  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
                     14:  * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
                     15:  * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
                     16:  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
                     17:  */
                     18:
                     19: #include <sys/types.h>
                     20:
                     21: #include <string.h>
                     22:
                     23: #include "tmux.h"
                     24:
                     25: /* Create a buffer. */
                     26: struct buffer *
                     27: buffer_create(size_t size)
                     28: {
                     29:        struct buffer   *b;
                     30:
                     31:        if (size == 0)
                     32:                fatalx("zero size");
                     33:
                     34:        b = xcalloc(1, sizeof *b);
                     35:
                     36:        b->base = xmalloc(size);
                     37:        b->space = size;
                     38:
                     39:        return (b);
                     40: }
                     41:
                     42: /* Destroy a buffer. */
                     43: void
                     44: buffer_destroy(struct buffer *b)
                     45: {
                     46:        xfree(b->base);
                     47:        xfree(b);
                     48: }
                     49:
                     50: /* Ensure free space for size in buffer. */
                     51: void
                     52: buffer_ensure(struct buffer *b, size_t size)
                     53: {
                     54:        if (size == 0)
                     55:                fatalx("zero size");
                     56:
                     57:        if (BUFFER_FREE(b) >= size)
                     58:                return;
                     59:
                     60:        if (b->off > 0) {
                     61:                if (b->size > 0)
                     62:                        memmove(b->base, b->base + b->off, b->size);
                     63:                b->off = 0;
                     64:        }
                     65:
                     66:        if (SIZE_MAX - b->size < size)
                     67:                fatalx("size too big");
                     68:        while (b->space < b->size + size) {
                     69:                b->base = xrealloc(b->base, 2, b->space);
                     70:                b->space *= 2;
                     71:        }
                     72: }
                     73:
                     74: /* Adjust buffer after data appended. */
                     75: void
                     76: buffer_add(struct buffer *b, size_t size)
                     77: {
                     78:        if (size == 0)
                     79:                fatalx("zero size");
                     80:        if (size > b->space - b->size)
                     81:                fatalx("overflow");
                     82:
                     83:        b->size += size;
                     84: }
                     85:
                     86: /* Adjust buffer after data removed. */
                     87: void
                     88: buffer_remove(struct buffer *b, size_t size)
                     89: {
                     90:        if (size == 0)
                     91:                fatalx("zero size");
                     92:        if (size > b->size)
                     93:                fatalx("underflow");
                     94:
                     95:        b->size -= size;
                     96:        b->off += size;
                     97: }
                     98:
                     99: /* Copy data into a buffer. */
                    100: void
                    101: buffer_write(struct buffer *b, const void *data, size_t size)
                    102: {
                    103:        buffer_ensure(b, size);
                    104:        memcpy(BUFFER_IN(b), data, size);
                    105:        buffer_add(b, size);
                    106: }
                    107:
                    108: /* Copy data out of a buffer. */
                    109: void
                    110: buffer_read(struct buffer *b, void *data, size_t size)
                    111: {
                    112:        if (size == 0)
                    113:                fatalx("zero size");
                    114:        if (size > b->size)
                    115:                fatalx("underflow");
                    116:
                    117:        memcpy(data, BUFFER_OUT(b), size);
                    118:        buffer_remove(b, size);
                    119: }
                    120:
                    121: /* Store an 8-bit value. */
                    122: void
                    123: buffer_write8(struct buffer *b, uint8_t n)
                    124: {
                    125:        buffer_ensure(b, 1);
                    126:        BUFFER_IN(b)[0] = n;
1.3     ! nicm      127:        b->size++;
1.1       nicm      128: }
                    129:
                    130: /* Extract an 8-bit value. */
                    131: uint8_t
                    132: buffer_read8(struct buffer *b)
                    133: {
                    134:        uint8_t n;
                    135:
                    136:        n = BUFFER_OUT(b)[0];
                    137:        buffer_remove(b, 1);
                    138:        return (n);
                    139: }