xref: /illumos-gate/usr/src/cmd/svc/svccfg/svccfg.l (revision 6a634c9dca3093f3922e4b7ab826d7bdf17bf78e)

%{
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
 */


#pragma error_messages(off, E_BLOCK_DECL_UNUSED)
#pragma error_messages(off, E_EQUALITY_NOT_ASSIGNMENT)
#pragma error_messages(off, E_FUNC_RET_MAYBE_IGNORED2)
#pragma error_messages(off, E_STMT_NOT_REACHED)

#include <libintl.h>
#include <string.h>

#include "svccfg.h"
#include "svccfg_grammar.h"

/*
 * We need to undefine lex's input, unput, and output macros so that references
 * to these call the functions we provide at the end of this source file,
 * instead of the default versions based on libc's stdio.
 */
#ifdef input
#undef input
#endif

#ifdef unput
#undef unput
#endif

#ifdef output
#undef output
#endif

static int input(void);
static void unput(int);
static void output(int);

int parens = 0;

extern int yyerror(const char *);

%}

/*
 * Since command tokens are only valid at the beginning of the command (or
 * after help), we'll only return them in the INITIAL state, and report them
 * as SCV_WORDs afterwards.
 */
%Start	WORD

/*
 * The default value of lex for transitions is 2000 and it seems we reached it.
 * So we are bumping it up!
 */
%a 3000

%%

#.*$			;	/* comments */

<INITIAL>validate	{ BEGIN WORD; return (SCC_VALIDATE); }
<INITIAL>import		{ BEGIN WORD; return (SCC_IMPORT); }
<INITIAL>cleanup	{ BEGIN WORD; return (SCC_CLEANUP); }
<INITIAL>export		{ BEGIN WORD; return (SCC_EXPORT); }
<INITIAL>archive	{ BEGIN WORD; return (SCC_ARCHIVE); }
<INITIAL>restore	{ BEGIN WORD; return (SCC_RESTORE); }
<INITIAL>apply		{ BEGIN WORD; return (SCC_APPLY); }
<INITIAL>extract	{ BEGIN WORD; return (SCC_EXTRACT); }
<INITIAL>repository	{ BEGIN WORD; return (SCC_REPOSITORY); }
<INITIAL>inventory	{ BEGIN WORD; return (SCC_INVENTORY); }
<INITIAL>set		{ BEGIN WORD; return (SCC_SET); }
<INITIAL>end		{ BEGIN WORD; return (SCC_END); }
<INITIAL>exit		{ BEGIN WORD; return (SCC_END); }
<INITIAL>quit		{ BEGIN WORD; return (SCC_END); }
<INITIAL>help		{ return (SCC_HELP); }

<INITIAL>list		{ BEGIN WORD; return (SCC_LIST); }
<INITIAL>add		{ BEGIN WORD; return (SCC_ADD); }
<INITIAL>delete		{ BEGIN WORD; return (SCC_DELETE); }
<INITIAL>select		{ BEGIN WORD; return (SCC_SELECT); }
<INITIAL>unselect	{ BEGIN WORD; return (SCC_UNSELECT); }

<INITIAL>listpg		{ BEGIN WORD; return (SCC_LISTPG); }
<INITIAL>addpg		{ BEGIN WORD; return (SCC_ADDPG); }
<INITIAL>delpg		{ BEGIN WORD; return (SCC_DELPG); }
<INITIAL>delhash	{ BEGIN WORD; return (SCC_DELHASH); }
<INITIAL>listprop	{ BEGIN WORD; return (SCC_LISTPROP); }
<INITIAL>setprop	{ BEGIN WORD; return (SCC_SETPROP); }
<INITIAL>delprop	{ BEGIN WORD; return (SCC_DELPROP); }
<INITIAL>editprop	{ BEGIN WORD; return (SCC_EDITPROP); }
<INITIAL>describe	{ BEGIN WORD; return (SCC_DESCRIBE); }
<INITIAL>addpropvalue	{ BEGIN WORD; return (SCC_ADDPROPVALUE); }
<INITIAL>delpropvalue	{ BEGIN WORD; return (SCC_DELPROPVALUE); }
<INITIAL>setenv		{ BEGIN WORD; return (SCC_SETENV); }
<INITIAL>unsetenv	{ BEGIN WORD; return (SCC_UNSETENV); }

<INITIAL>listsnap	{ BEGIN WORD; return (SCC_LISTSNAP); }
<INITIAL>selectsnap	{ BEGIN WORD; return (SCC_SELECTSNAP); }
<INITIAL>revert		{ BEGIN WORD; return (SCC_REVERT); }
<INITIAL>refresh	{ BEGIN WORD; return (SCC_REFRESH); }

<INITIAL>delnotify	{ BEGIN WORD; return (SCC_DELNOTIFY); }
<INITIAL>listnotify	{ BEGIN WORD; return (SCC_LISTNOTIFY); }
<INITIAL>setnotify	{ BEGIN WORD; return (SCC_SETNOTIFY); }

[^ \t\n">=()]+		{
				if ((yylval.str = strdup(yytext)) == NULL) {
					yyerror(gettext("Out of memory"));
					exit(UU_EXIT_FATAL);
				}

				return SCV_WORD;
			}

\"([^"\\]|\\.)*\"	{
				/*
				 * double-quoted strings start at a
				 * double-quote, include characters other than
				 * double-quote and backslash, and
				 * backslashed-characters, and end with a
				 * double-quote.
				 */

				char *str, *cp;
				int shift;

				if ((str = strdup(yytext)) == NULL) {
					yyerror(gettext("Out of memory"));
					exit(UU_EXIT_FATAL);
				}

				/* Strip out the backslashes. */
				for (cp = str, shift = 0; *cp != '\0'; ++cp) {
					if (*cp == '\\') {
						++cp;

						/*
						 * This can't be null because
						 * the string always ends with
						 * a double-quote.
						 */

						++shift;
						*(cp - shift) = *cp;
					} else if (shift != 0)
						*(cp - shift) = *cp;
				}

				/* Nullify everything after trailing quote */
				*(cp - shift) = '\0';

				yylval.str = str;
				return SCV_STRING;
			}

\n			{
				est->sc_cmd_lineno++;
				BEGIN INITIAL;
				return (SCS_NEWLINE);
			}

[ \t]+			;

">"			{ return SCS_REDIRECT; }
"="			{ return SCS_EQUALS; }
"("			{ ++parens; return SCS_LPAREN; }
")"			{ --parens; return SCS_RPAREN; }

.			{
				uu_die(gettext("unrecognized character %s\n"),
				    yytext);
			}

%%

int
yyerror(const char *s)
{
	return (0);
}

static int
input(void)
{
	static int saw_eof = 0;

	int c = engine_cmd_getc(est);

	/*
	 * To ensure input is terminated, slip in a newline on EOF.
	 */
	if (c == EOF) {
		if (saw_eof)
			return (0);

		saw_eof = 1;
		return ('\n');
	} else
		saw_eof = 0;

	if (c == '\n')
		yylineno++;

	return (c);
}

static void
unput(int c)
{
	if (c == '\n')
		yylineno--;

	(void) engine_cmd_ungetc(est, c == 0 ? EOF : c);
}

static void
output(int c)
{
	char ch = c;
	engine_cmd_nputs(est, &ch, sizeof (ch));
}