tools/gator/daemon/libsensors/conf-parse.y - arm/linux-arm-legacy - Git at Google

 %{
 /*
     conf-parse.y - Part of libsensors, a Linux library for reading sensor data.
     Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>

     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 library 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 General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
     MA 02110-1301 USA.
 */

 #define YYERROR_VERBOSE

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>

 #include "data.h"
 #include "general.h"
 #include "error.h"
 #include "conf.h"
 #include "access.h"
 #include "init.h"

 static void sensors_yyerror(const char *err);
 static sensors_expr *malloc_expr(void);

 static sensors_chip *current_chip = NULL;

 #define bus_add_el(el) sensors_add_array_el(el,\
                                       &sensors_config_busses,\
                                       &sensors_config_busses_count,\
                                       &sensors_config_busses_max,\
                                       sizeof(sensors_bus))
 #define label_add_el(el) sensors_add_array_el(el,\
                                         &current_chip->labels,\
                                         &current_chip->labels_count,\
                                         &current_chip->labels_max,\
                                         sizeof(sensors_label));
 #define set_add_el(el) sensors_add_array_el(el,\
                                       &current_chip->sets,\
                                       &current_chip->sets_count,\
                                       &current_chip->sets_max,\
                                       sizeof(sensors_set));
 #define compute_add_el(el) sensors_add_array_el(el,\
                                           &current_chip->computes,\
                                           &current_chip->computes_count,\
                                           &current_chip->computes_max,\
                                           sizeof(sensors_compute));
 #define ignore_add_el(el) sensors_add_array_el(el,\
                                           &current_chip->ignores,\
                                           &current_chip->ignores_count,\
                                           &current_chip->ignores_max,\
                                           sizeof(sensors_ignore));
 #define chip_add_el(el) sensors_add_array_el(el,\
                                        &sensors_config_chips,\
                                        &sensors_config_chips_count,\
                                        &sensors_config_chips_max,\
                                        sizeof(sensors_chip));

 #define fits_add_el(el,list) sensors_add_array_el(el,\
                                                   &(list).fits,\
                                                   &(list).fits_count,\
                                                   &(list).fits_max, \
 		                                  sizeof(sensors_chip_name));

 %}

 %union {
   double value;
   char *name;
   void *nothing;
   sensors_chip_name_list chips;
   sensors_expr *expr;
   sensors_bus_id bus;
   sensors_chip_name chip;
   sensors_config_line line;
 }

 %left <nothing> '-' '+'
 %left <nothing> '*' '/'
 %left <nothing> NEG
 %right <nothing> '^' '`'

 %token <nothing> ','
 %token <nothing> EOL
 %token <line> BUS
 %token <line> LABEL
 %token <line> SET
 %token <line> CHIP
 %token <line> COMPUTE
 %token <line> IGNORE
 %token <value> FLOAT
 %token <name> NAME
 %token <nothing> ERROR

 %type <chips> chip_name_list
 %type <expr> expression
 %type <bus> bus_id
 %type <name> adapter_name
 %type <name> function_name
 %type <name> string
 %type <chip> chip_name

 %start input

 %%

 input:	  /* empty */
 	| input line
 ;

 line:	  bus_statement EOL
 	| label_statement EOL
 	| set_statement EOL
 	| chip_statement EOL
 	| compute_statement EOL
 	| ignore_statement EOL
 	| error	EOL
 ;

 bus_statement:	  BUS bus_id adapter_name
 		  { sensors_bus new_el;
 		    new_el.line = $1;
 		    new_el.bus = $2;
                     new_el.adapter = $3;
 		    bus_add_el(&new_el);
 		  }
 ;

 label_statement:	  LABEL function_name string
 			  { sensors_label new_el;
 			    if (!current_chip) {
 			      sensors_yyerror("Label statement before first chip statement");
 			      free($2);
 			      free($3);
 			      YYERROR;
 			    }
 			    new_el.line = $1;
 			    new_el.name = $2;
 			    new_el.value = $3;
 			    label_add_el(&new_el);
 			  }
 ;

 set_statement:	  SET function_name expression
 		  { sensors_set new_el;
 		    if (!current_chip) {
 		      sensors_yyerror("Set statement before first chip statement");
 		      free($2);
 		      sensors_free_expr($3);
 		      YYERROR;
 		    }
 		    new_el.line = $1;
 		    new_el.name = $2;
 		    new_el.value = $3;
 		    set_add_el(&new_el);
 		  }
 ;

 compute_statement:	  COMPUTE function_name expression ',' expression
 			  { sensors_compute new_el;
 			    if (!current_chip) {
 			      sensors_yyerror("Compute statement before first chip statement");
 			      free($2);
 			      sensors_free_expr($3);
 			      sensors_free_expr($5);
 			      YYERROR;
 			    }
 			    new_el.line = $1;
 			    new_el.name = $2;
 			    new_el.from_proc = $3;
 			    new_el.to_proc = $5;
 			    compute_add_el(&new_el);
 			  }
 ;

 ignore_statement:	IGNORE function_name
 			{ sensors_ignore new_el;
 			  if (!current_chip) {
 			    sensors_yyerror("Ignore statement before first chip statement");
 			    free($2);
 			    YYERROR;
 			  }
 			  new_el.line = $1;
 			  new_el.name = $2;
 			  ignore_add_el(&new_el);
 			}
 ;

 chip_statement:	  CHIP chip_name_list
 		  { sensors_chip new_el;
 		    new_el.line = $1;
 		    new_el.labels = NULL;
 		    new_el.sets = NULL;
 		    new_el.computes = NULL;
 		    new_el.ignores = NULL;
 		    new_el.labels_count = new_el.labels_max = 0;
 		    new_el.sets_count = new_el.sets_max = 0;
 		    new_el.computes_count = new_el.computes_max = 0;
 		    new_el.ignores_count = new_el.ignores_max = 0;
 		    new_el.chips = $2;
 		    chip_add_el(&new_el);
 		    current_chip = sensors_config_chips +
 		                   sensors_config_chips_count - 1;
 		  }
 ;

 chip_name_list:	  chip_name
 		  {
 		    $$.fits = NULL;
 		    $$.fits_count = $$.fits_max = 0;
 		    fits_add_el(&$1,$$);
 		  }
 		| chip_name_list chip_name
 		  { $$ = $1;
 		    fits_add_el(&$2,$$);
 		  }
 ;

 expression:	  FLOAT
 		  { $$ = malloc_expr();
 		    $$->data.val = $1;
 		    $$->kind = sensors_kind_val;
 		  }
 		| NAME
 		  { $$ = malloc_expr();
 		    $$->data.var = $1;
 		    $$->kind = sensors_kind_var;
 		  }
 		| '@'
 		  { $$ = malloc_expr();
 		    $$->kind = sensors_kind_source;
 		  }
 		| expression '+' expression
 		  { $$ = malloc_expr();
 		    $$->kind = sensors_kind_sub;
 		    $$->data.subexpr.op = sensors_add;
 		    $$->data.subexpr.sub1 = $1;
 		    $$->data.subexpr.sub2 = $3;
 		  }
 		| expression '-' expression
 		  { $$ = malloc_expr();
 		    $$->kind = sensors_kind_sub;
 		    $$->data.subexpr.op = sensors_sub;
 		    $$->data.subexpr.sub1 = $1;
 		    $$->data.subexpr.sub2 = $3;
 		  }
 		| expression '*' expression
 		  { $$ = malloc_expr();
 		    $$->kind = sensors_kind_sub;
 		    $$->data.subexpr.op = sensors_multiply;
 		    $$->data.subexpr.sub1 = $1;
 		    $$->data.subexpr.sub2 = $3;
 		  }
 		| expression '/' expression
 		  { $$ = malloc_expr();
 		    $$->kind = sensors_kind_sub;
 		    $$->data.subexpr.op = sensors_divide;
 		    $$->data.subexpr.sub1 = $1;
 		    $$->data.subexpr.sub2 = $3;
 		  }
 		| '-' expression  %prec NEG
 		  { $$ = malloc_expr();
 		    $$->kind = sensors_kind_sub;
 		    $$->data.subexpr.op = sensors_negate;
 		    $$->data.subexpr.sub1 = $2;
 		    $$->data.subexpr.sub2 = NULL;
 		  }
 		| '(' expression ')'
 		  { $$ = $2; }
 		| '^' expression
 		  { $$ = malloc_expr();
 		    $$->kind = sensors_kind_sub;
 		    $$->data.subexpr.op = sensors_exp;
 		    $$->data.subexpr.sub1 = $2;
 		    $$->data.subexpr.sub2 = NULL;
 		  }
 		| '`' expression
 		  { $$ = malloc_expr();
 		    $$->kind = sensors_kind_sub;
 		    $$->data.subexpr.op = sensors_log;
 		    $$->data.subexpr.sub1 = $2;
 		    $$->data.subexpr.sub2 = NULL;
 		  }
 ;

 bus_id:		  NAME
 		  { int res = sensors_parse_bus_id($1,&$$);
 		    free($1);
 		    if (res) {
                       sensors_yyerror("Parse error in bus id");
 		      YYERROR;
                     }
 		  }
 ;

 adapter_name:	  NAME
 		  { $$ = $1; }
 ;

 function_name:	  NAME
 		  { $$ = $1; }
 ;

 string:	  NAME
 	  { $$ = $1; }
 ;

 chip_name:	  NAME
 		  { int res = sensors_parse_chip_name($1,&$$);
 		    free($1);
 		    if (res) {
 		      sensors_yyerror("Parse error in chip name");
 		      YYERROR;
 		    }
 		  }
 ;

 %%

 void sensors_yyerror(const char *err)
 {
   if (sensors_lex_error[0]) {
     sensors_parse_error_wfn(sensors_lex_error, sensors_yyfilename, sensors_yylineno);
     sensors_lex_error[0] = '\0';
   } else
     sensors_parse_error_wfn(err, sensors_yyfilename, sensors_yylineno);
 }

 sensors_expr *malloc_expr(void)
 {
   sensors_expr *res = malloc(sizeof(sensors_expr));
   if (! res)
     sensors_fatal_error(__func__, "Allocating a new expression");
   return res;
 }
	%{
	/*
	conf-parse.y - Part of libsensors, a Linux library for reading sensor data.
	Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl>

	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 library 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 General Public License
	along with this program; if not, write to the Free Software
	Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
	MA 02110-1301 USA.
	*/

	#define YYERROR_VERBOSE

	#include <stdio.h>
	#include <string.h>
	#include <stdlib.h>

	#include "data.h"
	#include "general.h"
	#include "error.h"
	#include "conf.h"
	#include "access.h"
	#include "init.h"

	static void sensors_yyerror(const char *err);
	static sensors_expr *malloc_expr(void);

	static sensors_chip *current_chip = NULL;

	#define bus_add_el(el) sensors_add_array_el(el,\
	&sensors_config_busses,\
	&sensors_config_busses_count,\
	&sensors_config_busses_max,\
	sizeof(sensors_bus))
	#define label_add_el(el) sensors_add_array_el(el,\
	&current_chip->labels,\
	&current_chip->labels_count,\
	&current_chip->labels_max,\
	sizeof(sensors_label));
	#define set_add_el(el) sensors_add_array_el(el,\
	&current_chip->sets,\
	&current_chip->sets_count,\
	&current_chip->sets_max,\
	sizeof(sensors_set));
	#define compute_add_el(el) sensors_add_array_el(el,\
	&current_chip->computes,\
	&current_chip->computes_count,\
	&current_chip->computes_max,\
	sizeof(sensors_compute));
	#define ignore_add_el(el) sensors_add_array_el(el,\
	&current_chip->ignores,\
	&current_chip->ignores_count,\
	&current_chip->ignores_max,\
	sizeof(sensors_ignore));
	#define chip_add_el(el) sensors_add_array_el(el,\
	&sensors_config_chips,\
	&sensors_config_chips_count,\
	&sensors_config_chips_max,\
	sizeof(sensors_chip));

	#define fits_add_el(el,list) sensors_add_array_el(el,\
	&(list).fits,\
	&(list).fits_count,\
	&(list).fits_max, \
	sizeof(sensors_chip_name));

	%}

	%union {
	double value;
	char *name;
	void *nothing;
	sensors_chip_name_list chips;
	sensors_expr *expr;
	sensors_bus_id bus;
	sensors_chip_name chip;
	sensors_config_line line;
	}

	%left <nothing> '-' '+'
	%left <nothing> '*' '/'
	%left <nothing> NEG
	%right <nothing> '^' '`'

	%token <nothing> ','
	%token <nothing> EOL
	%token <line> BUS
	%token <line> LABEL
	%token <line> SET
	%token <line> CHIP
	%token <line> COMPUTE
	%token <line> IGNORE
	%token <value> FLOAT
	%token <name> NAME
	%token <nothing> ERROR

	%type <chips> chip_name_list
	%type <expr> expression
	%type <bus> bus_id
	%type <name> adapter_name
	%type <name> function_name
	%type <name> string
	%type <chip> chip_name

	%start input

	%%

	input: /* empty */
	\| input line
	;

	line: bus_statement EOL
	\| label_statement EOL
	\| set_statement EOL
	\| chip_statement EOL
	\| compute_statement EOL
	\| ignore_statement EOL
	\| error EOL
	;

	bus_statement: BUS bus_id adapter_name
	{ sensors_bus new_el;
	new_el.line = $1;
	new_el.bus = $2;
	new_el.adapter = $3;
	bus_add_el(&new_el);
	}
	;

	label_statement: LABEL function_name string
	{ sensors_label new_el;
	if (!current_chip) {
	sensors_yyerror("Label statement before first chip statement");
	free($2);
	free($3);
	YYERROR;
	}
	new_el.line = $1;
	new_el.name = $2;
	new_el.value = $3;
	label_add_el(&new_el);
	}
	;

	set_statement: SET function_name expression
	{ sensors_set new_el;
	if (!current_chip) {
	sensors_yyerror("Set statement before first chip statement");
	free($2);
	sensors_free_expr($3);
	YYERROR;
	}
	new_el.line = $1;
	new_el.name = $2;
	new_el.value = $3;
	set_add_el(&new_el);
	}
	;

	compute_statement: COMPUTE function_name expression ',' expression
	{ sensors_compute new_el;
	if (!current_chip) {
	sensors_yyerror("Compute statement before first chip statement");
	free($2);
	sensors_free_expr($3);
	sensors_free_expr($5);
	YYERROR;
	}
	new_el.line = $1;
	new_el.name = $2;
	new_el.from_proc = $3;
	new_el.to_proc = $5;
	compute_add_el(&new_el);
	}
	;

	ignore_statement: IGNORE function_name
	{ sensors_ignore new_el;
	if (!current_chip) {
	sensors_yyerror("Ignore statement before first chip statement");
	free($2);
	YYERROR;
	}
	new_el.line = $1;
	new_el.name = $2;
	ignore_add_el(&new_el);
	}
	;

	chip_statement: CHIP chip_name_list
	{ sensors_chip new_el;
	new_el.line = $1;
	new_el.labels = NULL;
	new_el.sets = NULL;
	new_el.computes = NULL;
	new_el.ignores = NULL;
	new_el.labels_count = new_el.labels_max = 0;
	new_el.sets_count = new_el.sets_max = 0;
	new_el.computes_count = new_el.computes_max = 0;
	new_el.ignores_count = new_el.ignores_max = 0;
	new_el.chips = $2;
	chip_add_el(&new_el);
	current_chip = sensors_config_chips +
	sensors_config_chips_count - 1;
	}
	;

	chip_name_list: chip_name
	{
	$$.fits = NULL;
	$$.fits_count = $$.fits_max = 0;
	fits_add_el(&$1,$$);
	}
	\| chip_name_list chip_name
	{ $$ = $1;
	fits_add_el(&$2,$$);
	}
	;

	expression: FLOAT
	{ $$ = malloc_expr();
	$$->data.val = $1;
	$$->kind = sensors_kind_val;
	}
	\| NAME
	{ $$ = malloc_expr();
	$$->data.var = $1;
	$$->kind = sensors_kind_var;
	}
	\| '@'
	{ $$ = malloc_expr();
	$$->kind = sensors_kind_source;
	}
	\| expression '+' expression
	{ $$ = malloc_expr();
	$$->kind = sensors_kind_sub;
	$$->data.subexpr.op = sensors_add;
	$$->data.subexpr.sub1 = $1;
	$$->data.subexpr.sub2 = $3;
	}
	\| expression '-' expression
	{ $$ = malloc_expr();
	$$->kind = sensors_kind_sub;
	$$->data.subexpr.op = sensors_sub;
	$$->data.subexpr.sub1 = $1;
	$$->data.subexpr.sub2 = $3;
	}
	\| expression '*' expression
	{ $$ = malloc_expr();
	$$->kind = sensors_kind_sub;
	$$->data.subexpr.op = sensors_multiply;
	$$->data.subexpr.sub1 = $1;
	$$->data.subexpr.sub2 = $3;
	}
	\| expression '/' expression
	{ $$ = malloc_expr();
	$$->kind = sensors_kind_sub;
	$$->data.subexpr.op = sensors_divide;
	$$->data.subexpr.sub1 = $1;
	$$->data.subexpr.sub2 = $3;
	}
	\| '-' expression %prec NEG
	{ $$ = malloc_expr();
	$$->kind = sensors_kind_sub;
	$$->data.subexpr.op = sensors_negate;
	$$->data.subexpr.sub1 = $2;
	$$->data.subexpr.sub2 = NULL;
	}
	\| '(' expression ')'
	{ $$ = $2; }
	\| '^' expression
	{ $$ = malloc_expr();
	$$->kind = sensors_kind_sub;
	$$->data.subexpr.op = sensors_exp;
	$$->data.subexpr.sub1 = $2;
	$$->data.subexpr.sub2 = NULL;
	}
	\| '`' expression
	{ $$ = malloc_expr();
	$$->kind = sensors_kind_sub;
	$$->data.subexpr.op = sensors_log;
	$$->data.subexpr.sub1 = $2;
	$$->data.subexpr.sub2 = NULL;
	}
	;

	bus_id: NAME
	{ int res = sensors_parse_bus_id($1,&$$);
	free($1);
	if (res) {
	sensors_yyerror("Parse error in bus id");
	YYERROR;
	}
	}
	;

	adapter_name: NAME
	{ $$ = $1; }
	;

	function_name: NAME
	{ $$ = $1; }
	;

	string: NAME
	{ $$ = $1; }
	;

	chip_name: NAME
	{ int res = sensors_parse_chip_name($1,&$$);
	free($1);
	if (res) {
	sensors_yyerror("Parse error in chip name");
	YYERROR;
	}
	}
	;

	%%

	void sensors_yyerror(const char *err)
	{
	if (sensors_lex_error[0]) {
	sensors_parse_error_wfn(sensors_lex_error, sensors_yyfilename, sensors_yylineno);
	sensors_lex_error[0] = '\0';
	} else
	sensors_parse_error_wfn(err, sensors_yyfilename, sensors_yylineno);
	}

	sensors_expr *malloc_expr(void)
	{
	sensors_expr *res = malloc(sizeof(sensors_expr));
	if (! res)
	sensors_fatal_error(__func__, "Allocating a new expression");
	return res;
	}