1 2 # line 2 "zonecfg_grammar.y" 3 /* 4 * CDDL HEADER START 5 * 6 * The contents of this file are subject to the terms of the 7 * Common Development and Distribution License (the "License"). 8 * You may not use this file except in compliance with the License. 9 * 10 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 11 * or http://www.opensolaris.org/os/licensing. 12 * See the License for the specific language governing permissions 13 * and limitations under the License. 14 * 15 * When distributing Covered Code, include this CDDL HEADER in each 16 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 17 * If applicable, add the following below this CDDL HEADER, with the 18 * fields enclosed by brackets "[]" replaced with your own identifying 19 * information: Portions Copyright [yyyy] [name of copyright owner] 20 * 21 * CDDL HEADER END 22 */ 23 24 /* 25 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. 26 */ 27 28 /* 29 * This file defines zonecfg(1M)'s grammar. 30 * 31 * Reduction rules that consume TOKENs must invoke claim_token() immediately 32 * before freeing the TOKENs or adding them to data structures (e.g., cmd) that 33 * will be cleaned up when the parser finishes or encounters errors. 34 */ 35 36 #include <stdio.h> 37 #include <strings.h> 38 39 #include "zonecfg.h" 40 41 static cmd_t *cmd = NULL; /* Command being processed */ 42 static complex_property_ptr_t complex = NULL; 43 static list_property_ptr_t new_list = NULL, tmp_list, last, 44 list[MAX_EQ_PROP_PAIRS]; 45 static property_value_t property[MAX_EQ_PROP_PAIRS]; 46 47 extern boolean_t newline_terminated; 48 extern int num_prop_vals; /* # of property values */ 49 50 /* yacc externals */ 51 extern int yydebug; 52 extern void yyerror(char *s); 53 54 /* 55 * This function is used by the simple_prop_val reduction rules to set up 56 * a list_property_ptr_t and adjust the above global variables appropriately. 57 * Note that this function duplicates the specified string and makes 58 * the new list's lp_simple field point to the duplicate. This function does 59 * not free the original string. 60 * 61 * This function returns a pointer to the duplicated string or NULL if an error 62 * occurred. The simple_prop_val reduction rules that invoke this function 63 * should set $$ to the returned pointer. 64 */ 65 static char * 66 simple_prop_val_func(const char *str) 67 { 68 char *retstr; 69 70 if ((new_list = alloc_list()) == NULL) 71 return (NULL); 72 if ((retstr = strdup(str)) == NULL) { 73 free_list(new_list); 74 return (NULL); 75 } 76 new_list->lp_simple = retstr; 77 new_list->lp_complex = NULL; 78 new_list->lp_next = NULL; 79 if (list[num_prop_vals] == NULL) { 80 list[num_prop_vals] = new_list; 81 } else { 82 for (tmp_list = list[num_prop_vals]; tmp_list != NULL; 83 tmp_list = tmp_list->lp_next) 84 last = tmp_list; 85 last->lp_next = new_list; 86 } 87 return (retstr); 88 } 89 90 /* 91 * This function is used by the complex_piece reduction rules to set up a 92 * complex_property_prt_t and adjust the above global variables appropriately. 93 * Note that this function duplicates the specified string and makes the new 94 * complex_property_ptr_t's cp_value field point to the duplicate. It also sets 95 * the complex_property_ptr_t's cp_type field to cp_type and its cp_next field 96 * to cp_next. This function does not free the original string. 97 * 98 * This function returns a pointer to the complex_property_t created for the 99 * complex_piece or NULL if an error occurred. The complex_piece reduction 100 * rules that invoke this function should set $$ to the returned pointer. 101 */ 102 static complex_property_ptr_t 103 complex_piece_func(int cp_type, const char *str, complex_property_ptr_t cp_next) 104 { 105 complex_property_ptr_t retval; 106 107 if ((retval = alloc_complex()) == NULL) 108 return (NULL); 109 if ((retval->cp_value = strdup(str)) == NULL) { 110 free_complex(retval); 111 return (NULL); 112 } 113 retval->cp_type = cp_type; 114 retval->cp_next = cp_next; 115 complex = retval; 116 return (retval); 117 } 118 119 120 121 # line 121 "zonecfg_grammar.y" 122 typedef union 123 #ifdef __cplusplus 124 YYSTYPE 125 #endif 126 { 127 int ival; 128 char *strval; 129 cmd_t *cmd; 130 complex_property_ptr_t complex; 131 list_property_ptr_t list; 132 } YYSTYPE; 133 # define HELP 257 134 # define CREATE 258 135 # define EXPORT 259 136 # define ADD 260 137 # define DELETE 261 138 # define REMOVE 262 139 # define SELECT 263 140 # define SET 264 141 # define INFO 265 142 # define CANCEL 266 143 # define END 267 144 # define VERIFY 268 145 # define COMMIT 269 146 # define REVERT 270 147 # define EXIT 271 148 # define SEMICOLON 272 149 # define TOKEN 273 150 # define ZONENAME 274 151 # define ZONEPATH 275 152 # define AUTOBOOT 276 153 # define POOL 277 154 # define NET 278 155 # define FS 279 156 # define ATTR 280 157 # define DEVICE 281 158 # define RCTL 282 159 # define SPECIAL 283 160 # define RAW 284 161 # define DIR 285 162 # define OPTIONS 286 163 # define TYPE 287 164 # define ADDRESS 288 165 # define PHYSICAL 289 166 # define IPTYPE 290 167 # define HOSTID 291 168 # define FS_ALLOWED 292 169 # define ALLOWED_ADDRESS 293 170 # define NAME 294 171 # define MATCH 295 172 # define PRIV 296 173 # define LIMIT 297 174 # define ACTION 298 175 # define VALUE 299 176 # define EQUAL 300 177 # define OPEN_SQ_BRACKET 301 178 # define CLOSE_SQ_BRACKET 302 179 # define OPEN_PAREN 303 180 # define CLOSE_PAREN 304 181 # define COMMA 305 182 # define DATASET 306 183 # define LIMITPRIV 307 184 # define BOOTARGS 308 185 # define BRAND 309 186 # define PSET 310 187 # define PCAP 311 188 # define MCAP 312 189 # define NCPUS 313 190 # define IMPORTANCE 314 191 # define SHARES 315 192 # define MAXLWPS 316 193 # define MAXSHMMEM 317 194 # define MAXSHMIDS 318 195 # define MAXMSGIDS 319 196 # define MAXSEMIDS 320 197 # define LOCKED 321 198 # define SWAP 322 199 # define SCHED 323 200 # define CLEAR 324 201 # define DEFROUTER 325 202 # define ADMIN 326 203 # define USER 327 204 # define AUTHS 328 205 # define MAXPROCS 329 206 207 #include <inttypes.h> 208 209 #ifdef __STDC__ 210 #include <stdlib.h> 211 #include <string.h> 212 #define YYCONST const 213 #else 214 #include <malloc.h> 215 #include <memory.h> 216 #define YYCONST 217 #endif 218 219 #include <values.h> 220 221 #if defined(__cplusplus) || defined(__STDC__) 222 223 #if defined(__cplusplus) && defined(__EXTERN_C__) 224 extern "C" { 225 #endif 226 #ifndef yyerror 227 #if defined(__cplusplus) 228 void yyerror(YYCONST char *); 229 #endif 230 #endif 231 #ifndef yylex 232 int yylex(void); 233 #endif 234 int yyparse(void); 235 #if defined(__cplusplus) && defined(__EXTERN_C__) 236 } 237 #endif 238 239 #endif 240 241 #define yyclearin yychar = -1 242 #define yyerrok yyerrflag = 0 243 extern int yychar; 244 extern int yyerrflag; 245 YYSTYPE yylval; 246 YYSTYPE yyval; 247 typedef int yytabelem; 248 #ifndef YYMAXDEPTH 249 #define YYMAXDEPTH 150 250 #endif 251 #if YYMAXDEPTH > 0 252 int yy_yys[YYMAXDEPTH], *yys = yy_yys; 253 YYSTYPE yy_yyv[YYMAXDEPTH], *yyv = yy_yyv; 254 #else /* user does initial allocation */ 255 int *yys; 256 YYSTYPE *yyv; 257 #endif 258 static int yymaxdepth = YYMAXDEPTH; 259 # define YYERRCODE 256 260 261 # line 1140 "zonecfg_grammar.y" 262 263 static YYCONST yytabelem yyexca[] ={ 264 -1, 1, 265 0, -1, 266 -2, 0, 267 -1, 127, 268 256, 81, 269 10, 81, 270 59, 81, 271 -2, 102, 272 -1, 128, 273 256, 82, 274 10, 82, 275 59, 82, 276 -2, 103, 277 -1, 129, 278 256, 83, 279 10, 83, 280 59, 83, 281 -2, 104, 282 }; 283 # define YYNPROD 163 284 # define YYLAST 789 285 static YYCONST yytabelem yyact[]={ 286 287 139, 60, 61, 62, 64, 45, 46, 49, 47, 48, 288 55, 56, 57, 59, 58, 67, 69, 63, 90, 93, 289 68, 71, 73, 74, 75, 76, 72, 185, 143, 184, 290 142, 183, 165, 50, 65, 66, 77, 51, 52, 53, 291 78, 81, 82, 83, 85, 86, 87, 88, 79, 80, 292 89, 169, 70, 54, 91, 92, 84, 139, 60, 61, 293 62, 64, 45, 46, 49, 47, 48, 55, 56, 57, 294 59, 58, 67, 69, 63, 90, 93, 68, 71, 73, 295 74, 75, 76, 72, 168, 167, 173, 142, 200, 199, 296 50, 65, 66, 77, 51, 52, 53, 78, 81, 82, 297 83, 85, 86, 87, 88, 79, 80, 89, 198, 70, 298 54, 91, 92, 84, 139, 60, 61, 62, 64, 45, 299 46, 49, 47, 48, 55, 56, 57, 59, 58, 67, 300 69, 63, 90, 93, 68, 71, 73, 74, 75, 76, 301 72, 152, 162, 188, 142, 187, 186, 50, 65, 66, 302 77, 51, 52, 53, 78, 81, 82, 83, 85, 86, 303 87, 88, 79, 80, 89, 166, 70, 54, 91, 92, 304 84, 139, 60, 61, 62, 64, 45, 46, 49, 47, 305 48, 55, 56, 57, 59, 58, 67, 69, 63, 90, 306 93, 68, 71, 73, 74, 75, 76, 72, 158, 164, 307 161, 142, 160, 159, 50, 65, 66, 77, 51, 52, 308 53, 78, 81, 82, 83, 85, 86, 87, 88, 79, 309 80, 89, 151, 70, 54, 91, 92, 84, 175, 60, 310 61, 62, 64, 45, 46, 49, 47, 48, 55, 56, 311 57, 59, 58, 67, 69, 63, 90, 93, 68, 71, 312 73, 74, 75, 76, 72, 145, 144, 133, 126, 102, 313 101, 50, 65, 66, 77, 51, 52, 53, 78, 81, 314 82, 83, 85, 86, 87, 88, 79, 80, 89, 100, 315 70, 54, 91, 92, 84, 123, 60, 61, 62, 64, 316 45, 46, 49, 47, 48, 55, 56, 57, 59, 58, 317 67, 69, 63, 90, 93, 68, 71, 73, 74, 75, 318 76, 72, 99, 98, 97, 96, 94, 155, 50, 65, 319 66, 77, 51, 52, 53, 78, 81, 82, 83, 85, 320 86, 87, 88, 79, 80, 89, 138, 70, 54, 91, 321 92, 84, 42, 60, 61, 62, 64, 45, 46, 49, 322 47, 48, 55, 56, 57, 59, 58, 67, 69, 63, 323 90, 93, 68, 71, 73, 74, 75, 76, 72, 20, 324 7, 19, 18, 17, 16, 50, 65, 66, 77, 51, 325 52, 53, 78, 81, 82, 83, 85, 86, 87, 88, 326 79, 80, 89, 15, 70, 54, 91, 92, 84, 132, 327 60, 61, 62, 64, 14, 13, 153, 12, 11, 55, 328 56, 57, 59, 58, 67, 69, 63, 90, 93, 68, 329 71, 73, 74, 75, 76, 72, 10, 8, 9, 6, 330 5, 2, 1, 65, 66, 77, 21, 135, 0, 78, 331 81, 82, 83, 85, 86, 87, 88, 79, 80, 89, 332 0, 70, 0, 91, 92, 84, 60, 61, 62, 64, 333 137, 0, 0, 0, 136, 55, 56, 57, 59, 58, 334 67, 69, 63, 90, 93, 68, 71, 73, 74, 75, 335 76, 72, 0, 21, 21, 22, 178, 179, 0, 65, 336 66, 77, 0, 0, 0, 78, 81, 82, 83, 85, 337 86, 87, 88, 79, 80, 89, 0, 70, 0, 91, 338 92, 84, 103, 105, 106, 108, 110, 45, 46, 49, 339 47, 48, 0, 4, 0, 0, 39, 41, 0, 109, 340 121, 122, 22, 22, 0, 0, 0, 0, 45, 46, 341 49, 47, 48, 0, 0, 50, 111, 112, 107, 51, 342 52, 53, 0, 0, 114, 115, 117, 118, 119, 120, 343 0, 0, 113, 149, 134, 54, 50, 0, 116, 0, 344 51, 52, 53, 45, 46, 49, 47, 48, 0, 140, 345 0, 0, 0, 0, 0, 0, 54, 0, 0, 163, 346 189, 190, 191, 141, 0, 0, 0, 170, 171, 172, 347 0, 50, 174, 43, 157, 127, 128, 129, 156, 0, 348 0, 0, 0, 104, 124, 0, 130, 44, 0, 95, 349 0, 54, 0, 157, 192, 193, 194, 156, 125, 157, 350 157, 131, 0, 156, 156, 0, 201, 202, 203, 0, 351 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 352 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 353 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 354 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 355 0, 0, 3, 32, 26, 31, 23, 28, 34, 36, 356 37, 33, 24, 29, 38, 27, 35, 30, 146, 0, 357 0, 0, 0, 147, 0, 0, 0, 0, 0, 0, 358 0, 0, 0, 0, 0, 0, 0, 0, 148, 0, 359 0, 0, 0, 0, 150, 0, 0, 0, 0, 40, 360 0, 0, 0, 0, 0, 0, 154, 0, 0, 0, 361 0, 0, 0, 0, 0, 0, 176, 0, 0, 0, 362 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 363 177, 0, 0, 0, 180, 181, 182, 0, 0, 0, 364 0, 0, 0, 0, 0, 0, 0, 154, 154, 154, 365 0, 0, 0, 0, 0, 0, 195, 196, 197 }; 366 static YYCONST yytabelem yypact[]={ 367 368 426,-10000000, 473, 474,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, 369 -10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, 370 -10000000,-10000000,-10000000, 69, 43, 182, 42, 41, 40, 39, 371 6, -13, -14, 239, 12, -15, 295, 126, -16,-10000000, 372 474,-10000000,-10000000,-10000000, -273,-10000000,-10000000,-10000000,-10000000,-10000000, 373 -10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, 374 -10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, 375 -10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, 376 -10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, 377 -10000000,-10000000,-10000000,-10000000,-10000000,-10000000, -17,-10000000,-10000000,-10000000, 378 -10000000, -18,-10000000,-10000000, 182,-10000000,-10000000,-10000000,-10000000,-10000000, 379 -10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, 380 -10000000,-10000000,-10000000, 260, 182, -273,-10000000,-10000000,-10000000,-10000000, 381 182, -78, -134,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, 382 -10000000,-10000000, 182, -102, -75,-10000000, -97,-10000000, -98,-10000000, 383 -100, -159, -101, -272, -135, -217, -221, -254,-10000000, -273, 384 -273, -273, -216,-10000000, -273,-10000000, -45,-10000000, -102, -102, 385 182, 182, 182,-10000000,-10000000, -274, -276, -278,-10000000,-10000000, 386 -154, -155, -157, 182, 182, 182, -273, -273, -273,-10000000, 387 -10000000,-10000000, 182, 182, 182, -192, -211, -212, -273, -273, 388 -273,-10000000,-10000000,-10000000 }; 389 static YYCONST yytabelem yypgo[]={ 390 391 0, 432, 437, 464, 406, 460, 579, 593, 431, 430, 392 429, 428, 427, 426, 408, 407, 405, 404, 393, 374, 393 373, 372, 371, 370, 369, 523, 336, 317 }; 394 static YYCONST yytabelem yyr1[]={ 395 396 0, 1, 1, 1, 1, 8, 8, 8, 8, 8, 397 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 398 8, 25, 25, 9, 9, 9, 9, 10, 10, 12, 399 12, 12, 12, 11, 11, 13, 13, 14, 14, 15, 400 15, 16, 16, 16, 17, 17, 18, 18, 18, 18, 401 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 402 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 403 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 404 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 405 22, 22, 23, 23, 24, 24, 6, 6, 6, 6, 406 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 407 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 408 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 409 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 410 7, 7, 7, 7, 7, 2, 2, 2, 3, 3, 411 3, 5, 4, 4, 4, 4, 4, 4, 27, 27, 412 27, 27, 26 }; 413 static YYCONST yytabelem yyr2[]={ 414 415 0, 5, 7, 5, 3, 2, 2, 2, 2, 2, 416 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 417 2, 3, 3, 3, 5, 5, 7, 3, 5, 3, 418 5, 7, 9, 3, 5, 3, 5, 3, 5, 3, 419 5, 3, 5, 7, 3, 5, 3, 5, 5, 5, 420 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 421 5, 5, 5, 5, 5, 5, 5, 11, 17, 23, 422 3, 5, 5, 7, 7, 11, 17, 23, 3, 5, 423 3, 5, 5, 5, 5, 11, 17, 23, 3, 11, 424 9, 11, 3, 5, 3, 5, 3, 3, 3, 3, 425 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 426 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 427 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 428 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 429 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 430 3, 7, 7, 7, 7, 11, 11, 11, 2, 2, 431 6, 6, 6 }; 432 static YYCONST yytabelem yychk[]={ 433 434 -10000000, -1, -8, 256, -25, -9, -10, -23, -12, -11, 435 -13, -14, -15, -16, -17, -18, -19, -20, -21, -22, 436 -24, 10, 59, 260, 266, 324, 258, 269, 261, 267, 437 271, 259, 257, 265, 262, 270, 263, 264, 268, -25, 438 256, -25, 273, -6, -7, 278, 279, 281, 282, 280, 439 306, 310, 311, 312, 326, 283, 284, 285, 287, 286, 440 274, 275, 276, 290, 277, 307, 308, 288, 293, 289, 441 325, 294, 299, 295, 296, 297, 298, 309, 313, 321, 442 322, 314, 315, 316, 329, 317, 318, 319, 320, 323, 443 291, 327, 328, 292, 273, -7, 273, 273, 273, 273, 444 273, 273, 273, 273, -6, 274, 275, 309, 276, 290, 445 277, 307, 308, 323, 315, 316, 329, 317, 318, 319, 446 320, 291, 292, 273, -6, -7, 273, 310, 311, 312, 447 -6, -7, 273, 273, -25, -2, -3, -5, -26, 273, 448 -6, -7, 303, 301, 273, 273, -7, -6, -7, -2, 449 -7, 300, 275, -4, -7, -27, -3, -5, 273, 300, 450 300, 300, 301, -2, 300, 304, 300, 302, 305, 305, 451 -2, -2, -2, 302, -2, 273, -6, -7, -27, -27, 452 -7, -7, -7, 305, 305, 305, 300, 300, 300, -4, 453 -4, -4, -2, -2, -2, -7, -7, -7, 300, 300, 454 300, -2, -2, -2 }; 455 static YYCONST yytabelem yydef[]={ 456 457 0, -2, 0, 0, 4, 5, 6, 7, 8, 9, 458 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 459 20, 21, 22, 23, 27, 92, 29, 33, 35, 37, 460 39, 41, 44, 46, 70, 78, 80, 88, 94, 1, 461 0, 3, 24, 25, 0, 96, 97, 98, 99, 100, 462 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 463 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 464 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 465 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 466 141, 142, 143, 144, 28, 93, 30, 34, 36, 38, 467 40, 42, 45, 47, 48, 49, 50, 51, 52, 53, 468 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 469 64, 65, 66, 71, 72, 0, 79, -2, -2, -2, 470 84, 0, 0, 95, 2, 26, 145, 146, 147, 148, 471 149, 150, 0, 0, 31, 43, 0, 73, 0, 74, 472 0, 0, 0, 0, 0, 0, 158, 159, 32, 0, 473 0, 0, 0, 90, 0, 151, 0, 162, 0, 0, 474 67, 75, 85, 89, 91, 152, 153, 154, 160, 161, 475 0, 0, 0, 0, 0, 0, 0, 0, 0, 155, 476 156, 157, 68, 76, 86, 0, 0, 0, 0, 0, 477 0, 69, 77, 87 }; 478 typedef struct 479 #ifdef __cplusplus 480 yytoktype 481 #endif 482 { 483 #ifdef __cplusplus 484 const 485 #endif 486 char *t_name; int t_val; } yytoktype; 487 #ifndef YYDEBUG 488 # define YYDEBUG 0 /* don't allow debugging */ 489 #endif 490 491 #if YYDEBUG 492 493 yytoktype yytoks[] = 494 { 495 "HELP", 257, 496 "CREATE", 258, 497 "EXPORT", 259, 498 "ADD", 260, 499 "DELETE", 261, 500 "REMOVE", 262, 501 "SELECT", 263, 502 "SET", 264, 503 "INFO", 265, 504 "CANCEL", 266, 505 "END", 267, 506 "VERIFY", 268, 507 "COMMIT", 269, 508 "REVERT", 270, 509 "EXIT", 271, 510 "SEMICOLON", 272, 511 "TOKEN", 273, 512 "ZONENAME", 274, 513 "ZONEPATH", 275, 514 "AUTOBOOT", 276, 515 "POOL", 277, 516 "NET", 278, 517 "FS", 279, 518 "ATTR", 280, 519 "DEVICE", 281, 520 "RCTL", 282, 521 "SPECIAL", 283, 522 "RAW", 284, 523 "DIR", 285, 524 "OPTIONS", 286, 525 "TYPE", 287, 526 "ADDRESS", 288, 527 "PHYSICAL", 289, 528 "IPTYPE", 290, 529 "HOSTID", 291, 530 "FS_ALLOWED", 292, 531 "ALLOWED_ADDRESS", 293, 532 "NAME", 294, 533 "MATCH", 295, 534 "PRIV", 296, 535 "LIMIT", 297, 536 "ACTION", 298, 537 "VALUE", 299, 538 "EQUAL", 300, 539 "OPEN_SQ_BRACKET", 301, 540 "CLOSE_SQ_BRACKET", 302, 541 "OPEN_PAREN", 303, 542 "CLOSE_PAREN", 304, 543 "COMMA", 305, 544 "DATASET", 306, 545 "LIMITPRIV", 307, 546 "BOOTARGS", 308, 547 "BRAND", 309, 548 "PSET", 310, 549 "PCAP", 311, 550 "MCAP", 312, 551 "NCPUS", 313, 552 "IMPORTANCE", 314, 553 "SHARES", 315, 554 "MAXLWPS", 316, 555 "MAXSHMMEM", 317, 556 "MAXSHMIDS", 318, 557 "MAXMSGIDS", 319, 558 "MAXSEMIDS", 320, 559 "LOCKED", 321, 560 "SWAP", 322, 561 "SCHED", 323, 562 "CLEAR", 324, 563 "DEFROUTER", 325, 564 "ADMIN", 326, 565 "USER", 327, 566 "AUTHS", 328, 567 "MAXPROCS", 329, 568 "-unknown-", -1 /* ends search */ 569 }; 570 571 #ifdef __cplusplus 572 const 573 #endif 574 char * yyreds[] = 575 { 576 "-no such reduction-", 577 "commands : command terminator", 578 "commands : command error terminator", 579 "commands : error terminator", 580 "commands : terminator", 581 "command : add_command", 582 "command : cancel_command", 583 "command : clear_command", 584 "command : create_command", 585 "command : commit_command", 586 "command : delete_command", 587 "command : end_command", 588 "command : exit_command", 589 "command : export_command", 590 "command : help_command", 591 "command : info_command", 592 "command : remove_command", 593 "command : revert_command", 594 "command : select_command", 595 "command : set_command", 596 "command : verify_command", 597 "terminator : '\n'", 598 "terminator : ';'", 599 "add_command : ADD", 600 "add_command : ADD TOKEN", 601 "add_command : ADD resource_type", 602 "add_command : ADD property_name property_value", 603 "cancel_command : CANCEL", 604 "cancel_command : CANCEL TOKEN", 605 "create_command : CREATE", 606 "create_command : CREATE TOKEN", 607 "create_command : CREATE TOKEN TOKEN", 608 "create_command : CREATE TOKEN TOKEN TOKEN", 609 "commit_command : COMMIT", 610 "commit_command : COMMIT TOKEN", 611 "delete_command : DELETE", 612 "delete_command : DELETE TOKEN", 613 "end_command : END", 614 "end_command : END TOKEN", 615 "exit_command : EXIT", 616 "exit_command : EXIT TOKEN", 617 "export_command : EXPORT", 618 "export_command : EXPORT TOKEN", 619 "export_command : EXPORT TOKEN TOKEN", 620 "help_command : HELP", 621 "help_command : HELP TOKEN", 622 "info_command : INFO", 623 "info_command : INFO TOKEN", 624 "info_command : INFO resource_type", 625 "info_command : INFO ZONENAME", 626 "info_command : INFO ZONEPATH", 627 "info_command : INFO BRAND", 628 "info_command : INFO AUTOBOOT", 629 "info_command : INFO IPTYPE", 630 "info_command : INFO POOL", 631 "info_command : INFO LIMITPRIV", 632 "info_command : INFO BOOTARGS", 633 "info_command : INFO SCHED", 634 "info_command : INFO SHARES", 635 "info_command : INFO MAXLWPS", 636 "info_command : INFO MAXPROCS", 637 "info_command : INFO MAXSHMMEM", 638 "info_command : INFO MAXSHMIDS", 639 "info_command : INFO MAXMSGIDS", 640 "info_command : INFO MAXSEMIDS", 641 "info_command : INFO HOSTID", 642 "info_command : INFO FS_ALLOWED", 643 "info_command : INFO resource_type property_name EQUAL property_value", 644 "info_command : INFO resource_type property_name EQUAL property_value property_name EQUAL property_value", 645 "info_command : INFO resource_type property_name EQUAL property_value property_name EQUAL property_value property_name EQUAL property_value", 646 "remove_command : REMOVE", 647 "remove_command : REMOVE TOKEN", 648 "remove_command : REMOVE resource_type", 649 "remove_command : REMOVE TOKEN resource_type", 650 "remove_command : REMOVE property_name property_value", 651 "remove_command : REMOVE resource_type property_name EQUAL property_value", 652 "remove_command : REMOVE resource_type property_name EQUAL property_value property_name EQUAL property_value", 653 "remove_command : REMOVE resource_type property_name EQUAL property_value property_name EQUAL property_value property_name EQUAL property_value", 654 "revert_command : REVERT", 655 "revert_command : REVERT TOKEN", 656 "select_command : SELECT", 657 "select_command : SELECT PSET", 658 "select_command : SELECT PCAP", 659 "select_command : SELECT MCAP", 660 "select_command : SELECT resource_type", 661 "select_command : SELECT resource_type property_name EQUAL property_value", 662 "select_command : SELECT resource_type property_name EQUAL property_value property_name EQUAL property_value", 663 "select_command : SELECT resource_type property_name EQUAL property_value property_name EQUAL property_value property_name EQUAL property_value", 664 "set_command : SET", 665 "set_command : SET property_name EQUAL OPEN_SQ_BRACKET CLOSE_SQ_BRACKET", 666 "set_command : SET property_name EQUAL property_value", 667 "set_command : SET TOKEN ZONEPATH EQUAL property_value", 668 "clear_command : CLEAR", 669 "clear_command : CLEAR property_name", 670 "verify_command : VERIFY", 671 "verify_command : VERIFY TOKEN", 672 "resource_type : NET", 673 "resource_type : FS", 674 "resource_type : DEVICE", 675 "resource_type : RCTL", 676 "resource_type : ATTR", 677 "resource_type : DATASET", 678 "resource_type : PSET", 679 "resource_type : PCAP", 680 "resource_type : MCAP", 681 "resource_type : ADMIN", 682 "property_name : SPECIAL", 683 "property_name : RAW", 684 "property_name : DIR", 685 "property_name : TYPE", 686 "property_name : OPTIONS", 687 "property_name : ZONENAME", 688 "property_name : ZONEPATH", 689 "property_name : AUTOBOOT", 690 "property_name : IPTYPE", 691 "property_name : POOL", 692 "property_name : LIMITPRIV", 693 "property_name : BOOTARGS", 694 "property_name : ADDRESS", 695 "property_name : ALLOWED_ADDRESS", 696 "property_name : PHYSICAL", 697 "property_name : DEFROUTER", 698 "property_name : NAME", 699 "property_name : VALUE", 700 "property_name : MATCH", 701 "property_name : PRIV", 702 "property_name : LIMIT", 703 "property_name : ACTION", 704 "property_name : BRAND", 705 "property_name : NCPUS", 706 "property_name : LOCKED", 707 "property_name : SWAP", 708 "property_name : IMPORTANCE", 709 "property_name : SHARES", 710 "property_name : MAXLWPS", 711 "property_name : MAXPROCS", 712 "property_name : MAXSHMMEM", 713 "property_name : MAXSHMIDS", 714 "property_name : MAXMSGIDS", 715 "property_name : MAXSEMIDS", 716 "property_name : SCHED", 717 "property_name : HOSTID", 718 "property_name : USER", 719 "property_name : AUTHS", 720 "property_name : FS_ALLOWED", 721 "property_value : simple_prop_val", 722 "property_value : complex_prop_val", 723 "property_value : list_prop_val", 724 "simple_prop_val : TOKEN", 725 "simple_prop_val : resource_type", 726 "simple_prop_val : property_name", 727 "complex_prop_val : OPEN_PAREN complex_piece CLOSE_PAREN", 728 "complex_piece : property_name EQUAL TOKEN", 729 "complex_piece : property_name EQUAL resource_type", 730 "complex_piece : property_name EQUAL property_name", 731 "complex_piece : property_name EQUAL TOKEN COMMA complex_piece", 732 "complex_piece : property_name EQUAL resource_type COMMA complex_piece", 733 "complex_piece : property_name EQUAL property_name COMMA complex_piece", 734 "list_piece : simple_prop_val", 735 "list_piece : complex_prop_val", 736 "list_piece : simple_prop_val COMMA list_piece", 737 "list_piece : complex_prop_val COMMA list_piece", 738 "list_prop_val : OPEN_SQ_BRACKET list_piece CLOSE_SQ_BRACKET", 739 }; 740 #endif /* YYDEBUG */ 741 # line 1 "/usr/share/lib/ccs/yaccpar" 742 /* 743 * CDDL HEADER START 744 * 745 * The contents of this file are subject to the terms of the 746 * Common Development and Distribution License, Version 1.0 only 747 * (the "License"). You may not use this file except in compliance 748 * with the License. 749 * 750 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 751 * or http://www.opensolaris.org/os/licensing. 752 * See the License for the specific language governing permissions 753 * and limitations under the License. 754 * 755 * When distributing Covered Code, include this CDDL HEADER in each 756 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 757 * If applicable, add the following below this CDDL HEADER, with the 758 * fields enclosed by brackets "[]" replaced with your own identifying 759 * information: Portions Copyright [yyyy] [name of copyright owner] 760 * 761 * CDDL HEADER END 762 */ 763 /* 764 * Copyright 1993 Sun Microsystems, Inc. All rights reserved. 765 * Use is subject to license terms. 766 */ 767 768 /* Copyright (c) 1988 AT&T */ 769 /* All Rights Reserved */ 770 771 #pragma ident "%Z%%M% %I% %E% SMI" 772 773 /* 774 ** Skeleton parser driver for yacc output 775 */ 776 777 /* 778 ** yacc user known macros and defines 779 */ 780 #define YYERROR goto yyerrlab 781 #define YYACCEPT return(0) 782 #define YYABORT return(1) 783 #define YYBACKUP( newtoken, newvalue )\ 784 {\ 785 if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\ 786 {\ 787 yyerror( "syntax error - cannot backup" );\ 788 goto yyerrlab;\ 789 }\ 790 yychar = newtoken;\ 791 yystate = *yyps;\ 792 yylval = newvalue;\ 793 goto yynewstate;\ 794 } 795 #define YYRECOVERING() (!!yyerrflag) 796 #define YYNEW(type) malloc(sizeof(type) * yynewmax) 797 #define YYCOPY(to, from, type) \ 798 (type *) memcpy(to, (char *) from, yymaxdepth * sizeof (type)) 799 #define YYENLARGE( from, type) \ 800 (type *) realloc((char *) from, yynewmax * sizeof(type)) 801 #ifndef YYDEBUG 802 # define YYDEBUG 1 /* make debugging available */ 803 #endif 804 805 /* 806 ** user known globals 807 */ 808 int yydebug; /* set to 1 to get debugging */ 809 810 /* 811 ** driver internal defines 812 */ 813 #define YYFLAG (-10000000) 814 815 /* 816 ** global variables used by the parser 817 */ 818 YYSTYPE *yypv; /* top of value stack */ 819 int *yyps; /* top of state stack */ 820 821 int yystate; /* current state */ 822 int yytmp; /* extra var (lasts between blocks) */ 823 824 int yynerrs; /* number of errors */ 825 int yyerrflag; /* error recovery flag */ 826 int yychar; /* current input token number */ 827 828 829 830 #ifdef YYNMBCHARS 831 #define YYLEX() yycvtok(yylex()) 832 /* 833 ** yycvtok - return a token if i is a wchar_t value that exceeds 255. 834 ** If i<255, i itself is the token. If i>255 but the neither 835 ** of the 30th or 31st bit is on, i is already a token. 836 */ 837 #if defined(__STDC__) || defined(__cplusplus) 838 int yycvtok(int i) 839 #else 840 int yycvtok(i) int i; 841 #endif 842 { 843 int first = 0; 844 int last = YYNMBCHARS - 1; 845 int mid; 846 wchar_t j; 847 848 if(i&0x60000000){/*Must convert to a token. */ 849 if( yymbchars[last].character < i ){ 850 return i;/*Giving up*/ 851 } 852 while ((last>=first)&&(first>=0)) {/*Binary search loop*/ 853 mid = (first+last)/2; 854 j = yymbchars[mid].character; 855 if( j==i ){/*Found*/ 856 return yymbchars[mid].tvalue; 857 }else if( j<i ){ 858 first = mid + 1; 859 }else{ 860 last = mid -1; 861 } 862 } 863 /*No entry in the table.*/ 864 return i;/* Giving up.*/ 865 }else{/* i is already a token. */ 866 return i; 867 } 868 } 869 #else/*!YYNMBCHARS*/ 870 #define YYLEX() yylex() 871 #endif/*!YYNMBCHARS*/ 872 873 /* 874 ** yyparse - return 0 if worked, 1 if syntax error not recovered from 875 */ 876 #if defined(__STDC__) || defined(__cplusplus) 877 int yyparse(void) 878 #else 879 int yyparse() 880 #endif 881 { 882 register YYSTYPE *yypvt = 0; /* top of value stack for $vars */ 883 884 #if defined(__cplusplus) || defined(lint) 885 /* 886 hacks to please C++ and lint - goto's inside 887 switch should never be executed 888 */ 889 static int __yaccpar_lint_hack__ = 0; 890 switch (__yaccpar_lint_hack__) 891 { 892 case 1: goto yyerrlab; 893 case 2: goto yynewstate; 894 } 895 #endif 896 897 /* 898 ** Initialize externals - yyparse may be called more than once 899 */ 900 yypv = &yyv[-1]; 901 yyps = &yys[-1]; 902 yystate = 0; 903 yytmp = 0; 904 yynerrs = 0; 905 yyerrflag = 0; 906 yychar = -1; 907 908 #if YYMAXDEPTH <= 0 909 if (yymaxdepth <= 0) 910 { 911 if ((yymaxdepth = YYEXPAND(0)) <= 0) 912 { 913 yyerror("yacc initialization error"); 914 YYABORT; 915 } 916 } 917 #endif 918 919 { 920 register YYSTYPE *yy_pv; /* top of value stack */ 921 register int *yy_ps; /* top of state stack */ 922 register int yy_state; /* current state */ 923 register int yy_n; /* internal state number info */ 924 goto yystack; /* moved from 6 lines above to here to please C++ */ 925 926 /* 927 ** get globals into registers. 928 ** branch to here only if YYBACKUP was called. 929 */ 930 yynewstate: 931 yy_pv = yypv; 932 yy_ps = yyps; 933 yy_state = yystate; 934 goto yy_newstate; 935 936 /* 937 ** get globals into registers. 938 ** either we just started, or we just finished a reduction 939 */ 940 yystack: 941 yy_pv = yypv; 942 yy_ps = yyps; 943 yy_state = yystate; 944 945 /* 946 ** top of for (;;) loop while no reductions done 947 */ 948 yy_stack: 949 /* 950 ** put a state and value onto the stacks 951 */ 952 #if YYDEBUG 953 /* 954 ** if debugging, look up token value in list of value vs. 955 ** name pairs. 0 and negative (-1) are special values. 956 ** Note: linear search is used since time is not a real 957 ** consideration while debugging. 958 */ 959 if ( yydebug ) 960 { 961 register int yy_i; 962 963 printf( "State %d, token ", yy_state ); 964 if ( yychar == 0 ) 965 printf( "end-of-file\n" ); 966 else if ( yychar < 0 ) 967 printf( "-none-\n" ); 968 else 969 { 970 for ( yy_i = 0; yytoks[yy_i].t_val >= 0; 971 yy_i++ ) 972 { 973 if ( yytoks[yy_i].t_val == yychar ) 974 break; 975 } 976 printf( "%s\n", yytoks[yy_i].t_name ); 977 } 978 } 979 #endif /* YYDEBUG */ 980 if ( ++yy_ps >= &yys[ yymaxdepth ] ) /* room on stack? */ 981 { 982 /* 983 ** reallocate and recover. Note that pointers 984 ** have to be reset, or bad things will happen 985 */ 986 long yyps_index = (yy_ps - yys); 987 long yypv_index = (yy_pv - yyv); 988 long yypvt_index = (yypvt - yyv); 989 int yynewmax; 990 #ifdef YYEXPAND 991 yynewmax = YYEXPAND(yymaxdepth); 992 #else 993 yynewmax = 2 * yymaxdepth; /* double table size */ 994 if (yymaxdepth == YYMAXDEPTH) /* first time growth */ 995 { 996 char *newyys = (char *)YYNEW(int); 997 char *newyyv = (char *)YYNEW(YYSTYPE); 998 if (newyys != 0 && newyyv != 0) 999 { 1000 yys = YYCOPY(newyys, yys, int); 1001 yyv = YYCOPY(newyyv, yyv, YYSTYPE); 1002 } 1003 else 1004 yynewmax = 0; /* failed */ 1005 } 1006 else /* not first time */ 1007 { 1008 yys = YYENLARGE(yys, int); 1009 yyv = YYENLARGE(yyv, YYSTYPE); 1010 if (yys == 0 || yyv == 0) 1011 yynewmax = 0; /* failed */ 1012 } 1013 #endif 1014 if (yynewmax <= yymaxdepth) /* tables not expanded */ 1015 { 1016 yyerror( "yacc stack overflow" ); 1017 YYABORT; 1018 } 1019 yymaxdepth = yynewmax; 1020 1021 yy_ps = yys + yyps_index; 1022 yy_pv = yyv + yypv_index; 1023 yypvt = yyv + yypvt_index; 1024 } 1025 *yy_ps = yy_state; 1026 *++yy_pv = yyval; 1027 1028 /* 1029 ** we have a new state - find out what to do 1030 */ 1031 yy_newstate: 1032 if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG ) 1033 goto yydefault; /* simple state */ 1034 #if YYDEBUG 1035 /* 1036 ** if debugging, need to mark whether new token grabbed 1037 */ 1038 yytmp = yychar < 0; 1039 #endif 1040 if ( ( yychar < 0 ) && ( ( yychar = YYLEX() ) < 0 ) ) 1041 yychar = 0; /* reached EOF */ 1042 #if YYDEBUG 1043 if ( yydebug && yytmp ) 1044 { 1045 register int yy_i; 1046 1047 printf( "Received token " ); 1048 if ( yychar == 0 ) 1049 printf( "end-of-file\n" ); 1050 else if ( yychar < 0 ) 1051 printf( "-none-\n" ); 1052 else 1053 { 1054 for ( yy_i = 0; yytoks[yy_i].t_val >= 0; 1055 yy_i++ ) 1056 { 1057 if ( yytoks[yy_i].t_val == yychar ) 1058 break; 1059 } 1060 printf( "%s\n", yytoks[yy_i].t_name ); 1061 } 1062 } 1063 #endif /* YYDEBUG */ 1064 if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) ) 1065 goto yydefault; 1066 if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar ) /*valid shift*/ 1067 { 1068 yychar = -1; 1069 yyval = yylval; 1070 yy_state = yy_n; 1071 if ( yyerrflag > 0 ) 1072 yyerrflag--; 1073 goto yy_stack; 1074 } 1075 1076 yydefault: 1077 if ( ( yy_n = yydef[ yy_state ] ) == -2 ) 1078 { 1079 #if YYDEBUG 1080 yytmp = yychar < 0; 1081 #endif 1082 if ( ( yychar < 0 ) && ( ( yychar = YYLEX() ) < 0 ) ) 1083 yychar = 0; /* reached EOF */ 1084 #if YYDEBUG 1085 if ( yydebug && yytmp ) 1086 { 1087 register int yy_i; 1088 1089 printf( "Received token " ); 1090 if ( yychar == 0 ) 1091 printf( "end-of-file\n" ); 1092 else if ( yychar < 0 ) 1093 printf( "-none-\n" ); 1094 else 1095 { 1096 for ( yy_i = 0; 1097 yytoks[yy_i].t_val >= 0; 1098 yy_i++ ) 1099 { 1100 if ( yytoks[yy_i].t_val 1101 == yychar ) 1102 { 1103 break; 1104 } 1105 } 1106 printf( "%s\n", yytoks[yy_i].t_name ); 1107 } 1108 } 1109 #endif /* YYDEBUG */ 1110 /* 1111 ** look through exception table 1112 */ 1113 { 1114 register YYCONST int *yyxi = yyexca; 1115 1116 while ( ( *yyxi != -1 ) || 1117 ( yyxi[1] != yy_state ) ) 1118 { 1119 yyxi += 2; 1120 } 1121 while ( ( *(yyxi += 2) >= 0 ) && 1122 ( *yyxi != yychar ) ) 1123 ; 1124 if ( ( yy_n = yyxi[1] ) < 0 ) 1125 YYACCEPT; 1126 } 1127 } 1128 1129 /* 1130 ** check for syntax error 1131 */ 1132 if ( yy_n == 0 ) /* have an error */ 1133 { 1134 /* no worry about speed here! */ 1135 switch ( yyerrflag ) 1136 { 1137 case 0: /* new error */ 1138 yyerror( "syntax error" ); 1139 goto skip_init; 1140 yyerrlab: 1141 /* 1142 ** get globals into registers. 1143 ** we have a user generated syntax type error 1144 */ 1145 yy_pv = yypv; 1146 yy_ps = yyps; 1147 yy_state = yystate; 1148 skip_init: 1149 yynerrs++; 1150 /* FALLTHRU */ 1151 case 1: 1152 case 2: /* incompletely recovered error */ 1153 /* try again... */ 1154 yyerrflag = 3; 1155 /* 1156 ** find state where "error" is a legal 1157 ** shift action 1158 */ 1159 while ( yy_ps >= yys ) 1160 { 1161 yy_n = yypact[ *yy_ps ] + YYERRCODE; 1162 if ( yy_n >= 0 && yy_n < YYLAST && 1163 yychk[yyact[yy_n]] == YYERRCODE) { 1164 /* 1165 ** simulate shift of "error" 1166 */ 1167 yy_state = yyact[ yy_n ]; 1168 goto yy_stack; 1169 } 1170 /* 1171 ** current state has no shift on 1172 ** "error", pop stack 1173 */ 1174 #if YYDEBUG 1175 # define _POP_ "Error recovery pops state %d, uncovers state %d\n" 1176 if ( yydebug ) 1177 printf( _POP_, *yy_ps, 1178 yy_ps[-1] ); 1179 # undef _POP_ 1180 #endif 1181 yy_ps--; 1182 yy_pv--; 1183 } 1184 /* 1185 ** there is no state on stack with "error" as 1186 ** a valid shift. give up. 1187 */ 1188 YYABORT; 1189 case 3: /* no shift yet; eat a token */ 1190 #if YYDEBUG 1191 /* 1192 ** if debugging, look up token in list of 1193 ** pairs. 0 and negative shouldn't occur, 1194 ** but since timing doesn't matter when 1195 ** debugging, it doesn't hurt to leave the 1196 ** tests here. 1197 */ 1198 if ( yydebug ) 1199 { 1200 register int yy_i; 1201 1202 printf( "Error recovery discards " ); 1203 if ( yychar == 0 ) 1204 printf( "token end-of-file\n" ); 1205 else if ( yychar < 0 ) 1206 printf( "token -none-\n" ); 1207 else 1208 { 1209 for ( yy_i = 0; 1210 yytoks[yy_i].t_val >= 0; 1211 yy_i++ ) 1212 { 1213 if ( yytoks[yy_i].t_val 1214 == yychar ) 1215 { 1216 break; 1217 } 1218 } 1219 printf( "token %s\n", 1220 yytoks[yy_i].t_name ); 1221 } 1222 } 1223 #endif /* YYDEBUG */ 1224 if ( yychar == 0 ) /* reached EOF. quit */ 1225 YYABORT; 1226 yychar = -1; 1227 goto yy_newstate; 1228 } 1229 }/* end if ( yy_n == 0 ) */ 1230 /* 1231 ** reduction by production yy_n 1232 ** put stack tops, etc. so things right after switch 1233 */ 1234 #if YYDEBUG 1235 /* 1236 ** if debugging, print the string that is the user's 1237 ** specification of the reduction which is just about 1238 ** to be done. 1239 */ 1240 if ( yydebug ) 1241 printf( "Reduce by (%d) \"%s\"\n", 1242 yy_n, yyreds[ yy_n ] ); 1243 #endif 1244 yytmp = yy_n; /* value to switch over */ 1245 yypvt = yy_pv; /* $vars top of value stack */ 1246 /* 1247 ** Look in goto table for next state 1248 ** Sorry about using yy_state here as temporary 1249 ** register variable, but why not, if it works... 1250 ** If yyr2[ yy_n ] doesn't have the low order bit 1251 ** set, then there is no action to be done for 1252 ** this reduction. So, no saving & unsaving of 1253 ** registers done. The only difference between the 1254 ** code just after the if and the body of the if is 1255 ** the goto yy_stack in the body. This way the test 1256 ** can be made before the choice of what to do is needed. 1257 */ 1258 { 1259 /* length of production doubled with extra bit */ 1260 register int yy_len = yyr2[ yy_n ]; 1261 1262 if ( !( yy_len & 01 ) ) 1263 { 1264 yy_len >>= 1; 1265 yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */ 1266 yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] + 1267 *( yy_ps -= yy_len ) + 1; 1268 if ( yy_state >= YYLAST || 1269 yychk[ yy_state = 1270 yyact[ yy_state ] ] != -yy_n ) 1271 { 1272 yy_state = yyact[ yypgo[ yy_n ] ]; 1273 } 1274 goto yy_stack; 1275 } 1276 yy_len >>= 1; 1277 yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */ 1278 yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] + 1279 *( yy_ps -= yy_len ) + 1; 1280 if ( yy_state >= YYLAST || 1281 yychk[ yy_state = yyact[ yy_state ] ] != -yy_n ) 1282 { 1283 yy_state = yyact[ yypgo[ yy_n ] ]; 1284 } 1285 } 1286 /* save until reenter driver code */ 1287 yystate = yy_state; 1288 yyps = yy_ps; 1289 yypv = yy_pv; 1290 } 1291 /* 1292 ** code supplied by user is placed in this switch 1293 */ 1294 switch( yytmp ) 1295 { 1296 1297 case 1: 1298 # line 176 "zonecfg_grammar.y" 1299 { 1300 if (yypvt[-1].cmd != NULL) { 1301 if (yypvt[-1].cmd->cmd_handler != NULL) 1302 yypvt[-1].cmd->cmd_handler(yypvt[-1].cmd); 1303 free_cmd(yypvt[-1].cmd); 1304 bzero(list, sizeof (list_property_t)); 1305 num_prop_vals = 0; 1306 } 1307 assert_no_unclaimed_tokens(); 1308 return (0); 1309 } break; 1310 case 2: 1311 # line 188 "zonecfg_grammar.y" 1312 { 1313 if (yypvt[-2].cmd != NULL) { 1314 free_cmd(yypvt[-2].cmd); 1315 bzero(list, sizeof (list_property_t)); 1316 num_prop_vals = 0; 1317 } 1318 if (YYRECOVERING()) 1319 YYABORT; 1320 yyclearin; 1321 yyerrok; 1322 } break; 1323 case 3: 1324 # line 200 "zonecfg_grammar.y" 1325 { 1326 if (YYRECOVERING()) 1327 YYABORT; 1328 yyclearin; 1329 yyerrok; 1330 } break; 1331 case 4: 1332 # line 207 "zonecfg_grammar.y" 1333 { 1334 assert_no_unclaimed_tokens(); 1335 return (0); 1336 } break; 1337 case 21: 1338 # line 229 "zonecfg_grammar.y" 1339 { newline_terminated = B_TRUE; } break; 1340 case 22: 1341 # line 230 "zonecfg_grammar.y" 1342 { newline_terminated = B_FALSE; } break; 1343 case 23: 1344 # line 233 "zonecfg_grammar.y" 1345 { 1346 short_usage(CMD_ADD); 1347 (void) fputs("\n", stderr); 1348 usage(B_FALSE, HELP_RES_PROPS); 1349 YYERROR; 1350 } break; 1351 case 24: 1352 # line 240 "zonecfg_grammar.y" 1353 { 1354 if ((yyval.cmd = alloc_cmd()) == NULL) 1355 YYERROR; 1356 cmd = yyval.cmd; 1357 yyval.cmd->cmd_handler = &add_func; 1358 yyval.cmd->cmd_argc = 1; 1359 yyval.cmd->cmd_argv[0] = claim_token(yypvt[-0].strval); 1360 yyval.cmd->cmd_argv[1] = NULL; 1361 } break; 1362 case 25: 1363 # line 250 "zonecfg_grammar.y" 1364 { 1365 if ((yyval.cmd = alloc_cmd()) == NULL) 1366 YYERROR; 1367 cmd = yyval.cmd; 1368 yyval.cmd->cmd_handler = &add_func; 1369 yyval.cmd->cmd_argc = 0; 1370 yyval.cmd->cmd_res_type = yypvt[-0].ival; 1371 yyval.cmd->cmd_prop_nv_pairs = 0; 1372 } break; 1373 case 26: 1374 # line 260 "zonecfg_grammar.y" 1375 { 1376 if ((yyval.cmd = alloc_cmd()) == NULL) 1377 YYERROR; 1378 cmd = yyval.cmd; 1379 yyval.cmd->cmd_handler = &add_func; 1380 yyval.cmd->cmd_argc = 0; 1381 yyval.cmd->cmd_prop_nv_pairs = 1; 1382 yyval.cmd->cmd_prop_name[0] = yypvt[-1].ival; 1383 yyval.cmd->cmd_property_ptr[0] = &property[0]; 1384 } break; 1385 case 27: 1386 # line 272 "zonecfg_grammar.y" 1387 { 1388 if ((yyval.cmd = alloc_cmd()) == NULL) 1389 YYERROR; 1390 cmd = yyval.cmd; 1391 yyval.cmd->cmd_handler = &cancel_func; 1392 yyval.cmd->cmd_argc = 0; 1393 yyval.cmd->cmd_argv[0] = NULL; 1394 } break; 1395 case 28: 1396 # line 281 "zonecfg_grammar.y" 1397 { 1398 if ((yyval.cmd = alloc_cmd()) == NULL) 1399 YYERROR; 1400 cmd = yyval.cmd; 1401 yyval.cmd->cmd_handler = &cancel_func; 1402 yyval.cmd->cmd_argc = 1; 1403 yyval.cmd->cmd_argv[0] = claim_token(yypvt[-0].strval); 1404 yyval.cmd->cmd_argv[1] = NULL; 1405 } break; 1406 case 29: 1407 # line 292 "zonecfg_grammar.y" 1408 { 1409 if ((yyval.cmd = alloc_cmd()) == NULL) 1410 YYERROR; 1411 cmd = yyval.cmd; 1412 yyval.cmd->cmd_handler = &create_func; 1413 yyval.cmd->cmd_argc = 0; 1414 yyval.cmd->cmd_argv[0] = NULL; 1415 } break; 1416 case 30: 1417 # line 301 "zonecfg_grammar.y" 1418 { 1419 if ((yyval.cmd = alloc_cmd()) == NULL) 1420 YYERROR; 1421 cmd = yyval.cmd; 1422 yyval.cmd->cmd_handler = &create_func; 1423 yyval.cmd->cmd_argc = 1; 1424 yyval.cmd->cmd_argv[0] = claim_token(yypvt[-0].strval); 1425 yyval.cmd->cmd_argv[1] = NULL; 1426 } break; 1427 case 31: 1428 # line 311 "zonecfg_grammar.y" 1429 { 1430 if ((yyval.cmd = alloc_cmd()) == NULL) 1431 YYERROR; 1432 cmd = yyval.cmd; 1433 yyval.cmd->cmd_handler = &create_func; 1434 yyval.cmd->cmd_argc = 2; 1435 yyval.cmd->cmd_argv[0] = claim_token(yypvt[-1].strval); 1436 yyval.cmd->cmd_argv[1] = claim_token(yypvt[-0].strval); 1437 yyval.cmd->cmd_argv[2] = NULL; 1438 } break; 1439 case 32: 1440 # line 322 "zonecfg_grammar.y" 1441 { 1442 if ((yyval.cmd = alloc_cmd()) == NULL) 1443 YYERROR; 1444 cmd = yyval.cmd; 1445 yyval.cmd->cmd_handler = &create_func; 1446 yyval.cmd->cmd_argc = 3; 1447 yyval.cmd->cmd_argv[0] = claim_token(yypvt[-2].strval); 1448 yyval.cmd->cmd_argv[1] = claim_token(yypvt[-1].strval); 1449 yyval.cmd->cmd_argv[2] = claim_token(yypvt[-0].strval); 1450 yyval.cmd->cmd_argv[3] = NULL; 1451 } break; 1452 case 33: 1453 # line 335 "zonecfg_grammar.y" 1454 { 1455 if ((yyval.cmd = alloc_cmd()) == NULL) 1456 YYERROR; 1457 cmd = yyval.cmd; 1458 yyval.cmd->cmd_handler = &commit_func; 1459 yyval.cmd->cmd_argc = 0; 1460 yyval.cmd->cmd_argv[0] = NULL; 1461 } break; 1462 case 34: 1463 # line 344 "zonecfg_grammar.y" 1464 { 1465 if ((yyval.cmd = alloc_cmd()) == NULL) 1466 YYERROR; 1467 cmd = yyval.cmd; 1468 yyval.cmd->cmd_handler = &commit_func; 1469 yyval.cmd->cmd_argc = 1; 1470 yyval.cmd->cmd_argv[0] = claim_token(yypvt[-0].strval); 1471 yyval.cmd->cmd_argv[1] = NULL; 1472 } break; 1473 case 35: 1474 # line 355 "zonecfg_grammar.y" 1475 { 1476 if ((yyval.cmd = alloc_cmd()) == NULL) 1477 YYERROR; 1478 cmd = yyval.cmd; 1479 yyval.cmd->cmd_handler = &delete_func; 1480 yyval.cmd->cmd_argc = 0; 1481 yyval.cmd->cmd_argv[0] = NULL; 1482 } break; 1483 case 36: 1484 # line 364 "zonecfg_grammar.y" 1485 { 1486 if ((yyval.cmd = alloc_cmd()) == NULL) 1487 YYERROR; 1488 cmd = yyval.cmd; 1489 yyval.cmd->cmd_handler = &delete_func; 1490 yyval.cmd->cmd_argc = 1; 1491 yyval.cmd->cmd_argv[0] = claim_token(yypvt[-0].strval); 1492 yyval.cmd->cmd_argv[1] = NULL; 1493 } break; 1494 case 37: 1495 # line 375 "zonecfg_grammar.y" 1496 { 1497 if ((yyval.cmd = alloc_cmd()) == NULL) 1498 YYERROR; 1499 cmd = yyval.cmd; 1500 yyval.cmd->cmd_handler = &end_func; 1501 yyval.cmd->cmd_argc = 0; 1502 yyval.cmd->cmd_argv[0] = NULL; 1503 } break; 1504 case 38: 1505 # line 384 "zonecfg_grammar.y" 1506 { 1507 if ((yyval.cmd = alloc_cmd()) == NULL) 1508 YYERROR; 1509 cmd = yyval.cmd; 1510 yyval.cmd->cmd_handler = &end_func; 1511 yyval.cmd->cmd_argc = 1; 1512 yyval.cmd->cmd_argv[0] = claim_token(yypvt[-0].strval); 1513 yyval.cmd->cmd_argv[1] = NULL; 1514 } break; 1515 case 39: 1516 # line 395 "zonecfg_grammar.y" 1517 { 1518 if ((yyval.cmd = alloc_cmd()) == NULL) 1519 YYERROR; 1520 cmd = yyval.cmd; 1521 yyval.cmd->cmd_handler = &exit_func; 1522 yyval.cmd->cmd_argc = 0; 1523 yyval.cmd->cmd_argv[0] = NULL; 1524 } break; 1525 case 40: 1526 # line 404 "zonecfg_grammar.y" 1527 { 1528 if ((yyval.cmd = alloc_cmd()) == NULL) 1529 YYERROR; 1530 cmd = yyval.cmd; 1531 yyval.cmd->cmd_handler = &exit_func; 1532 yyval.cmd->cmd_argc = 1; 1533 yyval.cmd->cmd_argv[0] = claim_token(yypvt[-0].strval); 1534 yyval.cmd->cmd_argv[1] = NULL; 1535 } break; 1536 case 41: 1537 # line 415 "zonecfg_grammar.y" 1538 { 1539 if ((yyval.cmd = alloc_cmd()) == NULL) 1540 YYERROR; 1541 cmd = yyval.cmd; 1542 yyval.cmd->cmd_handler = &export_func; 1543 yyval.cmd->cmd_argc = 0; 1544 yyval.cmd->cmd_argv[0] = NULL; 1545 } break; 1546 case 42: 1547 # line 424 "zonecfg_grammar.y" 1548 { 1549 if ((yyval.cmd = alloc_cmd()) == NULL) 1550 YYERROR; 1551 cmd = yyval.cmd; 1552 yyval.cmd->cmd_handler = &export_func; 1553 yyval.cmd->cmd_argc = 1; 1554 yyval.cmd->cmd_argv[0] = claim_token(yypvt[-0].strval); 1555 yyval.cmd->cmd_argv[1] = NULL; 1556 } break; 1557 case 43: 1558 # line 434 "zonecfg_grammar.y" 1559 { 1560 if ((yyval.cmd = alloc_cmd()) == NULL) 1561 YYERROR; 1562 cmd = yyval.cmd; 1563 yyval.cmd->cmd_handler = &export_func; 1564 yyval.cmd->cmd_argc = 2; 1565 yyval.cmd->cmd_argv[0] = claim_token(yypvt[-1].strval); 1566 yyval.cmd->cmd_argv[1] = claim_token(yypvt[-0].strval); 1567 yyval.cmd->cmd_argv[2] = NULL; 1568 } break; 1569 case 44: 1570 # line 446 "zonecfg_grammar.y" 1571 { 1572 if ((yyval.cmd = alloc_cmd()) == NULL) 1573 YYERROR; 1574 cmd = yyval.cmd; 1575 yyval.cmd->cmd_handler = &help_func; 1576 yyval.cmd->cmd_argc = 0; 1577 yyval.cmd->cmd_argv[0] = NULL; 1578 } break; 1579 case 45: 1580 # line 455 "zonecfg_grammar.y" 1581 { 1582 if ((yyval.cmd = alloc_cmd()) == NULL) 1583 YYERROR; 1584 cmd = yyval.cmd; 1585 yyval.cmd->cmd_handler = &help_func; 1586 yyval.cmd->cmd_argc = 1; 1587 yyval.cmd->cmd_argv[0] = claim_token(yypvt[-0].strval); 1588 yyval.cmd->cmd_argv[1] = NULL; 1589 } break; 1590 case 46: 1591 # line 466 "zonecfg_grammar.y" 1592 { 1593 if ((yyval.cmd = alloc_cmd()) == NULL) 1594 YYERROR; 1595 cmd = yyval.cmd; 1596 yyval.cmd->cmd_handler = &info_func; 1597 yyval.cmd->cmd_res_type = RT_UNKNOWN; 1598 yyval.cmd->cmd_prop_nv_pairs = 0; 1599 } break; 1600 case 47: 1601 # line 475 "zonecfg_grammar.y" 1602 { 1603 short_usage(CMD_INFO); 1604 (void) fputs("\n", stderr); 1605 usage(B_FALSE, HELP_RES_PROPS); 1606 free(claim_token(yypvt[-0].strval)); 1607 YYERROR; 1608 } break; 1609 case 48: 1610 # line 483 "zonecfg_grammar.y" 1611 { 1612 if ((yyval.cmd = alloc_cmd()) == NULL) 1613 YYERROR; 1614 cmd = yyval.cmd; 1615 yyval.cmd->cmd_handler = &info_func; 1616 yyval.cmd->cmd_res_type = yypvt[-0].ival; 1617 yyval.cmd->cmd_prop_nv_pairs = 0; 1618 } break; 1619 case 49: 1620 # line 492 "zonecfg_grammar.y" 1621 { 1622 if ((yyval.cmd = alloc_cmd()) == NULL) 1623 YYERROR; 1624 cmd = yyval.cmd; 1625 yyval.cmd->cmd_handler = &info_func; 1626 yyval.cmd->cmd_res_type = RT_ZONENAME; 1627 yyval.cmd->cmd_prop_nv_pairs = 0; 1628 } break; 1629 case 50: 1630 # line 501 "zonecfg_grammar.y" 1631 { 1632 if ((yyval.cmd = alloc_cmd()) == NULL) 1633 YYERROR; 1634 cmd = yyval.cmd; 1635 yyval.cmd->cmd_handler = &info_func; 1636 yyval.cmd->cmd_res_type = RT_ZONEPATH; 1637 yyval.cmd->cmd_prop_nv_pairs = 0; 1638 } break; 1639 case 51: 1640 # line 510 "zonecfg_grammar.y" 1641 { 1642 if ((yyval.cmd = alloc_cmd()) == NULL) 1643 YYERROR; 1644 cmd = yyval.cmd; 1645 yyval.cmd->cmd_handler = &info_func; 1646 yyval.cmd->cmd_res_type = RT_BRAND; 1647 yyval.cmd->cmd_prop_nv_pairs = 0; 1648 } break; 1649 case 52: 1650 # line 519 "zonecfg_grammar.y" 1651 { 1652 if ((yyval.cmd = alloc_cmd()) == NULL) 1653 YYERROR; 1654 cmd = yyval.cmd; 1655 yyval.cmd->cmd_handler = &info_func; 1656 yyval.cmd->cmd_res_type = RT_AUTOBOOT; 1657 yyval.cmd->cmd_prop_nv_pairs = 0; 1658 } break; 1659 case 53: 1660 # line 528 "zonecfg_grammar.y" 1661 { 1662 if ((yyval.cmd = alloc_cmd()) == NULL) 1663 YYERROR; 1664 cmd = yyval.cmd; 1665 yyval.cmd->cmd_handler = &info_func; 1666 yyval.cmd->cmd_res_type = RT_IPTYPE; 1667 yyval.cmd->cmd_prop_nv_pairs = 0; 1668 } break; 1669 case 54: 1670 # line 537 "zonecfg_grammar.y" 1671 { 1672 if ((yyval.cmd = alloc_cmd()) == NULL) 1673 YYERROR; 1674 cmd = yyval.cmd; 1675 yyval.cmd->cmd_handler = &info_func; 1676 yyval.cmd->cmd_res_type = RT_POOL; 1677 yyval.cmd->cmd_prop_nv_pairs = 0; 1678 } break; 1679 case 55: 1680 # line 546 "zonecfg_grammar.y" 1681 { 1682 if ((yyval.cmd = alloc_cmd()) == NULL) 1683 YYERROR; 1684 cmd = yyval.cmd; 1685 yyval.cmd->cmd_handler = &info_func; 1686 yyval.cmd->cmd_res_type = RT_LIMITPRIV; 1687 yyval.cmd->cmd_prop_nv_pairs = 0; 1688 } break; 1689 case 56: 1690 # line 555 "zonecfg_grammar.y" 1691 { 1692 if ((yyval.cmd = alloc_cmd()) == NULL) 1693 YYERROR; 1694 cmd = yyval.cmd; 1695 yyval.cmd->cmd_handler = &info_func; 1696 yyval.cmd->cmd_res_type = RT_BOOTARGS; 1697 yyval.cmd->cmd_prop_nv_pairs = 0; 1698 } break; 1699 case 57: 1700 # line 564 "zonecfg_grammar.y" 1701 { 1702 if ((yyval.cmd = alloc_cmd()) == NULL) 1703 YYERROR; 1704 cmd = yyval.cmd; 1705 yyval.cmd->cmd_handler = &info_func; 1706 yyval.cmd->cmd_res_type = RT_SCHED; 1707 yyval.cmd->cmd_prop_nv_pairs = 0; 1708 } break; 1709 case 58: 1710 # line 573 "zonecfg_grammar.y" 1711 { 1712 if ((yyval.cmd = alloc_cmd()) == NULL) 1713 YYERROR; 1714 cmd = yyval.cmd; 1715 yyval.cmd->cmd_handler = &info_func; 1716 yyval.cmd->cmd_res_type = RT_SHARES; 1717 yyval.cmd->cmd_prop_nv_pairs = 0; 1718 } break; 1719 case 59: 1720 # line 582 "zonecfg_grammar.y" 1721 { 1722 if ((yyval.cmd = alloc_cmd()) == NULL) 1723 YYERROR; 1724 cmd = yyval.cmd; 1725 yyval.cmd->cmd_handler = &info_func; 1726 yyval.cmd->cmd_res_type = RT_MAXLWPS; 1727 yyval.cmd->cmd_prop_nv_pairs = 0; 1728 } break; 1729 case 60: 1730 # line 591 "zonecfg_grammar.y" 1731 { 1732 if ((yyval.cmd = alloc_cmd()) == NULL) 1733 YYERROR; 1734 cmd = yyval.cmd; 1735 yyval.cmd->cmd_handler = &info_func; 1736 yyval.cmd->cmd_res_type = RT_MAXPROCS; 1737 yyval.cmd->cmd_prop_nv_pairs = 0; 1738 } break; 1739 case 61: 1740 # line 600 "zonecfg_grammar.y" 1741 { 1742 if ((yyval.cmd = alloc_cmd()) == NULL) 1743 YYERROR; 1744 cmd = yyval.cmd; 1745 yyval.cmd->cmd_handler = &info_func; 1746 yyval.cmd->cmd_res_type = RT_MAXSHMMEM; 1747 yyval.cmd->cmd_prop_nv_pairs = 0; 1748 } break; 1749 case 62: 1750 # line 609 "zonecfg_grammar.y" 1751 { 1752 if ((yyval.cmd = alloc_cmd()) == NULL) 1753 YYERROR; 1754 cmd = yyval.cmd; 1755 yyval.cmd->cmd_handler = &info_func; 1756 yyval.cmd->cmd_res_type = RT_MAXSHMIDS; 1757 yyval.cmd->cmd_prop_nv_pairs = 0; 1758 } break; 1759 case 63: 1760 # line 618 "zonecfg_grammar.y" 1761 { 1762 if ((yyval.cmd = alloc_cmd()) == NULL) 1763 YYERROR; 1764 cmd = yyval.cmd; 1765 yyval.cmd->cmd_handler = &info_func; 1766 yyval.cmd->cmd_res_type = RT_MAXMSGIDS; 1767 yyval.cmd->cmd_prop_nv_pairs = 0; 1768 } break; 1769 case 64: 1770 # line 627 "zonecfg_grammar.y" 1771 { 1772 if ((yyval.cmd = alloc_cmd()) == NULL) 1773 YYERROR; 1774 cmd = yyval.cmd; 1775 yyval.cmd->cmd_handler = &info_func; 1776 yyval.cmd->cmd_res_type = RT_MAXSEMIDS; 1777 yyval.cmd->cmd_prop_nv_pairs = 0; 1778 } break; 1779 case 65: 1780 # line 636 "zonecfg_grammar.y" 1781 { 1782 if ((yyval.cmd = alloc_cmd()) == NULL) 1783 YYERROR; 1784 cmd = yyval.cmd; 1785 yyval.cmd->cmd_handler = &info_func; 1786 yyval.cmd->cmd_res_type = RT_HOSTID; 1787 yyval.cmd->cmd_prop_nv_pairs = 0; 1788 } break; 1789 case 66: 1790 # line 645 "zonecfg_grammar.y" 1791 { 1792 if ((yyval.cmd = alloc_cmd()) == NULL) 1793 YYERROR; 1794 cmd = yyval.cmd; 1795 yyval.cmd->cmd_handler = &info_func; 1796 yyval.cmd->cmd_res_type = RT_FS_ALLOWED; 1797 yyval.cmd->cmd_prop_nv_pairs = 0; 1798 } break; 1799 case 67: 1800 # line 654 "zonecfg_grammar.y" 1801 { 1802 if ((yyval.cmd = alloc_cmd()) == NULL) 1803 YYERROR; 1804 cmd = yyval.cmd; 1805 yyval.cmd->cmd_handler = &info_func; 1806 yyval.cmd->cmd_res_type = yypvt[-3].ival; 1807 yyval.cmd->cmd_prop_nv_pairs = 1; 1808 yyval.cmd->cmd_prop_name[0] = yypvt[-2].ival; 1809 yyval.cmd->cmd_property_ptr[0] = &property[0]; 1810 } break; 1811 case 68: 1812 # line 665 "zonecfg_grammar.y" 1813 { 1814 if ((yyval.cmd = alloc_cmd()) == NULL) 1815 YYERROR; 1816 cmd = yyval.cmd; 1817 yyval.cmd->cmd_handler = &info_func; 1818 yyval.cmd->cmd_res_type = yypvt[-6].ival; 1819 yyval.cmd->cmd_prop_nv_pairs = 2; 1820 yyval.cmd->cmd_prop_name[0] = yypvt[-5].ival; 1821 yyval.cmd->cmd_property_ptr[0] = &property[0]; 1822 yyval.cmd->cmd_prop_name[1] = yypvt[-2].ival; 1823 yyval.cmd->cmd_property_ptr[1] = &property[1]; 1824 } break; 1825 case 69: 1826 # line 678 "zonecfg_grammar.y" 1827 { 1828 if ((yyval.cmd = alloc_cmd()) == NULL) 1829 YYERROR; 1830 cmd = yyval.cmd; 1831 yyval.cmd->cmd_handler = &info_func; 1832 yyval.cmd->cmd_res_type = yypvt[-9].ival; 1833 yyval.cmd->cmd_prop_nv_pairs = 3; 1834 yyval.cmd->cmd_prop_name[0] = yypvt[-8].ival; 1835 yyval.cmd->cmd_property_ptr[0] = &property[0]; 1836 yyval.cmd->cmd_prop_name[1] = yypvt[-5].ival; 1837 yyval.cmd->cmd_property_ptr[1] = &property[1]; 1838 yyval.cmd->cmd_prop_name[2] = yypvt[-2].ival; 1839 yyval.cmd->cmd_property_ptr[2] = &property[2]; 1840 } break; 1841 case 70: 1842 # line 694 "zonecfg_grammar.y" 1843 { 1844 short_usage(CMD_REMOVE); 1845 (void) fputs("\n", stderr); 1846 usage(B_FALSE, HELP_RES_PROPS); 1847 YYERROR; 1848 } break; 1849 case 71: 1850 # line 701 "zonecfg_grammar.y" 1851 { 1852 short_usage(CMD_REMOVE); 1853 (void) fputs("\n", stderr); 1854 usage(B_FALSE, HELP_RES_PROPS); 1855 free(claim_token(yypvt[-0].strval)); 1856 YYERROR; 1857 } break; 1858 case 72: 1859 # line 709 "zonecfg_grammar.y" 1860 { 1861 if ((yyval.cmd = alloc_cmd()) == NULL) 1862 YYERROR; 1863 cmd = yyval.cmd; 1864 yyval.cmd->cmd_handler = &remove_func; 1865 yyval.cmd->cmd_res_type = yypvt[-0].ival; 1866 } break; 1867 case 73: 1868 # line 717 "zonecfg_grammar.y" 1869 { 1870 if ((yyval.cmd = alloc_cmd()) == NULL) 1871 YYERROR; 1872 cmd = yyval.cmd; 1873 yyval.cmd->cmd_handler = &remove_func; 1874 yyval.cmd->cmd_res_type = yypvt[-0].ival; 1875 yyval.cmd->cmd_argc = 1; 1876 yyval.cmd->cmd_argv[0] = claim_token(yypvt[-1].strval); 1877 yyval.cmd->cmd_argv[1] = NULL; 1878 } break; 1879 case 74: 1880 # line 728 "zonecfg_grammar.y" 1881 { 1882 if ((yyval.cmd = alloc_cmd()) == NULL) 1883 YYERROR; 1884 cmd = yyval.cmd; 1885 yyval.cmd->cmd_handler = &remove_func; 1886 yyval.cmd->cmd_prop_nv_pairs = 1; 1887 yyval.cmd->cmd_prop_name[0] = yypvt[-1].ival; 1888 yyval.cmd->cmd_property_ptr[0] = &property[0]; 1889 } break; 1890 case 75: 1891 # line 738 "zonecfg_grammar.y" 1892 { 1893 if ((yyval.cmd = alloc_cmd()) == NULL) 1894 YYERROR; 1895 cmd = yyval.cmd; 1896 yyval.cmd->cmd_handler = &remove_func; 1897 yyval.cmd->cmd_res_type = yypvt[-3].ival; 1898 yyval.cmd->cmd_prop_nv_pairs = 1; 1899 yyval.cmd->cmd_prop_name[0] = yypvt[-2].ival; 1900 yyval.cmd->cmd_property_ptr[0] = &property[0]; 1901 } break; 1902 case 76: 1903 # line 749 "zonecfg_grammar.y" 1904 { 1905 if ((yyval.cmd = alloc_cmd()) == NULL) 1906 YYERROR; 1907 cmd = yyval.cmd; 1908 yyval.cmd->cmd_handler = &remove_func; 1909 yyval.cmd->cmd_res_type = yypvt[-6].ival; 1910 yyval.cmd->cmd_prop_nv_pairs = 2; 1911 yyval.cmd->cmd_prop_name[0] = yypvt[-5].ival; 1912 yyval.cmd->cmd_property_ptr[0] = &property[0]; 1913 yyval.cmd->cmd_prop_name[1] = yypvt[-2].ival; 1914 yyval.cmd->cmd_property_ptr[1] = &property[1]; 1915 } break; 1916 case 77: 1917 # line 762 "zonecfg_grammar.y" 1918 { 1919 if ((yyval.cmd = alloc_cmd()) == NULL) 1920 YYERROR; 1921 cmd = yyval.cmd; 1922 yyval.cmd->cmd_handler = &remove_func; 1923 yyval.cmd->cmd_res_type = yypvt[-9].ival; 1924 yyval.cmd->cmd_prop_nv_pairs = 3; 1925 yyval.cmd->cmd_prop_name[0] = yypvt[-8].ival; 1926 yyval.cmd->cmd_property_ptr[0] = &property[0]; 1927 yyval.cmd->cmd_prop_name[1] = yypvt[-5].ival; 1928 yyval.cmd->cmd_property_ptr[1] = &property[1]; 1929 yyval.cmd->cmd_prop_name[2] = yypvt[-2].ival; 1930 yyval.cmd->cmd_property_ptr[2] = &property[2]; 1931 } break; 1932 case 78: 1933 # line 778 "zonecfg_grammar.y" 1934 { 1935 if ((yyval.cmd = alloc_cmd()) == NULL) 1936 YYERROR; 1937 cmd = yyval.cmd; 1938 yyval.cmd->cmd_handler = &revert_func; 1939 yyval.cmd->cmd_argc = 0; 1940 yyval.cmd->cmd_argv[0] = NULL; 1941 } break; 1942 case 79: 1943 # line 787 "zonecfg_grammar.y" 1944 { 1945 if ((yyval.cmd = alloc_cmd()) == NULL) 1946 YYERROR; 1947 cmd = yyval.cmd; 1948 yyval.cmd->cmd_handler = &revert_func; 1949 yyval.cmd->cmd_argc = 1; 1950 yyval.cmd->cmd_argv[0] = claim_token(yypvt[-0].strval); 1951 yyval.cmd->cmd_argv[1] = NULL; 1952 } break; 1953 case 80: 1954 # line 798 "zonecfg_grammar.y" 1955 { 1956 short_usage(CMD_SELECT); 1957 (void) fputs("\n", stderr); 1958 usage(B_FALSE, HELP_RES_PROPS); 1959 YYERROR; 1960 } break; 1961 case 81: 1962 # line 805 "zonecfg_grammar.y" 1963 { 1964 if ((yyval.cmd = alloc_cmd()) == NULL) 1965 YYERROR; 1966 cmd = yyval.cmd; 1967 yyval.cmd->cmd_handler = &select_func; 1968 yyval.cmd->cmd_res_type = RT_DCPU; 1969 } break; 1970 case 82: 1971 # line 813 "zonecfg_grammar.y" 1972 { 1973 if ((yyval.cmd = alloc_cmd()) == NULL) 1974 YYERROR; 1975 cmd = yyval.cmd; 1976 yyval.cmd->cmd_handler = &select_func; 1977 yyval.cmd->cmd_res_type = RT_PCAP; 1978 } break; 1979 case 83: 1980 # line 821 "zonecfg_grammar.y" 1981 { 1982 if ((yyval.cmd = alloc_cmd()) == NULL) 1983 YYERROR; 1984 cmd = yyval.cmd; 1985 yyval.cmd->cmd_handler = &select_func; 1986 yyval.cmd->cmd_res_type = RT_MCAP; 1987 } break; 1988 case 84: 1989 # line 829 "zonecfg_grammar.y" 1990 { 1991 short_usage(CMD_SELECT); 1992 YYERROR; 1993 } break; 1994 case 85: 1995 # line 834 "zonecfg_grammar.y" 1996 { 1997 if ((yyval.cmd = alloc_cmd()) == NULL) 1998 YYERROR; 1999 cmd = yyval.cmd; 2000 yyval.cmd->cmd_handler = &select_func; 2001 yyval.cmd->cmd_res_type = yypvt[-3].ival; 2002 yyval.cmd->cmd_prop_nv_pairs = 1; 2003 yyval.cmd->cmd_prop_name[0] = yypvt[-2].ival; 2004 yyval.cmd->cmd_property_ptr[0] = &property[0]; 2005 } break; 2006 case 86: 2007 # line 845 "zonecfg_grammar.y" 2008 { 2009 if ((yyval.cmd = alloc_cmd()) == NULL) 2010 YYERROR; 2011 cmd = yyval.cmd; 2012 yyval.cmd->cmd_handler = &select_func; 2013 yyval.cmd->cmd_res_type = yypvt[-6].ival; 2014 yyval.cmd->cmd_prop_nv_pairs = 2; 2015 yyval.cmd->cmd_prop_name[0] = yypvt[-5].ival; 2016 yyval.cmd->cmd_property_ptr[0] = &property[0]; 2017 yyval.cmd->cmd_prop_name[1] = yypvt[-2].ival; 2018 yyval.cmd->cmd_property_ptr[1] = &property[1]; 2019 } break; 2020 case 87: 2021 # line 858 "zonecfg_grammar.y" 2022 { 2023 if ((yyval.cmd = alloc_cmd()) == NULL) 2024 YYERROR; 2025 cmd = yyval.cmd; 2026 yyval.cmd->cmd_handler = &select_func; 2027 yyval.cmd->cmd_res_type = yypvt[-9].ival; 2028 yyval.cmd->cmd_prop_nv_pairs = 3; 2029 yyval.cmd->cmd_prop_name[0] = yypvt[-8].ival; 2030 yyval.cmd->cmd_property_ptr[0] = &property[0]; 2031 yyval.cmd->cmd_prop_name[1] = yypvt[-5].ival; 2032 yyval.cmd->cmd_property_ptr[1] = &property[1]; 2033 yyval.cmd->cmd_prop_name[2] = yypvt[-2].ival; 2034 yyval.cmd->cmd_property_ptr[2] = &property[2]; 2035 } break; 2036 case 88: 2037 # line 874 "zonecfg_grammar.y" 2038 { 2039 short_usage(CMD_SET); 2040 (void) fputs("\n", stderr); 2041 usage(B_FALSE, HELP_PROPS); 2042 YYERROR; 2043 } break; 2044 case 89: 2045 # line 881 "zonecfg_grammar.y" 2046 { 2047 if ((yyval.cmd = alloc_cmd()) == NULL) 2048 YYERROR; 2049 cmd = yyval.cmd; 2050 yyval.cmd->cmd_handler = &set_func; 2051 yyval.cmd->cmd_prop_nv_pairs = 0; 2052 yyval.cmd->cmd_prop_name[0] = yypvt[-3].ival; 2053 property[0].pv_type = PROP_VAL_LIST; 2054 property[0].pv_list = NULL; 2055 yyval.cmd->cmd_property_ptr[0] = &property[0]; 2056 } break; 2057 case 90: 2058 # line 893 "zonecfg_grammar.y" 2059 { 2060 if ((yyval.cmd = alloc_cmd()) == NULL) 2061 YYERROR; 2062 cmd = yyval.cmd; 2063 yyval.cmd->cmd_handler = &set_func; 2064 yyval.cmd->cmd_prop_nv_pairs = 1; 2065 yyval.cmd->cmd_prop_name[0] = yypvt[-2].ival; 2066 yyval.cmd->cmd_property_ptr[0] = &property[0]; 2067 } break; 2068 case 91: 2069 # line 903 "zonecfg_grammar.y" 2070 { 2071 if ((yyval.cmd = alloc_cmd()) == NULL) 2072 YYERROR; 2073 cmd = yyval.cmd; 2074 yyval.cmd->cmd_argc = 1; 2075 yyval.cmd->cmd_argv[0] = claim_token(yypvt[-3].strval); 2076 yyval.cmd->cmd_argv[1] = NULL; 2077 yyval.cmd->cmd_handler = &set_func; 2078 yyval.cmd->cmd_prop_nv_pairs = 1; 2079 yyval.cmd->cmd_prop_name[0] = PT_ZONEPATH; 2080 yyval.cmd->cmd_property_ptr[0] = &property[0]; 2081 } break; 2082 case 92: 2083 # line 917 "zonecfg_grammar.y" 2084 { 2085 short_usage(CMD_CLEAR); 2086 (void) fputs("\n", stderr); 2087 usage(B_FALSE, HELP_PROPS); 2088 YYERROR; 2089 } break; 2090 case 93: 2091 # line 924 "zonecfg_grammar.y" 2092 { 2093 if ((yyval.cmd = alloc_cmd()) == NULL) 2094 YYERROR; 2095 cmd = yyval.cmd; 2096 yyval.cmd->cmd_handler = &clear_func; 2097 yyval.cmd->cmd_res_type = yypvt[-0].ival; 2098 } break; 2099 case 94: 2100 # line 933 "zonecfg_grammar.y" 2101 { 2102 if ((yyval.cmd = alloc_cmd()) == NULL) 2103 YYERROR; 2104 cmd = yyval.cmd; 2105 yyval.cmd->cmd_handler = &verify_func; 2106 yyval.cmd->cmd_argc = 0; 2107 yyval.cmd->cmd_argv[0] = NULL; 2108 } break; 2109 case 95: 2110 # line 942 "zonecfg_grammar.y" 2111 { 2112 if ((yyval.cmd = alloc_cmd()) == NULL) 2113 YYERROR; 2114 cmd = yyval.cmd; 2115 yyval.cmd->cmd_handler = &verify_func; 2116 yyval.cmd->cmd_argc = 1; 2117 yyval.cmd->cmd_argv[0] = claim_token(yypvt[-0].strval); 2118 yyval.cmd->cmd_argv[1] = NULL; 2119 } break; 2120 case 96: 2121 # line 952 "zonecfg_grammar.y" 2122 { yyval.ival = RT_NET; } break; 2123 case 97: 2124 # line 953 "zonecfg_grammar.y" 2125 { yyval.ival = RT_FS; } break; 2126 case 98: 2127 # line 954 "zonecfg_grammar.y" 2128 { yyval.ival = RT_DEVICE; } break; 2129 case 99: 2130 # line 955 "zonecfg_grammar.y" 2131 { yyval.ival = RT_RCTL; } break; 2132 case 100: 2133 # line 956 "zonecfg_grammar.y" 2134 { yyval.ival = RT_ATTR; } break; 2135 case 101: 2136 # line 957 "zonecfg_grammar.y" 2137 { yyval.ival = RT_DATASET; } break; 2138 case 102: 2139 # line 958 "zonecfg_grammar.y" 2140 { yyval.ival = RT_DCPU; } break; 2141 case 103: 2142 # line 959 "zonecfg_grammar.y" 2143 { yyval.ival = RT_PCAP; } break; 2144 case 104: 2145 # line 960 "zonecfg_grammar.y" 2146 { yyval.ival = RT_MCAP; } break; 2147 case 105: 2148 # line 961 "zonecfg_grammar.y" 2149 { yyval.ival = RT_ADMIN; } break; 2150 case 106: 2151 # line 963 "zonecfg_grammar.y" 2152 { yyval.ival = PT_SPECIAL; } break; 2153 case 107: 2154 # line 964 "zonecfg_grammar.y" 2155 { yyval.ival = PT_RAW; } break; 2156 case 108: 2157 # line 965 "zonecfg_grammar.y" 2158 { yyval.ival = PT_DIR; } break; 2159 case 109: 2160 # line 966 "zonecfg_grammar.y" 2161 { yyval.ival = PT_TYPE; } break; 2162 case 110: 2163 # line 967 "zonecfg_grammar.y" 2164 { yyval.ival = PT_OPTIONS; } break; 2165 case 111: 2166 # line 968 "zonecfg_grammar.y" 2167 { yyval.ival = PT_ZONENAME; } break; 2168 case 112: 2169 # line 969 "zonecfg_grammar.y" 2170 { yyval.ival = PT_ZONEPATH; } break; 2171 case 113: 2172 # line 970 "zonecfg_grammar.y" 2173 { yyval.ival = PT_AUTOBOOT; } break; 2174 case 114: 2175 # line 971 "zonecfg_grammar.y" 2176 { yyval.ival = PT_IPTYPE; } break; 2177 case 115: 2178 # line 972 "zonecfg_grammar.y" 2179 { yyval.ival = PT_POOL; } break; 2180 case 116: 2181 # line 973 "zonecfg_grammar.y" 2182 { yyval.ival = PT_LIMITPRIV; } break; 2183 case 117: 2184 # line 974 "zonecfg_grammar.y" 2185 { yyval.ival = PT_BOOTARGS; } break; 2186 case 118: 2187 # line 975 "zonecfg_grammar.y" 2188 { yyval.ival = PT_ADDRESS; } break; 2189 case 119: 2190 # line 976 "zonecfg_grammar.y" 2191 { yyval.ival = PT_ALLOWED_ADDRESS; } break; 2192 case 120: 2193 # line 977 "zonecfg_grammar.y" 2194 { yyval.ival = PT_PHYSICAL; } break; 2195 case 121: 2196 # line 978 "zonecfg_grammar.y" 2197 { yyval.ival = PT_DEFROUTER; } break; 2198 case 122: 2199 # line 979 "zonecfg_grammar.y" 2200 { yyval.ival = PT_NAME; } break; 2201 case 123: 2202 # line 980 "zonecfg_grammar.y" 2203 { yyval.ival = PT_VALUE; } break; 2204 case 124: 2205 # line 981 "zonecfg_grammar.y" 2206 { yyval.ival = PT_MATCH; } break; 2207 case 125: 2208 # line 982 "zonecfg_grammar.y" 2209 { yyval.ival = PT_PRIV; } break; 2210 case 126: 2211 # line 983 "zonecfg_grammar.y" 2212 { yyval.ival = PT_LIMIT; } break; 2213 case 127: 2214 # line 984 "zonecfg_grammar.y" 2215 { yyval.ival = PT_ACTION; } break; 2216 case 128: 2217 # line 985 "zonecfg_grammar.y" 2218 { yyval.ival = PT_BRAND; } break; 2219 case 129: 2220 # line 986 "zonecfg_grammar.y" 2221 { yyval.ival = PT_NCPUS; } break; 2222 case 130: 2223 # line 987 "zonecfg_grammar.y" 2224 { yyval.ival = PT_LOCKED; } break; 2225 case 131: 2226 # line 988 "zonecfg_grammar.y" 2227 { yyval.ival = PT_SWAP; } break; 2228 case 132: 2229 # line 989 "zonecfg_grammar.y" 2230 { yyval.ival = PT_IMPORTANCE; } break; 2231 case 133: 2232 # line 990 "zonecfg_grammar.y" 2233 { yyval.ival = PT_SHARES; } break; 2234 case 134: 2235 # line 991 "zonecfg_grammar.y" 2236 { yyval.ival = PT_MAXLWPS; } break; 2237 case 135: 2238 # line 992 "zonecfg_grammar.y" 2239 { yyval.ival = PT_MAXPROCS; } break; 2240 case 136: 2241 # line 993 "zonecfg_grammar.y" 2242 { yyval.ival = PT_MAXSHMMEM; } break; 2243 case 137: 2244 # line 994 "zonecfg_grammar.y" 2245 { yyval.ival = PT_MAXSHMIDS; } break; 2246 case 138: 2247 # line 995 "zonecfg_grammar.y" 2248 { yyval.ival = PT_MAXMSGIDS; } break; 2249 case 139: 2250 # line 996 "zonecfg_grammar.y" 2251 { yyval.ival = PT_MAXSEMIDS; } break; 2252 case 140: 2253 # line 997 "zonecfg_grammar.y" 2254 { yyval.ival = PT_SCHED; } break; 2255 case 141: 2256 # line 998 "zonecfg_grammar.y" 2257 { yyval.ival = PT_HOSTID; } break; 2258 case 142: 2259 # line 999 "zonecfg_grammar.y" 2260 { yyval.ival = PT_USER; } break; 2261 case 143: 2262 # line 1000 "zonecfg_grammar.y" 2263 { yyval.ival = PT_AUTHS; } break; 2264 case 144: 2265 # line 1001 "zonecfg_grammar.y" 2266 { yyval.ival = PT_FS_ALLOWED; } break; 2267 case 145: 2268 # line 1019 "zonecfg_grammar.y" 2269 { 2270 property[num_prop_vals].pv_type = PROP_VAL_SIMPLE; 2271 property[num_prop_vals].pv_simple = yypvt[-0].strval; 2272 if (list[num_prop_vals] != NULL) { 2273 free_outer_list(list[num_prop_vals]); 2274 list[num_prop_vals] = NULL; 2275 } 2276 num_prop_vals++; 2277 } break; 2278 case 146: 2279 # line 1029 "zonecfg_grammar.y" 2280 { 2281 property[num_prop_vals].pv_type = PROP_VAL_COMPLEX; 2282 property[num_prop_vals].pv_complex = complex; 2283 if (list[num_prop_vals] != NULL) { 2284 free_outer_list(list[num_prop_vals]); 2285 list[num_prop_vals] = NULL; 2286 } 2287 num_prop_vals++; 2288 } break; 2289 case 147: 2290 # line 1039 "zonecfg_grammar.y" 2291 { 2292 property[num_prop_vals].pv_type = PROP_VAL_LIST; 2293 property[num_prop_vals].pv_list = list[num_prop_vals]; 2294 num_prop_vals++; 2295 } break; 2296 case 148: 2297 # line 1063 "zonecfg_grammar.y" 2298 { 2299 yyval.strval = simple_prop_val_func(yypvt[-0].strval); 2300 free(claim_token(yypvt[-0].strval)); 2301 if (yyval.strval == NULL) 2302 YYERROR; 2303 } break; 2304 case 149: 2305 # line 1070 "zonecfg_grammar.y" 2306 { 2307 if ((yyval.strval = simple_prop_val_func(res_types[yypvt[-0].ival])) == NULL) 2308 YYERROR; 2309 } break; 2310 case 150: 2311 # line 1075 "zonecfg_grammar.y" 2312 { 2313 if ((yyval.strval = simple_prop_val_func(prop_types[yypvt[-0].ival])) == NULL) 2314 YYERROR; 2315 } break; 2316 case 151: 2317 # line 1081 "zonecfg_grammar.y" 2318 { 2319 if ((new_list = alloc_list()) == NULL) 2320 YYERROR; 2321 new_list->lp_simple = NULL; 2322 new_list->lp_complex = complex; 2323 new_list->lp_next = NULL; 2324 if (list[num_prop_vals] == NULL) { 2325 list[num_prop_vals] = new_list; 2326 } else { 2327 for (tmp_list = list[num_prop_vals]; tmp_list != NULL; 2328 tmp_list = tmp_list->lp_next) 2329 last = tmp_list; 2330 last->lp_next = new_list; 2331 } 2332 } break; 2333 case 152: 2334 # line 1098 "zonecfg_grammar.y" 2335 { 2336 yyval.complex = complex_piece_func(yypvt[-2].ival, yypvt[-0].strval, NULL); 2337 free(claim_token(yypvt[-0].strval)); 2338 if (yyval.complex == NULL) 2339 YYERROR; 2340 } break; 2341 case 153: 2342 # line 1105 "zonecfg_grammar.y" 2343 { 2344 if ((yyval.complex = complex_piece_func(yypvt[-2].ival, res_types[yypvt[-0].ival], NULL)) == NULL) 2345 YYERROR; 2346 } break; 2347 case 154: 2348 # line 1110 "zonecfg_grammar.y" 2349 { 2350 if ((yyval.complex = complex_piece_func(yypvt[-2].ival, prop_types[yypvt[-0].ival], NULL)) == NULL) 2351 YYERROR; 2352 } break; 2353 case 155: 2354 # line 1115 "zonecfg_grammar.y" 2355 { 2356 yyval.complex = complex_piece_func(yypvt[-4].ival, yypvt[-2].strval, complex); 2357 free(claim_token(yypvt[-2].strval)); 2358 if (yyval.complex == NULL) 2359 YYERROR; 2360 } break; 2361 case 156: 2362 # line 1122 "zonecfg_grammar.y" 2363 { 2364 if ((yyval.complex = complex_piece_func(yypvt[-4].ival, res_types[yypvt[-2].ival], complex)) == 2365 NULL) 2366 YYERROR; 2367 } break; 2368 case 157: 2369 # line 1128 "zonecfg_grammar.y" 2370 { 2371 if ((yyval.complex = complex_piece_func(yypvt[-4].ival, prop_types[yypvt[-2].ival], complex)) == 2372 NULL) 2373 YYERROR; 2374 } break; 2375 # line 556 "/usr/share/lib/ccs/yaccpar" 2376 } 2377 goto yystack; /* reset registers in driver code */ 2378 } 2379 2380