root/lm-sensors/trunk/lib/conf-parse.y @ 4788

Revision 4788, 9.4 KB (checked in by khali, 7 years ago)

Delete redundant declarations.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1%{
2/*
3    conf-parse.y - Part of libsensors, a Linux library for reading sensor data.
4    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19*/
20
21#define YYERROR_VERBOSE
22
23#include <stdio.h>
24#include <string.h>
25#include <stdlib.h>
26
27#include "data.h"
28#include "general.h"
29#include "error.h"
30#include "conf.h"
31#include "access.h"
32
33static void sensors_yyerror(const char *err);
34static sensors_expr *malloc_expr(void);
35
36static sensors_chip *current_chip = NULL;
37
38#define bus_add_el(el) sensors_add_array_el(el,\
39                                      &sensors_config_busses,\
40                                      &sensors_config_busses_count,\
41                                      &sensors_config_busses_max,\
42                                      sizeof(sensors_bus))
43#define label_add_el(el) sensors_add_array_el(el,\
44                                        &current_chip->labels,\
45                                        &current_chip->labels_count,\
46                                        &current_chip->labels_max,\
47                                        sizeof(sensors_label));
48#define set_add_el(el) sensors_add_array_el(el,\
49                                      &current_chip->sets,\
50                                      &current_chip->sets_count,\
51                                      &current_chip->sets_max,\
52                                      sizeof(sensors_set));
53#define compute_add_el(el) sensors_add_array_el(el,\
54                                          &current_chip->computes,\
55                                          &current_chip->computes_count,\
56                                          &current_chip->computes_max,\
57                                          sizeof(sensors_compute));
58#define ignore_add_el(el) sensors_add_array_el(el,\
59                                          &current_chip->ignores,\
60                                          &current_chip->ignores_count,\
61                                          &current_chip->ignores_max,\
62                                          sizeof(sensors_ignore));
63#define chip_add_el(el) sensors_add_array_el(el,\
64                                       &sensors_config_chips,\
65                                       &sensors_config_chips_count,\
66                                       &sensors_config_chips_max,\
67                                       sizeof(sensors_chip));
68
69#define fits_add_el(el,list) sensors_add_array_el(el,\
70                                                  &(list).fits,\
71                                                  &(list).fits_count,\
72                                                  &(list).fits_max, \
73                                                  sizeof(sensors_chip_name));
74
75/* YYERROR can only be called in rules, not in other functions, so this must
76   be a macro */
77#define check_current_chip()\
78  do { if (! current_chip) {\
79      sensors_yyerror("Label, Set or Compute statement before first chip statement");\
80      YYERROR;\
81    }\
82  } while (0)
83
84%}
85
86%union {
87  double value;
88  char *name;
89  void *nothing;
90  sensors_chip_name_list chips;
91  sensors_expr *expr;
92  int bus;
93  sensors_chip_name chip;
94  int line;
95
96
97%left <nothing> '-' '+'
98%left <nothing> '*' '/'
99%left <nothing> NEG
100%right <nothing> '^' '`'
101
102%token <nothing> ','
103%token <nothing> EOL
104%token <line> BUS
105%token <line> LABEL
106%token <line> SET
107%token <line> CHIP
108%token <line> COMPUTE
109%token <line> IGNORE
110%token <value> FLOAT
111%token <name> NAME
112%token <nothing> ERROR
113
114%type <chips> chip_name_list
115%type <expr> expression
116%type <bus> i2cbus_name
117%type <name> adapter_name
118%type <name> algorithm_name
119%type <name> function_name
120%type <name> string
121%type <chip> chip_name
122
123%start input
124
125%%
126
127input:    /* empty */
128        | input line
129;
130
131line:     bus_statement EOL
132        | busalgo_statement EOL
133        | label_statement EOL
134        | set_statement EOL
135        | chip_statement EOL
136        | compute_statement EOL
137        | ignore_statement EOL
138        | error EOL
139;
140
141bus_statement:    BUS i2cbus_name adapter_name
142                  { sensors_bus new_el;
143                    new_el.lineno = $1;
144                    new_el.number = $2;
145                    new_el.adapter = $3;
146                    bus_add_el(&new_el);
147                  }
148;
149
150/* for compatibility, deprecated */
151busalgo_statement:        BUS i2cbus_name adapter_name algorithm_name
152                          { sensors_bus new_el;
153                            new_el.lineno = $1;
154                            new_el.number = $2;
155                            new_el.adapter = $3;
156                            free($4);
157                            bus_add_el(&new_el);
158                          }
159;
160
161label_statement:          LABEL function_name string
162                          { sensors_label new_el;
163                            check_current_chip();
164                            new_el.lineno = $1;
165                            new_el.name = $2;
166                            new_el.value = $3;
167                            label_add_el(&new_el);
168                          }
169;
170
171set_statement:    SET function_name expression
172                  { sensors_set new_el;
173                    check_current_chip();
174                    new_el.lineno = $1;
175                    new_el.name = $2;
176                    new_el.value = $3;
177                    set_add_el(&new_el);
178                  }
179;
180
181compute_statement:        COMPUTE function_name expression ',' expression
182                          { sensors_compute new_el;
183                            check_current_chip();
184                            new_el.lineno = $1;
185                            new_el.name = $2;
186                            new_el.from_proc = $3;
187                            new_el.to_proc = $5;
188                            compute_add_el(&new_el);
189                          }
190;
191
192ignore_statement:       IGNORE function_name
193                        { sensors_ignore new_el;
194                          check_current_chip();
195                          new_el.lineno = $1;
196                          new_el.name = $2;
197                          ignore_add_el(&new_el);
198                        }
199;
200
201chip_statement:   CHIP chip_name_list
202                  { sensors_chip new_el;
203                    new_el.lineno = $1;
204                    new_el.labels = NULL;
205                    new_el.sets = NULL;
206                    new_el.computes = NULL;
207                    new_el.ignores = NULL;
208                    new_el.labels_count = new_el.labels_max = 0;
209                    new_el.sets_count = new_el.sets_max = 0;
210                    new_el.computes_count = new_el.computes_max = 0;
211                    new_el.ignores_count = new_el.ignores_max = 0;
212                    new_el.chips = $2;
213                    chip_add_el(&new_el);
214                    current_chip = sensors_config_chips +
215                                   sensors_config_chips_count - 1;
216                  }
217;
218
219chip_name_list:   chip_name
220                  {
221                    $$.fits = NULL;
222                    $$.fits_count = $$.fits_max = 0;
223                    fits_add_el(&$1,$$);
224                  }
225                | chip_name_list chip_name
226                  { $$ = $1;
227                    fits_add_el(&$2,$$);
228                  }
229;
230       
231expression:       FLOAT
232                  { $$ = malloc_expr();
233                    $$->data.val = $1;
234                    $$->kind = sensors_kind_val;
235                  }
236                | NAME
237                  { $$ = malloc_expr();
238                    $$->data.var = $1;
239                    $$->kind = sensors_kind_var;
240                  }
241                | '@'
242                  { $$ = malloc_expr();
243                    $$->kind = sensors_kind_source;
244                  }
245                | expression '+' expression
246                  { $$ = malloc_expr();
247                    $$->kind = sensors_kind_sub;
248                    $$->data.subexpr.op = sensors_add;
249                    $$->data.subexpr.sub1 = $1;
250                    $$->data.subexpr.sub2 = $3;
251                  }
252                | expression '-' expression
253                  { $$ = malloc_expr();
254                    $$->kind = sensors_kind_sub;
255                    $$->data.subexpr.op = sensors_sub;
256                    $$->data.subexpr.sub1 = $1;
257                    $$->data.subexpr.sub2 = $3;
258                  }
259                | expression '*' expression
260                  { $$ = malloc_expr();
261                    $$->kind = sensors_kind_sub;
262                    $$->data.subexpr.op = sensors_multiply;
263                    $$->data.subexpr.sub1 = $1;
264                    $$->data.subexpr.sub2 = $3;
265                  }
266                | expression '/' expression
267                  { $$ = malloc_expr();
268                    $$->kind = sensors_kind_sub;
269                    $$->data.subexpr.op = sensors_divide;
270                    $$->data.subexpr.sub1 = $1;
271                    $$->data.subexpr.sub2 = $3;
272                  }
273                | '-' expression  %prec NEG
274                  { $$ = malloc_expr();
275                    $$->kind = sensors_kind_sub;
276                    $$->data.subexpr.op = sensors_negate;
277                    $$->data.subexpr.sub1 = $2;
278                    $$->data.subexpr.sub2 = NULL;
279                  }
280                | '(' expression ')'
281                  { $$ = $2; }
282                | '^' expression
283                  { $$ = malloc_expr();
284                    $$->kind = sensors_kind_sub;
285                    $$->data.subexpr.op = sensors_exp;
286                    $$->data.subexpr.sub1 = $2;
287                    $$->data.subexpr.sub2 = NULL;
288                  }
289                | '`' expression
290                  { $$ = malloc_expr();
291                    $$->kind = sensors_kind_sub;
292                    $$->data.subexpr.op = sensors_log;
293                    $$->data.subexpr.sub1 = $2;
294                    $$->data.subexpr.sub2 = NULL;
295                  }
296;
297
298i2cbus_name:      NAME
299                  { int res = sensors_parse_i2cbus_name($1,&$$);
300                    free($1);
301                    if (res) {
302                      sensors_yyerror("Parse error in i2c bus name");
303                      YYERROR;
304                    }
305                  }
306;
307
308adapter_name:     NAME
309                  { sensors_strip_of_spaces($1);
310                    $$ = $1; }
311;
312
313algorithm_name:   NAME
314                  { sensors_strip_of_spaces($1);
315                    $$ = $1; }
316;
317
318function_name:    NAME
319                  { $$ = $1; }
320;
321
322string:   NAME
323          { $$ = $1; }
324;
325
326chip_name:        NAME
327                  { int res = sensors_parse_chip_name($1,&$$);
328                    free($1);
329                    if (res) {
330                      sensors_yyerror("Parse error in chip name");
331                      YYERROR;
332                    }
333                  }
334;
335
336%%
337
338void sensors_yyerror(const char *err)
339{
340  if (sensors_lex_error[0]) {
341    sensors_parse_error(sensors_lex_error,sensors_yylineno);
342    sensors_lex_error[0] = '\0';
343  } else
344    sensors_parse_error(err,sensors_yylineno);
345}
346
347sensors_expr *malloc_expr(void)
348{
349  sensors_expr *res = malloc(sizeof(sensors_expr));
350  if (! res)
351    sensors_fatal_error("malloc_expr","Allocating a new expression");
352  return res;
353}
354 
Note: See TracBrowser for help on using the browser.