%{
/*
 * 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.
 */


#include <libintl.h>

#include "svccfg.h"

extern int yylex(void);

uu_list_pool_t *string_pool;

%}

%union {
	int tok;
	char *str;
	uu_list_t *uul;
}

%start commands

%token SCC_VALIDATE SCC_IMPORT SCC_EXPORT SCC_ARCHIVE SCC_APPLY SCC_EXTRACT
%token SCC_CLEANUP
%token SCC_REPOSITORY SCC_INVENTORY SCC_SET SCC_END SCC_HELP SCC_RESTORE
%token SCC_LIST SCC_ADD SCC_DELETE SCC_SELECT SCC_UNSELECT
%token SCC_LISTPG SCC_ADDPG SCC_DELPG SCC_DELHASH
%token SCC_LISTPROP SCC_SETPROP SCC_DELPROP SCC_EDITPROP
%token SCC_DESCRIBE
%token SCC_ADDPROPVALUE SCC_DELPROPVALUE SCC_SETENV SCC_UNSETENV
%token SCC_LISTSNAP SCC_SELECTSNAP SCC_REVERT SCC_REFRESH
%token SCS_REDIRECT SCS_NEWLINE SCS_EQUALS SCS_LPAREN SCS_RPAREN
%token SCV_WORD SCV_STRING
%token SCC_DELNOTIFY SCC_SETNOTIFY SCC_LISTNOTIFY

%type <tok> command_token
%type <str> SCV_WORD SCV_STRING
%type <str> string opt_word
%type <uul> string_list multiline_string_list

%%

/*
 * We could hoist the command terminator for all the rules up here, but then
 * the parser would reduce before shifting the terminator, which would require
 * an additional error rule (per command) to catch extra arguments.
 * This way requires all input to be terminated, which is done by input() in
 * svccfg.l.
 */

commands : command
	| commands command

command : terminator
	| validate_cmd
	| import_cmd
	| cleanup_cmd
	| export_cmd
	| archive_cmd
	| restore_cmd
	| apply_cmd
	| extract_cmd
	| repository_cmd
	| inventory_cmd
	| set_cmd
	| end_cmd
	| help_cmd
	| list_cmd
	| add_cmd
	| delete_cmd
	| select_cmd
	| unselect_cmd
	| listpg_cmd
	| addpg_cmd
	| delpg_cmd
	| delhash_cmd
	| listprop_cmd
	| setprop_cmd
	| delprop_cmd
	| editprop_cmd
	| describe_cmd
	| addpropvalue_cmd
	| delpropvalue_cmd
	| setenv_cmd
	| unsetenv_cmd
	| listsnap_cmd
	| selectsnap_cmd
	| revert_cmd
	| refresh_cmd
	| unknown_cmd
	| delnotify_cmd
	| listnotify_cmd
	| setnotify_cmd
	| error terminator	{ semerr(gettext("Syntax error.\n")); }

unknown_cmd : SCV_WORD terminator
	{
		semerr(gettext("Unknown command \"%s\".\n"), $1);
		free($1);
	}
	| SCV_WORD string_list terminator
	{
		string_list_t *slp;
		void *cookie = NULL;

		semerr(gettext("Unknown command \"%s\".\n"), $1);

		while ((slp = uu_list_teardown($2, &cookie)) != NULL) {
			free(slp->str);
			free(slp);
		}

		uu_list_destroy($2);
		free($1);
	}

validate_cmd : SCC_VALIDATE SCV_WORD terminator
	{
		lscf_validate($2);
		free($2);
	}
	| SCC_VALIDATE terminator { lscf_validate_fmri(NULL); }
	| SCC_VALIDATE error terminator	{ synerr(SCC_VALIDATE); return(0); }

import_cmd : SCC_IMPORT string_list terminator
	{
		string_list_t *slp;
		void *cookie = NULL;

		if (engine_import($2) == -2) {
			synerr(SCC_IMPORT);
			return(0);
		}

		while ((slp = uu_list_teardown($2, &cookie)) != NULL) {
			free(slp->str);
			free(slp);
		}

		uu_list_destroy($2);
	}
	| SCC_IMPORT error terminator	{ synerr(SCC_IMPORT); return(0); }

cleanup_cmd : SCC_CLEANUP terminator
	{
		engine_cleanup(0);
	}
	| SCC_CLEANUP SCV_WORD terminator
	{
		if (strcmp($2, "-a") == 0) {
			engine_cleanup(1);
			free($2);
		} else {
			synerr(SCC_CLEANUP);
			free($2);
			return (0);
		}
	}
	| SCC_CLEANUP error terminator { synerr(SCC_CLEANUP); return(0); }


export_cmd : SCC_EXPORT SCV_WORD terminator
	{
		lscf_service_export($2, NULL, 0);
		free($2);
	}
	| SCC_EXPORT SCV_WORD SCS_REDIRECT SCV_WORD terminator
	{
		lscf_service_export($2, $4, 0);
		free($2);
		free($4);
	}
	| SCC_EXPORT SCV_WORD SCV_WORD terminator
	{
		if (strcmp($2, "-a") == 0) {
			lscf_service_export($3, NULL, SCE_ALL_VALUES);
			free($2);
			free($3);
		} else {
			synerr(SCC_EXPORT);
			free($2);
			free($3);
			return (0);
		}
	}
	| SCC_EXPORT SCV_WORD SCV_WORD SCS_REDIRECT SCV_WORD terminator
	{
		if (strcmp($2, "-a") == 0) {
			lscf_service_export($3, $5, SCE_ALL_VALUES);
			free($2);
			free($3);
			free($5);
		} else {
			synerr(SCC_EXPORT);
			free($2);
			free($3);
			free($5);
			return (0);
		}
	}
	| SCC_EXPORT error terminator	{ synerr(SCC_EXPORT); return(0); }

archive_cmd : SCC_ARCHIVE terminator
	{
		lscf_archive(NULL, 0);
	}
	| SCC_ARCHIVE SCV_WORD terminator
	{
		if (strcmp($2, "-a") == 0) {
			lscf_archive(NULL, SCE_ALL_VALUES);
			free($2);
		} else {
			synerr(SCC_ARCHIVE);
			free($2);
			return (0);
		}
	}
	| SCC_ARCHIVE SCS_REDIRECT SCV_WORD terminator
	{
		lscf_archive($3, 0);
		free($3);
	}
	| SCC_ARCHIVE SCV_WORD SCS_REDIRECT SCV_WORD terminator
	{
		if (strcmp($2, "-a") == 0) {
			lscf_archive($4, SCE_ALL_VALUES);
			free($2);
			free($4);
		} else {
			synerr(SCC_ARCHIVE);
			free($2);
			free($4);
			return (0);
		}
	}
	| SCC_ARCHIVE error terminator	{ synerr(SCC_ARCHIVE); return(0); }

restore_cmd : SCC_RESTORE SCV_WORD terminator
	{
		(void) engine_restore($2);
		free($2);
	}
	| SCC_RESTORE error terminator	{ synerr(SCC_RESTORE); return(0); }

apply_cmd : SCC_APPLY SCV_WORD terminator
	{
		if (engine_apply($2, 1) == -1) {
			if ((est->sc_cmd_flags & (SC_CMD_IACTIVE|SC_CMD_DONT_EXIT)) == 0)
				exit(1);

			free($2);
			return (0);
		}

		free($2);
	}
	| SCC_APPLY SCV_WORD SCV_WORD terminator
	{
		if (strcmp($2, "-n") == 0) {
			(void) engine_apply($3, 0);
			free($2);
			free($3);
		} else {
			synerr(SCC_APPLY);
			free($2);
			free($3);
			return (0);
		}
	}
	| SCC_APPLY error terminator	{ synerr(SCC_APPLY); return(0); }

extract_cmd: SCC_EXTRACT terminator	{ lscf_profile_extract(NULL); }
	| SCC_EXTRACT SCS_REDIRECT SCV_WORD terminator
	{
		lscf_profile_extract($3);
		free($3);
	}
	| SCC_EXTRACT error terminator	{ synerr(SCC_EXTRACT); return(0); }

repository_cmd: SCC_REPOSITORY SCV_WORD terminator
	{
		if (strcmp($2, "-f") == 0) {
			synerr(SCC_REPOSITORY);
			return(0);
		}
		lscf_set_repository($2, 0);
		free($2);
	}
	| SCC_REPOSITORY SCV_WORD SCV_WORD terminator
	{
		if (strcmp($2, "-f") == 0) {
			lscf_set_repository($3, 1);
			free($2);
			free($3);
		} else {
			synerr(SCC_REPOSITORY);
			return(0);
		}
	}
	| SCC_REPOSITORY error terminator   { synerr(SCC_REPOSITORY); return(0); }

inventory_cmd : SCC_INVENTORY SCV_WORD terminator
					{ lxml_inventory($2); free($2); }
	| SCC_INVENTORY error terminator	{ synerr(SCC_INVENTORY); return(0); }

set_cmd : SCC_SET string_list terminator
	{
		string_list_t *slp;
		void *cookie = NULL;

		(void) engine_set($2);

		while ((slp = uu_list_teardown($2, &cookie)) != NULL) {
			free(slp->str);
			free(slp);
		}

		uu_list_destroy($2);
	}
	| SCC_SET error terminator		{ synerr(SCC_SET); return(0); }

end_cmd : SCC_END terminator			{ exit(0); }
	| SCC_END error terminator		{ synerr (SCC_END); return(0); }

help_cmd : SCC_HELP terminator			{ help(0); }
	| SCC_HELP command_token terminator	{ help($2); }
	| SCC_HELP error terminator		{ synerr(SCC_HELP); return(0); }

list_cmd : SCC_LIST opt_word terminator	{ lscf_list($2); free($2); }
	| SCC_LIST error terminator	{ synerr(SCC_LIST); return(0); }

add_cmd : SCC_ADD SCV_WORD terminator	{ lscf_add($2); free($2); }
	| SCC_ADD error terminator	{ synerr(SCC_ADD); return(0); }

delete_cmd : SCC_DELETE SCV_WORD terminator
					{ lscf_delete($2, 0); free($2); }
	| SCC_DELETE SCV_WORD SCV_WORD terminator
	{
		if (strcmp($2, "-f") == 0) {
			lscf_delete($3, 1);
			free($2);
			free($3);
		} else {
			synerr(SCC_DELETE);
			free($2);
			free($3);
			return(0);
		}
	}
	| SCC_DELETE error terminator	{ synerr(SCC_DELETE); return(0); }

select_cmd : SCC_SELECT SCV_WORD terminator	{ lscf_select($2); free($2); }
	| SCC_SELECT error terminator	{ synerr(SCC_SELECT); return(0) ;}

unselect_cmd : SCC_UNSELECT terminator	{ lscf_unselect(); }
	| SCC_UNSELECT error terminator	{ synerr(SCC_UNSELECT); return(0); }

listpg_cmd : SCC_LISTPG opt_word terminator
					{ lscf_listpg($2); free($2); }
	| SCC_LISTPG error terminator	{ synerr(SCC_LISTPG); return(0); }

addpg_cmd : SCC_ADDPG SCV_WORD SCV_WORD opt_word terminator
	{
		(void) lscf_addpg($2, $3, $4);
		free($2);
		free($3);
		free($4);
	}
	| SCC_ADDPG error terminator	{ synerr(SCC_ADDPG); return(0); }

delpg_cmd : SCC_DELPG SCV_WORD terminator
					{ lscf_delpg($2); free($2); }
	| SCC_DELPG error terminator	{ synerr(SCC_DELPG); return(0); }

delhash_cmd : SCC_DELHASH SCV_WORD terminator
	{
		lscf_delhash($2, 0); free($2);
	}
	| SCC_DELHASH SCV_WORD SCV_WORD terminator
	{
		if (strcmp($2, "-d") == 0) {
			lscf_delhash($3, 1);
			free($2);
			free($3);
		} else {
			synerr(SCC_DELHASH);
			free($2);
			free($3);
			return(0);
		}
	}
	| SCC_DELHASH error terminator	{ synerr(SCC_DELHASH); return(0); }

listprop_cmd : SCC_LISTPROP opt_word terminator
					{ lscf_listprop($2); free($2); }
	| SCC_LISTPROP error terminator	{ synerr(SCC_LISTPROP); return(0); }

setprop_cmd : SCC_SETPROP SCV_WORD SCS_EQUALS string terminator
	{
		lscf_setprop($2, NULL, $4, NULL);
		free($2);
		free($4);
	}
	| SCC_SETPROP SCV_WORD SCS_EQUALS SCV_WORD string terminator
	{
		(void) lscf_setprop($2, $4, $5, NULL);
		free($2);
		free($4);
		free($5);
	}
	| SCC_SETPROP SCV_WORD SCS_EQUALS opt_word SCS_LPAREN
	      multiline_string_list SCS_RPAREN terminator
	{
		string_list_t *slp;
		void *cookie = NULL;

		(void) lscf_setprop($2, $4, NULL, $6);

		free($2);
		free($4);

		while ((slp = uu_list_teardown($6, &cookie)) != NULL) {
			free(slp->str);
			free(slp);
		}

		uu_list_destroy($6);
	}
	| SCC_SETPROP error terminator	{ synerr(SCC_SETPROP); return(0); }
	| SCC_SETPROP error		{ synerr(SCC_SETPROP); return(0); }

delprop_cmd : SCC_DELPROP SCV_WORD terminator
					{ lscf_delprop($2); free($2); }
	| SCC_DELPROP error terminator	{ synerr(SCC_DELPROP); return(0); }

editprop_cmd : SCC_EDITPROP terminator	{ lscf_editprop(); }
	| SCC_EDITPROP error terminator	{ synerr(SCC_EDITPROP); return(0); }

describe_cmd : SCC_DESCRIBE string_list terminator
	{
		string_list_t *slp;
		void *cookie = NULL;

		if (lscf_describe($2, 1) == -2) {
			synerr(SCC_DESCRIBE);
			return(0);
		}

		while ((slp = uu_list_teardown($2, &cookie)) != NULL) {
			free(slp->str);
			free(slp);
		}

		uu_list_destroy($2);
	}
	| SCC_DESCRIBE terminator { lscf_describe(NULL, 0); }
	| SCC_DESCRIBE error terminator	 { synerr(SCC_DESCRIBE); return(0); }

addpropvalue_cmd : SCC_ADDPROPVALUE SCV_WORD string terminator
	{
		lscf_addpropvalue($2, NULL, $3);
		free($2);
		free($3);
	}
	| SCC_ADDPROPVALUE SCV_WORD string string terminator
	{
		(void) lscf_addpropvalue($2, $3, $4);
		free($2);
		free($3);
		free($4);
	}
	| SCC_ADDPROPVALUE error terminator { synerr(SCC_ADDPROPVALUE); return(0); }

delpropvalue_cmd : SCC_DELPROPVALUE SCV_WORD string terminator
	{
		lscf_delpropvalue($2, $3, 0);
		free($2);
		free($3);
	}
	| SCC_DELPROPVALUE error terminator { synerr(SCC_DELPROPVALUE); return(0); }

setenv_cmd : SCC_SETENV string_list terminator
	{
		string_list_t *slp;
		void *cookie = NULL;

		if (lscf_setenv($2, 0) == -2) {
			synerr(SCC_SETENV);
			return(0);
		}

		while ((slp = uu_list_teardown($2, &cookie)) != NULL) {
			free(slp->str);
			free(slp);
		}

		uu_list_destroy($2);
	}
	| SCC_SETENV error terminator		{ synerr(SCC_SETENV); return(0); }

unsetenv_cmd : SCC_UNSETENV string_list terminator
	{
		string_list_t *slp;
		void *cookie = NULL;

		if (lscf_setenv($2, 1) == -2) {
			synerr(SCC_UNSETENV);
			return(0);
		}

		while ((slp = uu_list_teardown($2, &cookie)) != NULL) {
			free(slp->str);
			free(slp);
		}

		uu_list_destroy($2);
	}
	| SCC_UNSETENV error terminator	{ synerr(SCC_UNSETENV); return(0); }

listsnap_cmd : SCC_LISTSNAP terminator	{ lscf_listsnap(); }
	| SCC_LISTSNAP error terminator	{ synerr(SCC_LISTSNAP); return(0); }

selectsnap_cmd : SCC_SELECTSNAP opt_word terminator
					{ lscf_selectsnap($2); free($2); }
	| SCC_SELECTSNAP error terminator
					{ synerr(SCC_SELECTSNAP); return(0); }

revert_cmd: SCC_REVERT opt_word terminator	{ lscf_revert($2); free ($2); }
	| SCC_REVERT error terminator		{ synerr(SCC_REVERT); return(0); }

refresh_cmd: SCC_REFRESH terminator	{ lscf_refresh(); }
	| SCC_REFRESH error terminator	{ synerr(SCC_REFRESH); return(0); }

delnotify_cmd : SCC_DELNOTIFY SCV_WORD terminator
	{
		lscf_delnotify($2, 0);
		free($2);
	}
	| SCC_DELNOTIFY SCV_WORD SCV_WORD terminator
	{
		if (strcmp($2, "-g") == 0) {
			lscf_delnotify($3, 1);
			free($2);
			free($3);
		} else {
			synerr(SCC_DELNOTIFY);
			free($2);
			free($3);
			return(0);
		}
	}
	| SCC_DELNOTIFY error terminator { synerr(SCC_DELNOTIFY); return(0); }

listnotify_cmd : SCC_LISTNOTIFY terminator
	{
		lscf_listnotify("all", 0);
	}
	| SCC_LISTNOTIFY SCV_WORD terminator
	{
		if (strcmp($2, "-g") == 0) {
			lscf_listnotify("all", 1);
		} else {
			lscf_listnotify($2, 0);
		}
		free($2);
	}
	| SCC_LISTNOTIFY SCV_WORD SCV_WORD terminator
	{
		if (strcmp($2, "-g") == 0) {
			lscf_listnotify($3, 1);
			free($2);
			free($3);
		} else {
			synerr(SCC_LISTNOTIFY);
			free($2);
			free($3);
			return(0);
		}
	}
	| SCC_LISTNOTIFY error terminator { synerr(SCC_LISTNOTIFY); return(0); }

setnotify_cmd : SCC_SETNOTIFY string_list terminator
	{
		string_list_t *slp;
		void *cookie = NULL;

		if (lscf_setnotify($2) == -2)
			synerr(SCC_SETNOTIFY);

		while ((slp = uu_list_teardown($2, &cookie)) != NULL) {
			free(slp->str);
			free(slp);
		}

		uu_list_destroy($2);
	}
	| SCC_SETNOTIFY error terminator { synerr(SCC_SETNOTIFY); return(0); }

terminator : SCS_NEWLINE

string_list :
	{
		$$ = uu_list_create(string_pool, NULL, 0);
		if ($$ == NULL)
			uu_die(gettext("Out of memory\n"));
	}
	| string_list string
	{
		string_list_t *slp;

		slp = safe_malloc(sizeof (*slp));

		slp->str = $2;
		uu_list_node_init(slp, &slp->node, string_pool);
		uu_list_append($1, slp);
		$$ = $1;
	}

multiline_string_list : string_list
	{
		$$ = $1;
	}
	| multiline_string_list SCS_NEWLINE string_list
	{
		void *cookie = NULL;
		string_list_t *slp;

		/* Append $3 to $1. */
		while ((slp = uu_list_teardown($3, &cookie)) != NULL)
			uu_list_append($1, slp);

		uu_list_destroy($3);
	}

string : SCV_WORD	{ $$ = $1; }
	| SCV_STRING	{ $$ = $1; }

opt_word :		{ $$ = NULL; }
	| SCV_WORD	{ $$ = $1; }

command_token : SCC_VALIDATE	{ $$ = SCC_VALIDATE; }
	| SCC_IMPORT		{ $$ = SCC_IMPORT; }
	| SCC_CLEANUP		{ $$ = SCC_CLEANUP; }
	| SCC_EXPORT		{ $$ = SCC_EXPORT; }
	| SCC_APPLY		{ $$ = SCC_APPLY; }
	| SCC_EXTRACT		{ $$ = SCC_EXTRACT; }
	| SCC_REPOSITORY	{ $$ = SCC_REPOSITORY; }
	| SCC_ARCHIVE		{ $$ = SCC_ARCHIVE; }
	| SCC_INVENTORY		{ $$ = SCC_INVENTORY; }
	| SCC_SET		{ $$ = SCC_SET; }
	| SCC_END		{ $$ = SCC_END; }
	| SCC_HELP		{ $$ = SCC_HELP; }
	| SCC_LIST		{ $$ = SCC_LIST; }
	| SCC_ADD		{ $$ = SCC_ADD; }
	| SCC_DELETE		{ $$ = SCC_DELETE; }
	| SCC_SELECT		{ $$ = SCC_SELECT; }
	| SCC_UNSELECT		{ $$ = SCC_UNSELECT; }
	| SCC_LISTPG		{ $$ = SCC_LISTPG; }
	| SCC_ADDPG		{ $$ = SCC_ADDPG; }
	| SCC_DELPG		{ $$ = SCC_DELPG; }
	| SCC_DELHASH		{ $$ = SCC_DELHASH; }
	| SCC_LISTPROP		{ $$ = SCC_LISTPROP; }
	| SCC_SETPROP		{ $$ = SCC_SETPROP; }
	| SCC_DELPROP		{ $$ = SCC_DELPROP; }
	| SCC_EDITPROP		{ $$ = SCC_EDITPROP; }
	| SCC_ADDPROPVALUE	{ $$ = SCC_ADDPROPVALUE; }
	| SCC_DELPROPVALUE	{ $$ = SCC_DELPROPVALUE; }
	| SCC_SETENV		{ $$ = SCC_SETENV; }
	| SCC_UNSETENV		{ $$ = SCC_UNSETENV; }
	| SCC_LISTSNAP		{ $$ = SCC_LISTSNAP; }
	| SCC_SELECTSNAP	{ $$ = SCC_SELECTSNAP; }
	| SCC_REVERT		{ $$ = SCC_REVERT; }
	| SCC_REFRESH		{ $$ = SCC_REFRESH; }
	| SCC_DESCRIBE		{ $$ = SCC_DESCRIBE; }
	| SCC_DELNOTIFY		{ $$ = SCC_DELNOTIFY; }
	| SCC_LISTNOTIFY	{ $$ = SCC_LISTNOTIFY; }
	| SCC_SETNOTIFY		{ $$ = SCC_SETNOTIFY; }