/**

 * \file input.c

 * \brief Generic stdio-like input interface

 * \author Abramo Bagnara <abramo@alsa-project.org>

 * \date 2000

 *

 * Generic stdio-like input interface

 */

/*

 *  Input object

 *  Copyright (c) 2000 by Abramo Bagnara <abramo@alsa-project.org>

 *

 *

 *   This library is free software; you can redistribute it and/or modify

 *   it under the terms of the GNU Lesser General Public License as

 *   published by the Free Software Foundation; either version 2.1 of

 *   the License, or (at your option) any later version.

 *

 *   This program is distributed in the hope that it will be useful,

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *   GNU Lesser General Public License for more details.

 *

 *   You should have received a copy of the GNU Lesser General Public

 *   License along with this library; if not, write to the Free Software

 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

 *

 */

#include <stdarg.h>

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include "local.h"

#ifndef DOC_HIDDEN

typedef struct _snd_input_ops {

	int (*close)(snd_input_t *input);

	int (*scan)(snd_input_t *input, const char *format, va_list args);

	char *(*(gets))(snd_input_t *input, char *str, size_t size);

	int (*getch)(snd_input_t *input);

	int (*ungetch)(snd_input_t *input, int c);

} snd_input_ops_t;

struct _snd_input {

	snd_input_type_t type;

	const snd_input_ops_t *ops;

	void *private_data;

};

#endif

/**

 * \brief Closes an input handle.

 * \param input The input handle to be closed.

 * \return Zero if successful, otherwise a negative error code.

 */

int snd_input_close(snd_input_t *input)

{

	int err = input->ops->close(input);

	free(input);

	return err;

}

/**

 * \brief Reads formatted input (like \c fscanf(3)) from an input handle.

 * \param input The input handle.

 * \param format Format string in \c fscanf format.

 * \param ... Other \c fscanf arguments.

 * \return The number of input items assigned, or \c EOF.

 *

 * \bug Reading from a memory buffer doesn't work.

 */

int snd_input_scanf(snd_input_t *input, const char *format, ...)

{

	int result;

	va_list args;

	va_start(args, format);

	result = input->ops->scan(input, format, args);

	va_end(args);

	return result;

}

/**

 * \brief Reads a line from an input handle (like \c fgets(3)).

 * \param input The input handle.

 * \param str Address of the destination buffer.

 * \param size The size of the destination buffer.

 * \return Pointer to the buffer if successful, otherwise \c NULL.

 *

 * Like \c fgets, the returned string is zero-terminated, and contains

 * the new-line character \c '\\n' if the line fits into the buffer.

 */

char *snd_input_gets(snd_input_t *input, char *str, size_t size)

{

	return (input->ops->gets)(input, str, size);

}

/**

 * \brief Reads a character from an input handle (like \c fgetc(3)).

 * \param input The input handle.

 * \return The character read, or \c EOF on end of file or error.

 */

int snd_input_getc(snd_input_t *input)

{

	return input->ops->getch(input);

}

/**

 * \brief Puts the last character read back to an input handle (like \c ungetc(3)).

 * \param input The input handle.

 * \param c The character to push back.

 * \return The character pushed back, or \c EOF on error.

 */

int snd_input_ungetc(snd_input_t *input, int c)

{

	return input->ops->ungetch(input, c);

}

#ifndef DOC_HIDDEN

typedef struct _snd_input_stdio {

	int close;

	FILE *fp;

} snd_input_stdio_t;

static int snd_input_stdio_close(snd_input_t *input ATTRIBUTE_UNUSED)

{

	snd_input_stdio_t *stdio = input->private_data;

	if (stdio->close)

		fclose(stdio->fp);

	free(stdio);

	return 0;

}

static int snd_input_stdio_scan(snd_input_t *input, const char *format, va_list args)

{

	snd_input_stdio_t *stdio = input->private_data;

	extern int vfscanf(FILE *, const char *, va_list);

	return vfscanf(stdio->fp, format, args);

}

static char *snd_input_stdio_gets(snd_input_t *input, char *str, size_t size)

{

	snd_input_stdio_t *stdio = input->private_data;

	return fgets(str, (int) size, stdio->fp);

}

static int snd_input_stdio_getc(snd_input_t *input)

{

	snd_input_stdio_t *stdio = input->private_data;

	return getc(stdio->fp);

}

static int snd_input_stdio_ungetc(snd_input_t *input, int c)

{

	snd_input_stdio_t *stdio = input->private_data;

	return ungetc(c, stdio->fp);

}

static const snd_input_ops_t snd_input_stdio_ops = {

	.close		= snd_input_stdio_close,

	.scan		= snd_input_stdio_scan,

	.gets		= snd_input_stdio_gets,

	.getch		= snd_input_stdio_getc,

	.ungetch	= snd_input_stdio_ungetc,

};

#endif

/**

 * \brief Creates a new input object using an existing stdio \c FILE pointer.

 * \param inputp The function puts the pointer to the new input object

 *               at the address specified by \p inputp.

 * \param fp The \c FILE pointer to read from.

 *           Reading begins at the current file position.

 * \param _close Close flag. Set this to 1 if #snd_input_close should close

 *              \p fp by calling \c fclose.

 * \return Zero if successful, otherwise a negative error code.

 */

int snd_input_stdio_attach(snd_input_t **inputp, FILE *fp, int _close)

{

	snd_input_t *input;

	snd_input_stdio_t *stdio;

	assert(inputp && fp);

	stdio = calloc(1, sizeof(*stdio));

	if (!stdio)

		return -ENOMEM;

	input = calloc(1, sizeof(*input));

	if (!input) {

		free(stdio);

		return -ENOMEM;

	}

	stdio->fp = fp;

	stdio->close = _close;

	input->type = SND_INPUT_STDIO;

	input->ops = &snd_input_stdio_ops;

	input->private_data = stdio;

	*inputp = input;

	return 0;

}

/**

 * \brief Creates a new input object reading from a file.

 * \param inputp The functions puts the pointer to the new input object

 *               at the address specified by \p inputp.

 * \param file The name of the file to read from.

 * \param mode The open mode, like \c fopen(3).

 * \return Zero if successful, otherwise a negative error code.

 */

int snd_input_stdio_open(snd_input_t **inputp, const char *file, const char *mode)

{

	int err;

	FILE *fp = fopen(file, mode);

	if (!fp) {

		//SYSERR("fopen");

		return -errno;

	}

	err = snd_input_stdio_attach(inputp, fp, 1);

	if (err < 0)

		fclose(fp);

	return err;

}

#ifndef DOC_HIDDEN

typedef struct _snd_input_buffer {

	unsigned char *buf;

	unsigned char *ptr;

	size_t size;

} snd_input_buffer_t;

static int snd_input_buffer_close(snd_input_t *input)

{

	snd_input_buffer_t *buffer = input->private_data;

	free(buffer->buf);

	free(buffer);

	return 0;

}

static int snd_input_buffer_scan(snd_input_t *input, const char *format, va_list args)

{

	snd_input_buffer_t *buffer = input->private_data;

	extern int vsscanf(const char *, const char *, va_list);

	/* FIXME: how can I obtain consumed chars count? */

	assert(0);

	return vsscanf((char *)buffer->ptr, format, args);

}

static char *snd_input_buffer_gets(snd_input_t *input, char *str, size_t size)

{

	snd_input_buffer_t *buffer = input->private_data;

	size_t bsize = buffer->size;

	while (--size > 0 && bsize > 0) {

		unsigned char c = *buffer->ptr++;

		bsize--;

		*str++ = c;

		if (c == '\n')

			break;

	}

	if (bsize == buffer->size)

		return NULL;

	buffer->size = bsize;

	*str = '\0';

	return str;

}

static int snd_input_buffer_getc(snd_input_t *input)

{

	snd_input_buffer_t *buffer = input->private_data;

	if (buffer->size == 0)

		return EOF;

	buffer->size--;

	return *buffer->ptr++;

}

static int snd_input_buffer_ungetc(snd_input_t *input, int c)

{

	snd_input_buffer_t *buffer = input->private_data;

	if (buffer->ptr == buffer->buf)

		return EOF;

	buffer->ptr--;

	assert(*buffer->ptr == (unsigned char) c);

	buffer->size++;

	return c;

}

static const snd_input_ops_t snd_input_buffer_ops = {

	.close		= snd_input_buffer_close,

	.scan		= snd_input_buffer_scan,

	.gets		= snd_input_buffer_gets,

	.getch		= snd_input_buffer_getc,

	.ungetch	= snd_input_buffer_ungetc,

};

#endif

/**

 * \brief Creates a new input object from a memory buffer.

 * \param inputp The function puts the pointer to the new input object

 *               at the address specified by \p inputp.

 * \param buf Address of the input buffer.

 * \param size Size of the input buffer.

 * \return Zero if successful, otherwise a negative error code.

 *

 * This functions creates a copy of the input buffer, so the application is

 * not required to preserve the buffer after this function has been called.

 */

int snd_input_buffer_open(snd_input_t **inputp, const char *buf, ssize_t size)

{

	snd_input_t *input;

	snd_input_buffer_t *buffer;

	assert(inputp);

	buffer = calloc(1, sizeof(*buffer));

	if (!buffer)

		return -ENOMEM;

	input = calloc(1, sizeof(*input));

	if (!input) {

		free(buffer);

		return -ENOMEM;

	}

	if (size < 0)

		size = strlen(buf);

	buffer->buf = malloc((size_t)size + 1);

	if (!buffer->buf) {

		free(input);

		free(buffer);

		return -ENOMEM;

	}

	memcpy(buffer->buf, buf, (size_t) size);

	buffer->buf[size] = 0;

	buffer->ptr = buffer->buf;

	buffer->size = size;

	input->type = SND_INPUT_BUFFER;

	input->ops = &snd_input_buffer_ops;

	input->private_data = buffer;

	*inputp = input;

	return 0;

}