usr.sbin/config/lang.l

   1 %{
   2 /*-
   3  * Copyright (c) 1980, 1993
   4  *      The Regents of the University of California.  All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. Neither the name of the University nor the names of its contributors
  15  *    may be used to endorse or promote products derived from this software
  16  *    without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  *
  30  *      @(#)lang.l      8.1 (Berkeley) 6/6/93
  31  * $FreeBSD: src/usr.sbin/config/lang.l,v 1.27 1999/11/09 07:20:22 peter Exp $
  32  */
  33
  34 #include <ctype.h>
  35 #include <string.h>
  36 #include "y.tab.h"
  37 #include "config.h"
  38
  39 /*
  40  * Key word table
  41  */
  42
  43 struct kt {
  44         const char *kt_name;
  45         int kt_val;
  46 } key_words[] = {
  47         { "at",         AT },
  48         { "bus",        BUS },
  49         { "config",     CONFIG },
  50         { "cpu",        CPU },
  51         { "device",     DEVICE },
  52         { "disable",    DISABLE },
  53         { "drive",      DRIVE },
  54         { "drq",        DRQ },
  55         { "flags",      FLAGS },
  56         { "ident",      IDENT },
  57         { "iomem",      IOMEM },
  58         { "iosiz",      IOSIZ },
  59         { "irq",        IRQ },
  60         { "machine",    CONFIG_MACHINE },
  61         { "machine_arch", CONFIG_MACHINE_ARCH },
  62         { "makeoptions", MAKEOPTIONS },
  63         { "maxusers",   MAXUSERS },
  64         { "nexus",      NEXUS },
  65         { "option",     OPTIONS },
  66         { "options",    OPTIONS },
  67         { "platform",   CONFIG_PLATFORM },
  68         { "port",       PORT },
  69         { "pseudo-device",PSEUDO_DEVICE },
  70         { "target",     TARGET },
  71         { "unit",       UNIT },
  72         { 0, 0 },
  73 };
  74
  75
  76 int kw_lookup(char *);
  77 int octal(char *);
  78 int hex(char *);
  79
  80 %}
  81 WORD    [A-Za-z_][-A-Za-z_]*
  82 ID      [A-Za-z_][-A-Za-z_0-9]*
  83 %START NONUM TOEOL
  84 %option noinput
  85 %option nounput
  86 %%
  87 <NONUM>{WORD}   {
  88                         int i;
  89
  90                         BEGIN 0;
  91                         if ((i = kw_lookup(yytext)) == -1)
  92                         {
  93                                 yylval.str = strdup(yytext);
  94                                 return(ID);
  95                         }
  96                         return(i);
  97                 }
  98 <INITIAL>{WORD}/[0-9]* {
  99                         int i;
 100
 101                         if ((i = kw_lookup(yytext)) == -1)
 102                                 REJECT;
 103                         if (i == DEVICE || i == PSEUDO_DEVICE || i == AT)
 104                                 BEGIN NONUM;
 105                         return(i);
 106                 }
 107 <INITIAL>{ID}   {
 108                         BEGIN 0;
 109                         yylval.str = strdup(yytext);
 110                         return(ID);
 111                 }
 112 \\\"[^"]+\\\"   {
 113                         BEGIN 0;
 114                         yytext[yyleng-2] = '"';
 115                         yytext[yyleng-1] = '\0';
 116                         yylval.str = strdup(yytext + 1);
 117                         return(ID);
 118                 }
 119 \"[^"]+\"       {
 120                         BEGIN 0;
 121                         yytext[yyleng-1] = '\0';
 122                         yylval.str = strdup(yytext + 1);
 123                         return(ID);
 124                 }
 125 <TOEOL>[^# \t\n]*       {
 126                         BEGIN 0;
 127                         yylval.str = strdup(yytext);
 128                         return(ID);
 129                 }
 130 0[0-7]*         {
 131                         yylval.val = octal(yytext);
 132                         return(NUMBER);
 133                 }
 134 0x[0-9a-fA-F]+  {
 135                         yylval.val = hex(yytext);
 136                         return(NUMBER);
 137                 }
 138 -?[1-9][0-9]*   {
 139                         yylval.val = atoi(yytext);
 140                         return(NUMBER);
 141                 }
 142 [0-9]"."[0-9]*  {
 143                         yylval.val = (int)(60 * atof(yytext) + 0.5);
 144                         return(FPNUMBER);
 145                 }
 146 "?"             {
 147                         yylval.val = -1;
 148                         return(NUMBER);
 149                 }
 150 \n/[ \t]        {
 151                         yyline++;
 152                 }
 153 \n              {
 154                         yyline++;
 155                         return(SEMICOLON);
 156                 }
 157 #.*             {       /* Ignored (comment) */;        }
 158 [ \t\f]*        {       /* Ignored (white space) */;    }
 159 ";"             {       return(SEMICOLON);              }
 160 ","             {       return(COMMA);                  }
 161 "="             {       BEGIN TOEOL; return(EQUALS);    }
 162 "@"             {       return(AT);                     }
 163 .               {       return(yytext[0]);              }
 164
 165 %%
 166 /*
 167  * kw_lookup
 168  *      Look up a string in the keyword table.  Returns a -1 if the
 169  *      string is not a keyword otherwise it returns the keyword number
 170  */
 171
 172 int
 173 kw_lookup(char *word)
 174 {
 175         struct kt *kp;
 176
 177         for (kp = key_words; kp->kt_name != NULL; kp++)
 178                 if (!strcmp(word, kp->kt_name))
 179                         return(kp->kt_val);
 180         return(-1);
 181 }
 182
 183 /*
 184  * Number conversion routines
 185  */
 186
 187 int
 188 octal(char *str)
 189 {
 190         int num;
 191
 192         sscanf(str, "%o", &num);
 193         return(num);
 194 }
 195
 196 int
 197 hex(char *str)
 198 {
 199         int num;
 200
 201         sscanf(str + 2, "%x", &num);
 202         return(num);
 203 }