# line 2 "zonecfg_grammar.y" /* * 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) 2003, 2010, Oracle and/or its affiliates. All rights reserved. */ /* * This file defines zonecfg(1M)'s grammar. * * Reduction rules that consume TOKENs must invoke claim_token() immediately * before freeing the TOKENs or adding them to data structures (e.g., cmd) that * will be cleaned up when the parser finishes or encounters errors. */ #include #include #include "zonecfg.h" static cmd_t *cmd = NULL; /* Command being processed */ static complex_property_ptr_t complex = NULL; static list_property_ptr_t new_list = NULL, tmp_list, last, list[MAX_EQ_PROP_PAIRS]; static property_value_t property[MAX_EQ_PROP_PAIRS]; extern boolean_t newline_terminated; extern int num_prop_vals; /* # of property values */ /* yacc externals */ extern int yydebug; extern void yyerror(char *s); /* * This function is used by the simple_prop_val reduction rules to set up * a list_property_ptr_t and adjust the above global variables appropriately. * Note that this function duplicates the specified string and makes * the new list's lp_simple field point to the duplicate. This function does * not free the original string. * * This function returns a pointer to the duplicated string or NULL if an error * occurred. The simple_prop_val reduction rules that invoke this function * should set $$ to the returned pointer. */ static char * simple_prop_val_func(const char *str) { char *retstr; if ((new_list = alloc_list()) == NULL) return (NULL); if ((retstr = strdup(str)) == NULL) { free_list(new_list); return (NULL); } new_list->lp_simple = retstr; new_list->lp_complex = NULL; new_list->lp_next = NULL; if (list[num_prop_vals] == NULL) { list[num_prop_vals] = new_list; } else { for (tmp_list = list[num_prop_vals]; tmp_list != NULL; tmp_list = tmp_list->lp_next) last = tmp_list; last->lp_next = new_list; } return (retstr); } /* * This function is used by the complex_piece reduction rules to set up a * complex_property_prt_t and adjust the above global variables appropriately. * Note that this function duplicates the specified string and makes the new * complex_property_ptr_t's cp_value field point to the duplicate. It also sets * the complex_property_ptr_t's cp_type field to cp_type and its cp_next field * to cp_next. This function does not free the original string. * * This function returns a pointer to the complex_property_t created for the * complex_piece or NULL if an error occurred. The complex_piece reduction * rules that invoke this function should set $$ to the returned pointer. */ static complex_property_ptr_t complex_piece_func(int cp_type, const char *str, complex_property_ptr_t cp_next) { complex_property_ptr_t retval; if ((retval = alloc_complex()) == NULL) return (NULL); if ((retval->cp_value = strdup(str)) == NULL) { free_complex(retval); return (NULL); } retval->cp_type = cp_type; retval->cp_next = cp_next; complex = retval; return (retval); } # line 121 "zonecfg_grammar.y" typedef union #ifdef __cplusplus YYSTYPE #endif { int ival; char *strval; cmd_t *cmd; complex_property_ptr_t complex; list_property_ptr_t list; } YYSTYPE; # define HELP 257 # define CREATE 258 # define EXPORT 259 # define ADD 260 # define DELETE 261 # define REMOVE 262 # define SELECT 263 # define SET 264 # define INFO 265 # define CANCEL 266 # define END 267 # define VERIFY 268 # define COMMIT 269 # define REVERT 270 # define EXIT 271 # define SEMICOLON 272 # define TOKEN 273 # define ZONENAME 274 # define ZONEPATH 275 # define AUTOBOOT 276 # define POOL 277 # define NET 278 # define FS 279 # define ATTR 280 # define DEVICE 281 # define RCTL 282 # define SPECIAL 283 # define RAW 284 # define DIR 285 # define OPTIONS 286 # define TYPE 287 # define ADDRESS 288 # define PHYSICAL 289 # define IPTYPE 290 # define HOSTID 291 # define FS_ALLOWED 292 # define ALLOWED_ADDRESS 293 # define NAME 294 # define MATCH 295 # define PRIV 296 # define LIMIT 297 # define ACTION 298 # define VALUE 299 # define EQUAL 300 # define OPEN_SQ_BRACKET 301 # define CLOSE_SQ_BRACKET 302 # define OPEN_PAREN 303 # define CLOSE_PAREN 304 # define COMMA 305 # define DATASET 306 # define LIMITPRIV 307 # define BOOTARGS 308 # define BRAND 309 # define PSET 310 # define PCAP 311 # define MCAP 312 # define NCPUS 313 # define IMPORTANCE 314 # define SHARES 315 # define MAXLWPS 316 # define MAXSHMMEM 317 # define MAXSHMIDS 318 # define MAXMSGIDS 319 # define MAXSEMIDS 320 # define LOCKED 321 # define SWAP 322 # define SCHED 323 # define CLEAR 324 # define DEFROUTER 325 # define ADMIN 326 # define USER 327 # define AUTHS 328 # define MAXPROCS 329 #include #ifdef __STDC__ #include #include #define YYCONST const #else #include #include #define YYCONST #endif #include #if defined(__cplusplus) || defined(__STDC__) #if defined(__cplusplus) && defined(__EXTERN_C__) extern "C" { #endif #ifndef yyerror #if defined(__cplusplus) void yyerror(YYCONST char *); #endif #endif #ifndef yylex int yylex(void); #endif int yyparse(void); #if defined(__cplusplus) && defined(__EXTERN_C__) } #endif #endif #define yyclearin yychar = -1 #define yyerrok yyerrflag = 0 extern int yychar; extern int yyerrflag; YYSTYPE yylval; YYSTYPE yyval; typedef int yytabelem; #ifndef YYMAXDEPTH #define YYMAXDEPTH 150 #endif #if YYMAXDEPTH > 0 int yy_yys[YYMAXDEPTH], *yys = yy_yys; YYSTYPE yy_yyv[YYMAXDEPTH], *yyv = yy_yyv; #else /* user does initial allocation */ int *yys; YYSTYPE *yyv; #endif static int yymaxdepth = YYMAXDEPTH; # define YYERRCODE 256 # line 1140 "zonecfg_grammar.y" static YYCONST yytabelem yyexca[] ={ -1, 1, 0, -1, -2, 0, -1, 127, 256, 81, 10, 81, 59, 81, -2, 102, -1, 128, 256, 82, 10, 82, 59, 82, -2, 103, -1, 129, 256, 83, 10, 83, 59, 83, -2, 104, }; # define YYNPROD 163 # define YYLAST 789 static YYCONST yytabelem yyact[]={ 139, 60, 61, 62, 64, 45, 46, 49, 47, 48, 55, 56, 57, 59, 58, 67, 69, 63, 90, 93, 68, 71, 73, 74, 75, 76, 72, 185, 143, 184, 142, 183, 165, 50, 65, 66, 77, 51, 52, 53, 78, 81, 82, 83, 85, 86, 87, 88, 79, 80, 89, 169, 70, 54, 91, 92, 84, 139, 60, 61, 62, 64, 45, 46, 49, 47, 48, 55, 56, 57, 59, 58, 67, 69, 63, 90, 93, 68, 71, 73, 74, 75, 76, 72, 168, 167, 173, 142, 200, 199, 50, 65, 66, 77, 51, 52, 53, 78, 81, 82, 83, 85, 86, 87, 88, 79, 80, 89, 198, 70, 54, 91, 92, 84, 139, 60, 61, 62, 64, 45, 46, 49, 47, 48, 55, 56, 57, 59, 58, 67, 69, 63, 90, 93, 68, 71, 73, 74, 75, 76, 72, 152, 162, 188, 142, 187, 186, 50, 65, 66, 77, 51, 52, 53, 78, 81, 82, 83, 85, 86, 87, 88, 79, 80, 89, 166, 70, 54, 91, 92, 84, 139, 60, 61, 62, 64, 45, 46, 49, 47, 48, 55, 56, 57, 59, 58, 67, 69, 63, 90, 93, 68, 71, 73, 74, 75, 76, 72, 158, 164, 161, 142, 160, 159, 50, 65, 66, 77, 51, 52, 53, 78, 81, 82, 83, 85, 86, 87, 88, 79, 80, 89, 151, 70, 54, 91, 92, 84, 175, 60, 61, 62, 64, 45, 46, 49, 47, 48, 55, 56, 57, 59, 58, 67, 69, 63, 90, 93, 68, 71, 73, 74, 75, 76, 72, 145, 144, 133, 126, 102, 101, 50, 65, 66, 77, 51, 52, 53, 78, 81, 82, 83, 85, 86, 87, 88, 79, 80, 89, 100, 70, 54, 91, 92, 84, 123, 60, 61, 62, 64, 45, 46, 49, 47, 48, 55, 56, 57, 59, 58, 67, 69, 63, 90, 93, 68, 71, 73, 74, 75, 76, 72, 99, 98, 97, 96, 94, 155, 50, 65, 66, 77, 51, 52, 53, 78, 81, 82, 83, 85, 86, 87, 88, 79, 80, 89, 138, 70, 54, 91, 92, 84, 42, 60, 61, 62, 64, 45, 46, 49, 47, 48, 55, 56, 57, 59, 58, 67, 69, 63, 90, 93, 68, 71, 73, 74, 75, 76, 72, 20, 7, 19, 18, 17, 16, 50, 65, 66, 77, 51, 52, 53, 78, 81, 82, 83, 85, 86, 87, 88, 79, 80, 89, 15, 70, 54, 91, 92, 84, 132, 60, 61, 62, 64, 14, 13, 153, 12, 11, 55, 56, 57, 59, 58, 67, 69, 63, 90, 93, 68, 71, 73, 74, 75, 76, 72, 10, 8, 9, 6, 5, 2, 1, 65, 66, 77, 21, 135, 0, 78, 81, 82, 83, 85, 86, 87, 88, 79, 80, 89, 0, 70, 0, 91, 92, 84, 60, 61, 62, 64, 137, 0, 0, 0, 136, 55, 56, 57, 59, 58, 67, 69, 63, 90, 93, 68, 71, 73, 74, 75, 76, 72, 0, 21, 21, 22, 178, 179, 0, 65, 66, 77, 0, 0, 0, 78, 81, 82, 83, 85, 86, 87, 88, 79, 80, 89, 0, 70, 0, 91, 92, 84, 103, 105, 106, 108, 110, 45, 46, 49, 47, 48, 0, 4, 0, 0, 39, 41, 0, 109, 121, 122, 22, 22, 0, 0, 0, 0, 45, 46, 49, 47, 48, 0, 0, 50, 111, 112, 107, 51, 52, 53, 0, 0, 114, 115, 117, 118, 119, 120, 0, 0, 113, 149, 134, 54, 50, 0, 116, 0, 51, 52, 53, 45, 46, 49, 47, 48, 0, 140, 0, 0, 0, 0, 0, 0, 54, 0, 0, 163, 189, 190, 191, 141, 0, 0, 0, 170, 171, 172, 0, 50, 174, 43, 157, 127, 128, 129, 156, 0, 0, 0, 0, 104, 124, 0, 130, 44, 0, 95, 0, 54, 0, 157, 192, 193, 194, 156, 125, 157, 157, 131, 0, 156, 156, 0, 201, 202, 203, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 32, 26, 31, 23, 28, 34, 36, 37, 33, 24, 29, 38, 27, 35, 30, 146, 0, 0, 0, 0, 147, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 148, 0, 0, 0, 0, 0, 150, 0, 0, 0, 0, 40, 0, 0, 0, 0, 0, 0, 154, 0, 0, 0, 0, 0, 0, 0, 0, 0, 176, 0, 0, 0, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 177, 0, 0, 0, 180, 181, 182, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 154, 154, 154, 0, 0, 0, 0, 0, 0, 195, 196, 197 }; static YYCONST yytabelem yypact[]={ 426,-10000000, 473, 474,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, -10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, -10000000,-10000000,-10000000, 69, 43, 182, 42, 41, 40, 39, 6, -13, -14, 239, 12, -15, 295, 126, -16,-10000000, 474,-10000000,-10000000,-10000000, -273,-10000000,-10000000,-10000000,-10000000,-10000000, -10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, -10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, -10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, -10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, -10000000,-10000000,-10000000,-10000000,-10000000,-10000000, -17,-10000000,-10000000,-10000000, -10000000, -18,-10000000,-10000000, 182,-10000000,-10000000,-10000000,-10000000,-10000000, -10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, -10000000,-10000000,-10000000, 260, 182, -273,-10000000,-10000000,-10000000,-10000000, 182, -78, -134,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, -10000000,-10000000, 182, -102, -75,-10000000, -97,-10000000, -98,-10000000, -100, -159, -101, -272, -135, -217, -221, -254,-10000000, -273, -273, -273, -216,-10000000, -273,-10000000, -45,-10000000, -102, -102, 182, 182, 182,-10000000,-10000000, -274, -276, -278,-10000000,-10000000, -154, -155, -157, 182, 182, 182, -273, -273, -273,-10000000, -10000000,-10000000, 182, 182, 182, -192, -211, -212, -273, -273, -273,-10000000,-10000000,-10000000 }; static YYCONST yytabelem yypgo[]={ 0, 432, 437, 464, 406, 460, 579, 593, 431, 430, 429, 428, 427, 426, 408, 407, 405, 404, 393, 374, 373, 372, 371, 370, 369, 523, 336, 317 }; static YYCONST yytabelem yyr1[]={ 0, 1, 1, 1, 1, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 25, 25, 9, 9, 9, 9, 10, 10, 12, 12, 12, 12, 11, 11, 13, 13, 14, 14, 15, 15, 16, 16, 16, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 23, 23, 24, 24, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 2, 2, 3, 3, 3, 5, 4, 4, 4, 4, 4, 4, 27, 27, 27, 27, 26 }; static YYCONST yytabelem yyr2[]={ 0, 5, 7, 5, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 5, 5, 7, 3, 5, 3, 5, 7, 9, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 7, 3, 5, 3, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 11, 17, 23, 3, 5, 5, 7, 7, 11, 17, 23, 3, 5, 3, 5, 5, 5, 5, 11, 17, 23, 3, 11, 9, 11, 3, 5, 3, 5, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 7, 7, 7, 7, 11, 11, 11, 2, 2, 6, 6, 6 }; static YYCONST yytabelem yychk[]={ -10000000, -1, -8, 256, -25, -9, -10, -23, -12, -11, -13, -14, -15, -16, -17, -18, -19, -20, -21, -22, -24, 10, 59, 260, 266, 324, 258, 269, 261, 267, 271, 259, 257, 265, 262, 270, 263, 264, 268, -25, 256, -25, 273, -6, -7, 278, 279, 281, 282, 280, 306, 310, 311, 312, 326, 283, 284, 285, 287, 286, 274, 275, 276, 290, 277, 307, 308, 288, 293, 289, 325, 294, 299, 295, 296, 297, 298, 309, 313, 321, 322, 314, 315, 316, 329, 317, 318, 319, 320, 323, 291, 327, 328, 292, 273, -7, 273, 273, 273, 273, 273, 273, 273, 273, -6, 274, 275, 309, 276, 290, 277, 307, 308, 323, 315, 316, 329, 317, 318, 319, 320, 291, 292, 273, -6, -7, 273, 310, 311, 312, -6, -7, 273, 273, -25, -2, -3, -5, -26, 273, -6, -7, 303, 301, 273, 273, -7, -6, -7, -2, -7, 300, 275, -4, -7, -27, -3, -5, 273, 300, 300, 300, 301, -2, 300, 304, 300, 302, 305, 305, -2, -2, -2, 302, -2, 273, -6, -7, -27, -27, -7, -7, -7, 305, 305, 305, 300, 300, 300, -4, -4, -4, -2, -2, -2, -7, -7, -7, 300, 300, 300, -2, -2, -2 }; static YYCONST yytabelem yydef[]={ 0, -2, 0, 0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 27, 92, 29, 33, 35, 37, 39, 41, 44, 46, 70, 78, 80, 88, 94, 1, 0, 3, 24, 25, 0, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 28, 93, 30, 34, 36, 38, 40, 42, 45, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 71, 72, 0, 79, -2, -2, -2, 84, 0, 0, 95, 2, 26, 145, 146, 147, 148, 149, 150, 0, 0, 31, 43, 0, 73, 0, 74, 0, 0, 0, 0, 0, 0, 158, 159, 32, 0, 0, 0, 0, 90, 0, 151, 0, 162, 0, 0, 67, 75, 85, 89, 91, 152, 153, 154, 160, 161, 0, 0, 0, 0, 0, 0, 0, 0, 0, 155, 156, 157, 68, 76, 86, 0, 0, 0, 0, 0, 0, 69, 77, 87 }; typedef struct #ifdef __cplusplus yytoktype #endif { #ifdef __cplusplus const #endif char *t_name; int t_val; } yytoktype; #ifndef YYDEBUG # define YYDEBUG 0 /* don't allow debugging */ #endif #if YYDEBUG yytoktype yytoks[] = { "HELP", 257, "CREATE", 258, "EXPORT", 259, "ADD", 260, "DELETE", 261, "REMOVE", 262, "SELECT", 263, "SET", 264, "INFO", 265, "CANCEL", 266, "END", 267, "VERIFY", 268, "COMMIT", 269, "REVERT", 270, "EXIT", 271, "SEMICOLON", 272, "TOKEN", 273, "ZONENAME", 274, "ZONEPATH", 275, "AUTOBOOT", 276, "POOL", 277, "NET", 278, "FS", 279, "ATTR", 280, "DEVICE", 281, "RCTL", 282, "SPECIAL", 283, "RAW", 284, "DIR", 285, "OPTIONS", 286, "TYPE", 287, "ADDRESS", 288, "PHYSICAL", 289, "IPTYPE", 290, "HOSTID", 291, "FS_ALLOWED", 292, "ALLOWED_ADDRESS", 293, "NAME", 294, "MATCH", 295, "PRIV", 296, "LIMIT", 297, "ACTION", 298, "VALUE", 299, "EQUAL", 300, "OPEN_SQ_BRACKET", 301, "CLOSE_SQ_BRACKET", 302, "OPEN_PAREN", 303, "CLOSE_PAREN", 304, "COMMA", 305, "DATASET", 306, "LIMITPRIV", 307, "BOOTARGS", 308, "BRAND", 309, "PSET", 310, "PCAP", 311, "MCAP", 312, "NCPUS", 313, "IMPORTANCE", 314, "SHARES", 315, "MAXLWPS", 316, "MAXSHMMEM", 317, "MAXSHMIDS", 318, "MAXMSGIDS", 319, "MAXSEMIDS", 320, "LOCKED", 321, "SWAP", 322, "SCHED", 323, "CLEAR", 324, "DEFROUTER", 325, "ADMIN", 326, "USER", 327, "AUTHS", 328, "MAXPROCS", 329, "-unknown-", -1 /* ends search */ }; #ifdef __cplusplus const #endif char * yyreds[] = { "-no such reduction-", "commands : command terminator", "commands : command error terminator", "commands : error terminator", "commands : terminator", "command : add_command", "command : cancel_command", "command : clear_command", "command : create_command", "command : commit_command", "command : delete_command", "command : end_command", "command : exit_command", "command : export_command", "command : help_command", "command : info_command", "command : remove_command", "command : revert_command", "command : select_command", "command : set_command", "command : verify_command", "terminator : '\n'", "terminator : ';'", "add_command : ADD", "add_command : ADD TOKEN", "add_command : ADD resource_type", "add_command : ADD property_name property_value", "cancel_command : CANCEL", "cancel_command : CANCEL TOKEN", "create_command : CREATE", "create_command : CREATE TOKEN", "create_command : CREATE TOKEN TOKEN", "create_command : CREATE TOKEN TOKEN TOKEN", "commit_command : COMMIT", "commit_command : COMMIT TOKEN", "delete_command : DELETE", "delete_command : DELETE TOKEN", "end_command : END", "end_command : END TOKEN", "exit_command : EXIT", "exit_command : EXIT TOKEN", "export_command : EXPORT", "export_command : EXPORT TOKEN", "export_command : EXPORT TOKEN TOKEN", "help_command : HELP", "help_command : HELP TOKEN", "info_command : INFO", "info_command : INFO TOKEN", "info_command : INFO resource_type", "info_command : INFO ZONENAME", "info_command : INFO ZONEPATH", "info_command : INFO BRAND", "info_command : INFO AUTOBOOT", "info_command : INFO IPTYPE", "info_command : INFO POOL", "info_command : INFO LIMITPRIV", "info_command : INFO BOOTARGS", "info_command : INFO SCHED", "info_command : INFO SHARES", "info_command : INFO MAXLWPS", "info_command : INFO MAXPROCS", "info_command : INFO MAXSHMMEM", "info_command : INFO MAXSHMIDS", "info_command : INFO MAXMSGIDS", "info_command : INFO MAXSEMIDS", "info_command : INFO HOSTID", "info_command : INFO FS_ALLOWED", "info_command : INFO resource_type property_name EQUAL property_value", "info_command : INFO resource_type property_name EQUAL property_value property_name EQUAL property_value", "info_command : INFO resource_type property_name EQUAL property_value property_name EQUAL property_value property_name EQUAL property_value", "remove_command : REMOVE", "remove_command : REMOVE TOKEN", "remove_command : REMOVE resource_type", "remove_command : REMOVE TOKEN resource_type", "remove_command : REMOVE property_name property_value", "remove_command : REMOVE resource_type property_name EQUAL property_value", "remove_command : REMOVE resource_type property_name EQUAL property_value property_name EQUAL property_value", "remove_command : REMOVE resource_type property_name EQUAL property_value property_name EQUAL property_value property_name EQUAL property_value", "revert_command : REVERT", "revert_command : REVERT TOKEN", "select_command : SELECT", "select_command : SELECT PSET", "select_command : SELECT PCAP", "select_command : SELECT MCAP", "select_command : SELECT resource_type", "select_command : SELECT resource_type property_name EQUAL property_value", "select_command : SELECT resource_type property_name EQUAL property_value property_name EQUAL property_value", "select_command : SELECT resource_type property_name EQUAL property_value property_name EQUAL property_value property_name EQUAL property_value", "set_command : SET", "set_command : SET property_name EQUAL OPEN_SQ_BRACKET CLOSE_SQ_BRACKET", "set_command : SET property_name EQUAL property_value", "set_command : SET TOKEN ZONEPATH EQUAL property_value", "clear_command : CLEAR", "clear_command : CLEAR property_name", "verify_command : VERIFY", "verify_command : VERIFY TOKEN", "resource_type : NET", "resource_type : FS", "resource_type : DEVICE", "resource_type : RCTL", "resource_type : ATTR", "resource_type : DATASET", "resource_type : PSET", "resource_type : PCAP", "resource_type : MCAP", "resource_type : ADMIN", "property_name : SPECIAL", "property_name : RAW", "property_name : DIR", "property_name : TYPE", "property_name : OPTIONS", "property_name : ZONENAME", "property_name : ZONEPATH", "property_name : AUTOBOOT", "property_name : IPTYPE", "property_name : POOL", "property_name : LIMITPRIV", "property_name : BOOTARGS", "property_name : ADDRESS", "property_name : ALLOWED_ADDRESS", "property_name : PHYSICAL", "property_name : DEFROUTER", "property_name : NAME", "property_name : VALUE", "property_name : MATCH", "property_name : PRIV", "property_name : LIMIT", "property_name : ACTION", "property_name : BRAND", "property_name : NCPUS", "property_name : LOCKED", "property_name : SWAP", "property_name : IMPORTANCE", "property_name : SHARES", "property_name : MAXLWPS", "property_name : MAXPROCS", "property_name : MAXSHMMEM", "property_name : MAXSHMIDS", "property_name : MAXMSGIDS", "property_name : MAXSEMIDS", "property_name : SCHED", "property_name : HOSTID", "property_name : USER", "property_name : AUTHS", "property_name : FS_ALLOWED", "property_value : simple_prop_val", "property_value : complex_prop_val", "property_value : list_prop_val", "simple_prop_val : TOKEN", "simple_prop_val : resource_type", "simple_prop_val : property_name", "complex_prop_val : OPEN_PAREN complex_piece CLOSE_PAREN", "complex_piece : property_name EQUAL TOKEN", "complex_piece : property_name EQUAL resource_type", "complex_piece : property_name EQUAL property_name", "complex_piece : property_name EQUAL TOKEN COMMA complex_piece", "complex_piece : property_name EQUAL resource_type COMMA complex_piece", "complex_piece : property_name EQUAL property_name COMMA complex_piece", "list_piece : simple_prop_val", "list_piece : complex_prop_val", "list_piece : simple_prop_val COMMA list_piece", "list_piece : complex_prop_val COMMA list_piece", "list_prop_val : OPEN_SQ_BRACKET list_piece CLOSE_SQ_BRACKET", }; #endif /* YYDEBUG */ # line 1 "/usr/share/lib/ccs/yaccpar" /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (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 1993 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* Copyright (c) 1988 AT&T */ /* All Rights Reserved */ #pragma ident "%Z%%M% %I% %E% SMI" /* ** Skeleton parser driver for yacc output */ /* ** yacc user known macros and defines */ #define YYERROR goto yyerrlab #define YYACCEPT return(0) #define YYABORT return(1) #define YYBACKUP( newtoken, newvalue )\ {\ if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\ {\ yyerror( "syntax error - cannot backup" );\ goto yyerrlab;\ }\ yychar = newtoken;\ yystate = *yyps;\ yylval = newvalue;\ goto yynewstate;\ } #define YYRECOVERING() (!!yyerrflag) #define YYNEW(type) malloc(sizeof(type) * yynewmax) #define YYCOPY(to, from, type) \ (type *) memcpy(to, (char *) from, yymaxdepth * sizeof (type)) #define YYENLARGE( from, type) \ (type *) realloc((char *) from, yynewmax * sizeof(type)) #ifndef YYDEBUG # define YYDEBUG 1 /* make debugging available */ #endif /* ** user known globals */ int yydebug; /* set to 1 to get debugging */ /* ** driver internal defines */ #define YYFLAG (-10000000) /* ** global variables used by the parser */ YYSTYPE *yypv; /* top of value stack */ int *yyps; /* top of state stack */ int yystate; /* current state */ int yytmp; /* extra var (lasts between blocks) */ int yynerrs; /* number of errors */ int yyerrflag; /* error recovery flag */ int yychar; /* current input token number */ #ifdef YYNMBCHARS #define YYLEX() yycvtok(yylex()) /* ** yycvtok - return a token if i is a wchar_t value that exceeds 255. ** If i<255, i itself is the token. If i>255 but the neither ** of the 30th or 31st bit is on, i is already a token. */ #if defined(__STDC__) || defined(__cplusplus) int yycvtok(int i) #else int yycvtok(i) int i; #endif { int first = 0; int last = YYNMBCHARS - 1; int mid; wchar_t j; if(i&0x60000000){/*Must convert to a token. */ if( yymbchars[last].character < i ){ return i;/*Giving up*/ } while ((last>=first)&&(first>=0)) {/*Binary search loop*/ mid = (first+last)/2; j = yymbchars[mid].character; if( j==i ){/*Found*/ return yymbchars[mid].tvalue; }else if( j= 0; yy_i++ ) { if ( yytoks[yy_i].t_val == yychar ) break; } printf( "%s\n", yytoks[yy_i].t_name ); } } #endif /* YYDEBUG */ if ( ++yy_ps >= &yys[ yymaxdepth ] ) /* room on stack? */ { /* ** reallocate and recover. Note that pointers ** have to be reset, or bad things will happen */ long yyps_index = (yy_ps - yys); long yypv_index = (yy_pv - yyv); long yypvt_index = (yypvt - yyv); int yynewmax; #ifdef YYEXPAND yynewmax = YYEXPAND(yymaxdepth); #else yynewmax = 2 * yymaxdepth; /* double table size */ if (yymaxdepth == YYMAXDEPTH) /* first time growth */ { char *newyys = (char *)YYNEW(int); char *newyyv = (char *)YYNEW(YYSTYPE); if (newyys != 0 && newyyv != 0) { yys = YYCOPY(newyys, yys, int); yyv = YYCOPY(newyyv, yyv, YYSTYPE); } else yynewmax = 0; /* failed */ } else /* not first time */ { yys = YYENLARGE(yys, int); yyv = YYENLARGE(yyv, YYSTYPE); if (yys == 0 || yyv == 0) yynewmax = 0; /* failed */ } #endif if (yynewmax <= yymaxdepth) /* tables not expanded */ { yyerror( "yacc stack overflow" ); YYABORT; } yymaxdepth = yynewmax; yy_ps = yys + yyps_index; yy_pv = yyv + yypv_index; yypvt = yyv + yypvt_index; } *yy_ps = yy_state; *++yy_pv = yyval; /* ** we have a new state - find out what to do */ yy_newstate: if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG ) goto yydefault; /* simple state */ #if YYDEBUG /* ** if debugging, need to mark whether new token grabbed */ yytmp = yychar < 0; #endif if ( ( yychar < 0 ) && ( ( yychar = YYLEX() ) < 0 ) ) yychar = 0; /* reached EOF */ #if YYDEBUG if ( yydebug && yytmp ) { register int yy_i; printf( "Received token " ); if ( yychar == 0 ) printf( "end-of-file\n" ); else if ( yychar < 0 ) printf( "-none-\n" ); else { for ( yy_i = 0; yytoks[yy_i].t_val >= 0; yy_i++ ) { if ( yytoks[yy_i].t_val == yychar ) break; } printf( "%s\n", yytoks[yy_i].t_name ); } } #endif /* YYDEBUG */ if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) ) goto yydefault; if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar ) /*valid shift*/ { yychar = -1; yyval = yylval; yy_state = yy_n; if ( yyerrflag > 0 ) yyerrflag--; goto yy_stack; } yydefault: if ( ( yy_n = yydef[ yy_state ] ) == -2 ) { #if YYDEBUG yytmp = yychar < 0; #endif if ( ( yychar < 0 ) && ( ( yychar = YYLEX() ) < 0 ) ) yychar = 0; /* reached EOF */ #if YYDEBUG if ( yydebug && yytmp ) { register int yy_i; printf( "Received token " ); if ( yychar == 0 ) printf( "end-of-file\n" ); else if ( yychar < 0 ) printf( "-none-\n" ); else { for ( yy_i = 0; yytoks[yy_i].t_val >= 0; yy_i++ ) { if ( yytoks[yy_i].t_val == yychar ) { break; } } printf( "%s\n", yytoks[yy_i].t_name ); } } #endif /* YYDEBUG */ /* ** look through exception table */ { register YYCONST int *yyxi = yyexca; while ( ( *yyxi != -1 ) || ( yyxi[1] != yy_state ) ) { yyxi += 2; } while ( ( *(yyxi += 2) >= 0 ) && ( *yyxi != yychar ) ) ; if ( ( yy_n = yyxi[1] ) < 0 ) YYACCEPT; } } /* ** check for syntax error */ if ( yy_n == 0 ) /* have an error */ { /* no worry about speed here! */ switch ( yyerrflag ) { case 0: /* new error */ yyerror( "syntax error" ); goto skip_init; yyerrlab: /* ** get globals into registers. ** we have a user generated syntax type error */ yy_pv = yypv; yy_ps = yyps; yy_state = yystate; skip_init: yynerrs++; /* FALLTHRU */ case 1: case 2: /* incompletely recovered error */ /* try again... */ yyerrflag = 3; /* ** find state where "error" is a legal ** shift action */ while ( yy_ps >= yys ) { yy_n = yypact[ *yy_ps ] + YYERRCODE; if ( yy_n >= 0 && yy_n < YYLAST && yychk[yyact[yy_n]] == YYERRCODE) { /* ** simulate shift of "error" */ yy_state = yyact[ yy_n ]; goto yy_stack; } /* ** current state has no shift on ** "error", pop stack */ #if YYDEBUG # define _POP_ "Error recovery pops state %d, uncovers state %d\n" if ( yydebug ) printf( _POP_, *yy_ps, yy_ps[-1] ); # undef _POP_ #endif yy_ps--; yy_pv--; } /* ** there is no state on stack with "error" as ** a valid shift. give up. */ YYABORT; case 3: /* no shift yet; eat a token */ #if YYDEBUG /* ** if debugging, look up token in list of ** pairs. 0 and negative shouldn't occur, ** but since timing doesn't matter when ** debugging, it doesn't hurt to leave the ** tests here. */ if ( yydebug ) { register int yy_i; printf( "Error recovery discards " ); if ( yychar == 0 ) printf( "token end-of-file\n" ); else if ( yychar < 0 ) printf( "token -none-\n" ); else { for ( yy_i = 0; yytoks[yy_i].t_val >= 0; yy_i++ ) { if ( yytoks[yy_i].t_val == yychar ) { break; } } printf( "token %s\n", yytoks[yy_i].t_name ); } } #endif /* YYDEBUG */ if ( yychar == 0 ) /* reached EOF. quit */ YYABORT; yychar = -1; goto yy_newstate; } }/* end if ( yy_n == 0 ) */ /* ** reduction by production yy_n ** put stack tops, etc. so things right after switch */ #if YYDEBUG /* ** if debugging, print the string that is the user's ** specification of the reduction which is just about ** to be done. */ if ( yydebug ) printf( "Reduce by (%d) \"%s\"\n", yy_n, yyreds[ yy_n ] ); #endif yytmp = yy_n; /* value to switch over */ yypvt = yy_pv; /* $vars top of value stack */ /* ** Look in goto table for next state ** Sorry about using yy_state here as temporary ** register variable, but why not, if it works... ** If yyr2[ yy_n ] doesn't have the low order bit ** set, then there is no action to be done for ** this reduction. So, no saving & unsaving of ** registers done. The only difference between the ** code just after the if and the body of the if is ** the goto yy_stack in the body. This way the test ** can be made before the choice of what to do is needed. */ { /* length of production doubled with extra bit */ register int yy_len = yyr2[ yy_n ]; if ( !( yy_len & 01 ) ) { yy_len >>= 1; yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */ yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] + *( yy_ps -= yy_len ) + 1; if ( yy_state >= YYLAST || yychk[ yy_state = yyact[ yy_state ] ] != -yy_n ) { yy_state = yyact[ yypgo[ yy_n ] ]; } goto yy_stack; } yy_len >>= 1; yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */ yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] + *( yy_ps -= yy_len ) + 1; if ( yy_state >= YYLAST || yychk[ yy_state = yyact[ yy_state ] ] != -yy_n ) { yy_state = yyact[ yypgo[ yy_n ] ]; } } /* save until reenter driver code */ yystate = yy_state; yyps = yy_ps; yypv = yy_pv; } /* ** code supplied by user is placed in this switch */ switch( yytmp ) { case 1: # line 176 "zonecfg_grammar.y" { if (yypvt[-1].cmd != NULL) { if (yypvt[-1].cmd->cmd_handler != NULL) yypvt[-1].cmd->cmd_handler(yypvt[-1].cmd); free_cmd(yypvt[-1].cmd); bzero(list, sizeof (list_property_t)); num_prop_vals = 0; } assert_no_unclaimed_tokens(); return (0); } break; case 2: # line 188 "zonecfg_grammar.y" { if (yypvt[-2].cmd != NULL) { free_cmd(yypvt[-2].cmd); bzero(list, sizeof (list_property_t)); num_prop_vals = 0; } if (YYRECOVERING()) YYABORT; yyclearin; yyerrok; } break; case 3: # line 200 "zonecfg_grammar.y" { if (YYRECOVERING()) YYABORT; yyclearin; yyerrok; } break; case 4: # line 207 "zonecfg_grammar.y" { assert_no_unclaimed_tokens(); return (0); } break; case 21: # line 229 "zonecfg_grammar.y" { newline_terminated = B_TRUE; } break; case 22: # line 230 "zonecfg_grammar.y" { newline_terminated = B_FALSE; } break; case 23: # line 233 "zonecfg_grammar.y" { short_usage(CMD_ADD); (void) fputs("\n", stderr); usage(B_FALSE, HELP_RES_PROPS); YYERROR; } break; case 24: # line 240 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &add_func; yyval.cmd->cmd_argc = 1; yyval.cmd->cmd_argv[0] = claim_token(yypvt[-0].strval); yyval.cmd->cmd_argv[1] = NULL; } break; case 25: # line 250 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &add_func; yyval.cmd->cmd_argc = 0; yyval.cmd->cmd_res_type = yypvt[-0].ival; yyval.cmd->cmd_prop_nv_pairs = 0; } break; case 26: # line 260 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &add_func; yyval.cmd->cmd_argc = 0; yyval.cmd->cmd_prop_nv_pairs = 1; yyval.cmd->cmd_prop_name[0] = yypvt[-1].ival; yyval.cmd->cmd_property_ptr[0] = &property[0]; } break; case 27: # line 272 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &cancel_func; yyval.cmd->cmd_argc = 0; yyval.cmd->cmd_argv[0] = NULL; } break; case 28: # line 281 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &cancel_func; yyval.cmd->cmd_argc = 1; yyval.cmd->cmd_argv[0] = claim_token(yypvt[-0].strval); yyval.cmd->cmd_argv[1] = NULL; } break; case 29: # line 292 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &create_func; yyval.cmd->cmd_argc = 0; yyval.cmd->cmd_argv[0] = NULL; } break; case 30: # line 301 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &create_func; yyval.cmd->cmd_argc = 1; yyval.cmd->cmd_argv[0] = claim_token(yypvt[-0].strval); yyval.cmd->cmd_argv[1] = NULL; } break; case 31: # line 311 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &create_func; yyval.cmd->cmd_argc = 2; yyval.cmd->cmd_argv[0] = claim_token(yypvt[-1].strval); yyval.cmd->cmd_argv[1] = claim_token(yypvt[-0].strval); yyval.cmd->cmd_argv[2] = NULL; } break; case 32: # line 322 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &create_func; yyval.cmd->cmd_argc = 3; yyval.cmd->cmd_argv[0] = claim_token(yypvt[-2].strval); yyval.cmd->cmd_argv[1] = claim_token(yypvt[-1].strval); yyval.cmd->cmd_argv[2] = claim_token(yypvt[-0].strval); yyval.cmd->cmd_argv[3] = NULL; } break; case 33: # line 335 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &commit_func; yyval.cmd->cmd_argc = 0; yyval.cmd->cmd_argv[0] = NULL; } break; case 34: # line 344 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &commit_func; yyval.cmd->cmd_argc = 1; yyval.cmd->cmd_argv[0] = claim_token(yypvt[-0].strval); yyval.cmd->cmd_argv[1] = NULL; } break; case 35: # line 355 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &delete_func; yyval.cmd->cmd_argc = 0; yyval.cmd->cmd_argv[0] = NULL; } break; case 36: # line 364 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &delete_func; yyval.cmd->cmd_argc = 1; yyval.cmd->cmd_argv[0] = claim_token(yypvt[-0].strval); yyval.cmd->cmd_argv[1] = NULL; } break; case 37: # line 375 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &end_func; yyval.cmd->cmd_argc = 0; yyval.cmd->cmd_argv[0] = NULL; } break; case 38: # line 384 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &end_func; yyval.cmd->cmd_argc = 1; yyval.cmd->cmd_argv[0] = claim_token(yypvt[-0].strval); yyval.cmd->cmd_argv[1] = NULL; } break; case 39: # line 395 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &exit_func; yyval.cmd->cmd_argc = 0; yyval.cmd->cmd_argv[0] = NULL; } break; case 40: # line 404 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &exit_func; yyval.cmd->cmd_argc = 1; yyval.cmd->cmd_argv[0] = claim_token(yypvt[-0].strval); yyval.cmd->cmd_argv[1] = NULL; } break; case 41: # line 415 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &export_func; yyval.cmd->cmd_argc = 0; yyval.cmd->cmd_argv[0] = NULL; } break; case 42: # line 424 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &export_func; yyval.cmd->cmd_argc = 1; yyval.cmd->cmd_argv[0] = claim_token(yypvt[-0].strval); yyval.cmd->cmd_argv[1] = NULL; } break; case 43: # line 434 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &export_func; yyval.cmd->cmd_argc = 2; yyval.cmd->cmd_argv[0] = claim_token(yypvt[-1].strval); yyval.cmd->cmd_argv[1] = claim_token(yypvt[-0].strval); yyval.cmd->cmd_argv[2] = NULL; } break; case 44: # line 446 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &help_func; yyval.cmd->cmd_argc = 0; yyval.cmd->cmd_argv[0] = NULL; } break; case 45: # line 455 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &help_func; yyval.cmd->cmd_argc = 1; yyval.cmd->cmd_argv[0] = claim_token(yypvt[-0].strval); yyval.cmd->cmd_argv[1] = NULL; } break; case 46: # line 466 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &info_func; yyval.cmd->cmd_res_type = RT_UNKNOWN; yyval.cmd->cmd_prop_nv_pairs = 0; } break; case 47: # line 475 "zonecfg_grammar.y" { short_usage(CMD_INFO); (void) fputs("\n", stderr); usage(B_FALSE, HELP_RES_PROPS); free(claim_token(yypvt[-0].strval)); YYERROR; } break; case 48: # line 483 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &info_func; yyval.cmd->cmd_res_type = yypvt[-0].ival; yyval.cmd->cmd_prop_nv_pairs = 0; } break; case 49: # line 492 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &info_func; yyval.cmd->cmd_res_type = RT_ZONENAME; yyval.cmd->cmd_prop_nv_pairs = 0; } break; case 50: # line 501 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &info_func; yyval.cmd->cmd_res_type = RT_ZONEPATH; yyval.cmd->cmd_prop_nv_pairs = 0; } break; case 51: # line 510 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &info_func; yyval.cmd->cmd_res_type = RT_BRAND; yyval.cmd->cmd_prop_nv_pairs = 0; } break; case 52: # line 519 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &info_func; yyval.cmd->cmd_res_type = RT_AUTOBOOT; yyval.cmd->cmd_prop_nv_pairs = 0; } break; case 53: # line 528 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &info_func; yyval.cmd->cmd_res_type = RT_IPTYPE; yyval.cmd->cmd_prop_nv_pairs = 0; } break; case 54: # line 537 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &info_func; yyval.cmd->cmd_res_type = RT_POOL; yyval.cmd->cmd_prop_nv_pairs = 0; } break; case 55: # line 546 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &info_func; yyval.cmd->cmd_res_type = RT_LIMITPRIV; yyval.cmd->cmd_prop_nv_pairs = 0; } break; case 56: # line 555 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &info_func; yyval.cmd->cmd_res_type = RT_BOOTARGS; yyval.cmd->cmd_prop_nv_pairs = 0; } break; case 57: # line 564 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &info_func; yyval.cmd->cmd_res_type = RT_SCHED; yyval.cmd->cmd_prop_nv_pairs = 0; } break; case 58: # line 573 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &info_func; yyval.cmd->cmd_res_type = RT_SHARES; yyval.cmd->cmd_prop_nv_pairs = 0; } break; case 59: # line 582 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &info_func; yyval.cmd->cmd_res_type = RT_MAXLWPS; yyval.cmd->cmd_prop_nv_pairs = 0; } break; case 60: # line 591 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &info_func; yyval.cmd->cmd_res_type = RT_MAXPROCS; yyval.cmd->cmd_prop_nv_pairs = 0; } break; case 61: # line 600 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &info_func; yyval.cmd->cmd_res_type = RT_MAXSHMMEM; yyval.cmd->cmd_prop_nv_pairs = 0; } break; case 62: # line 609 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &info_func; yyval.cmd->cmd_res_type = RT_MAXSHMIDS; yyval.cmd->cmd_prop_nv_pairs = 0; } break; case 63: # line 618 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &info_func; yyval.cmd->cmd_res_type = RT_MAXMSGIDS; yyval.cmd->cmd_prop_nv_pairs = 0; } break; case 64: # line 627 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &info_func; yyval.cmd->cmd_res_type = RT_MAXSEMIDS; yyval.cmd->cmd_prop_nv_pairs = 0; } break; case 65: # line 636 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &info_func; yyval.cmd->cmd_res_type = RT_HOSTID; yyval.cmd->cmd_prop_nv_pairs = 0; } break; case 66: # line 645 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &info_func; yyval.cmd->cmd_res_type = RT_FS_ALLOWED; yyval.cmd->cmd_prop_nv_pairs = 0; } break; case 67: # line 654 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &info_func; yyval.cmd->cmd_res_type = yypvt[-3].ival; yyval.cmd->cmd_prop_nv_pairs = 1; yyval.cmd->cmd_prop_name[0] = yypvt[-2].ival; yyval.cmd->cmd_property_ptr[0] = &property[0]; } break; case 68: # line 665 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &info_func; yyval.cmd->cmd_res_type = yypvt[-6].ival; yyval.cmd->cmd_prop_nv_pairs = 2; yyval.cmd->cmd_prop_name[0] = yypvt[-5].ival; yyval.cmd->cmd_property_ptr[0] = &property[0]; yyval.cmd->cmd_prop_name[1] = yypvt[-2].ival; yyval.cmd->cmd_property_ptr[1] = &property[1]; } break; case 69: # line 678 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &info_func; yyval.cmd->cmd_res_type = yypvt[-9].ival; yyval.cmd->cmd_prop_nv_pairs = 3; yyval.cmd->cmd_prop_name[0] = yypvt[-8].ival; yyval.cmd->cmd_property_ptr[0] = &property[0]; yyval.cmd->cmd_prop_name[1] = yypvt[-5].ival; yyval.cmd->cmd_property_ptr[1] = &property[1]; yyval.cmd->cmd_prop_name[2] = yypvt[-2].ival; yyval.cmd->cmd_property_ptr[2] = &property[2]; } break; case 70: # line 694 "zonecfg_grammar.y" { short_usage(CMD_REMOVE); (void) fputs("\n", stderr); usage(B_FALSE, HELP_RES_PROPS); YYERROR; } break; case 71: # line 701 "zonecfg_grammar.y" { short_usage(CMD_REMOVE); (void) fputs("\n", stderr); usage(B_FALSE, HELP_RES_PROPS); free(claim_token(yypvt[-0].strval)); YYERROR; } break; case 72: # line 709 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &remove_func; yyval.cmd->cmd_res_type = yypvt[-0].ival; } break; case 73: # line 717 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &remove_func; yyval.cmd->cmd_res_type = yypvt[-0].ival; yyval.cmd->cmd_argc = 1; yyval.cmd->cmd_argv[0] = claim_token(yypvt[-1].strval); yyval.cmd->cmd_argv[1] = NULL; } break; case 74: # line 728 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &remove_func; yyval.cmd->cmd_prop_nv_pairs = 1; yyval.cmd->cmd_prop_name[0] = yypvt[-1].ival; yyval.cmd->cmd_property_ptr[0] = &property[0]; } break; case 75: # line 738 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &remove_func; yyval.cmd->cmd_res_type = yypvt[-3].ival; yyval.cmd->cmd_prop_nv_pairs = 1; yyval.cmd->cmd_prop_name[0] = yypvt[-2].ival; yyval.cmd->cmd_property_ptr[0] = &property[0]; } break; case 76: # line 749 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &remove_func; yyval.cmd->cmd_res_type = yypvt[-6].ival; yyval.cmd->cmd_prop_nv_pairs = 2; yyval.cmd->cmd_prop_name[0] = yypvt[-5].ival; yyval.cmd->cmd_property_ptr[0] = &property[0]; yyval.cmd->cmd_prop_name[1] = yypvt[-2].ival; yyval.cmd->cmd_property_ptr[1] = &property[1]; } break; case 77: # line 762 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &remove_func; yyval.cmd->cmd_res_type = yypvt[-9].ival; yyval.cmd->cmd_prop_nv_pairs = 3; yyval.cmd->cmd_prop_name[0] = yypvt[-8].ival; yyval.cmd->cmd_property_ptr[0] = &property[0]; yyval.cmd->cmd_prop_name[1] = yypvt[-5].ival; yyval.cmd->cmd_property_ptr[1] = &property[1]; yyval.cmd->cmd_prop_name[2] = yypvt[-2].ival; yyval.cmd->cmd_property_ptr[2] = &property[2]; } break; case 78: # line 778 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &revert_func; yyval.cmd->cmd_argc = 0; yyval.cmd->cmd_argv[0] = NULL; } break; case 79: # line 787 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &revert_func; yyval.cmd->cmd_argc = 1; yyval.cmd->cmd_argv[0] = claim_token(yypvt[-0].strval); yyval.cmd->cmd_argv[1] = NULL; } break; case 80: # line 798 "zonecfg_grammar.y" { short_usage(CMD_SELECT); (void) fputs("\n", stderr); usage(B_FALSE, HELP_RES_PROPS); YYERROR; } break; case 81: # line 805 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &select_func; yyval.cmd->cmd_res_type = RT_DCPU; } break; case 82: # line 813 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &select_func; yyval.cmd->cmd_res_type = RT_PCAP; } break; case 83: # line 821 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &select_func; yyval.cmd->cmd_res_type = RT_MCAP; } break; case 84: # line 829 "zonecfg_grammar.y" { short_usage(CMD_SELECT); YYERROR; } break; case 85: # line 834 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &select_func; yyval.cmd->cmd_res_type = yypvt[-3].ival; yyval.cmd->cmd_prop_nv_pairs = 1; yyval.cmd->cmd_prop_name[0] = yypvt[-2].ival; yyval.cmd->cmd_property_ptr[0] = &property[0]; } break; case 86: # line 845 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &select_func; yyval.cmd->cmd_res_type = yypvt[-6].ival; yyval.cmd->cmd_prop_nv_pairs = 2; yyval.cmd->cmd_prop_name[0] = yypvt[-5].ival; yyval.cmd->cmd_property_ptr[0] = &property[0]; yyval.cmd->cmd_prop_name[1] = yypvt[-2].ival; yyval.cmd->cmd_property_ptr[1] = &property[1]; } break; case 87: # line 858 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &select_func; yyval.cmd->cmd_res_type = yypvt[-9].ival; yyval.cmd->cmd_prop_nv_pairs = 3; yyval.cmd->cmd_prop_name[0] = yypvt[-8].ival; yyval.cmd->cmd_property_ptr[0] = &property[0]; yyval.cmd->cmd_prop_name[1] = yypvt[-5].ival; yyval.cmd->cmd_property_ptr[1] = &property[1]; yyval.cmd->cmd_prop_name[2] = yypvt[-2].ival; yyval.cmd->cmd_property_ptr[2] = &property[2]; } break; case 88: # line 874 "zonecfg_grammar.y" { short_usage(CMD_SET); (void) fputs("\n", stderr); usage(B_FALSE, HELP_PROPS); YYERROR; } break; case 89: # line 881 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &set_func; yyval.cmd->cmd_prop_nv_pairs = 0; yyval.cmd->cmd_prop_name[0] = yypvt[-3].ival; property[0].pv_type = PROP_VAL_LIST; property[0].pv_list = NULL; yyval.cmd->cmd_property_ptr[0] = &property[0]; } break; case 90: # line 893 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &set_func; yyval.cmd->cmd_prop_nv_pairs = 1; yyval.cmd->cmd_prop_name[0] = yypvt[-2].ival; yyval.cmd->cmd_property_ptr[0] = &property[0]; } break; case 91: # line 903 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_argc = 1; yyval.cmd->cmd_argv[0] = claim_token(yypvt[-3].strval); yyval.cmd->cmd_argv[1] = NULL; yyval.cmd->cmd_handler = &set_func; yyval.cmd->cmd_prop_nv_pairs = 1; yyval.cmd->cmd_prop_name[0] = PT_ZONEPATH; yyval.cmd->cmd_property_ptr[0] = &property[0]; } break; case 92: # line 917 "zonecfg_grammar.y" { short_usage(CMD_CLEAR); (void) fputs("\n", stderr); usage(B_FALSE, HELP_PROPS); YYERROR; } break; case 93: # line 924 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &clear_func; yyval.cmd->cmd_res_type = yypvt[-0].ival; } break; case 94: # line 933 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &verify_func; yyval.cmd->cmd_argc = 0; yyval.cmd->cmd_argv[0] = NULL; } break; case 95: # line 942 "zonecfg_grammar.y" { if ((yyval.cmd = alloc_cmd()) == NULL) YYERROR; cmd = yyval.cmd; yyval.cmd->cmd_handler = &verify_func; yyval.cmd->cmd_argc = 1; yyval.cmd->cmd_argv[0] = claim_token(yypvt[-0].strval); yyval.cmd->cmd_argv[1] = NULL; } break; case 96: # line 952 "zonecfg_grammar.y" { yyval.ival = RT_NET; } break; case 97: # line 953 "zonecfg_grammar.y" { yyval.ival = RT_FS; } break; case 98: # line 954 "zonecfg_grammar.y" { yyval.ival = RT_DEVICE; } break; case 99: # line 955 "zonecfg_grammar.y" { yyval.ival = RT_RCTL; } break; case 100: # line 956 "zonecfg_grammar.y" { yyval.ival = RT_ATTR; } break; case 101: # line 957 "zonecfg_grammar.y" { yyval.ival = RT_DATASET; } break; case 102: # line 958 "zonecfg_grammar.y" { yyval.ival = RT_DCPU; } break; case 103: # line 959 "zonecfg_grammar.y" { yyval.ival = RT_PCAP; } break; case 104: # line 960 "zonecfg_grammar.y" { yyval.ival = RT_MCAP; } break; case 105: # line 961 "zonecfg_grammar.y" { yyval.ival = RT_ADMIN; } break; case 106: # line 963 "zonecfg_grammar.y" { yyval.ival = PT_SPECIAL; } break; case 107: # line 964 "zonecfg_grammar.y" { yyval.ival = PT_RAW; } break; case 108: # line 965 "zonecfg_grammar.y" { yyval.ival = PT_DIR; } break; case 109: # line 966 "zonecfg_grammar.y" { yyval.ival = PT_TYPE; } break; case 110: # line 967 "zonecfg_grammar.y" { yyval.ival = PT_OPTIONS; } break; case 111: # line 968 "zonecfg_grammar.y" { yyval.ival = PT_ZONENAME; } break; case 112: # line 969 "zonecfg_grammar.y" { yyval.ival = PT_ZONEPATH; } break; case 113: # line 970 "zonecfg_grammar.y" { yyval.ival = PT_AUTOBOOT; } break; case 114: # line 971 "zonecfg_grammar.y" { yyval.ival = PT_IPTYPE; } break; case 115: # line 972 "zonecfg_grammar.y" { yyval.ival = PT_POOL; } break; case 116: # line 973 "zonecfg_grammar.y" { yyval.ival = PT_LIMITPRIV; } break; case 117: # line 974 "zonecfg_grammar.y" { yyval.ival = PT_BOOTARGS; } break; case 118: # line 975 "zonecfg_grammar.y" { yyval.ival = PT_ADDRESS; } break; case 119: # line 976 "zonecfg_grammar.y" { yyval.ival = PT_ALLOWED_ADDRESS; } break; case 120: # line 977 "zonecfg_grammar.y" { yyval.ival = PT_PHYSICAL; } break; case 121: # line 978 "zonecfg_grammar.y" { yyval.ival = PT_DEFROUTER; } break; case 122: # line 979 "zonecfg_grammar.y" { yyval.ival = PT_NAME; } break; case 123: # line 980 "zonecfg_grammar.y" { yyval.ival = PT_VALUE; } break; case 124: # line 981 "zonecfg_grammar.y" { yyval.ival = PT_MATCH; } break; case 125: # line 982 "zonecfg_grammar.y" { yyval.ival = PT_PRIV; } break; case 126: # line 983 "zonecfg_grammar.y" { yyval.ival = PT_LIMIT; } break; case 127: # line 984 "zonecfg_grammar.y" { yyval.ival = PT_ACTION; } break; case 128: # line 985 "zonecfg_grammar.y" { yyval.ival = PT_BRAND; } break; case 129: # line 986 "zonecfg_grammar.y" { yyval.ival = PT_NCPUS; } break; case 130: # line 987 "zonecfg_grammar.y" { yyval.ival = PT_LOCKED; } break; case 131: # line 988 "zonecfg_grammar.y" { yyval.ival = PT_SWAP; } break; case 132: # line 989 "zonecfg_grammar.y" { yyval.ival = PT_IMPORTANCE; } break; case 133: # line 990 "zonecfg_grammar.y" { yyval.ival = PT_SHARES; } break; case 134: # line 991 "zonecfg_grammar.y" { yyval.ival = PT_MAXLWPS; } break; case 135: # line 992 "zonecfg_grammar.y" { yyval.ival = PT_MAXPROCS; } break; case 136: # line 993 "zonecfg_grammar.y" { yyval.ival = PT_MAXSHMMEM; } break; case 137: # line 994 "zonecfg_grammar.y" { yyval.ival = PT_MAXSHMIDS; } break; case 138: # line 995 "zonecfg_grammar.y" { yyval.ival = PT_MAXMSGIDS; } break; case 139: # line 996 "zonecfg_grammar.y" { yyval.ival = PT_MAXSEMIDS; } break; case 140: # line 997 "zonecfg_grammar.y" { yyval.ival = PT_SCHED; } break; case 141: # line 998 "zonecfg_grammar.y" { yyval.ival = PT_HOSTID; } break; case 142: # line 999 "zonecfg_grammar.y" { yyval.ival = PT_USER; } break; case 143: # line 1000 "zonecfg_grammar.y" { yyval.ival = PT_AUTHS; } break; case 144: # line 1001 "zonecfg_grammar.y" { yyval.ival = PT_FS_ALLOWED; } break; case 145: # line 1019 "zonecfg_grammar.y" { property[num_prop_vals].pv_type = PROP_VAL_SIMPLE; property[num_prop_vals].pv_simple = yypvt[-0].strval; if (list[num_prop_vals] != NULL) { free_outer_list(list[num_prop_vals]); list[num_prop_vals] = NULL; } num_prop_vals++; } break; case 146: # line 1029 "zonecfg_grammar.y" { property[num_prop_vals].pv_type = PROP_VAL_COMPLEX; property[num_prop_vals].pv_complex = complex; if (list[num_prop_vals] != NULL) { free_outer_list(list[num_prop_vals]); list[num_prop_vals] = NULL; } num_prop_vals++; } break; case 147: # line 1039 "zonecfg_grammar.y" { property[num_prop_vals].pv_type = PROP_VAL_LIST; property[num_prop_vals].pv_list = list[num_prop_vals]; num_prop_vals++; } break; case 148: # line 1063 "zonecfg_grammar.y" { yyval.strval = simple_prop_val_func(yypvt[-0].strval); free(claim_token(yypvt[-0].strval)); if (yyval.strval == NULL) YYERROR; } break; case 149: # line 1070 "zonecfg_grammar.y" { if ((yyval.strval = simple_prop_val_func(res_types[yypvt[-0].ival])) == NULL) YYERROR; } break; case 150: # line 1075 "zonecfg_grammar.y" { if ((yyval.strval = simple_prop_val_func(prop_types[yypvt[-0].ival])) == NULL) YYERROR; } break; case 151: # line 1081 "zonecfg_grammar.y" { if ((new_list = alloc_list()) == NULL) YYERROR; new_list->lp_simple = NULL; new_list->lp_complex = complex; new_list->lp_next = NULL; if (list[num_prop_vals] == NULL) { list[num_prop_vals] = new_list; } else { for (tmp_list = list[num_prop_vals]; tmp_list != NULL; tmp_list = tmp_list->lp_next) last = tmp_list; last->lp_next = new_list; } } break; case 152: # line 1098 "zonecfg_grammar.y" { yyval.complex = complex_piece_func(yypvt[-2].ival, yypvt[-0].strval, NULL); free(claim_token(yypvt[-0].strval)); if (yyval.complex == NULL) YYERROR; } break; case 153: # line 1105 "zonecfg_grammar.y" { if ((yyval.complex = complex_piece_func(yypvt[-2].ival, res_types[yypvt[-0].ival], NULL)) == NULL) YYERROR; } break; case 154: # line 1110 "zonecfg_grammar.y" { if ((yyval.complex = complex_piece_func(yypvt[-2].ival, prop_types[yypvt[-0].ival], NULL)) == NULL) YYERROR; } break; case 155: # line 1115 "zonecfg_grammar.y" { yyval.complex = complex_piece_func(yypvt[-4].ival, yypvt[-2].strval, complex); free(claim_token(yypvt[-2].strval)); if (yyval.complex == NULL) YYERROR; } break; case 156: # line 1122 "zonecfg_grammar.y" { if ((yyval.complex = complex_piece_func(yypvt[-4].ival, res_types[yypvt[-2].ival], complex)) == NULL) YYERROR; } break; case 157: # line 1128 "zonecfg_grammar.y" { if ((yyval.complex = complex_piece_func(yypvt[-4].ival, prop_types[yypvt[-2].ival], complex)) == NULL) YYERROR; } break; # line 556 "/usr/share/lib/ccs/yaccpar" } goto yystack; /* reset registers in driver code */ }