controller_load.c

/*
	Copyright Jeroen Vreeken (pe1rxq@amsat.org), 2009
	Copyright Stichting C.A. Muller Radioastronomiestation, 2009

	This program is free software: you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation, either version 3 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 General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program.  If not, see <http://www.gnu.org/licenses/>.

 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include "controller_load_parser.tab.h"
#include "controller_load_parser.yy.h"
#include "controller_load.h"
#include "controller_sample.h"
#include "controller_block.h"
#include "../../common/include/dynarg.h"
#include <shell/shell.h>
#include "log.h"

struct controller_load_array {
	void *array;
	size_t size;
};


struct controller_load_extra {
	char *filename;
	int ret;
	bool va_list_start;
	va_list va_list;
	struct controller_load_va_entry *va_entries;
	struct controller_load_array *array;
	bool use_string;
	char *string;
	size_t stringlen;
	FILE *input_file;
};


int yyparse(yyscan_t scanner, FILE *);

void yyerror(yyscan_t scanner, char const *s)
{
	struct controller_load_extra *extra = yyget_extra(scanner);
	
	log_send(LOG_T_ERROR, "%s:%d: %s", 
	    extra->filename,
	    yyget_lineno(scanner),
	    s);
	extra->ret = -1;
}

void controller_load_fatal_error (char* msg , yyscan_t yyscanner)
{
    	log_send(LOG_T_ERROR, "Fatal: %s", msg );
	log_server_flush();
	exit(1);
}

struct controller_load_va_entry {
	struct controller_load_va_entry *next;
	void *ptr;
};


void controller_load_var_add_str(char *string, yyscan_t scanner)
{
	struct controller_load_extra *extra = yyget_extra(scanner);

	struct controller_load_va_entry **entryp;
	
	if (!extra->va_list_start) {
		va_new(extra->va_list);
		extra->va_list_start = true;
	}
	
	va_add(extra->va_list, char *, string);
	
	for (entryp = &extra->va_entries; *entryp; entryp = &(*entryp)->next);
	
	*entryp = malloc(sizeof(struct controller_load_va_entry));
	(*entryp)->next = NULL;
	(*entryp)->ptr = string;
}

void controller_load_var_add_dbl(double dbl, yyscan_t scanner)
{
	struct controller_load_extra *extra = yyget_extra(scanner);

	if (!extra->va_list_start) {
		va_new(extra->va_list);
		extra->va_list_start = true;
	}
	
	va_add(extra->va_list, double, dbl);
}

void controller_load_var_add_flt(float flt, yyscan_t scanner)
{
	struct controller_load_extra *extra = yyget_extra(scanner);

	if (extra->array) {
		extra->array->array = realloc(
		    extra->array->array,
		    extra->array->size + sizeof(float));
		*(float*)(extra->array->array + extra->array->size) = flt;
		extra->array->size += sizeof(float);
	} else {
		/* float is promoted to double in a variadic function */
		controller_load_var_add_dbl(flt, scanner);
	}
}

void controller_load_var_add_float_array_start(yyscan_t scanner)
{
	struct controller_load_extra *extra = yyget_extra(scanner);

	extra->array = malloc(sizeof(struct controller_load_array));
	extra->array->array = NULL;
	extra->array->size = 0;
}

void controller_load_var_add_float_array_end(yyscan_t scanner)
{
	struct controller_load_extra *extra = yyget_extra(scanner);
	struct controller_load_va_entry **entryp;
	
	if (!extra->va_list_start) {
		va_new(extra->va_list);
		extra->va_list_start = true;
	}
	
	va_add(extra->va_list, float *, extra->array->array);
	
	for (entryp = &extra->va_entries; *entryp; entryp = &(*entryp)->next);
	
	*entryp = malloc(sizeof(struct controller_load_va_entry));
	(*entryp)->next = NULL;
	(*entryp)->ptr = extra->array->array;
	
	free(extra->array);
	extra->array = NULL;
}

void controller_load_var_add_int(int i, yyscan_t scanner)
{
	struct controller_load_extra *extra = yyget_extra(scanner);
	if (!extra->va_list_start) {
		va_new(extra->va_list);
		extra->va_list_start = true;
	}
	
	va_add(extra->va_list, int, i);
}

void controller_load_var_add_ul(unsigned long ul, yyscan_t scanner)
{
	struct controller_load_extra *extra = yyget_extra(scanner);
	if (!extra->va_list_start) {
		va_new(extra->va_list);
		extra->va_list_start = true;
	}
	
	va_add(extra->va_list, unsigned long, ul);
}

void controller_load_var_clear(yyscan_t scanner)
{
	struct controller_load_extra *extra = yyget_extra(scanner);
	struct controller_load_va_entry *entry, *next;
	
	for (entry = extra->va_entries; entry; entry = next) {
		if (entry->ptr)
			free(entry->ptr);
		next = entry->next;
		free(entry);
	}
	extra->va_entries = NULL;
	
	if (extra->va_list_start) {
		va_free(extra->va_list);
		extra->va_list_start = false;
	}
}

void controller_load_frequency(double frequency)
{
	controller_sample_frequency_set(frequency);
}

int controller_load_block_create(char *type, char *name, yyscan_t scanner)
{
	struct controller_load_extra *extra = yyget_extra(scanner);

	return controller_block_create(type, name, extra->va_list);
}

int controller_load_block_param_set(char *block, char *param, yyscan_t scanner)
{
	struct controller_load_extra *extra = yyget_extra(scanner);

	return controller_block_param_set(block, param, extra->va_list);
}

int controller_load_include(char *file_name)
{
	int r;

	log_send(LOG_T_DEBUG, "Include '%s'", file_name);
	r = controller_load(file_name);
	log_send(LOG_T_DEBUG, "End of include '%s': %d", file_name, r);

	return r;
}


int controller_load_yy_input(char *buf, int *readbytes, int sizebytes, yyscan_t scanner)
{
	struct controller_load_extra *extra = yyget_extra(scanner);

	if (!extra->use_string) {
		*readbytes = fread(buf, 1, sizebytes, extra->input_file);
	} else {
		int copybytes;
		
		copybytes = sizebytes;
		if (copybytes > extra->stringlen)
			copybytes = extra->stringlen;
		*readbytes = copybytes;
		memcpy(buf, extra->string, copybytes);
		extra->string += copybytes;
		extra->stringlen -= copybytes;
	}
	
	return 0;
}


static int controller_load_shell(char *args, char *out, int *outlen)
{
	int ret;
	struct controller_load_extra extra;
	char *safe_context;
	yyscan_t scanner;

	if (!args) {
		*outlen = sprintf(out,
		     "no arguments\n");
		return *outlen;
	}

	extra.ret = 0;
	extra.va_entries = NULL;
	extra.va_list_start = false;
	extra.array = NULL;
	extra.use_string = true;
	extra.stringlen = strlen(args);
	extra.string = args;

	log_send(LOG_T_DEBUG, "parsing: %s", args);

	yylex_init_extra(&extra, &scanner);

	safe_context = controller_block_context_get();
	controller_block_context_set("shell");

	ret = yyparse(scanner, NULL);

	controller_block_context_set(safe_context);

	yylex_destroy(scanner);
	
	if (ret) {
		*outlen = sprintf(out,
		     "failed to parse arguments\n");
	} else {
		*outlen = sprintf(out,
		     "parsed arguments\n");
	}
	
	return *outlen;
}

static int controller_load_file_shell(char *args, char *out, int *outlen)
{
	int ret;

	if (!args) {
		*outlen = sprintf(out,
		     "no arguments\n");
		return *outlen;
	}

	log_send(LOG_T_DEBUG, "loading: %s", args);

	ret = controller_load(args);
	
	if (ret) {
		*outlen = sprintf(out,
		     "failed to load file\n");
	} else {
		*outlen = sprintf(out,
		     "parsed file\n");
	}
	
	return *outlen;
}

static struct shell_cmd controller_cmd[] = {
	{ "controller", 
	  "parse arguments as controller commands",
	  controller_load_shell
	},
	{ "controller_file", 
	  "load controller commands from file",
	  controller_load_file_shell
	}
};

int controller_load_shell_add(void)
{
	int ret = 0, i;
	
	for (i = 0; i < sizeof(controller_cmd)/sizeof(struct shell_cmd); i++) {
		ret |= shell_cmd_add(&controller_cmd[i]);
	}
	
	return ret;
}

int controller_load(char *filename)
{
	struct controller_load_extra extra;
	char *safe_context;
	yyscan_t scanner;
	
	extra.filename = filename;
	extra.ret = 0;
	extra.va_entries = NULL;
	extra.va_list_start = false;
	extra.array = NULL;
	extra.use_string = false;
	extra.stringlen = 0;


	extra.input_file = fopen(filename, "r");
	if (!extra.input_file) {
		extra.ret = -1;
		goto err_nofile;
	}
	
	yylex_init_extra(&extra, &scanner);

	safe_context = controller_block_context_get();
	controller_block_context_set(filename);

	extra.ret = yyparse(scanner, extra.input_file);

	controller_block_context_set(safe_context);
	
	yylex_destroy(scanner);
	fclose(extra.input_file);

	controller_block_link();
	
err_nofile:
	return extra.ret;
}