controller_load.c

/*
	Copyright (c) 2015,
		Daan Vreeken <Daan @ Vitsch . nl> - Vitsch Electronics
	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 <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

#include <controller/controller_load_int.h>
#include <controller/controller_load_parser.tab.h>
#include <controller/controller_load_parser.yy.h>
#include <controller/controller_load.h>
#include <controller/controller_sample.h>
#include <controller/controller_block.h>
#include <controller/controller_module.h>
#include <dynarg.h>
#include <limits.h>

#include <shell/shell.h>
#include <log/log.h>

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


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


static int controller_load_one_file(char *filename);


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);
}

static int controller_load_add_va_type(yyscan_t scanner, char *type)
{
	struct controller_load_extra *extra = yyget_extra(scanner);
	char **tmp;
	
	tmp = realloc(extra->va_type_list, sizeof(char *)*(extra->va_list_argc+1));
	if (!tmp)
		return -1;
	extra->va_type_list = tmp;
	tmp[extra->va_list_argc] = type;
	extra->va_list_argc++;
	
	return 0;
}

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);
	controller_load_add_va_type(scanner, "char*");
	
	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);
	controller_load_add_va_type(scanner, "double");
}

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);
	controller_load_add_va_type(scanner, "float*");
	
	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_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_int_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, int *, extra->array->array);
	controller_load_add_va_type(scanner, "int*");
	
	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->array) {
		extra->array->array = realloc(
		    extra->array->array,
		    extra->array->size + sizeof(int));
		*(int*)(extra->array->array + extra->array->size) = i;
		extra->array->size += sizeof(int);
	} else {
		if (!extra->va_list_start) {
			va_new(extra->va_list);
			extra->va_list_start = true;
		}
	
		va_add(extra->va_list, int, i);
		controller_load_add_va_type(scanner, "int");
	}
}

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);
	controller_load_add_va_type(scanner, "unsigned long");
}

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);
		free(extra->va_type_list);
		extra->va_type_list = NULL;
		extra->va_list_start = false;
		extra->va_list_argc = 0;
	}
}

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

	return controller_sample_trigger_create(name, extra->va_list_argc,
	    extra->va_list, extra->va_type_list);
}

static char *rel2file(yyscan_t scanner, char *rel_name)
{
	struct controller_load_extra *extra = yyget_extra(scanner);
	struct stat stattmp;
	char *ret;
	char *tmp;
	char *slash;

	if ((stat(rel_name, &stattmp) == 0) && (!(stattmp.st_mode & S_IFDIR)))
		return strdup(rel_name);
	
	if (!extra->filename)
		return NULL;

	tmp = strdup(extra->filename);
	slash = strrchr(tmp, '/');
	if (slash == NULL) {
		free(tmp);
		return NULL;
	}
	*slash = '\0';
	asprintf(&ret, "%s/%s", tmp, rel_name);
	free(tmp);

	if ((stat(ret, &stattmp) == 0) && (!(stattmp.st_mode & S_IFDIR)))
		return ret;

	free(ret);
	return NULL;
}


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

	ret = controller_block_create(type, prefname, extra->va_list_argc, 
	    extra->va_list, extra->va_type_list);

	if (!ret)
		return 0;
	
	
	char *file_name = rel2file(scanner, type);

	if (!file_name) {
		log_send(LOG_T_ERROR, 
		    "Could not load or create block '%s'", type);
		return -1;
	}
	
	log_send(LOG_T_DEBUG, "Load module '%s' with prefix '%s'", 
	    file_name, prefname);
	controller_module_push(prefname);
	ret = controller_load_one_file(file_name);
	controller_module_pop();
	log_send(LOG_T_DEBUG, "End of module '%s': %d", file_name, ret);

	free(prefname);

	return ret;
}

static char *get_next_type(char **str)
{
	char *comma, *tmp;
	int comma_idx;

	if (**str == '\0')
		// No more arguments left.
		return NULL;

	// This function returns a copy of the first part of a comma separated
	// string, upto the comma. The user is expected to free() the returned
	// string. When a comma is found, the '*str' pointer is advanced to
	// the first character following the comma.
	comma = index(*str, ',');
	if (comma == NULL) {
		// This is the last argument. Advance '*str' to \0 character.
		tmp = *str;
		*str += strlen(tmp);
		return strdup(tmp);
	}
	
	// More arguments to come. Return this argument and advance '*str'.
	comma_idx = comma - *str;
	tmp = *str;
	*str += comma_idx + 1;
	return strndup(tmp, comma_idx);
}

static int check_one_argument_type_list(char *expected_types,
    int supplied_argc, char **supplied_types, bool show_errs)
{
	char *supplied_type, *expected_type, *iter;
	int idx;

	//log_send(LOG_T_DEBUG, "check '%s'", expected_types);
	if (strcmp(expected_types, "*") == 0) {
		// It's the "we'll accept anything" wildcard. We're
		// done.
		return 0;
	}
	
	// Walk through the supplied va_list, filled with strings that
	// describe the argument types and compare them to the expected types.
	iter = expected_types;
	for (idx = 0; idx < supplied_argc; idx++) {
		supplied_type = supplied_types[idx];
		expected_type = get_next_type(&iter);
		//log_send(LOG_T_DEBUG, "sup: '%s', idx:%d, exp: '%s'", supplied_type, idx, expected_type);

		if (expected_type == NULL) {
			// Too many arguments supplied.
			if (show_errs)
				log_send(LOG_T_ERROR, "Invalid number of "
				    "arguments! Expecting %d argument%s "
				    "instead of %d.", idx,
				    (idx > 1) ? "s" : "", supplied_argc);
			return -1;
		}
		
		if (strcmp(expected_type, "*") == 0) {
			// It's the "we'll accept anything" wildcard. We're
			// done.
			free(expected_type);
			return 0;
		}
		
		if (strcmp(supplied_type, expected_type) != 0) {
			if (show_errs)
				log_send(LOG_T_ERROR, "Argument mismatch in "
				    "argument %d. Expected argument of type "
				    "'%s' instead of '%s'", idx + 1,
				    expected_type, supplied_type);
			free(expected_type);
			return -1;
		}
		free(expected_type);
	}
	if (*iter != '\0') {
		// Not enough arguments.
		if (show_errs) {
			// See how many are missing..
			while (expected_type != NULL) {
				expected_type = get_next_type(&iter);
				if (expected_type != NULL)
					free(expected_type);
				idx++;
			}
			idx--;
			log_send(LOG_T_ERROR, "Invalid number of arguments! "
			    "Expecting %d argument%s instead of %d.", idx,
			    (idx > 1) ? "s" : "", supplied_argc);
		}
		return -1;
	}
	
	return 0;
}

int controller_load_check_arg(char **expected_types, int supplied_argc,
    char **supplied_types)
{
	char **first;
	char *str;
	bool show_errs;
	int ret;

	if (expected_types[0] == NULL) {
		// This function doesn't expect arguments.
		if (supplied_argc > 0) {
			log_send(LOG_T_ERROR, "Too many arguments supplied! "
			    "This function doesn't accept arguments.");
			return -1;
		}
		return 0;
	}

	show_errs = (expected_types[1] == NULL);

	first = expected_types;
	while (*expected_types != NULL) {
		ret = check_one_argument_type_list(*expected_types,
		    supplied_argc, supplied_types, show_errs);
		if (ret == 0)
			// Found a match. We're done.
			return 0;
		
		expected_types++;
	}
	
	// If we make it to this point, none of the expected argument type
	// lists matched, so the supplied argument types are invalid (or
	// there are too many / not enough of them).
	// List the possible options to the user to help out the best we can..
	log_send(LOG_T_ERROR, 
	    "Invalid arguments! This function accepts %sthe following:",
	    (expected_types[1] != NULL) ? "any of " : "");
	expected_types = first;
	while (*expected_types != NULL) {
		str = *expected_types++;
		log_send(LOG_T_ERROR, "\t%s", (*str != '\0') ?
		    str : "(no arguments)");
	}
	if (supplied_argc) {
		log_send(LOG_T_ERROR, "The given arguments are:");
		int i;
		for (i = 0; i < supplied_argc; i++) {
			log_send(LOG_T_ERROR, "\t%s", supplied_types[i]);
		}
	}

	return -1;
}

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

	ret = controller_block_param_set(prefblock, param, 
	    extra->va_list_argc, extra->va_list, extra->va_type_list);
	free(prefblock);
	
	return ret;
}

int controller_load_include(yyscan_t scanner, char *rel_name)
{
	int r;
	char *file_name = rel2file(scanner, rel_name);

	log_send(LOG_T_DEBUG, "Include '%s' (%s)", file_name, rel_name);

	if (!file_name) {
		log_send(LOG_T_ERROR, "Could not find file");
		return -1;
	}

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

	free(rel_name);

	return r;
}

static int controller_load_import_nr;
static char **controller_load_imports;

int controller_load_import(yyscan_t scanner, char *rel_name)
{
	int r, i;
	char *file_name = rel2file(scanner, rel_name);
	char **imports;

	log_send(LOG_T_DEBUG, "Import '%s' (%s)", file_name, rel_name);

	if (!file_name) {
		log_send(LOG_T_ERROR, "Could not find file");
		return -1;
	}

	char *realname = realpath(file_name, NULL);

	if (!realname) {
		log_send(LOG_T_ERROR, "Could not find realpath");
		free(file_name);
		return -1;
	}

	for (i = 0; i < controller_load_import_nr; i++) {
		if (!strcmp(realname, controller_load_imports[i])) {
			log_send(LOG_T_DEBUG, 
			    "'%s' ('%s') has already been imported",
			    file_name, realname);
			free(realname);
			free(file_name);

			return 0;
		}
	}
	imports = realloc(controller_load_imports,
	    (controller_load_import_nr + 1) * sizeof(char *));
	if (!imports) {
		log_send(LOG_T_ERROR, "Could not allocate memory for import administration");
		free(realname);
		free(file_name);
		
		return -1;
	}
	imports[controller_load_import_nr] = realname;
	controller_load_imports = imports;
	controller_load_import_nr++;

	r = controller_load_one_file(file_name);
	log_send(LOG_T_DEBUG, "End of import '%s': %d", file_name, r);

	free(file_name);

	return r;
}

int controller_load_block_connect(char *outblock, char *outterm,
    char *inblock, char *interm, int chain)
{
	int ret;
	char *prefinblock, *prefoutblock;
	
	prefinblock = controller_module_prefix_block(inblock);
	prefoutblock = controller_module_prefix_block(outblock);
	
	ret = controller_block_connect(
	    prefoutblock, outterm, prefinblock, interm, chain);
	
	free(prefinblock);
	free(prefoutblock);
	
	return ret;
}

int controller_load_yy_input(char *buf, size_t *readbytes, size_t 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.filename = "shell";
	extra.ret = 0;
	extra.va_entries = NULL;
	extra.va_list_start = false;
	extra.va_list_argc = 0;
	extra.va_type_list = NULL;
	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);

	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_one_file(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;
}

// This routine is called (possibly recursively) to load a single file.
// Linking all inputs/outputs is allowed to fail here, since there might be
// links that go to/come from blocks that will be instantiated in other files
// later on.
static int controller_load_one_file(char *filename)
{
	struct controller_load_extra extra;
	char *saved_context;
	yyscan_t scanner;
	int ret;
	
	extra.filename = filename;
	extra.ret = 0;
	extra.va_entries = NULL;
	extra.va_list_start = false;
	extra.va_list_argc = 0;
	extra.va_type_list = NULL;
	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);

	saved_context = controller_block_context_get();
	controller_block_context_set(filename);

	extra.ret = yyparse(scanner);

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

	ret = controller_block_link();
	// We'll allow -1 (missing blocks), but we'll bail out on lower return
	// values, which indicate unrecoverable errors like type mismatches in
	// links, etc.
	if (ret < -1) {
		log_send(LOG_T_ERROR, "Failed to link controller!");
		return ret;
	}
	
err_nofile:
	return extra.ret;
}

// This routine will only be called to load the top-most file in a hierarchy.
// When it is loaded successfully, all earlier unresolved links must have been
// resolved.
int controller_load(char *filename)
{
	int ret;
	
	ret = controller_load_one_file(filename);
	if (ret != 0)
		return ret;
	
	// See if the linker can now resolve all links.
	ret = controller_block_link();
	if (ret != 0) {
		log_send(LOG_T_ERROR, "Final linking stage failed.");
	}
	return ret;
}