Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	bin/chio/parse.c	Lines:	0	111	0.0 %
Date:	2017-11-07	Branches:	0	103	0.0 %


#include <stdlib.h>
#include <string.h>
#define YYBYACC 1
#define YYMAJOR 1
#define YYMINOR 9
#define YYLEX yylex()
#define YYEMPTY -1
#define yyclearin (yychar=(YYEMPTY))
#define yyerrok (yyerrflag=0)
#define YYRECOVERING() (yyerrflag!=0)
#define YYPREFIX "yy"
#line 24 "parse.y"
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/queue.h>

#include <ctype.h>
#include <err.h>
#include <libgen.h>
#include <limits.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>

TAILQ_HEAD(files, file)		 files = TAILQ_HEAD_INITIALIZER(files);
static struct file {
	TAILQ_ENTRY(file)	 entry;
	FILE			*stream;
	char			*name;
	int			 lineno;
	int			 errors;
} *file, *topfile;
struct file	*pushfile(const char *);
int		 popfile(void);
int		 yyparse(void);
int		 yylex(void);
int		 yyerror(const char *, ...)
    __attribute__((__format__ (printf, 1, 2)))
    __attribute__((__nonnull__ (1)));
int		 kw_cmp(const void *, const void *);
int		 lookup(char *);
int		 lgetc(int);
int		 lungetc(int);
int		 findeol(void);
char		*parse_tapedev(const char *, const char *, int);
struct changer	*new_changer(char *);

struct changer {
	TAILQ_ENTRY(changer)	  entry;
	char			 *name;
	char			**drives;
	u_int			  drivecnt;
};
TAILQ_HEAD(changers, changer)	 changers;
struct changer			*curchanger;

typedef struct {
	union {
		int64_t			 number;
		char			*string;
	} v;
	int lineno;
} YYSTYPE;

#line 66 "parse.c"
#define CHANGER 257
#define DRIVE 258
#define ERROR 259
#define STRING 260
#define NUMBER 261
#define YYERRCODE 256
const short yylhs[] =
	{                                        -1,
    0,    0,    0,    0,    2,    2,    3,    5,    1,    4,
    4,    6,    6,    7,
};
const short yylen[] =
	{                                         2,
    0,    2,    3,    3,    2,    0,    2,    0,    8,    2,
    1,    2,    2,    2,
};
const short yydefred[] =
	{                                      1,
    0,    0,    0,    2,    0,    4,    0,    3,    0,    0,
    5,    0,    8,    0,    0,    0,    0,   11,    0,    0,
   13,   14,    9,   10,   12,    7,
};
const short yydgoto[] =
	{                                       1,
    5,   10,   21,   17,   14,   18,   19,
};
const short yysindex[] =
	{                                      0,
  -10,    2, -255,    0,    3,    0,    4,    0,    4, -107,
    0,    4,    0, -248,    7, -242, -123,    0,    7,    4,
    0,    0,    0,    0,    0,    0,};
const short yyrindex[] =
	{                                      0,
    0,    0,    0,    0,    0,    0, -104,    0, -122,    0,
    0, -247,    0,    0,    0,    0,    0,    0,    0, -119,
    0,    0,    0,    0,    0,    0,};
const short yygindex[] =
	{                                      0,
    0,   -5,    1,    0,    0,    5,    0,
};
#define YYTABLESIZE 247
const short yytable[] =
	{                                       4,
    6,   23,    6,   11,    7,    6,   13,   15,    6,   16,
    6,    6,    8,    9,   26,   12,   20,   22,    6,   25,
    0,   24,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,   15,    6,   16,    6,    6,    0,    6,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    2,    3,
};
const short yycheck[] =
	{                                      10,
  123,  125,  125,    9,  260,  125,   12,  256,  256,  258,
  258,   10,   10,   10,   20,  123,   10,  260,  123,   19,
   -1,   17,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,  256,  256,  258,  258,  256,   -1,  258,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,  256,  257,
};
#define YYFINAL 1
#ifndef YYDEBUG
#define YYDEBUG 0
#endif
#define YYMAXTOKEN 261
#if YYDEBUG
const char * const yyname[] =
	{
"end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,"'{'",0,"'}'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"CHANGER","DRIVE",
"ERROR","STRING","NUMBER",
};
const char * const yyrule[] =
	{"$accept : grammar",
"grammar :",
"grammar : grammar '\\n'",
"grammar : grammar main '\\n'",
"grammar : grammar error '\\n'",
"optnl : '\\n' optnl",
"optnl :",
"nl : '\\n' optnl",
"$$1 :",
"main : CHANGER STRING optnl '{' optnl $$1 changeropts_l '}'",
"changeropts_l : changeropts_l changeroptsl",
"changeropts_l : changeroptsl",
"changeroptsl : changeropts nl",
"changeroptsl : error nl",
"changeropts : DRIVE STRING",
};
#endif
#ifdef YYSTACKSIZE
#undef YYMAXDEPTH
#define YYMAXDEPTH YYSTACKSIZE
#else
#ifdef YYMAXDEPTH
#define YYSTACKSIZE YYMAXDEPTH
#else
#define YYSTACKSIZE 10000
#define YYMAXDEPTH 10000
#endif
#endif
#define YYINITSTACKSIZE 200
/* LINTUSED */
int yydebug;
int yynerrs;
int yyerrflag;
int yychar;
short *yyssp;
YYSTYPE *yyvsp;
YYSTYPE yyval;
YYSTYPE yylval;
short *yyss;
short *yysslim;
YYSTYPE *yyvs;
unsigned int yystacksize;
int yyparse(void);
#line 132 "parse.y"

struct keywords {
	const char	*k_name;
	int		 k_val;
};

int
yyerror(const char *fmt, ...)
{
	va_list		 ap;
	char		*msg;

	file->errors++;
	va_start(ap, fmt);
	if (vasprintf(&msg, fmt, ap) == -1)
		err(1, "yyerror vasprintf");
	va_end(ap);
	err(1, "%s:%d: %s", file->name, yylval.lineno, msg);
	free(msg);
	return (0);
}

int
kw_cmp(const void *k, const void *e)
{
	return (strcmp(k, ((const struct keywords *)e)->k_name));
}

int
lookup(char *s)
{
	/* this has to be sorted always */
	static const struct keywords keywords[] = {
		{ "changer",		CHANGER},
		{ "drive",		DRIVE}
	};
	const struct keywords	*p;

	p = bsearch(s, keywords, sizeof(keywords)/sizeof(keywords[0]),
	    sizeof(keywords[0]), kw_cmp);

	if (p)
		return (p->k_val);
	else
		return (STRING);
}

#define MAXPUSHBACK	128

u_char	*parsebuf;
int	 parseindex;
u_char	 pushback_buffer[MAXPUSHBACK];
int	 pushback_index = 0;

int
lgetc(int quotec)
{
	int		c, next;

	if (parsebuf) {
		/* Read character from the parsebuffer instead of input. */
		if (parseindex >= 0) {
			c = parsebuf[parseindex++];
			if (c != '\0')
				return (c);
			parsebuf = NULL;
		} else
			parseindex++;
	}

	if (pushback_index)
		return (pushback_buffer[--pushback_index]);

	if (quotec) {
		if ((c = getc(file->stream)) == EOF) {
			yyerror("reached end of file while parsing "
			    "quoted string");
			if (file == topfile || popfile() == EOF)
				return (EOF);
			return (quotec);
		}
		return (c);
	}

	while ((c = getc(file->stream)) == '\\') {
		next = getc(file->stream);
		if (next != '\n') {
			c = next;
			break;
		}
		yylval.lineno = file->lineno;
		file->lineno++;
	}

	while (c == EOF) {
		if (file == topfile || popfile() == EOF)
			return (EOF);
		c = getc(file->stream);
	}
	return (c);
}

int
lungetc(int c)
{
	if (c == EOF)
		return (EOF);
	if (parsebuf) {
		parseindex--;
		if (parseindex >= 0)
			return (c);
	}
	if (pushback_index < MAXPUSHBACK-1)
		return (pushback_buffer[pushback_index++] = c);
	else
		return (EOF);
}

int
findeol(void)
{
	int	c;

	parsebuf = NULL;
	pushback_index = 0;

	/* skip to either EOF or the first real EOL */
	while (1) {
		c = lgetc(0);
		if (c == '\n') {
			file->lineno++;
			break;
		}
		if (c == EOF)
			break;
	}
	return (ERROR);
}

int
yylex(void)
{
	u_char	 buf[8096];
	u_char	*p;
	int	 quotec, next, c;
	int	 token;

	p = buf;
	while ((c = lgetc(0)) == ' ' || c == '\t')
		; /* nothing */

	yylval.lineno = file->lineno;
	if (c == '#')
		while ((c = lgetc(0)) != '\n' && c != EOF)
			; /* nothing */

	switch (c) {
	case '\'':
	case '"':
		quotec = c;
		while (1) {
			if ((c = lgetc(quotec)) == EOF)
				return (0);
			if (c == '\n') {
				file->lineno++;
				continue;
			} else if (c == '\\') {
				if ((next = lgetc(quotec)) == EOF)
					return (0);
				if (next == quotec || c == ' ' || c == '\t')
					c = next;
				else if (next == '\n')
					continue;
				else
					lungetc(next);
			} else if (c == quotec) {
				*p = '\0';
				break;
			} else if (c == '\0') {
				yyerror("syntax error");
				return (findeol());
			}
			if (p + 1 >= buf + sizeof(buf) - 1) {
				yyerror("string too long");
				return (findeol());
			}
			*p++ = c;
		}
		yylval.v.string = strdup(buf);
		if (yylval.v.string == NULL)
			err(1, "yylex: strdup");
		return (STRING);
	}

#define allowed_to_end_number(x) \
	(isspace(x) || x == ')' || x ==',' || x == '/' || x == '}' || x == '=')

	if (c == '-' || isdigit(c)) {
		do {
			*p++ = c;
			if ((unsigned)(p-buf) >= sizeof(buf)) {
				yyerror("string too long");
				return (findeol());
			}
		} while ((c = lgetc(0)) != EOF && isdigit(c));
		lungetc(c);
		if (p == buf + 1 && buf[0] == '-')
			goto nodigits;
		if (c == EOF || allowed_to_end_number(c)) {
			const char *errstr = NULL;

			*p = '\0';
			yylval.v.number = strtonum(buf, LLONG_MIN,
			    LLONG_MAX, &errstr);
			if (errstr) {
				yyerror("\"%s\" invalid number: %s",
				    buf, errstr);
				return (findeol());
			}
			return (NUMBER);
		} else {
nodigits:
			while (p > buf + 1)
				lungetc(*--p);
			c = *--p;
			if (c == '-')
				return (c);
		}
	}

#define allowed_in_string(x) \
	(isalnum(x) || (ispunct(x) && x != '(' && x != ')' && \
	x != '{' && x != '}' && x != '<' && x != '>' && \
	x != '!' && x != '=' && x != '/' && x != '#' && \
	x != ','))

	if (isalnum(c) || c == ':' || c == '_' || c == '*') {
		do {
			*p++ = c;
			if ((unsigned)(p-buf) >= sizeof(buf)) {
				yyerror("string too long");
				return (findeol());
			}
		} while ((c = lgetc(0)) != EOF && (allowed_in_string(c)));
		lungetc(c);
		*p = '\0';
		if ((token = lookup(buf)) == STRING)
			if ((yylval.v.string = strdup(buf)) == NULL)
				err(1, "yylex: strdup");
		return (token);
	}
	if (c == '\n') {
		yylval.lineno = file->lineno;
		file->lineno++;
	}
	if (c == EOF)
		return (0);
	return (c);
}

struct file *
pushfile(const char *name)
{
	struct file	*nfile;

	if ((nfile = calloc(1, sizeof(struct file))) == NULL)
		return (NULL);
	if ((nfile->name = strdup(name)) == NULL) {
		free(nfile);
		return (NULL);
	}
	if ((nfile->stream = fopen(nfile->name, "r")) == NULL) {
		free(nfile->name);
		free(nfile);
		return (NULL);
	}
	nfile->lineno = 1;
	TAILQ_INSERT_TAIL(&files, nfile, entry);
	return (nfile);
}

int
popfile(void)
{
	struct file	*prev;

	if ((prev = TAILQ_PREV(file, files, entry)) != NULL)
		prev->errors += file->errors;

	TAILQ_REMOVE(&files, file, entry);
	fclose(file->stream);
	free(file->name);
	free(file);
	file = prev;
	return (file ? 0 : EOF);
}

char *
parse_tapedev(const char *filename, const char *changer, int drive)
{
	struct changer	*p;
	char		*tapedev = NULL;
	int		 errors = 0;

	TAILQ_INIT(&changers);

	if ((file = pushfile(filename)) == NULL) {
		warnx("cannot open the main config file!");
		goto guess;
	}
	topfile = file;

	yyparse();
	errors = file->errors;
	popfile();

	TAILQ_FOREACH(p, &changers, entry) {
		if (strcmp(basename(changer), p->name) == 0) {
			if (drive >= 0 && drive < p->drivecnt) {
				if (asprintf(&tapedev, "/dev/%s",
				     p->drives[drive]) == -1)
					errx(1, "malloc failed");
			} else
				tapedev = NULL;
		}
	}

guess:
	/* if no device found, do the default of /dev/rstX */
	if (tapedev == NULL)
		if (asprintf(&tapedev, "/dev/rst%d", drive) == -1)
			errx(1, "malloc failed");
	return (tapedev);
}

struct changer *
new_changer(char *name)
{
	struct changer	*p;

	if ((p = calloc(1, sizeof(*p))) == NULL)
		err(1, NULL);

	if ((p->name = strdup(name)) == NULL)
		err(1, NULL);

	return (p);
}


#line 568 "parse.c"
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(void)
{
    unsigned int newsize;
    long sslen;
    short *newss;
    YYSTYPE *newvs;

    if ((newsize = yystacksize) == 0)
        newsize = YYINITSTACKSIZE;
    else if (newsize >= YYMAXDEPTH)
        return -1;
    else if ((newsize *= 2) > YYMAXDEPTH)
        newsize = YYMAXDEPTH;
    sslen = yyssp - yyss;
#ifdef SIZE_MAX
#define YY_SIZE_MAX SIZE_MAX
#else
#define YY_SIZE_MAX 0xffffffffU
#endif
    if (newsize && YY_SIZE_MAX / newsize < sizeof *newss)
        goto bail;
    newss = yyss ? (short *)realloc(yyss, newsize * sizeof *newss) :
      (short *)malloc(newsize * sizeof *newss); /* overflow check above */
    if (newss == NULL)
        goto bail;
    yyss = newss;
    yyssp = newss + sslen;
    if (newsize && YY_SIZE_MAX / newsize < sizeof *newvs)
        goto bail;
    newvs = yyvs ? (YYSTYPE *)realloc(yyvs, newsize * sizeof *newvs) :
      (YYSTYPE *)malloc(newsize * sizeof *newvs); /* overflow check above */
    if (newvs == NULL)
        goto bail;
    yyvs = newvs;
    yyvsp = newvs + sslen;
    yystacksize = newsize;
    yysslim = yyss + newsize - 1;
    return 0;
bail:
    if (yyss)
            free(yyss);
    if (yyvs)
            free(yyvs);
    yyss = yyssp = NULL;
    yyvs = yyvsp = NULL;
    yystacksize = 0;
    return -1;
}

#define YYABORT goto yyabort
#define YYREJECT goto yyabort
#define YYACCEPT goto yyaccept
#define YYERROR goto yyerrlab
int
yyparse(void)
{
    int yym, yyn, yystate;
#if YYDEBUG
    const char *yys;

    if ((yys = getenv("YYDEBUG")))
    {
        yyn = *yys;
        if (yyn >= '0' && yyn <= '9')
            yydebug = yyn - '0';
    }
#endif /* YYDEBUG */

    yynerrs = 0;
    yyerrflag = 0;
    yychar = (-1);

    if (yyss == NULL && yygrowstack()) goto yyoverflow;
    yyssp = yyss;
    yyvsp = yyvs;
    *yyssp = yystate = 0;

yyloop:
    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
    if (yychar < 0)
    {
        if ((yychar = yylex()) < 0) yychar = 0;
#if YYDEBUG
        if (yydebug)
        {
            yys = 0;
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
            if (!yys) yys = "illegal-symbol";
            printf("%sdebug: state %d, reading %d (%s)\n",
                    YYPREFIX, yystate, yychar, yys);
        }
#endif
    }
    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
#if YYDEBUG
        if (yydebug)
            printf("%sdebug: state %d, shifting to state %d\n",
                    YYPREFIX, yystate, yytable[yyn]);
#endif
        if (yyssp >= yysslim && yygrowstack())
        {
            goto yyoverflow;
        }
        *++yyssp = yystate = yytable[yyn];
        *++yyvsp = yylval;
        yychar = (-1);
        if (yyerrflag > 0)  --yyerrflag;
        goto yyloop;
    }
    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
        yyn = yytable[yyn];
        goto yyreduce;
    }
    if (yyerrflag) goto yyinrecovery;
#if defined(__GNUC__)
    goto yynewerror;
#endif
yynewerror:
    yyerror("syntax error");
#if defined(__GNUC__)
    goto yyerrlab;
#endif
yyerrlab:
    ++yynerrs;
yyinrecovery:
    if (yyerrflag < 3)
    {
        yyerrflag = 3;
        for (;;)
        {
            if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
            {
#if YYDEBUG
                if (yydebug)
                    printf("%sdebug: state %d, error recovery shifting\
 to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
#endif
                if (yyssp >= yysslim && yygrowstack())
                {
                    goto yyoverflow;
                }
                *++yyssp = yystate = yytable[yyn];
                *++yyvsp = yylval;
                goto yyloop;
            }
            else
            {
#if YYDEBUG
                if (yydebug)
                    printf("%sdebug: error recovery discarding state %d\n",
                            YYPREFIX, *yyssp);
#endif
                if (yyssp <= yyss) goto yyabort;
                --yyssp;
                --yyvsp;
            }
        }
    }
    else
    {
        if (yychar == 0) goto yyabort;
#if YYDEBUG
        if (yydebug)
        {
            yys = 0;
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
            if (!yys) yys = "illegal-symbol";
            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
                    YYPREFIX, yystate, yychar, yys);
        }
#endif
        yychar = (-1);
        goto yyloop;
    }
yyreduce:
#if YYDEBUG
    if (yydebug)
        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
                YYPREFIX, yystate, yyn, yyrule[yyn]);
#endif
    yym = yylen[yyn];
    if (yym)
        yyval = yyvsp[1-yym];
    else
        memset(&yyval, 0, sizeof yyval);
    switch (yyn)
    {
case 4:
#line 88 "parse.y"
{ file->errors++; }
break;
case 8:
#line 98 "parse.y"
{
			curchanger = new_changer(yyvsp[-3].v.string);
		}
break;
case 9:
#line 101 "parse.y"
{
			TAILQ_INSERT_TAIL(&changers, curchanger, entry);
			curchanger = NULL;
		}
break;
case 14:
#line 115 "parse.y"
{
			void *newp;

			if ((newp = reallocarray(curchanger->drives,
			    curchanger->drivecnt + 1,
			    sizeof(curchanger->drives))) == NULL)
				err(1, NULL);
			curchanger->drives = newp;
			if ((curchanger->drives[curchanger->drivecnt] =
			    strdup(yyvsp[0].v.string)) == NULL)
				err(1, NULL);
			curchanger->drivecnt++;
			free(yyvsp[0].v.string);
		}
break;
#line 796 "parse.c"
    }
    yyssp -= yym;
    yystate = *yyssp;
    yyvsp -= yym;
    yym = yylhs[yyn];
    if (yystate == 0 && yym == 0)
    {
#if YYDEBUG
        if (yydebug)
            printf("%sdebug: after reduction, shifting from state 0 to\
 state %d\n", YYPREFIX, YYFINAL);
#endif
        yystate = YYFINAL;
        *++yyssp = YYFINAL;
        *++yyvsp = yyval;
        if (yychar < 0)
        {
            if ((yychar = yylex()) < 0) yychar = 0;
#if YYDEBUG
            if (yydebug)
            {
                yys = 0;
                if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
                if (!yys) yys = "illegal-symbol";
                printf("%sdebug: state %d, reading %d (%s)\n",
                        YYPREFIX, YYFINAL, yychar, yys);
            }
#endif
        }
        if (yychar == 0) goto yyaccept;
        goto yyloop;
    }
    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
        yystate = yytable[yyn];
    else
        yystate = yydgoto[yym];
#if YYDEBUG
    if (yydebug)
        printf("%sdebug: after reduction, shifting from state %d \
to state %d\n", YYPREFIX, *yyssp, yystate);
#endif
    if (yyssp >= yysslim && yygrowstack())
    {
        goto yyoverflow;
    }
    *++yyssp = yystate;
    *++yyvsp = yyval;
    goto yyloop;
yyoverflow:
    yyerror("yacc stack overflow");
yyabort:
    if (yyss)
            free(yyss);
    if (yyvs)
            free(yyvs);
    yyss = yyssp = NULL;
    yyvs = yyvsp = NULL;
    yystacksize = 0;
    return (1);
yyaccept:
    if (yyss)
            free(yyss);
    if (yyvs)
            free(yyvs);
    yyss = yyssp = NULL;
    yyvs = yyvsp = NULL;
    yystacksize = 0;
    return (0);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			#include <stdlib.h>
2			#include <string.h>
3			#define YYBYACC 1
4			#define YYMAJOR 1
5			#define YYMINOR 9
6			#define YYLEX yylex()
7			#define YYEMPTY -1
8			#define yyclearin (yychar=(YYEMPTY))
9			#define yyerrok (yyerrflag=0)
10			#define YYRECOVERING() (yyerrflag!=0)
11			#define YYPREFIX "yy"
12			#line 24 "parse.y"
13			#include <sys/types.h>
14			#include <sys/socket.h>
15			#include <sys/queue.h>
16
17			#include <ctype.h>
18			#include <err.h>
19			#include <libgen.h>
20			#include <limits.h>
21			#include <stdarg.h>
22			#include <stdio.h>
23			#include <string.h>
24
25			TAILQ_HEAD(files, file) files = TAILQ_HEAD_INITIALIZER(files);
26			static struct file {
27			TAILQ_ENTRY(file) entry;
28			FILE *stream;
29			char *name;
30			int lineno;
31			int errors;
32			} file, topfile;
33			struct file pushfile(const char );
34			int popfile(void);
35			int yyparse(void);
36			int yylex(void);
37			int yyerror(const char *, ...)
38			__attribute__((__format__ (printf, 1, 2)))
39			__attribute__((__nonnull__ (1)));
40			int kw_cmp(const void , const void );
41			int lookup(char *);
42			int lgetc(int);
43			int lungetc(int);
44			int findeol(void);
45			char parse_tapedev(const char , const char *, int);
46			struct changer new_changer(char );
47
48			struct changer {
49			TAILQ_ENTRY(changer) entry;
50			char *name;
51			char **drives;
52			u_int drivecnt;
53			};
54			TAILQ_HEAD(changers, changer) changers;
55			struct changer *curchanger;
56
57			typedef struct {
58			union {
59			int64_t number;
60			char *string;
61			} v;
62			int lineno;
63			} YYSTYPE;
64
65			#line 66 "parse.c"
66			#define CHANGER 257
67			#define DRIVE 258
68			#define ERROR 259
69			#define STRING 260
70			#define NUMBER 261
71			#define YYERRCODE 256
72			const short yylhs[] =
73			{ -1,
74			0, 0, 0, 0, 2, 2, 3, 5, 1, 4,
75			4, 6, 6, 7,
76			};
77			const short yylen[] =
78			{ 2,
79			0, 2, 3, 3, 2, 0, 2, 0, 8, 2,
80			1, 2, 2, 2,
81			};
82			const short yydefred[] =
83			{ 1,
84			0, 0, 0, 2, 0, 4, 0, 3, 0, 0,
85			5, 0, 8, 0, 0, 0, 0, 11, 0, 0,
86			13, 14, 9, 10, 12, 7,
87			};
88			const short yydgoto[] =
89			{ 1,
90			5, 10, 21, 17, 14, 18, 19,
91			};
92			const short yysindex[] =
93			{ 0,
94			-10, 2, -255, 0, 3, 0, 4, 0, 4, -107,
95			0, 4, 0, -248, 7, -242, -123, 0, 7, 4,
96			0, 0, 0, 0, 0, 0,};
97			const short yyrindex[] =
98			{ 0,
99			0, 0, 0, 0, 0, 0, -104, 0, -122, 0,
100			0, -247, 0, 0, 0, 0, 0, 0, 0, -119,
101			0, 0, 0, 0, 0, 0,};
102			const short yygindex[] =
103			{ 0,
104			0, -5, 1, 0, 0, 5, 0,
105			};
106			#define YYTABLESIZE 247
107			const short yytable[] =
108			{ 4,
109			6, 23, 6, 11, 7, 6, 13, 15, 6, 16,
110			6, 6, 8, 9, 26, 12, 20, 22, 6, 25,
111			0, 24, 0, 0, 0, 0, 0, 0, 0, 0,
112			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
113			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
114			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
115			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
116			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
117			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
118			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
119			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
120			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
121			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
122			0, 0, 15, 6, 16, 6, 6, 0, 6, 0,
123			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
124			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
125			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
126			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
127			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
128			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
129			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
130			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
131			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
132			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
133			0, 0, 0, 0, 0, 2, 3,
134			};
135			const short yycheck[] =
136			{ 10,
137			123, 125, 125, 9, 260, 125, 12, 256, 256, 258,
138			258, 10, 10, 10, 20, 123, 10, 260, 123, 19,
139			-1, 17, -1, -1, -1, -1, -1, -1, -1, -1,
140			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
141			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
142			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
143			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
144			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
145			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
146			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
147			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
148			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
149			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
150			-1, -1, 256, 256, 258, 258, 256, -1, 258, -1,
151			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
152			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
153			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
154			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
155			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
156			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
157			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
158			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
159			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
160			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
161			-1, -1, -1, -1, -1, 256, 257,
162			};
163			#define YYFINAL 1
164			#ifndef YYDEBUG
165			#define YYDEBUG 0
166			#endif
167			#define YYMAXTOKEN 261
168			#if YYDEBUG
169			const char * const yyname[] =
170			{
171			"end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
172			0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
173			0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
174			0,0,0,0,0,0,0,0,0,0,0,0,"'{'",0,"'}'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
175			0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
176			0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
177			0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"CHANGER","DRIVE",
178			"ERROR","STRING","NUMBER",
179			};
180			const char * const yyrule[] =
181			{"$accept : grammar",
182			"grammar :",
183			"grammar : grammar '\\n'",
184			"grammar : grammar main '\\n'",
185			"grammar : grammar error '\\n'",
186			"optnl : '\\n' optnl",
187			"optnl :",
188			"nl : '\\n' optnl",
189			"$$1 :",
190			"main : CHANGER STRING optnl '{' optnl $$1 changeropts_l '}'",
191			"changeropts_l : changeropts_l changeroptsl",
192			"changeropts_l : changeroptsl",
193			"changeroptsl : changeropts nl",
194			"changeroptsl : error nl",
195			"changeropts : DRIVE STRING",
196			};
197			#endif
198			#ifdef YYSTACKSIZE
199			#undef YYMAXDEPTH
200			#define YYMAXDEPTH YYSTACKSIZE
201			#else
202			#ifdef YYMAXDEPTH
203			#define YYSTACKSIZE YYMAXDEPTH
204			#else
205			#define YYSTACKSIZE 10000
206			#define YYMAXDEPTH 10000
207			#endif
208			#endif
209			#define YYINITSTACKSIZE 200
210			/* LINTUSED */
211			int yydebug;
212			int yynerrs;
213			int yyerrflag;
214			int yychar;
215			short *yyssp;
216			YYSTYPE *yyvsp;
217			YYSTYPE yyval;
218			YYSTYPE yylval;
219			short *yyss;
220			short *yysslim;
221			YYSTYPE *yyvs;
222			unsigned int yystacksize;
223			int yyparse(void);
224			#line 132 "parse.y"
225
226			struct keywords {
227			const char *k_name;
228			int k_val;
229			};
230
231			int
232			yyerror(const char *fmt, ...)
233			{
234			va_list ap;
235			char *msg;
236
237			file->errors++;
238			va_start(ap, fmt);
239			if (vasprintf(&msg, fmt, ap) == -1)
240			err(1, "yyerror vasprintf");
241			va_end(ap);
242			err(1, "%s:%d: %s", file->name, yylval.lineno, msg);
243			free(msg);
244			return (0);
245			}
246
247			int
248			kw_cmp(const void k, const void e)
249			{
250			return (strcmp(k, ((const struct keywords *)e)->k_name));
251			}
252
253			int
254			lookup(char *s)
255			{
256			/* this has to be sorted always */
257			static const struct keywords keywords[] = {
258			{ "changer", CHANGER},
259			{ "drive", DRIVE}
260			};
261			const struct keywords *p;
262
263			p = bsearch(s, keywords, sizeof(keywords)/sizeof(keywords[0]),
264			sizeof(keywords[0]), kw_cmp);
265
266			if (p)
267			return (p->k_val);
268			else
269			return (STRING);
270			}
271
272			#define MAXPUSHBACK 128
273
274			u_char *parsebuf;
275			int parseindex;
276			u_char pushback_buffer[MAXPUSHBACK];
277			int pushback_index = 0;
278
279			int
280			lgetc(int quotec)
281			{
282			int c, next;
283
284			if (parsebuf) {
285			/* Read character from the parsebuffer instead of input. */
286			if (parseindex >= 0) {
287			c = parsebuf[parseindex++];
288			if (c != '\0')
289			return (c);
290			parsebuf = NULL;
291			} else
292			parseindex++;
293			}
294
295			if (pushback_index)
296			return (pushback_buffer[--pushback_index]);
297
298			if (quotec) {
299			if ((c = getc(file->stream)) == EOF) {
300			yyerror("reached end of file while parsing "
301			"quoted string");
302			if (file == topfile \|\| popfile() == EOF)
303			return (EOF);
304			return (quotec);
305			}
306			return (c);
307			}
308
309			while ((c = getc(file->stream)) == '\\') {
310			next = getc(file->stream);
311			if (next != '\n') {
312			c = next;
313			break;
314			}
315			yylval.lineno = file->lineno;
316			file->lineno++;
317			}
318
319			while (c == EOF) {
320			if (file == topfile \|\| popfile() == EOF)
321			return (EOF);
322			c = getc(file->stream);
323			}
324			return (c);
325			}
326
327			int
328			lungetc(int c)
329			{
330			if (c == EOF)
331			return (EOF);
332			if (parsebuf) {
333			parseindex--;
334			if (parseindex >= 0)
335			return (c);
336			}
337			if (pushback_index < MAXPUSHBACK-1)
338			return (pushback_buffer[pushback_index++] = c);
339			else
340			return (EOF);
341			}
342
343			int
344			findeol(void)
345			{
346			int c;
347
348			parsebuf = NULL;
349			pushback_index = 0;
350
351			/* skip to either EOF or the first real EOL */
352			while (1) {
353			c = lgetc(0);
354			if (c == '\n') {
355			file->lineno++;
356			break;
357			}
358			if (c == EOF)
359			break;
360			}
361			return (ERROR);
362			}
363
364			int
365			yylex(void)
366			{
367			u_char buf[8096];
368			u_char *p;
369			int quotec, next, c;
370			int token;
371
372			p = buf;
373			while ((c = lgetc(0)) == ' ' \|\| c == '\t')
374			; /* nothing */
375
376			yylval.lineno = file->lineno;
377			if (c == '#')
378			while ((c = lgetc(0)) != '\n' && c != EOF)
379			; /* nothing */
380
381			switch (c) {
382			case '\'':
383			case '"':
384			quotec = c;
385			while (1) {
386			if ((c = lgetc(quotec)) == EOF)
387			return (0);
388			if (c == '\n') {
389			file->lineno++;
390			continue;
391			} else if (c == '\\') {
392			if ((next = lgetc(quotec)) == EOF)
393			return (0);
394			if (next == quotec \|\| c == ' ' \|\| c == '\t')
395			c = next;
396			else if (next == '\n')
397			continue;
398			else
399			lungetc(next);
400			} else if (c == quotec) {
401			*p = '\0';
402			break;
403			} else if (c == '\0') {
404			yyerror("syntax error");
405			return (findeol());
406			}
407			if (p + 1 >= buf + sizeof(buf) - 1) {
408			yyerror("string too long");
409			return (findeol());
410			}
411			*p++ = c;
412			}
413			yylval.v.string = strdup(buf);
414			if (yylval.v.string == NULL)
415			err(1, "yylex: strdup");
416			return (STRING);
417			}
418
419			#define allowed_to_end_number(x) \
420			(isspace(x) \|\| x == ')' \|\| x ==',' \|\| x == '/' \|\| x == '}' \|\| x == '=')
421
422			if (c == '-' \|\| isdigit(c)) {
423			do {
424			*p++ = c;
425			if ((unsigned)(p-buf) >= sizeof(buf)) {
426			yyerror("string too long");
427			return (findeol());
428			}
429			} while ((c = lgetc(0)) != EOF && isdigit(c));
430			lungetc(c);
431			if (p == buf + 1 && buf[0] == '-')
432			goto nodigits;
433			if (c == EOF \|\| allowed_to_end_number(c)) {
434			const char *errstr = NULL;
435
436			*p = '\0';
437			yylval.v.number = strtonum(buf, LLONG_MIN,
438			LLONG_MAX, &errstr);
439			if (errstr) {
440			yyerror("\"%s\" invalid number: %s",
441			buf, errstr);
442			return (findeol());
443			}
444			return (NUMBER);
445			} else {
446			nodigits:
447			while (p > buf + 1)
448			lungetc(*--p);
449			c = *--p;
450			if (c == '-')
451			return (c);
452			}
453			}
454
455			#define allowed_in_string(x) \
456			(isalnum(x) \|\| (ispunct(x) && x != '(' && x != ')' && \
457			x != '{' && x != '}' && x != '<' && x != '>' && \
458			x != '!' && x != '=' && x != '/' && x != '#' && \
459			x != ','))
460
461			if (isalnum(c) \|\| c == ':' \|\| c == '_' \|\| c == '*') {
462			do {
463			*p++ = c;
464			if ((unsigned)(p-buf) >= sizeof(buf)) {
465			yyerror("string too long");
466			return (findeol());
467			}
468			} while ((c = lgetc(0)) != EOF && (allowed_in_string(c)));
469			lungetc(c);
470			*p = '\0';
471			if ((token = lookup(buf)) == STRING)
472			if ((yylval.v.string = strdup(buf)) == NULL)
473			err(1, "yylex: strdup");
474			return (token);
475			}
476			if (c == '\n') {
477			yylval.lineno = file->lineno;
478			file->lineno++;
479			}
480			if (c == EOF)
481			return (0);
482			return (c);
483			}
484
485			struct file *
486			pushfile(const char *name)
487			{
488			struct file *nfile;
489
490			if ((nfile = calloc(1, sizeof(struct file))) == NULL)
491			return (NULL);
492			if ((nfile->name = strdup(name)) == NULL) {
493			free(nfile);
494			return (NULL);
495			}
496			if ((nfile->stream = fopen(nfile->name, "r")) == NULL) {
497			free(nfile->name);
498			free(nfile);
499			return (NULL);
500			}
501			nfile->lineno = 1;
502			TAILQ_INSERT_TAIL(&files, nfile, entry);
503			return (nfile);
504			}
505
506			int
507			popfile(void)
508			{
509			struct file *prev;
510
511			if ((prev = TAILQ_PREV(file, files, entry)) != NULL)
512			prev->errors += file->errors;
513
514			TAILQ_REMOVE(&files, file, entry);
515			fclose(file->stream);
516			free(file->name);
517			free(file);
518			file = prev;
519			return (file ? 0 : EOF);
520			}
521
522			char *
523			parse_tapedev(const char filename, const char changer, int drive)
524			{
525			struct changer *p;
526			char *tapedev = NULL;
527			int errors = 0;
528
529			TAILQ_INIT(&changers);
530
531			if ((file = pushfile(filename)) == NULL) {
532			warnx("cannot open the main config file!");
533			goto guess;
534			}
535			topfile = file;
536
537			yyparse();
538			errors = file->errors;
539			popfile();
540
541			TAILQ_FOREACH(p, &changers, entry) {
542			if (strcmp(basename(changer), p->name) == 0) {
543			if (drive >= 0 && drive < p->drivecnt) {
544			if (asprintf(&tapedev, "/dev/%s",
545			p->drives[drive]) == -1)
546			errx(1, "malloc failed");
547			} else
548			tapedev = NULL;
549			}
550			}
551
552			guess:
553			/* if no device found, do the default of /dev/rstX */
554			if (tapedev == NULL)
555			if (asprintf(&tapedev, "/dev/rst%d", drive) == -1)
556			errx(1, "malloc failed");
557			return (tapedev);
558			}
559
560			struct changer *
561			new_changer(char *name)
562			{
563			struct changer *p;
564
565			if ((p = calloc(1, sizeof(*p))) == NULL)
566			err(1, NULL);
567
568			if ((p->name = strdup(name)) == NULL)
569			err(1, NULL);
570
571			return (p);
572			}
573
574
575			#line 568 "parse.c"
576			/* allocate initial stack or double stack size, up to YYMAXDEPTH */
577			static int yygrowstack(void)
578			{
579			unsigned int newsize;
580			long sslen;
581			short *newss;
582			YYSTYPE *newvs;
583
584			if ((newsize = yystacksize) == 0)
585			newsize = YYINITSTACKSIZE;
586			else if (newsize >= YYMAXDEPTH)
587			return -1;
588			else if ((newsize *= 2) > YYMAXDEPTH)
589			newsize = YYMAXDEPTH;
590			sslen = yyssp - yyss;
591			#ifdef SIZE_MAX
592			#define YY_SIZE_MAX SIZE_MAX
593			#else
594			#define YY_SIZE_MAX 0xffffffffU
595			#endif
596			if (newsize && YY_SIZE_MAX / newsize < sizeof *newss)
597			goto bail;
598			newss = yyss ? (short )realloc(yyss, newsize sizeof *newss) :
599			(short )malloc(newsize sizeof newss); / overflow check above */
600			if (newss == NULL)
601			goto bail;
602			yyss = newss;
603			yyssp = newss + sslen;
604			if (newsize && YY_SIZE_MAX / newsize < sizeof *newvs)
605			goto bail;
606			newvs = yyvs ? (YYSTYPE )realloc(yyvs, newsize sizeof *newvs) :
607			(YYSTYPE )malloc(newsize sizeof newvs); / overflow check above */
608			if (newvs == NULL)
609			goto bail;
610			yyvs = newvs;
611			yyvsp = newvs + sslen;
612			yystacksize = newsize;
613			yysslim = yyss + newsize - 1;
614			return 0;
615			bail:
616			if (yyss)
617			free(yyss);
618			if (yyvs)
619			free(yyvs);
620			yyss = yyssp = NULL;
621			yyvs = yyvsp = NULL;
622			yystacksize = 0;
623			return -1;
624			}
625
626			#define YYABORT goto yyabort
627			#define YYREJECT goto yyabort
628			#define YYACCEPT goto yyaccept
629			#define YYERROR goto yyerrlab
630			int
631			yyparse(void)
632			{
633			int yym, yyn, yystate;
634			#if YYDEBUG
635			const char *yys;
636
637			if ((yys = getenv("YYDEBUG")))
638			{
639			yyn = *yys;
640			if (yyn >= '0' && yyn <= '9')
641			yydebug = yyn - '0';
642			}
643			#endif /* YYDEBUG */
644
645			yynerrs = 0;
646			yyerrflag = 0;
647			yychar = (-1);
648
649			if (yyss == NULL && yygrowstack()) goto yyoverflow;
650			yyssp = yyss;
651			yyvsp = yyvs;
652			*yyssp = yystate = 0;
653
654			yyloop:
655			if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
656			if (yychar < 0)
657			{
658			if ((yychar = yylex()) < 0) yychar = 0;
659			#if YYDEBUG
660			if (yydebug)
661			{
662			yys = 0;
663			if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
664			if (!yys) yys = "illegal-symbol";
665			printf("%sdebug: state %d, reading %d (%s)\n",
666			YYPREFIX, yystate, yychar, yys);
667			}
668			#endif
669			}
670			if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
671			yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
672			{
673			#if YYDEBUG
674			if (yydebug)
675			printf("%sdebug: state %d, shifting to state %d\n",
676			YYPREFIX, yystate, yytable[yyn]);
677			#endif
678			if (yyssp >= yysslim && yygrowstack())
679			{
680			goto yyoverflow;
681			}
682			*++yyssp = yystate = yytable[yyn];
683			*++yyvsp = yylval;
684			yychar = (-1);
685			if (yyerrflag > 0) --yyerrflag;
686			goto yyloop;
687			}
688			if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
689			yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
690			{
691			yyn = yytable[yyn];
692			goto yyreduce;
693			}
694			if (yyerrflag) goto yyinrecovery;
695			#if defined(__GNUC__)
696			goto yynewerror;
697			#endif
698			yynewerror:
699			yyerror("syntax error");
700			#if defined(__GNUC__)
701			goto yyerrlab;
702			#endif
703			yyerrlab:
704			++yynerrs;
705			yyinrecovery:
706			if (yyerrflag < 3)
707			{
708			yyerrflag = 3;
709			for (;;)
710			{
711			if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
712			yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
713			{
714			#if YYDEBUG
715			if (yydebug)
716			printf("%sdebug: state %d, error recovery shifting\
717			to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
718			#endif
719			if (yyssp >= yysslim && yygrowstack())
720			{
721			goto yyoverflow;
722			}
723			*++yyssp = yystate = yytable[yyn];
724			*++yyvsp = yylval;
725			goto yyloop;
726			}
727			else
728			{
729			#if YYDEBUG
730			if (yydebug)
731			printf("%sdebug: error recovery discarding state %d\n",
732			YYPREFIX, *yyssp);
733			#endif
734			if (yyssp <= yyss) goto yyabort;
735			--yyssp;
736			--yyvsp;
737			}
738			}
739			}
740			else
741			{
742			if (yychar == 0) goto yyabort;
743			#if YYDEBUG
744			if (yydebug)
745			{
746			yys = 0;
747			if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
748			if (!yys) yys = "illegal-symbol";
749			printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
750			YYPREFIX, yystate, yychar, yys);
751			}
752			#endif
753			yychar = (-1);
754			goto yyloop;
755			}
756			yyreduce:
757			#if YYDEBUG
758			if (yydebug)
759			printf("%sdebug: state %d, reducing by rule %d (%s)\n",
760			YYPREFIX, yystate, yyn, yyrule[yyn]);
761			#endif
762			yym = yylen[yyn];
763			if (yym)
764			yyval = yyvsp[1-yym];
765			else
766			memset(&yyval, 0, sizeof yyval);
767			switch (yyn)
768			{
769			case 4:
770			#line 88 "parse.y"
771			{ file->errors++; }
772			break;
773			case 8:
774			#line 98 "parse.y"
775			{
776			curchanger = new_changer(yyvsp[-3].v.string);
777			}
778			break;
779			case 9:
780			#line 101 "parse.y"
781			{
782			TAILQ_INSERT_TAIL(&changers, curchanger, entry);
783			curchanger = NULL;
784			}
785			break;
786			case 14:
787			#line 115 "parse.y"
788			{
789			void *newp;
790
791			if ((newp = reallocarray(curchanger->drives,
792			curchanger->drivecnt + 1,
793			sizeof(curchanger->drives))) == NULL)
794			err(1, NULL);
795			curchanger->drives = newp;
796			if ((curchanger->drives[curchanger->drivecnt] =
797			strdup(yyvsp[0].v.string)) == NULL)
798			err(1, NULL);
799			curchanger->drivecnt++;
800			free(yyvsp[0].v.string);
801			}
802			break;
803			#line 796 "parse.c"
804			}
805			yyssp -= yym;
806			yystate = *yyssp;
807			yyvsp -= yym;
808			yym = yylhs[yyn];
809			if (yystate == 0 && yym == 0)
810			{
811			#if YYDEBUG
812			if (yydebug)
813			printf("%sdebug: after reduction, shifting from state 0 to\
814			state %d\n", YYPREFIX, YYFINAL);
815			#endif
816			yystate = YYFINAL;
817			*++yyssp = YYFINAL;
818			*++yyvsp = yyval;
819			if (yychar < 0)
820			{
821			if ((yychar = yylex()) < 0) yychar = 0;
822			#if YYDEBUG
823			if (yydebug)
824			{
825			yys = 0;
826			if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
827			if (!yys) yys = "illegal-symbol";
828			printf("%sdebug: state %d, reading %d (%s)\n",
829			YYPREFIX, YYFINAL, yychar, yys);
830			}
831			#endif
832			}
833			if (yychar == 0) goto yyaccept;
834			goto yyloop;
835			}
836			if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
837			yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
838			yystate = yytable[yyn];
839			else
840			yystate = yydgoto[yym];
841			#if YYDEBUG
842			if (yydebug)
843			printf("%sdebug: after reduction, shifting from state %d \
844			to state %d\n", YYPREFIX, *yyssp, yystate);
845			#endif
846			if (yyssp >= yysslim && yygrowstack())
847			{
848			goto yyoverflow;
849			}
850			*++yyssp = yystate;
851			*++yyvsp = yyval;
852			goto yyloop;
853			yyoverflow:
854			yyerror("yacc stack overflow");
855			yyabort:
856			if (yyss)
857			free(yyss);
858			if (yyvs)
859			free(yyvs);
860			yyss = yyssp = NULL;
861			yyvs = yyvsp = NULL;
862			yystacksize = 0;
863			return (1);
864			yyaccept:
865			if (yyss)
866			free(yyss);
867			if (yyvs)
868			free(yyvs);
869			yyss = yyssp = NULL;
870			yyvs = yyvsp = NULL;
871			yystacksize = 0;
872			return (0);
873			}