root/lm-sensors/branches/scanner-opt-branch/lib/conf-lex.l @ 4123

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

    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 2 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, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

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

#include "general.h"
#include "data.h"
#include "conf-parse.h"
#include "error.h"
#include "scanner.h"

static int buffer_count;
static int buffer_max;
static char *buffer;

char sensors_lex_error[100];

int sensors_yylineno;

#define buffer_malloc() sensors_malloc_array(&buffer,&buffer_count,\
                                             &buffer_max,1)
#define buffer_free() sensors_free_array(&buffer,&buffer_count,\
                                         &buffer_max)
#define buffer_add_char(c) sensors_add_array_el(c,&buffer,\
                                                &buffer_count,\
                                                &buffer_max,1)
#define buffer_add_string(s) sensors_add_array_els(s,strlen(s),\
                                                   &buffer, \
                                                   &buffer_count,&buffer_max,1)

%}

 /* Scanner for configuration files */

%option nodefault
%option noyywrap
%option nounput

 /*
  * States. 'Normal' states STRING and MIDDLE share some rules;
  * other states have only their own rules
  */

%s MIDDLE
%x STRING
%x ERR

 /* Any whitespace-like character */

BLANK           [ \f\t\v]

IDCHAR          [[:alnum:]_]

 /* Note: `10', `10.4' and `.4' are valid, `10.' is not */

FLOAT   [[:digit:]]*\.?[[:digit:]]+

 /* Only positive whole numbers are recognized here */

NUM     0|([1-9][[:digit:]]*)

 /* Only number between 1 and 255, octally represented. */

OCTESC          (1[0-7]{0,2})|([2-7][0-7]?)|(0[1-7][0-7]?)|(00[1-7])


%%


<MIDDLE>\n      { /* newline here sends EOL token to parser */
                  BEGIN(INITIAL);
                  sensors_yylineno++;
                  return EOL;
                }

<MIDDLE><<EOF>> { /* EOF here sends EOL token to parser also */
                  BEGIN(INITIAL);
                  return EOL;
                }

{BLANK}+ ;        /* eat as many blanks as possible at once */

{BLANK}*\n      { /* eat a bare newline (possibly preceded by blanks) */
                  sensors_yylineno++;
                }

<MIDDLE>\\{BLANK}*\n { /* eat an escaped newline with no state change */
                  sensors_yylineno++;
                }

<MIDDLE>#.*     ; /* eat the rest of the line after comment char */

<MIDDLE>#.*\n   { /* eat the rest of the line after comment char */
                  BEGIN(INITIAL);
                  sensors_yylineno++;
                  return EOL;
                }

#.*             ; /* eat the rest of the line after comment char */

#.*\n           { /* eat the rest of the line after comment char */
                  sensors_yylineno++;
                }

 /* Some keywords at the beginning of lines */

<INITIAL>"label" {
                  sensors_yylval.line = sensors_yylineno;
                  BEGIN(MIDDLE);
                  return LABEL;
                }

<INITIAL>"set"  {
                  sensors_yylval.line = sensors_yylineno;
                  BEGIN(MIDDLE);
                  return SET;
                }

<INITIAL>"compute" {
                  sensors_yylval.line = sensors_yylineno;
                  BEGIN(MIDDLE);
                  return COMPUTE;
                }

<INITIAL>"bus"  {
                  sensors_yylval.line = sensors_yylineno;
                  BEGIN(MIDDLE);
                  return BUS;
                }

<INITIAL>"chip" {
                  sensors_yylval.line = sensors_yylineno;
                  BEGIN(MIDDLE);
                  return CHIP;
                }
<INITIAL>"ignore" {
                  sensors_yylval.line = sensors_yylineno;
                  BEGIN(MIDDLE);
                  return IGNORE;
                }

 /* Anything else at the beginning of a line is an error */

<INITIAL>.      {
                  yymore();
                  BEGIN(ERR);
                }

<ERR>[^\n]*\n   {
                  BEGIN(INITIAL);
                  strcpy(sensors_lex_error,"Invalid keyword");
                  return ERROR;
                }

 /* A number */

<MIDDLE>{FLOAT} {
                  sensors_yylval.value = atof(sensors_yytext);
                  return FLOAT;
                }

 /* Some operators */

<MIDDLE>"+"     return '+';
<MIDDLE>"-"     return '-';
<MIDDLE>"*"     return '*';
<MIDDLE>"/"     return '/';
<MIDDLE>"("     return '(';
<MIDDLE>")"     return ')';
<MIDDLE>","     return ',';
<MIDDLE>"@"     return '@';
<MIDDLE>"^"     return '^';
<MIDDLE>"`"     return '`';

 /* Quoted string */

<MIDDLE>\"      {
                  buffer_malloc();
                  BEGIN(STRING);
                }

 /* Oops, newline while in a string is not good */

<STRING>\n      |
<STRING>\\\n    {
                  buffer_add_char("\0");
                  strcpy(sensors_lex_error,"No matching double quote");
                  buffer_free();
                  BEGIN(INITIAL);
                  return ERROR;
                }

 /* At the end */

<STRING>\"      {
                  buffer_add_char("\0");
                  sensors_yylval.name = strdup(buffer);
                  if (! sensors_yylval.name)
                    sensors_fatal_error("conf-lex.l",
                                        "Allocating a new string");
                  buffer_free();
                  BEGIN(MIDDLE);
                  return NAME;
                }

<STRING>\\a     {
                  buffer_add_char("\a");
                }

<STRING>\\b     {
                  buffer_add_char("\b");
                }

<STRING>\\f     {
                  buffer_add_char("\f");
                }

<STRING>\\n     {
                  buffer_add_char("\n");
                }

<STRING>\\r     {
                  buffer_add_char("\r");
                }

<STRING>\\t     {
                  buffer_add_char("\t");
                }

<STRING>\\v     {
                  buffer_add_char("\v");
                }

 /* We can't support \0, this would cause havoc! */

<STRING>\\{OCTESC} {
                  int res;
                  sscanf(sensors_yytext+1,"%o",&res);
                  buffer_add_char(&res);
                }

 /* Other escapes: just copy the character behind the slash */

<STRING>\\.     {
                  buffer_add_char(&sensors_yytext[1]);
                }

 /* Anything else */

<STRING>[^\\\n\"]+ {
                  buffer_add_string(sensors_yytext);
                }

 /* A normal, unquoted identifier */

<MIDDLE>{IDCHAR}+ {
                  sensors_yylval.name = strdup(sensors_yytext);
                  if (! sensors_yylval.name)
                    sensors_fatal_error("conf-lex.l",
                                        "Allocating a new string");
                  
                  return NAME;
                }

%%

/*
        Do the buffer handling manually.  This allows us to scan as many
        config files as we need to, while cleaning up properly after each
        one.  The "BEGIN(0)" line ensures that we start in the default state,
        even if e.g. the previous config file was syntactically broken.

        Returns 0 if successful, !0 otherwise.
*/

static YY_BUFFER_STATE scan_buf = (YY_BUFFER_STATE)0;

int sensors_scanner_init(FILE *input)
{
        BEGIN(0);
        if (!(scan_buf = sensors_yy_create_buffer(input, YY_BUF_SIZE)))
                return -1;

        sensors_yy_switch_to_buffer(scan_buf);
        sensors_yylineno = 1;
        return 0;
}

void sensors_scanner_exit(void)
{
        sensors_yy_delete_buffer(scan_buf);
        scan_buf = (YY_BUFFER_STATE)0;
}