controller_load_parser.y

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

	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/>.

 */

//%code requires {
//typedef void*                 yyscan_t;
//}

%{

#include <stdio.h>
#include <math.h>
#include <controller/controller_block.h>
#include <controller/controller_load_int.h>
#include <controller/controller_trace.h>
#include <controller/controller_sample.h>
#include <controller/controller_time.h>
#include <controller/controller_module.h>

#define YYERROR_VERBOSE

#include <controller/controller_load_parser.tab.h>
#include <controller/controller_load_parser.yy.h>

void yyerror(yyscan_t *scanner, char const *s);

%}

%parse-param {yyscan_t scanner}
%lex-param {yyscan_t scanner}

%pure-parser

%start ctrllist

%token ALIASSYM
%token BRACEOPENSYM
%token BRACECLOSESYM
%token COMMASYM
%token <string> ALIASVARIABLESYM
%token <string> STRINGSYM
%token <string> VARIABLENAMESYM
%token <string> INTVARIABLESYM
%token <string> DOUBLEVARIABLESYM
%token <string> STRINGVARIABLESYM
%token <integer> BOOLSYM
%token <integer> INTSYM
%token <dbl> DOUBLESYM
%token <ul> UNSIGNEDLONGSYM
%token TRIGGERSYM
%token BLOCKSSYM
%token MODULESYM
%token LINKSSYM
%token TRACESSYM
%token PARAMSSYM
%token SETSYM
%token PARENTHESESOPENSYM
%token PARENTHESESCLOSESYM
%token INCLUDESYM
%token IMPORTSYM

%token FUNC_DEG2RAD_SYM
%token FUNC_RPM2RADS_SYM

%token <dbl> CONST_PI_SYM
%token <dbl> CONST_INF_SYM

%left DUMMY_DOUBLEVAR
%left DUMMY_INTVAR
%left FLOATCASTSYM DOUBLECASTSYM INTCASTSYM BOOLCASTSYM

%left MINSYM
%left PLUSSYM
%left SLASHSYM
%left STARSYM
%left UMINUS

%union
{
	char *string;
	int integer;
	double dbl;
	unsigned long ul;
}

%type <string> stringvar
%type <dbl> doublevar
%type <integer> intvar
%type <ul> unsignedlongvar

%type <dbl> deg2rad
%type <dbl> rpm2rads

%%

ctrllist: ctrl
	| ctrl ctrllist
	;

ctrl	: aliases
	| triggers
	| links
	| blocks
	| traces
	| params
	| include
	| import
	| set
	;

include: INCLUDESYM stringvar
		{ 
			if (controller_load_include($2)) {
				yyerror(scanner, "Failed to parse include");
				YYERROR;
			}
		}
	;

import: IMPORTSYM stringvar
		{ 
			if (controller_load_import($2)) {
				yyerror(scanner, "Failed to parse import");
				YYERROR;
			}
		}
	;

aliases: ALIASSYM BRACEOPENSYM aliaslist BRACECLOSESYM

aliaslist: alias
	| alias aliaslist
	;

alias: BRACEOPENSYM
		stringvar COMMASYM
		stringvar COMMASYM
		stringvar
		BRACECLOSESYM
		{
			controller_load_variable_alias_set($2, $4, $6);
		}


triggers: TRIGGERSYM BRACEOPENSYM triggerlist BRACECLOSESYM

triggerlist: trigger
	| trigger triggerlist
	;

trigger	: BRACEOPENSYM
		stringvar varlist
		BRACECLOSESYM
		{
			if(controller_load_trigger($2, scanner)) {
				yyerror(scanner, "Error in trigger");
				YYERROR;
			}
			free($2);
			controller_load_var_clear(scanner);
		}


blocks	: BLOCKSSYM PARENTHESESOPENSYM doublevar COMMASYM doublevar 
		{
			controller_time_param_set($3, $5);
		}
	 PARENTHESESCLOSESYM BRACEOPENSYM blocklist BRACECLOSESYM

blocklist: block 
	| module
	| block blocklist
	| module blocklist
	;

block	: BRACEOPENSYM
		stringvar COMMASYM 
		stringvar varlist
		BRACECLOSESYM
		{
			if(controller_load_block_create($2, $4, scanner)) {
				yyerror(scanner, "Error creating block");
				YYERROR;
			}
			free($2);
			free($4);
			controller_load_var_clear(scanner);
		}
	;

module	: MODULESYM 
		PARENTHESESOPENSYM stringvar PARENTHESESCLOSESYM
		BRACEOPENSYM
		BRACEOPENSYM moduleinputlist BRACECLOSESYM
		BRACEOPENSYM moduleoutputlist BRACECLOSESYM
		BRACECLOSESYM
		{
			if (controller_module_create($3)) {
				yyerror(scanner, "Error creating module");
				YYERROR;
			}
		}
	;

moduleinputlist : moduleinput
	| moduleinput moduleinputlist
	;

moduleinput : BRACEOPENSYM 
		stringvar COMMASYM stringvar COMMASYM stringvar 
		{
			if (controller_module_input_add($2, $4, $6)) {
				yyerror(scanner, "Error adding module input");
				YYERROR;
			}
		}
	    BRACECLOSESYM

moduleoutputlist : moduleoutput
	| moduleoutput moduleoutputlist
	;

moduleoutput : BRACEOPENSYM 
		stringvar COMMASYM stringvar COMMASYM stringvar
		{
			if (controller_module_output_add($2, $4, $6)) {
				yyerror(scanner, "Error adding module output");
				YYERROR;
			}
		}
	    BRACECLOSESYM

params	: PARAMSSYM BRACEOPENSYM paramlist BRACECLOSESYM

paramlist: param
	| param paramlist
	;

param	: BRACEOPENSYM
		stringvar COMMASYM
		stringvar
		varlist
		BRACECLOSESYM
		{
			if (controller_load_block_param_set($2, $4, scanner)) {
				yyerror(scanner, "Error setting parameter");
				yyerror(scanner, $4);
				YYERROR;
			}
			controller_load_var_clear(scanner);
		}
	;

varlist	:	/* varlist may be emtpy */
	| COMMASYM var varlist
	;

var	: stringvar
		{ controller_load_var_add_str($1, scanner); }
	| doublevar %prec DUMMY_DOUBLEVAR
		{ controller_load_var_add_dbl($1, scanner); }
	| intvar %prec DUMMY_INTVAR
		{ controller_load_var_add_int($1, scanner); }
	| unsignedlongvar
		{ controller_load_var_add_ul($1, scanner); }
	| INTCASTSYM
		{ controller_load_var_add_int_array_start(scanner); }
		BRACEOPENSYM intlist BRACECLOSESYM
		{ controller_load_var_add_int_array_end(scanner); }
	| FLOATCASTSYM 
		{ controller_load_var_add_float_array_start(scanner); }
		BRACEOPENSYM floatlist BRACECLOSESYM
		{ controller_load_var_add_float_array_end(scanner); }
	;

stringvar: STRINGSYM
	| STRINGVARIABLESYM
		{ controller_load_variable_string_get($1); }
	;

floatlist: floatlistvar
	| floatlistvar COMMASYM floatlist
	;

floatlistvar: doublevar
		{ controller_load_var_add_flt($1, scanner); }
	;

intlist: intlistvar
	| intlistvar COMMASYM intlist
	;

intlistvar: intvar
		{ controller_load_var_add_int($1, scanner); }
	;

doublevar: DOUBLEVARIABLESYM
		{ $$ = controller_load_variable_double_get($1); }
	| DOUBLESYM
		{ $$ = $1; }
	| FLOATCASTSYM doublevar
		{ $$ = $2; }
	| DOUBLECASTSYM doublevar
		{ $$ = $2; }
	| FLOATCASTSYM intvar
		{ $$ = $2; }
	| DOUBLECASTSYM intvar
		{ $$ = $2; }
	| FLOATCASTSYM unsignedlongvar
		{ $$ = $2; }
	| DOUBLECASTSYM unsignedlongvar
		{ $$ = $2; }
	| doublevar MINSYM doublevar
		{ $$ = ($1) - ($3); }
	| doublevar PLUSSYM doublevar
		{ $$ = ($1) + ($3); }
	| doublevar SLASHSYM doublevar
		{ $$ = ($1) / ($3); }
	| doublevar STARSYM doublevar
		{ $$ = ($1) * ($3); }
	| deg2rad
		{ $$ = $1; }
	| rpm2rads
		{ $$ = $1; }
	| CONST_PI_SYM
		{ $$ = M_PI; }
	| CONST_INF_SYM
		{ $$ = INFINITY; }
	| MINSYM doublevar %prec UMINUS
		{ $$ = - $2; }
	;


deg2rad: FUNC_DEG2RAD_SYM PARENTHESESOPENSYM doublevar PARENTHESESCLOSESYM
		{ $$ = ($3) * M_PI / 180.0; }
	;

rpm2rads: FUNC_RPM2RADS_SYM PARENTHESESOPENSYM doublevar PARENTHESESCLOSESYM
		{ $$ = ($3) * 2.0 * M_PI / 60.0; }
	;

intvar: INTVARIABLESYM
		{ $$ = controller_load_variable_int_get($1); }
	| INTSYM
		{ $$ = $1; }
	| INTCASTSYM intvar
		{ $$ = $2; }
	| INTCASTSYM doublevar
		{ $$ = $2; }
	| INTCASTSYM unsignedlongvar
		{ $$ = $2; }
	| BOOLSYM
		{ $$ = $1; }
	| BOOLCASTSYM intvar
		{ $$ = $2; }
	| MINSYM intvar %prec UMINUS
		{ $$ = - $2; }
	;

unsignedlongvar: UNSIGNEDLONGSYM
		{ $$ = $1; }
	;

set:	SETSYM VARIABLENAMESYM doublevar
		{ controller_load_variable_double_set($2, $3); }
	| SETSYM VARIABLENAMESYM intvar
		{ controller_load_variable_int_set($2, $3); }
	| SETSYM VARIABLENAMESYM stringvar
		{ controller_load_variable_string_set($2, $3); }
	;

links	: LINKSSYM BRACEOPENSYM linklist BRACECLOSESYM

linklist: link
	| link linklist
	;

link	: BRACEOPENSYM
		stringvar COMMASYM 
		stringvar COMMASYM 
		stringvar COMMASYM 
		stringvar COMMASYM
		BOOLSYM
		BRACECLOSESYM
		{
			if (controller_block_connect($2, $4, $6, $8, $10)) {
				yyerror(scanner, "Error connecting blocks");
				YYERROR;
			}
			free($2);
			free($4);
			free($6);
			free($8);
		}
	| BRACEOPENSYM
		ALIASVARIABLESYM COMMASYM
		ALIASVARIABLESYM COMMASYM 
		BOOLSYM
		BRACECLOSESYM
		{
			if (controller_block_connect(
			    controller_load_variable_alias_get_block($2),
			    controller_load_variable_alias_get_term($2),
			    controller_load_variable_alias_get_block($4),
			    controller_load_variable_alias_get_term($4), $6)) {
				yyerror(scanner, "Error connecting blocks");
				YYERROR;
			}
		}
	| BRACEOPENSYM
		stringvar COMMASYM 
		stringvar COMMASYM 
		ALIASVARIABLESYM COMMASYM 
		BOOLSYM
		BRACECLOSESYM
		{
			if (controller_block_connect($2, $4,
			    controller_load_variable_alias_get_block($6),
			    controller_load_variable_alias_get_term($6), $8)) {
				yyerror(scanner, "Error connecting blocks");
				YYERROR;
			}
			free($2);
			free($4);
		}
	| BRACEOPENSYM
		ALIASVARIABLESYM COMMASYM 
		stringvar COMMASYM 
		stringvar COMMASYM 
		BOOLSYM
		BRACECLOSESYM
		{
			if (controller_block_connect(
			    controller_load_variable_alias_get_block($2),
			    controller_load_variable_alias_get_term($2),
			    $4, $6, $8)) {
				yyerror(scanner, "Error connecting blocks");
				YYERROR;
			}
			free($2);
			free($4);
		}
	;

traces	: TRACESSYM BRACEOPENSYM tracelist BRACECLOSESYM

tracelist: trace
	| trace tracelist
	;

trace	: BRACEOPENSYM
		stringvar COMMASYM
		stringvar COMMASYM
		stringvar COMMASYM
		stringvar
		BRACECLOSESYM
		{
			struct controller_trace_name trace;
			
			trace.name = $2;
			trace.unit = $4;
			trace.blockname = $6;
			trace.termname = $8;

			controller_trace_list_add(&trace);
		}
	| BRACEOPENSYM
		stringvar COMMASYM
		stringvar COMMASYM
		ALIASVARIABLESYM
		BRACECLOSESYM
		{
			struct controller_trace_name trace;
			
			trace.name = $2;
			trace.unit = $4;
			trace.blockname = controller_load_variable_alias_get_block($6);
			trace.termname = controller_load_variable_alias_get_term($6);

			controller_trace_list_add(&trace);
		}
	;