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  * 4. 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$
  32  */
  33
  34 #include <assert.h>
  35 #include <ctype.h>
  36 #include <err.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include "y.tab.h"
  40 #include "config.h"
  41
  42 /*
  43  * Data for returning to previous files from include files.
  44  */
  45 struct incl {
  46         struct  incl *in_prev;  /* previous includes in effect, if any */
  47         YY_BUFFER_STATE in_buf; /* previous lex state */
  48         const   char *in_fname; /* previous file name */
  49         int     in_lineno;      /* previous line number */
  50         int     in_ateof;       /* token to insert at EOF */
  51 };
  52 static struct   incl *inclp;
  53 static const    char *lastfile;
  54
  55 /*
  56  * Key word table
  57  */
  58
  59 struct kt {
  60         const char *kt_name;
  61         int kt_val;
  62 } key_words[] = {
  63         { "config",     CONFIG },
  64         { "cpu",        CPU },
  65         { "nocpu",      NOCPU },
  66         { "device",     DEVICE },
  67         { "devices",    DEVICE },
  68         { "nodevice",   NODEVICE },
  69         { "nodevices",  NODEVICE },
  70         { "env",        ENV },
  71         { "hints",      HINTS },
  72         { "ident",      IDENT },
  73         { "machine",    ARCH }, /* MACHINE is defined in /sys/param.h */
  74         { "makeoption", MAKEOPTIONS },
  75         { "makeoptions", MAKEOPTIONS },
  76         { "nomakeoption", NOMAKEOPTION },
  77         { "nomakeoptions", NOMAKEOPTION },
  78         { "maxusers",   MAXUSERS },
  79         { "profile",    PROFILE },
  80         { "option",     OPTIONS },
  81         { "options",    OPTIONS },
  82         { "nooption",   NOOPTION },
  83         { "nooptions",  NOOPTION },
  84         { "include",    INCLUDE },
  85         { "files",      FILES },
  86         { 0, 0 },
  87 };
  88
  89
  90 static int endinclude(void);
  91 int include(const char *, int);
  92 int kw_lookup(char *);
  93 unsigned int octal(const char *);
  94 unsigned int hex(const char *);
  95 int yyerror(const char *);
  96
  97 #define YY_DECL int yylex(void)
  98 %}
  99
 100 %option nounput
 101 %option noinput
 102
 103 ID      [A-Za-z_][-A-Za-z_0-9]*
 104 PATH    [./][-/.%^A-Za-z_0-9]+
 105 %START TOEOL
 106 %%
 107 {ID}            {
 108                         int i;
 109
 110                         BEGIN 0;
 111                         if ((i = kw_lookup(yytext)) == -1)
 112                         {
 113                                 yylval.str = strdup(yytext);
 114                                 return ID;
 115                         }
 116                         return i;
 117                 }
 118 \\\"[^"]*\\\"   {
 119                         BEGIN 0;
 120                         yytext[yyleng-2] = '"';
 121                         yytext[yyleng-1] = '\0';
 122                         yylval.str = strdup(yytext + 1);
 123                         return ID;
 124                 }
 125 \"[^"]+\"       {
 126                         BEGIN 0;
 127                         yytext[yyleng-1] = '\0';
 128                         yylval.str = strdup(yytext + 1);
 129                         return ID;
 130                 }
 131 <TOEOL>[^# \t\n]*       {
 132                         BEGIN 0;
 133                         yylval.str = strdup(yytext);
 134                         return ID;
 135                 }
 136 0[0-7]*         {
 137                         yylval.val = octal(yytext);
 138                         return NUMBER;
 139                 }
 140 0x[0-9a-fA-F]+  {
 141                         yylval.val = hex(yytext);
 142                         return NUMBER;
 143                 }
 144 -?[1-9][0-9]*   {
 145                         yylval.val = atoi(yytext);
 146                         return NUMBER;
 147                 }
 148 "?"             {
 149                         yylval.val = -1;
 150                         return NUMBER;
 151                 }
 152 \n/[ \t]        {
 153                         yyline++;
 154                 }
 155 \n              {
 156                         yyline++;
 157                         return SEMICOLON;
 158                 }
 159 #.*             {       /* Ignored (comment) */;        }
 160 [ \t\f]*        {       /* Ignored (white space) */;    }
 161 ";"             {       return SEMICOLON;               }
 162 ","             {       return COMMA;                   }
 163 "="             {       BEGIN TOEOL; return EQUALS;     }
 164 "+="            {       BEGIN TOEOL; return PLUSEQUALS; }
 165 <<EOF>>         {
 166                         int tok;
 167
 168                         if (inclp == NULL)
 169                                 return YY_NULL;
 170                         tok = endinclude();
 171                         if (tok != 0)
 172                                 return tok;
 173                         /* otherwise continue scanning */
 174                 }
 175 {PATH}          {
 176                         BEGIN 0;
 177                         yylval.str = strdup(yytext);
 178                         return PATH;
 179                 }
 180 .               {       return yytext[0];               }
 181
 182 %%
 183 /*
 184  * kw_lookup
 185  *      Look up a string in the keyword table.  Returns a -1 if the
 186  *      string is not a keyword otherwise it returns the keyword number
 187  */
 188
 189 int
 190 kw_lookup(char *word)
 191 {
 192         struct kt *kp;
 193
 194         for (kp = key_words; kp->kt_name != 0; kp++)
 195                 if (eq(word, kp->kt_name))
 196                         return kp->kt_val;
 197         return -1;
 198 }
 199
 200 /*
 201  * Number conversion routines
 202  */
 203
 204 unsigned int
 205 octal(const char *str)
 206 {
 207         unsigned int num;
 208
 209         (void) sscanf(str, "%o", &num);
 210         return num;
 211 }
 212
 213 unsigned int
 214 hex(const char *str)
 215 {
 216         unsigned int num;
 217
 218         (void) sscanf(str+2, "%x", &num);
 219         return num;
 220 }
 221
 222 void
 223 cfgfile_add(const char *fname)
 224 {
 225         struct cfgfile *cf;
 226
 227         cf = calloc(1, sizeof(*cf));
 228         if (cf == NULL)
 229                 err(EXIT_FAILURE, "calloc");
 230         assert(cf != NULL);
 231         asprintf(&cf->cfg_path, "%s", fname);
 232         STAILQ_INSERT_TAIL(&cfgfiles, cf, cfg_next);
 233 }
 234
 235 void
 236 cfgfile_removeall(void)
 237 {
 238         struct cfgfile *cf;
 239
 240         while (!STAILQ_EMPTY(&cfgfiles)) {
 241                 cf = STAILQ_FIRST(&cfgfiles);
 242                 STAILQ_REMOVE_HEAD(&cfgfiles, cfg_next);
 243                 if (cf->cfg_path != NULL)
 244                         free(cf->cfg_path);
 245                 free(cf);
 246         }
 247 }
 248
 249 /*
 250  * Open the named file for inclusion at the current point.  Returns 0 on
 251  * success (file opened and previous state pushed), nonzero on failure
 252  * (fopen failed, complaint made).  The `ateof' parameter controls the
 253  * token to be inserted at the end of the include file. If ateof == 0,
 254  * then nothing is inserted.
 255  */
 256 int
 257 include(const char *fname, int ateof)
 258 {
 259         FILE *fp;
 260         struct incl *in;
 261         struct includepath* ipath;
 262         char *fnamebuf;
 263
 264         fnamebuf = NULL;
 265         fp = fopen(fname, "r");
 266         if (fp == NULL && fname[0] != '.' && fname[0] != '/') {
 267                 asprintf(&fnamebuf, "../../conf/%s", fname);
 268                 if (fnamebuf != NULL) {
 269                         fp = fopen(fnamebuf, "r");
 270                         if (fp == NULL)
 271                                 free(fnamebuf);
 272                 }
 273         }
 274         if (fp == NULL) {
 275                 SLIST_FOREACH(ipath, &includepath, path_next) {
 276                         asprintf(&fnamebuf, "%s/%s", ipath->path, fname);
 277                         if (fnamebuf != NULL) {
 278                                 fp = fopen(fnamebuf, "r");
 279                         }
 280                         if (fp != NULL)
 281                                 break;
 282                         free(fnamebuf);
 283                 }
 284         }
 285         if (fp == NULL) {
 286                 yyerror("cannot open included file");
 287                 return (-1);
 288         }
 289         cfgfile_add(fnamebuf == NULL ? fname : fnamebuf);
 290         in = malloc(sizeof(*in));
 291         assert(in != NULL);
 292         in->in_prev = inclp;
 293         in->in_buf = YY_CURRENT_BUFFER;
 294         in->in_fname = yyfile;
 295         in->in_lineno = yyline;
 296         in->in_ateof = ateof;
 297         inclp = in;
 298         yy_switch_to_buffer(yy_create_buffer(fp, YY_BUF_SIZE));
 299         yyfile = fname;
 300         yyline = 0;
 301         return (0);
 302 }
 303
 304 /*
 305  * Terminate the most recent inclusion.
 306  */
 307 static int
 308 endinclude(void)
 309 {
 310         struct incl *in;
 311         int ateof;
 312
 313         in = inclp;
 314         assert(in != NULL);
 315         inclp = in->in_prev;
 316         lastfile = yyfile;
 317         yy_delete_buffer(YY_CURRENT_BUFFER);
 318         (void)fclose(yyin);
 319         yy_switch_to_buffer(in->in_buf);
 320         yyfile = in->in_fname;
 321         yyline = in->in_lineno;
 322         ateof  = in->in_ateof;
 323         free(in);
 324
 325         return (ateof);
 326 }