klish/tinyrl/history/history.c

/*
 * history.c
 * 
 * Simple non-readline hooks for the cli library
 */
#include <string.h>
#include <stdio.h>
#include <assert.h>

#include "private.h"
#include "lub/string.h"
#include <stdlib.h>

#include "tinyrl/history.h"

struct _tinyrl_history {
	tinyrl_history_entry_t **entries;	/* pointer entries */
	unsigned length;	/* Number of elements within this array */
	unsigned size;		/* Number of slots allocated in this array */
	unsigned current_index;
	unsigned stifle;
};

/*------------------------------------- */
void tinyrl_history_init(tinyrl_history_t * this, unsigned stifle)
{
	this->entries = NULL;
	this->stifle = stifle;
	this->current_index = 1;
	this->length = 0;
	this->size = 0;
}

/*------------------------------------- */
void tinyrl_history_fini(tinyrl_history_t * this)
{
	tinyrl_history_entry_t *entry;
	tinyrl_history_iterator_t iter;

	/* release the resource associated with each entry */
	for (entry = tinyrl_history_getfirst(this, &iter);
	     entry; entry = tinyrl_history_getnext(&iter)) {
		tinyrl_history_entry_delete(entry);
	}
	/* release the list */
	free(this->entries);
	this->entries = NULL;
}

/*------------------------------------- */
tinyrl_history_t *tinyrl_history_new(unsigned stifle)
{
	tinyrl_history_t *this = malloc(sizeof(tinyrl_history_t));
	if (NULL != this) {
		tinyrl_history_init(this, stifle);
	}
	return this;
}

/*------------------------------------- */
void tinyrl_history_delete(tinyrl_history_t * this)
{
	tinyrl_history_fini(this);
	free(this);
}

/*
HISTORY LIST MANAGEMENT 
*/
/*------------------------------------- */
/* insert a new entry at the current offset */
static void insert_entry(tinyrl_history_t * this, const char *line)
{
	tinyrl_history_entry_t *new_entry =
	    tinyrl_history_entry_new(line, this->current_index++);
	assert(this->length);
	assert(this->entries);
	if (new_entry) {
		this->entries[this->length - 1] = new_entry;
	}
}

/*------------------------------------- */
/*
 * This frees the specified entries from the 
 * entries vector. NB it doesn't perform any shuffling.
 * This function is inclusive of start and end
 */
static void
free_entries(const tinyrl_history_t * this, unsigned start, unsigned end)
{
	unsigned i;
	assert(start <= end);
	assert(end < this->length);

	for (i = start; i <= end; i++) {
		tinyrl_history_entry_t *entry = this->entries[i];
		tinyrl_history_entry_delete(entry);
		entry = NULL;
	}
}

/*------------------------------------- */
/*
 * This removes the specified entries from the 
 * entries vector. Shuffling up the array as necessary 
 * This function is inclusive of start and end
 */
static void
remove_entries(tinyrl_history_t * this, unsigned start, unsigned end)
{
	unsigned delta = (end - start) + 1;	/* number of entries being deleted */
	/* number of entries to shuffle */
	unsigned num_entries = (this->length - end) - 1;
	assert(start <= end);
	assert(end < this->length);

	if (num_entries) {
		/* move the remaining entries down to close the array */
		memmove(&this->entries[start],
			&this->entries[end + 1],
			sizeof(tinyrl_history_entry_t *) * num_entries);
	}
	/* now fix up the length variables */
	this->length -= delta;
}

/*------------------------------------- */
/* 
Search the current history buffer for the specified 
line and if found remove it.
*/
static bool_t remove_duplicate(tinyrl_history_t * this, const char *line)
{
	bool_t result = BOOL_FALSE;
	unsigned i;

	for (i = 0; i < this->length; i++) {
		tinyrl_history_entry_t *entry = this->entries[i];
		if (0 == strcmp(line, tinyrl_history_entry__get_line(entry))) {
			free_entries(this, i, i);
			remove_entries(this, i, i);
			result = BOOL_TRUE;
			break;
		}
	}
	return result;
}

/*------------------------------------- */
/* 
add an entry to the end of the current array 
if there is no space returns -1 else 0
*/
static void append_entry(tinyrl_history_t * this, const char *line)
{
	if (this->length < this->size) {
		this->length++;

		insert_entry(this, line);
	}
}

/*------------------------------------- */
/*
 add a new history entry replacing the oldest one 
 */
static void add_n_replace(tinyrl_history_t * this, const char *line)
{
	if (BOOL_FALSE == remove_duplicate(this, line)) {
		/* free the oldest entry */
		free_entries(this, 0, 0);
		/* shuffle the array */
		remove_entries(this, 0, 0);
	}
	/* add the new entry */
	append_entry(this, line);
}

/*------------------------------------- */
/* add a new history entry growing the array if necessary */
static void add_n_grow(tinyrl_history_t * this, const char *line)
{
	if (this->size == this->length) {
		/* increment the history memory by 10 entries each time we grow */
		unsigned new_size = this->size + 10;
		size_t nbytes;
		tinyrl_history_entry_t **new_entries;

		nbytes = sizeof(tinyrl_history_entry_t *) * new_size;
		new_entries = realloc(this->entries, nbytes);
		if (NULL != new_entries) {
			this->size = new_size;
			this->entries = new_entries;
		}
	}
	(void)remove_duplicate(this, line);
	append_entry(this, line);
}

/*------------------------------------- */
void tinyrl_history_add(tinyrl_history_t * this, const char *line)
{
	if (this->length && (this->length == this->stifle)) {
		add_n_replace(this, line);
	} else {
		add_n_grow(this, line);
	}
}

/*------------------------------------- */
tinyrl_history_entry_t *tinyrl_history_remove(tinyrl_history_t * this,
					      unsigned offset)
{
	tinyrl_history_entry_t *result = NULL;

	if (offset < this->length) {
		result = this->entries[offset];
		/* do the biz */
		remove_entries(this, offset, offset);
	}
	return result;
}

/*------------------------------------- */
void tinyrl_history_clear(tinyrl_history_t * this)
{
	/* free all the entries */
	free_entries(this, 0, this->length - 1);
	/* and shuffle the array */
	remove_entries(this, 0, this->length - 1);
}

/*------------------------------------- */
void tinyrl_history_stifle(tinyrl_history_t * this, unsigned stifle)
{
	/* 
	 * if we are stifling (i.e. non zero value) then 
	 * delete the obsolete entries
	 */
	if (stifle) {
		if (stifle < this->length) {
			unsigned num_deletes = this->length - stifle;
			/* free the entries */
			free_entries(this, 0, num_deletes - 1);
			/* shuffle the array shut */
			remove_entries(this, 0, num_deletes - 1);
		}
		this->stifle = stifle;
	}
}

/*------------------------------------- */
unsigned tinyrl_history_unstifle(tinyrl_history_t * this)
{
	unsigned result = this->stifle;

	this->stifle = 0;

	return result;
}

/*------------------------------------- */
bool_t tinyrl_history_is_stifled(const tinyrl_history_t * this)
{
	return this->stifle ? BOOL_TRUE : BOOL_FALSE;
}

/*
INFORMATION ABOUT THE HISTORY LIST 
*/
tinyrl_history_entry_t *tinyrl_history_get(const tinyrl_history_t * this,
					   unsigned position)
{
	unsigned i;
	tinyrl_history_entry_t *entry = NULL;
	for (i = 0; i < this->length; i++) {
		entry = this->entries[i];
		if (position == tinyrl_history_entry__get_index(entry)) {
			/* found it */
			break;
		}
		entry = NULL;
	}
	return entry;
}

/*------------------------------------- */
tinyrl_history_expand_t
tinyrl_history_expand(const tinyrl_history_t * this,
		      const char *string, char **output)
{
	tinyrl_history_expand_t result = tinyrl_history_NO_EXPANSION;	/* no expansion */
	const char *p, *start;
	char *buffer = NULL;
	unsigned len;

	for (p = string, start = string, len = 0; *p; p++, len++) {
		/* perform pling substitution */
		if (*p == '!') {
			/* assume the last command to start with... */
			unsigned offset = this->current_index - 1;
			unsigned skip;
			tinyrl_history_entry_t *entry;

			/* this could be an escape sequence */
			if (p[1] != '!') {
				int tmp;
				int res;
				/* read the numeric identifier */
				res = sscanf(p, "!%d", &tmp);
				if ((0 == res) || (EOF == res)) {
					/* error so ignore it */
					break;
				}

				if (tmp < 0) {
					/* this is a relative reference */
					/*lint -e737 Loss of sign in promotion from int to unsigend int */
					offset += tmp;	/* adding a negative substracts... */
					/*lint +e737 */
				} else {
					/* this is an absolute reference */
					offset = (unsigned)tmp;
				}
			}
			if (len > 0) {
				/* we need to add in some previous plain text */
				lub_string_catn(&buffer, start, len);
			}

			/* skip the escaped chars */
			p += skip = strspn(p, "!-0123456789");

			/* try and find the history entry */
			entry = tinyrl_history_get(this, offset);
			if (NULL != entry) {
				/* reset the non-escaped references */
				start = p;
				len = 0;
				/* add the expanded text to the buffer */
				result = tinyrl_history_EXPANDED;
				lub_string_cat(&buffer,
					       tinyrl_history_entry__get_line
					       (entry));
			} else {
				/* we simply leave the unexpanded sequence */
				len += skip;
			}
		}
	}
	/* add any left over plain text */
	lub_string_catn(&buffer, start, len);
	*output = buffer;

	return result;
}

/*-------------------------------------*/
tinyrl_history_entry_t *tinyrl_history_getfirst(const tinyrl_history_t * this,
						tinyrl_history_iterator_t *
						iter)
{
	tinyrl_history_entry_t *result = NULL;

	iter->history = this;
	iter->offset = 0;

	if (this->length) {
		result = this->entries[iter->offset];
	}
	return result;
}

/*-------------------------------------*/
tinyrl_history_entry_t *tinyrl_history_getnext(tinyrl_history_iterator_t * iter)
{
	tinyrl_history_entry_t *result = NULL;

	if (iter->offset < iter->history->length - 1) {
		iter->offset++;
		result = iter->history->entries[iter->offset];
	}

	return result;
}

/*-------------------------------------*/
tinyrl_history_entry_t *tinyrl_history_getlast(const tinyrl_history_t * this,
					       tinyrl_history_iterator_t * iter)
{
	iter->history = this;
	iter->offset = this->length;

	return tinyrl_history_getprevious(iter);
}

/*-------------------------------------*/
tinyrl_history_entry_t *tinyrl_history_getprevious(tinyrl_history_iterator_t *
						   iter)
{
	tinyrl_history_entry_t *result = NULL;

	if (iter->offset) {
		iter->offset--;
		result = iter->history->entries[iter->offset];
	}

	return result;
}

/*-------------------------------------*/