%{

/*

 * 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

 */

/*

 */

#include <string.h>

#include <libintl.h>

#include "zonecfg.h"

#include "zonecfg_grammar.tab.h"

int lex_lineno = 1;	/* line number for error reporting */

static int state = INITIAL;

extern boolean_t cmd_file_mode;

extern boolean_t saw_error;

extern void yyerror(char *s);

char *safe_strdup(char *s);

%}

%a 7000

%p 5000

%e 2000

%n 1000

%{

/*

 * The three states below are for tokens, lists and complex property values.

 * Note that simple property values are a subset of tokens.

 */

%}

%s TSTATE

%s LSTATE

%s CSTATE

%%

<INITIAL>"#"[^\n]*	{ }

<INITIAL>add	{

			BEGIN TSTATE;

			state = TSTATE;

			return ADD;

		}

<INITIAL>cancel	{

			BEGIN TSTATE;

			state = TSTATE;

			return CANCEL;

		}

<INITIAL>commit	{

			BEGIN TSTATE;

			state = TSTATE;

			return COMMIT;

		}

<INITIAL>create	{

			BEGIN TSTATE;

			state = TSTATE;

			return CREATE;

		}

<INITIAL>delete {

			BEGIN TSTATE;

			state = TSTATE;

			return DELETE;

		}

<INITIAL>end	{

			BEGIN TSTATE;

			state = TSTATE;

			return END;

		}

<INITIAL>exit	{

			BEGIN TSTATE;

			state = TSTATE;

			return EXIT;

		}

<INITIAL>export	{

			BEGIN TSTATE;

			state = TSTATE;

			return EXPORT;

		}

<INITIAL>"?"|help {

			BEGIN TSTATE;

			state = TSTATE;

			return HELP;

		}

<INITIAL>info	{

			BEGIN TSTATE;

			state = TSTATE;

			return INFO;

		}

<INITIAL>remove	{

			BEGIN TSTATE;

			state = TSTATE;

			return REMOVE;

		}

<INITIAL>revert	{

			BEGIN TSTATE;

			state = TSTATE;

			return REVERT;

		}

<INITIAL>select {

			BEGIN TSTATE;

			state = TSTATE;

			return SELECT;

		}

<INITIAL>set {

			BEGIN TSTATE;

			state = TSTATE;

			return SET;

		}

<INITIAL>clear {

			BEGIN TSTATE;

			state = TSTATE;

			return CLEAR;

		}

<INITIAL>verify	{

			BEGIN TSTATE;

			state = TSTATE;

			return VERIFY;

		}

<TSTATE>net	{ return NET; }

<TSTATE>fs	{ return FS; }

<TSTATE>inherit-pkg-dir	{ return IPD; }

<TSTATE>device	{ return DEVICE; }

<TSTATE>rctl	{ return RCTL; }

<TSTATE>attr	{ return ATTR; }

<TSTATE>admin	{ return ADMIN; }

<TSTATE>zonename	{ return ZONENAME; }

<CSTATE>zonename	{ return ZONENAME; }

<TSTATE>dataset	{ return DATASET; }

<TSTATE>dedicated-cpu	{ return PSET; }

<TSTATE>capped-cpu	{ return PCAP; }

<TSTATE>capped-memory	{ return MCAP; }

<TSTATE>zonepath	{ return ZONEPATH; }

<CSTATE>zonepath	{ return ZONEPATH; }

<TSTATE>brand	{ return BRAND; }

<CSTATE>brand	{ return BRAND; }

<TSTATE>autoboot	{ return AUTOBOOT; }

<CSTATE>autoboot	{ return AUTOBOOT; }

<TSTATE>ip-type		{ return IPTYPE; }

<CSTATE>ip-type		{ return IPTYPE; }

<TSTATE>pool	{ return POOL; }

<CSTATE>pool	{ return POOL; }

<TSTATE>limitpriv	{ return LIMITPRIV; }

<CSTATE>limitpriv	{ return LIMITPRIV; }

<TSTATE>bootargs	{ return BOOTARGS; }

<CSTATE>bootargs	{ return BOOTARGS; }

<TSTATE>type	{ return TYPE; }

<CSTATE>type	{ return TYPE; }

<TSTATE>value	{ return VALUE; }

<CSTATE>value	{ return VALUE; }

<TSTATE>options	{ return OPTIONS; }

<CSTATE>options	{ return OPTIONS; }

<TSTATE>address	{ return ADDRESS; }

<CSTATE>address	{ return ADDRESS; }

<TSTATE>physical	{ return PHYSICAL; }

<CSTATE>physical	{ return PHYSICAL; }

<TSTATE>defrouter	{ return DEFROUTER; }

<CSTATE>defrouter	{ return DEFROUTER; }

<TSTATE>dir	{ return DIR; }

<CSTATE>dir	{ return DIR; }

<TSTATE>special	{ return SPECIAL; }

<CSTATE>special	{ return SPECIAL; }

<TSTATE>raw	{ return RAW; }

<CSTATE>raw	{ return RAW; }

<TSTATE>name	{ return NAME; }

<CSTATE>name	{ return NAME; }

<TSTATE>match	{ return MATCH; }

<CSTATE>match	{ return MATCH; }

<TSTATE>priv	{ return PRIV; }

<CSTATE>priv	{ return PRIV; }

<TSTATE>limit	{ return LIMIT; }

<CSTATE>limit	{ return LIMIT; }

<TSTATE>action	{ return ACTION; }

<CSTATE>action	{ return ACTION; }

<TSTATE>ncpus	{ return NCPUS; }

<CSTATE>ncpus	{ return NCPUS; }

<TSTATE>locked	{ return LOCKED; }

<CSTATE>locked	{ return LOCKED; }

<TSTATE>swap	{ return SWAP; }

<CSTATE>swap	{ return SWAP; }

<TSTATE>importance	{ return IMPORTANCE; }

<CSTATE>importance	{ return IMPORTANCE; }

<TSTATE>cpu-shares	{ return SHARES; }

<CSTATE>cpu-shares	{ return SHARES; }

<TSTATE>max-lwps	{ return MAXLWPS; }

<CSTATE>max-lwps	{ return MAXLWPS; }

<TSTATE>max-shm-memory	{ return MAXSHMMEM; }

<CSTATE>max-shm-memory	{ return MAXSHMMEM; }

<TSTATE>max-shm-ids	{ return MAXSHMIDS; }

<CSTATE>max-shm-ids	{ return MAXSHMIDS; }

<TSTATE>max-msg-ids	{ return MAXMSGIDS; }

<CSTATE>max-msg-ids	{ return MAXMSGIDS; }

<TSTATE>max-sem-ids	{ return MAXSEMIDS; }

<CSTATE>max-sem-ids	{ return MAXSEMIDS; }

<TSTATE>scheduling-class	{ return SCHED; }

<CSTATE>scheduling-class	{ return SCHED; }

<TSTATE>hostid		{ return HOSTID; }

<CSTATE>hostid		{ return HOSTID; }

<TSTATE>user	{ return USER; }

<CSTATE>user	{ return USER; }

<TSTATE>auths	{ return AUTHS; }

<CSTATE>auths	{ return AUTHS; }

<TSTATE>=	{ return EQUAL; }

<LSTATE>=	{ return EQUAL; }

<CSTATE>=	{ return EQUAL; }

<TSTATE>"["	{

			BEGIN LSTATE;

			state = LSTATE;

			return OPEN_SQ_BRACKET;

		}

<LSTATE>"]"	{

			BEGIN TSTATE;

			state = TSTATE;

			return CLOSE_SQ_BRACKET;

		}

<TSTATE>"("	{

			BEGIN CSTATE;

			return OPEN_PAREN;

		}

<LSTATE>"("	{

			BEGIN CSTATE;

			return OPEN_PAREN;

		}

<CSTATE>")"	{

			BEGIN state;

			return CLOSE_PAREN;

		}

<LSTATE>","	{ return COMMA; }

<CSTATE>","	{ return COMMA; }

<TSTATE>[^ \t\n\";=\[\]\(\)]+	{

			yylval.strval = safe_strdup(yytext);

			return TOKEN;

		}

<LSTATE>[^ \t\n\",;=\[\]\(\)]+	{

			yylval.strval = safe_strdup(yytext);

			return TOKEN;

		}

<CSTATE>[^ \t\n\",;=\(\)]+	{

			yylval.strval = safe_strdup(yytext);

			return TOKEN;

		}

<TSTATE>\"[^\"\n]*[\"\n] {

			yylval.strval = safe_strdup(yytext + 1);

			if (yylval.strval[yyleng - 2] == '"')

				yylval.strval[yyleng - 2] = 0;

			return TOKEN;

		}

<LSTATE>\"[^\"\n]*[\"\n] {

			yylval.strval = safe_strdup(yytext + 1);

			if (yylval.strval[yyleng - 2] == '"')

				yylval.strval[yyleng - 2] = 0;

			return TOKEN;

		}

";"		{

			BEGIN INITIAL;

			return (yytext[0]);

		}

\n		{

			lex_lineno++;

			BEGIN INITIAL;

			return (yytext[0]);

		}

[ \t]		;	/* Ignore whitespace */

.		{

			return (yytext[0]);

		}

%%

char *

safe_strdup(char *s)

{

	char *result;

	if ((result = strdup(s)) == NULL) {

		yyerror("Out of memory");

		exit(Z_ERR);

	}

	return (result);

}

void

yyerror(char *s)

{

	/* feof(yyin) is not an error; anything else is, so we set saw_error */

	if (yytext[0] == '\0') {

		if (!feof(yyin)) {

			saw_error = B_TRUE;

			(void) fprintf(stderr, gettext("%s, token expected\n"),

			    s);

		}

		return;

	}

	saw_error = B_TRUE;

	if (cmd_file_mode)

		(void) fprintf(stderr, gettext("%s on line %d at '%s'\n"), s,

		    lex_lineno, (yytext[0] == '\n') ? "\\n" : yytext);

	else

		(void) fprintf(stderr, gettext("%s at '%s'\n"), s,

		    (yytext[0] == '\n') ? "\\n" : yytext);

	usage(B_FALSE, HELP_SUBCMDS);

}