cli_gapbuf.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright (c) 2019-2022 Intel Corporation.
 */
/* inspired by an email/code written by: Joseph H. Allen, 9/10/89 */
 
#include <stdlib.h>         // for realloc, NULL
#include <string.h>         // for memmove, strlen
#include <cne_log.h>        // for cne_panic
#include <stdint.h>         // for uint32_t
 
#include "cne_common.h"        // for CNDP_API
 
#ifndef _CLI_GAPBUF_H_
#define _CLI_GAPBUF_H_
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define GB_DEFAULT_GAP_SIZE 8
 
struct gapbuf {
    char *buf;   
    char *ebuf;  
    char *point; 
    char *gap;   
    char *egap;  
};
 
CNDP_API struct gapbuf *gb_create(void);
 
CNDP_API void gb_destroy(struct gapbuf *gb);
 
CNDP_API int gb_init_buf(struct gapbuf *gb, int size);
 
CNDP_API int gb_reset_buf(struct gapbuf *gb);
 
CNDP_API uint32_t gb_copy_to_buf(struct gapbuf *gb, char *dst, uint32_t size);
 
CNDP_API void gb_dump(struct gapbuf *gb, const char *msg);
 
/********************************************************/
 
static inline uint32_t
gb_buf_size(struct gapbuf *gb)
{
    return gb->ebuf - gb->buf;
}
 
static inline uint32_t
gb_gap_size(struct gapbuf *gb)
{
    return gb->egap - gb->gap;
}
 
static inline uint32_t
gb_data_size(struct gapbuf *gb)
{
    return (gb->ebuf - gb->buf) - (gb->egap - gb->gap);
}
 
static inline char *
gb_start_of_buf(struct gapbuf *gb)
{
    return gb->buf;
}
 
static inline char *
gb_start_of_gap(struct gapbuf *gb)
{
    return gb->gap;
}
 
static inline char *
gb_end_of_gap(struct gapbuf *gb)
{
    return gb->egap;
}
 
static inline char *
gb_end_of_buf(struct gapbuf *gb)
{
    return gb->ebuf;
}
 
static inline char *
gb_point_at(struct gapbuf *gb)
{
    return gb->point;
}
 
static inline int
gb_point_at_start(struct gapbuf *gb)
{
    return (gb->point == gb->buf);
}
 
static inline int
gb_point_at_end(struct gapbuf *gb)
{
    return (gb->ebuf == gb->point);
}
 
static inline int
gb_point_at_gap(struct gapbuf *gb)
{
    return (gb->gap == gb->point);
}
 
static inline void
gb_set_point(struct gapbuf *gb, int idx)
{
    if (idx == -1) {
        gb->point = gb->ebuf;
        return;
    }
    gb->point = gb->buf + idx;
    if (gb->point > gb->gap)
        gb->point += gb->egap - gb->gap;
}
 
static inline int
gb_point_offset(struct gapbuf *gb)
{
    if (gb->point > gb->egap)
        return (gb->point - gb->buf) - (gb->egap - gb->gap);
    else
        return gb->point - gb->buf;
}
 
static inline int
gb_eof(struct gapbuf *gb)
{
    return (gb->point == gb->gap) ? (gb->egap == gb->ebuf) : (gb->point == gb->ebuf);
}
 
/********************************************************/
 
static inline void
gb_move_gap_to_point(struct gapbuf *gb)
{
    if (gb->point == gb->gap)
        return;
 
    if (gb->point == gb->egap)
        gb->point = gb->gap;
    else {
        int cnt;
 
        if (gb->point < gb->gap) {
            cnt = gb->gap - gb->point;
            memmove(gb->egap - cnt, gb->point, cnt);
            gb->egap -= cnt;
            gb->gap = gb->point;
        } else if (gb->point > gb->egap) {
            cnt = gb->point - gb->egap;
            memmove(gb->gap, gb->egap, cnt);
            gb->gap += cnt;
            gb->egap  = gb->point;
            gb->point = gb->gap;
        } else { /* This case when point is between gap and egap. */
            cnt = gb->point - gb->gap;
            memmove(gb->gap, gb->egap, cnt);
            gb->egap += cnt;
            gb->gap += cnt;
            gb->point = gb->gap;
        }
    }
}
 
static inline void
gb_expand_buf(struct gapbuf *gb, uint32_t more)
{
    if (((gb->ebuf - gb->buf) + more) > gb_buf_size(gb)) {
        char *old = gb->buf;
 
        more = (gb->ebuf - gb->buf) + more + GB_DEFAULT_GAP_SIZE;
 
        gb->buf = (char *)realloc(gb->buf, more);
        if (gb->buf == NULL)
            cne_panic("realloc(%d) in %s failed", more, __func__);
 
        gb->point += (gb->buf - old);
        gb->ebuf += (gb->buf - old);
        gb->gap += (gb->buf - old);
        gb->egap += (gb->buf - old);
    }
}
 
static inline void
gb_expand_gap(struct gapbuf *gb, uint32_t size)
{
    if (size > gb_gap_size(gb)) {
        size += GB_DEFAULT_GAP_SIZE;
 
        gb_expand_buf(gb, size);
 
        memmove(gb->egap + size, gb->egap, gb->ebuf - gb->egap);
 
        gb->egap += size;
        gb->ebuf += size;
    }
}
 
static inline char
gb_get(struct gapbuf *gb)
{
    if (gb->point == gb->gap)
        gb->point = gb->egap;
 
    return *gb->point;
}
 
static inline char
gb_get_prev(struct gapbuf *gb)
{
    if (gb->point == gb->egap)
        gb->point = gb->gap;
 
    if (gb->point == gb->buf) {
        if (gb->point == gb->gap)
            return '\0';
        else
            return *gb->point;
    }
 
    return *(gb->point - 1);
}
 
static inline char
gb_get_next(struct gapbuf *gb)
{
    if (gb->point == gb->gap)
        gb->point = gb->egap;
 
    if (gb->point == gb->ebuf)
        return *gb->point;
 
    return *(gb->point + 1);
}
 
static inline void
gb_put(struct gapbuf *gb, char c)
{
    if (gb->point == gb->gap)
        gb->point = gb->egap;
 
    if (gb->point == gb->ebuf) {
        gb_expand_buf(gb, 1);
        gb->ebuf++;
    }
 
    *gb->point = c;
}
 
static inline char
gb_getc(struct gapbuf *gb)
{
    if (gb->point == gb->gap) {
        gb->point = gb->egap + 1;
        return *gb->egap;
    }
 
    return *(gb->point++);
}
 
static inline char
gb_getc_prev(struct gapbuf *gb)
{
    if (gb->point == gb->egap)
        gb->point = gb->gap;
 
    return *(--gb->point);
}
 
static inline void
gb_putc(struct gapbuf *gb, char c)
{
    gb_move_gap_to_point(gb);
 
    if (gb->point == gb->ebuf) {
        gb_expand_buf(gb, 1);
        gb->ebuf++;
    }
    *(gb->gap++) = c;
    gb->point++;
}
 
static inline void
gb_insert(struct gapbuf *gb, char c)
{
    if (gb->point != gb->gap)
        gb_move_gap_to_point(gb);
 
    if (gb->gap == gb->egap)
        gb_expand_gap(gb, 1);
 
    gb_putc(gb, c);
}
 
static inline void
gb_del(struct gapbuf *gb, int cnt)
{
    if (gb->point != gb->gap)
        gb_move_gap_to_point(gb);
 
    gb->egap += cnt;
}
 
static inline uint32_t
gb_str_insert(struct gapbuf *gb, char *str, uint32_t size)
{
    int len;
 
    if (size == 0)
        size = strlen(str);
    if (size == 0)
        return 0;
 
    gb_move_gap_to_point(gb);
 
    if (size > gb_gap_size(gb))
        gb_expand_gap(gb, size);
 
    len = size;
    do {
        gb_putc(gb, *str++);
    } while (--size);
 
    return len;
}
 
/********************************************************/
 
static inline uint32_t
gb_left_data_size(struct gapbuf *gb)
{
    return gb->gap - gb->buf;
}
 
static inline uint32_t
gb_right_data_size(struct gapbuf *gb)
{
    if (gb_eof(gb))
        return 0;
    return gb->ebuf - gb->egap;
}
 
static inline void
gb_move_right(struct gapbuf *gb)
{
    if (gb->point == gb->gap)
        gb->point = gb->egap;
    gb->point = ((gb->point + 1) > gb->ebuf) ? gb->ebuf : (gb->point + 1);
}
 
static inline void
gb_move_left(struct gapbuf *gb)
{
    if (gb->point == gb->egap)
        gb->point = gb->gap;
    gb->point = ((gb->point - 1) < gb->buf) ? gb->buf : (gb->point - 1);
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* _CLI_GAPBUF_H_ */