Changeset 4145

Show
Ignore:
Timestamp:
09/06/06 04:18:54 (8 years ago)
Author:
mmh
Message:

This patch makes all start conditions exclusive. This involves copying some
shared rules from the INITIAL s.c. into the MIDDLE s.c.

The patch also reorganizes the start conditions for easier maintenance. This
involves using a feature of flex called start condition scope.

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • lm-sensors/branches/scanner-opt-branch/lib/conf-lex.l

    r4123 r4145  
    5555%option nounput 
    5656 
    57  /* 
    58   * States. 'Normal' states STRING and MIDDLE share some rules; 
    59   * other states have only their own rules 
    60   */ 
    61  
    62 %s MIDDLE 
     57 /* All states are exclusive */ 
     58 
     59%x MIDDLE 
    6360%x STRING 
    6461%x ERR 
     
    8582%% 
    8683 
    87  
    88 <MIDDLE>\n      { /* newline here sends EOL token to parser */ 
    89                   BEGIN(INITIAL); 
    90                   sensors_yylineno++; 
    91                   return EOL; 
    92                 } 
    93  
    94 <MIDDLE><<EOF>> { /* EOF here sends EOL token to parser also */ 
    95                   BEGIN(INITIAL); 
    96                   return EOL; 
    97                 } 
    98  
    99 {BLANK}+ ;        /* eat as many blanks as possible at once */ 
     84 /* 
     85  * STATE: INITIAL 
     86  */ 
     87 
     88<INITIAL>{ 
     89 
     90<<EOF>>         { /* EOF from this state terminates */ 
     91                  return 0; 
     92                } 
     93 
     94{BLANK}+        ; /* eat as many blanks as possible at once */ 
    10095 
    10196{BLANK}*\n      { /* eat a bare newline (possibly preceded by blanks) */ 
     
    10398                } 
    10499 
    105 <MIDDLE>\\{BLANK}*\n { /* eat an escaped newline with no state change */ 
    106                   sensors_yylineno++; 
    107                 } 
    108  
    109 <MIDDLE>#.*     ; /* eat the rest of the line after comment char */ 
    110  
    111 <MIDDLE>#.*\n   { /* eat the rest of the line after comment char */ 
    112                   BEGIN(INITIAL); 
    113                   sensors_yylineno++; 
    114                   return EOL; 
    115                 } 
     100 /* comments */ 
    116101 
    117102#.*             ; /* eat the rest of the line after comment char */ 
     
    123108 /* Some keywords at the beginning of lines */ 
    124109 
    125 <INITIAL>"label" { 
     110"label"         { 
    126111                  sensors_yylval.line = sensors_yylineno; 
    127112                  BEGIN(MIDDLE); 
     
    129114                } 
    130115 
    131 <INITIAL>"set"  { 
     116"set"           { 
    132117                  sensors_yylval.line = sensors_yylineno; 
    133118                  BEGIN(MIDDLE); 
     
    135120                } 
    136121 
    137 <INITIAL>"compute" { 
     122"compute"       { 
    138123                  sensors_yylval.line = sensors_yylineno; 
    139124                  BEGIN(MIDDLE); 
     
    141126                } 
    142127 
    143 <INITIAL>"bus"  { 
     128"bus"           { 
    144129                  sensors_yylval.line = sensors_yylineno; 
    145130                  BEGIN(MIDDLE); 
     
    147132                } 
    148133 
    149 <INITIAL>"chip" { 
     134"chip"          { 
    150135                  sensors_yylval.line = sensors_yylineno; 
    151136                  BEGIN(MIDDLE); 
    152137                  return CHIP; 
    153138                } 
    154 <INITIAL>"ignore" { 
     139 
     140"ignore"        { 
    155141                  sensors_yylval.line = sensors_yylineno; 
    156142                  BEGIN(MIDDLE); 
     
    160146 /* Anything else at the beginning of a line is an error */ 
    161147 
    162 <INITIAL>.      { 
     148.               { 
    163149                  yymore(); 
    164150                  BEGIN(ERR); 
    165151                } 
    166  
    167 <ERR>[^\n]*\n   { 
     152} 
     153 
     154 /* 
     155  * STATE: ERROR 
     156  */ 
     157 
     158<ERR>{ 
     159 
     160.*(\n)?         { 
    168161                  BEGIN(INITIAL); 
    169162                  strcpy(sensors_lex_error,"Invalid keyword"); 
    170163                  return ERROR; 
    171164                } 
     165} 
     166 
     167 /* 
     168  * STATE: MIDDLE 
     169  */ 
     170 
     171<MIDDLE>{ 
     172 
     173{BLANK}+        ; /* eat as many blanks as possible at once */ 
     174 
     175\n              { /* newline here sends EOL token to parser */ 
     176                  BEGIN(INITIAL); 
     177                  sensors_yylineno++; 
     178                  return EOL; 
     179                } 
     180 
     181<<EOF>>         { /* EOF here sends EOL token to parser also */ 
     182                  BEGIN(INITIAL); 
     183                  return EOL; 
     184                } 
     185 
     186\\{BLANK}*\n    { /* eat an escaped newline with no state change */ 
     187                  sensors_yylineno++; 
     188                } 
     189 
     190#.*             ; /* eat the rest of the line after comment char */ 
     191 
     192#.*\n           { /* eat the rest of the line after comment char */ 
     193                  BEGIN(INITIAL); 
     194                  sensors_yylineno++; 
     195                  return EOL; 
     196                } 
    172197 
    173198 /* A number */ 
    174199 
    175 <MIDDLE>{FLOAT} { 
     200{FLOAT}         { 
    176201                  sensors_yylval.value = atof(sensors_yytext); 
    177202                  return FLOAT; 
     
    180205 /* Some operators */ 
    181206 
    182 <MIDDLE>"+"     return '+'; 
    183 <MIDDLE>"-"     return '-'; 
    184 <MIDDLE>"*"     return '*'; 
    185 <MIDDLE>"/"     return '/'; 
    186 <MIDDLE>"("     return '('; 
    187 <MIDDLE>")"     return ')'; 
    188 <MIDDLE>","     return ','; 
    189 <MIDDLE>"@"     return '@'; 
    190 <MIDDLE>"^"     return '^'; 
    191 <MIDDLE>"`"     return '`'; 
     207"+"             return '+'; 
     208"-"             return '-'; 
     209"*"             return '*'; 
     210"/"             return '/'; 
     211"("             return '('; 
     212")"             return ')'; 
     213","             return ','; 
     214"@"             return '@'; 
     215"^"             return '^'; 
     216"`"             return '`'; 
    192217 
    193218 /* Quoted string */ 
    194219 
    195 <MIDDLE>\"      { 
     220\"              { 
    196221                  buffer_malloc(); 
    197222                  BEGIN(STRING); 
    198223                } 
    199224 
     225 /* A normal, unquoted identifier */ 
     226 
     227{IDCHAR}+       { 
     228                  sensors_yylval.name = strdup(sensors_yytext); 
     229                  if (! sensors_yylval.name) 
     230                    sensors_fatal_error("conf-lex.l", 
     231                                        "Allocating a new string"); 
     232                   
     233                  return NAME; 
     234                } 
     235 
     236 /* anything else is bogus */ 
     237 
     238.               { 
     239                  yymore(); 
     240                  BEGIN(ERR); 
     241                } 
     242} 
     243 
     244 /* 
     245  * STATE: STRING 
     246  */ 
     247 
     248<STRING>{ 
     249 
    200250 /* Oops, newline while in a string is not good */ 
    201251 
    202 <STRING>\n      | 
    203 <STRING>\\\n    { 
     252\n              | 
     253\\\n            { 
    204254                  buffer_add_char("\0"); 
    205255                  strcpy(sensors_lex_error,"No matching double quote"); 
     
    211261 /* At the end */ 
    212262 
    213 <STRING>\"      { 
     263\"              { 
    214264                  buffer_add_char("\0"); 
    215265                  sensors_yylval.name = strdup(buffer); 
     
    222272                } 
    223273 
    224 <STRING>\\a     { 
     274\\a             { 
    225275                  buffer_add_char("\a"); 
    226276                } 
    227277 
    228 <STRING>\\b     { 
     278\\b             { 
    229279                  buffer_add_char("\b"); 
    230280                } 
    231281 
    232 <STRING>\\f     { 
     282\\f             { 
    233283                  buffer_add_char("\f"); 
    234284                } 
    235285 
    236 <STRING>\\n     { 
     286\\n             { 
    237287                  buffer_add_char("\n"); 
    238288                } 
    239289 
    240 <STRING>\\r     { 
     290\\r             { 
    241291                  buffer_add_char("\r"); 
    242292                } 
    243293 
    244 <STRING>\\t     { 
     294\\t             { 
    245295                  buffer_add_char("\t"); 
    246296                } 
    247297 
    248 <STRING>\\v     { 
     298\\v             { 
    249299                  buffer_add_char("\v"); 
    250300                } 
     
    252302 /* We can't support \0, this would cause havoc! */ 
    253303 
    254 <STRING>\\{OCTESC} { 
     304\\{OCTESC}      { 
    255305                  int res; 
    256306                  sscanf(sensors_yytext+1,"%o",&res); 
     
    260310 /* Other escapes: just copy the character behind the slash */ 
    261311 
    262 <STRING>\\.     { 
     312\\.             { 
    263313                  buffer_add_char(&sensors_yytext[1]); 
    264314                } 
     
    266316 /* Anything else */ 
    267317 
    268 <STRING>[^\\\n\"]+ { 
     318[^\\\n\"]+      { 
    269319                  buffer_add_string(sensors_yytext); 
    270320                } 
    271  
    272  /* A normal, unquoted identifier */ 
    273  
    274 <MIDDLE>{IDCHAR}+ { 
    275                   sensors_yylval.name = strdup(sensors_yytext); 
    276                   if (! sensors_yylval.name) 
    277                     sensors_fatal_error("conf-lex.l", 
    278                                         "Allocating a new string"); 
    279                    
    280                   return NAME; 
    281                 } 
     321} 
    282322 
    283323%%