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

Revision 101, 8.2 KB (checked in by frodo, 15 years ago)

More libary stuff

The bus translation functions.

  • 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  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
31/* These two functions are defined in conf-lex.l */
32extern int sensors_yylex(void);
33extern char sensors_lex_error[];
34extern int sensors_yylineno;
35
36static void sensors_yyerror(const char *err);
37static sensors_expr *malloc_expr(void);
38
39static sensors_chip *current_chip = NULL;
40
41#define bus_add_el(el) sensors_add_array_el(el,\
42                                      (void **) &sensors_config_busses,\
43                                      &sensors_config_busses_count,\
44                                      &sensors_config_busses_max,\
45                                      sizeof(sensors_bus))
46#define label_add_el(el) sensors_add_array_el(el,\
47                                        (void **) &current_chip->labels,\
48                                        &current_chip->labels_count,\
49                                        &current_chip->labels_max,\
50                                        sizeof(sensors_label));
51#define set_add_el(el) sensors_add_array_el(el,\
52                                      (void **) &current_chip->sets,\
53                                      &current_chip->sets_count,\
54                                      &current_chip->sets_max,\
55                                      sizeof(sensors_set));
56#define compute_add_el(el) sensors_add_array_el(el,\
57                                          (void **) &current_chip->computes,\
58                                          &current_chip->computes_count,\
59                                          &current_chip->computes_max,\
60                                          sizeof(sensors_compute));
61#define chip_add_el(el) sensors_add_array_el(el,\
62                                       (void **) &sensors_config_chips,\
63                                       &sensors_config_chips_count,\
64                                       &sensors_config_chips_max,\
65                                       sizeof(sensors_chip));
66
67#define fits_add_el(el,list) sensors_add_array_el(el,\
68                                                  (void **) &(list).fits,\
69                                                  &(list).fits_count,\
70                                                  &(list).fits_max, \
71                                                  sizeof(sensors_chip_name));
72
73/* YYERROR can only be called in rules, not in other functions, so this must
74   be a macro */
75#define check_current_chip()\
76  do { if (! current_chip) {\
77      sensors_yyerror("Label, Set or Compute statement before first chip statement");\
78      YYERROR;\
79    }\
80  } while (0)
81
82%}
83
84%union {
85  double value;
86  char *name;
87  void *nothing;
88  sensors_chip_name_list chips;
89  sensors_expr *expr;
90  int bus;
91  sensors_chip_name chip;
92  int line;
93
94
95%left <nothing> '-' '+'
96%left <nothing> '*' '/'
97%left <nothing> NEG
98
99%token <nothing> ','
100%token <nothing> EOL
101%token <line> BUS
102%token <line> LABEL
103%token <line> SET
104%token <line> CHIP
105%token <line> COMPUTE
106%token <value> FLOAT
107%token <name> NAME
108%token <nothing> ERROR
109
110%type <chips> chip_name_list
111%type <expr> expression
112%type <bus> i2cbus_name
113%type <name> adapter_name
114%type <name> algorithm_name
115%type <name> function_name
116%type <name> string
117%type <chip> chip_name
118
119%start input
120
121%%
122
123input:    /* empty */
124        | input line
125;
126
127line:     bus_statement EOL
128        | label_statement EOL
129        | set_statement EOL
130        | chip_statement EOL
131        | compute_statement EOL
132        | error EOL
133;
134
135bus_statement:    BUS i2cbus_name adapter_name algorithm_name
136                  { sensors_bus new_el;
137                    new_el.lineno = $1;
138                    new_el.number = $2;
139                    new_el.adapter = $3;
140                    new_el.algorithm = $4;
141                    bus_add_el(&new_el);
142                  }
143;
144
145label_statement:          LABEL function_name string
146                          { sensors_label new_el;
147                            check_current_chip();
148                            new_el.lineno = $1;
149                            new_el.name = $2;
150                            new_el.value = $3;
151                            label_add_el(&new_el);
152                          }
153;
154
155set_statement:    SET function_name expression
156                  { sensors_set new_el;
157                    check_current_chip();
158                    new_el.lineno = $1;
159                    new_el.name = $2;
160                    new_el.value = $3;
161                    set_add_el(&new_el);
162                  }
163;
164
165compute_statement:        COMPUTE function_name expression ',' expression
166                          { sensors_compute new_el;
167                            check_current_chip();
168                            new_el.lineno = $1;
169                            new_el.name = $2;
170                            new_el.from_proc = $3;
171                            new_el.to_proc = $5;
172                            compute_add_el(&new_el);
173                          }
174;
175
176chip_statement:   CHIP chip_name_list
177                  { sensors_chip new_el;
178                    new_el.lineno = $1;
179                    new_el.labels = NULL;
180                    new_el.sets = NULL;
181                    new_el.computes = NULL;
182                    new_el.labels_count = new_el.labels_max = 0;
183                    new_el.sets_count = new_el.sets_max = 0;
184                    new_el.computes_count = new_el.computes_max = 0;
185                    new_el.chips = $2;
186                    chip_add_el(&new_el);
187                    current_chip = sensors_config_chips +
188                                   sensors_config_chips_count - 1;
189                  }
190;
191
192chip_name_list:   chip_name
193                  {
194                    $$.fits = NULL;
195                    $$.fits_count = $$.fits_max = 0;
196                    fits_add_el(&$1,$$);
197                  }
198                | chip_name_list chip_name
199                  { $$ = $1;
200                    fits_add_el(&$2,$$);
201                  }
202;
203       
204expression:       FLOAT
205                  { $$ = malloc_expr();
206                    $$->data.val = $1;
207                    $$->kind = sensors_kind_val;
208                  }
209                | NAME
210                  { $$ = malloc_expr();
211                    $$->data.var = $1;
212                    $$->kind = sensors_kind_var;
213                  }
214                | expression '+' expression
215                  { $$ = malloc_expr();
216                    $$->kind = sensors_kind_sub;
217                    $$->data.subexpr.op = sensors_add;
218                    $$->data.subexpr.sub1 = $1;
219                    $$->data.subexpr.sub2 = $3;
220                  }
221                | expression '-' expression
222                  { $$ = malloc_expr();
223                    $$->kind = sensors_kind_sub;
224                    $$->data.subexpr.op = sensors_sub;
225                    $$->data.subexpr.sub1 = $1;
226                    $$->data.subexpr.sub2 = $3;
227                  }
228                | expression '*' expression
229                  { $$ = malloc_expr();
230                    $$->kind = sensors_kind_sub;
231                    $$->data.subexpr.op = sensors_multiply;
232                    $$->data.subexpr.sub1 = $1;
233                    $$->data.subexpr.sub2 = $3;
234                  }
235                | expression '/' expression
236                  { $$ = malloc_expr();
237                    $$->kind = sensors_kind_sub;
238                    $$->data.subexpr.op = sensors_divide;
239                    $$->data.subexpr.sub1 = $1;
240                    $$->data.subexpr.sub2 = $3;
241                  }
242                | '-' expression  %prec NEG
243                  { $$ = malloc_expr();
244                    $$->kind = sensors_kind_sub;
245                    $$->data.subexpr.op = sensors_negate;
246                    $$->data.subexpr.sub1 = $2;
247                    $$->data.subexpr.sub2 = NULL;
248                  }
249                | '(' expression ')'
250                  { $$ = $2; }
251;
252
253i2cbus_name:      NAME
254                  { int res = sensors_parse_i2cbus_name($1,&$$);
255                    free($1);
256                    if (res) {
257                      sensors_yyerror("Parse error in i2c bus name");
258                      YYERROR;
259                    }
260                  }
261;
262
263adapter_name:     NAME
264                  { sensors_strip_of_spaces($1);
265                    $$ = $1; }
266;
267
268algorithm_name:   NAME
269                  { sensors_strip_of_spaces($1);
270                    $$ = $1; }
271;
272
273function_name:    NAME
274                  { $$ = $1; }
275;
276
277string:   NAME
278          { $$ = $1; }
279;
280
281chip_name:        NAME
282                  { int res = sensors_parse_chip_name($1,&$$);
283                    free($1);
284                    if (res) {
285                      sensors_yyerror("Parse error in chip name");
286                      YYERROR;
287                    }
288                  }
289;
290
291%%
292
293void sensors_yyerror(const char *err)
294{
295  if (sensors_lex_error[0]) {
296    sensors_parse_error(sensors_lex_error,sensors_yylineno);
297    sensors_lex_error[0] = '\0';
298  } else
299    sensors_parse_error(err,sensors_yylineno);
300}
301
302sensors_expr *malloc_expr(void)
303{
304  sensors_expr *res = malloc(sizeof(sensors_expr));
305  if (! res)
306    sensors_fatal_error("malloc_expr","Allocating a new expression");
307  return res;
308}
309 
Note: See TracBrowser for help on using the browser.