1 2 # line 2 "nwamcfg_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 2010 Sun Microsystems, Inc. All rights reserved. 26 * Use is subject to license terms. 27 */ 28 29 #include <stdio.h> 30 #include <sys/types.h> 31 32 #include "nwamcfg.h" 33 34 static cmd_t *cmd = NULL; /* Command being processed */ 35 36 /* yacc externals */ 37 extern int yydebug; 38 extern void yyerror(char *s); 39 40 extern boolean_t newline_terminated; 41 42 43 # line 43 "nwamcfg_grammar.y" 44 typedef union 45 #ifdef __cplusplus 46 YYSTYPE 47 #endif 48 { 49 int ival; 50 char *strval; 51 cmd_t *cmd; 52 } YYSTYPE; 53 # define CANCEL 257 54 # define CLEAR 258 55 # define COMMIT 259 56 # define CREATE 260 57 # define DESTROY 261 58 # define END 262 59 # define EXIT 263 60 # define EXPORT 264 61 # define GET 265 62 # define HELP 266 63 # define LIST 267 64 # define REVERT 268 65 # define SELECT 269 66 # define SET 270 67 # define VERIFY 271 68 # define WALKPROP 272 69 # define LOC 273 70 # define NCP 274 71 # define NCU 275 72 # define ENM 276 73 # define WLAN 277 74 # define PHYS 278 75 # define IP 279 76 # define TOKEN 280 77 # define EQUAL 281 78 # define OPTION 282 79 # define UNKNOWN 283 80 # define ACTIVATION_MODE 284 81 # define CONDITIONS 285 82 # define ENABLED 286 83 # define TYPE 287 84 # define CLASS 288 85 # define PARENT 289 86 # define PRIORITY_GROUP 290 87 # define PRIORITY_MODE 291 88 # define LINK_MACADDR 292 89 # define LINK_AUTOPUSH 293 90 # define LINK_MTU 294 91 # define IP_VERSION 295 92 # define IPV4_ADDRSRC 296 93 # define IPV4_ADDR 297 94 # define IPV4_DEFAULT_ROUTE 298 95 # define IPV6_ADDRSRC 299 96 # define IPV6_ADDR 300 97 # define IPV6_DEFAULT_ROUTE 301 98 # define ENM_STATE 302 99 # define ENM_FMRI 303 100 # define ENM_START 304 101 # define ENM_STOP 305 102 # define LOC_NAMESERVICES 306 103 # define LOC_NAMESERVICES_CONFIG 307 104 # define LOC_DNS_CONFIGSRC 308 105 # define LOC_DNS_DOMAIN 309 106 # define LOC_DNS_SERVERS 310 107 # define LOC_DNS_SEARCH 311 108 # define LOC_NIS_CONFIGSRC 312 109 # define LOC_NIS_SERVERS 313 110 # define LOC_LDAP_CONFIGSRC 314 111 # define LOC_LDAP_SERVERS 315 112 # define LOC_DEFAULT_DOMAIN 316 113 # define LOC_NFSV4_DOMAIN 317 114 # define LOC_IPF_CONFIG 318 115 # define LOC_IPF_V6_CONFIG 319 116 # define LOC_IPNAT_CONFIG 320 117 # define LOC_IPPOOL_CONFIG 321 118 # define LOC_IKE_CONFIG 322 119 # define LOC_IPSECPOL_CONFIG 323 120 # define WLAN_BSSIDS 324 121 # define WLAN_PRIORITY 325 122 # define WLAN_KEYNAME 326 123 # define WLAN_KEYSLOT 327 124 # define WLAN_SECURITY_MODE 328 125 126 #include <inttypes.h> 127 128 #ifdef __STDC__ 129 #include <stdlib.h> 130 #include <string.h> 131 #define YYCONST const 132 #else 133 #include <malloc.h> 134 #include <memory.h> 135 #define YYCONST 136 #endif 137 138 #include <values.h> 139 140 #if defined(__cplusplus) || defined(__STDC__) 141 142 #if defined(__cplusplus) && defined(__EXTERN_C__) 143 extern "C" { 144 #endif 145 #ifndef yyerror 146 #if defined(__cplusplus) 147 void yyerror(YYCONST char *); 148 #endif 149 #endif 150 #ifndef yylex 151 int yylex(void); 152 #endif 153 int yyparse(void); 154 #if defined(__cplusplus) && defined(__EXTERN_C__) 155 } 156 #endif 157 158 #endif 159 160 #define yyclearin yychar = -1 161 #define yyerrok yyerrflag = 0 162 extern int yychar; 163 extern int yyerrflag; 164 YYSTYPE yylval; 165 YYSTYPE yyval; 166 typedef int yytabelem; 167 #ifndef YYMAXDEPTH 168 #define YYMAXDEPTH 150 169 #endif 170 #if YYMAXDEPTH > 0 171 int yy_yys[YYMAXDEPTH], *yys = yy_yys; 172 YYSTYPE yy_yyv[YYMAXDEPTH], *yyv = yy_yyv; 173 #else /* user does initial allocation */ 174 int *yys; 175 YYSTYPE *yyv; 176 #endif 177 static int yymaxdepth = YYMAXDEPTH; 178 # define YYERRCODE 256 179 180 # line 904 "nwamcfg_grammar.y" 181 182 static YYCONST yytabelem yyexca[] ={ 183 -1, 1, 184 0, -1, 185 -2, 0, 186 }; 187 # define YYNPROD 139 188 # define YYLAST 528 189 static YYCONST yytabelem yyact[]={ 190 191 105, 21, 107, 44, 45, 46, 47, 48, 49, 50, 192 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 193 61, 62, 118, 63, 64, 65, 66, 67, 68, 69, 194 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 195 80, 81, 82, 83, 84, 85, 86, 87, 88, 116, 196 22, 142, 44, 45, 46, 47, 48, 49, 50, 51, 197 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 198 62, 164, 63, 64, 65, 66, 67, 68, 69, 70, 199 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 200 81, 82, 83, 84, 85, 86, 87, 88, 42, 163, 201 162, 44, 45, 46, 47, 48, 49, 50, 51, 52, 202 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 203 159, 63, 64, 65, 66, 67, 68, 69, 70, 71, 204 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 205 82, 83, 84, 85, 86, 87, 88, 44, 45, 46, 206 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 207 57, 58, 59, 60, 61, 62, 157, 63, 64, 65, 208 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 209 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 210 86, 87, 88, 93, 94, 97, 95, 96, 156, 128, 211 109, 129, 110, 93, 94, 97, 95, 96, 155, 154, 212 101, 151, 102, 93, 94, 97, 95, 96, 150, 149, 213 89, 146, 92, 93, 94, 97, 95, 96, 143, 122, 214 123, 160, 98, 93, 94, 97, 95, 96, 139, 136, 215 113, 122, 123, 152, 122, 123, 140, 3, 23, 24, 216 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 217 35, 36, 37, 38, 122, 123, 137, 122, 123, 131, 218 122, 123, 126, 93, 94, 97, 95, 96, 130, 122, 219 123, 21, 125, 124, 120, 108, 121, 91, 43, 21, 220 4, 20, 19, 39, 41, 18, 17, 16, 90, 15, 221 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 222 2, 1, 0, 0, 0, 100, 0, 0, 104, 0, 223 106, 112, 0, 115, 0, 117, 99, 0, 0, 103, 224 22, 119, 111, 0, 114, 0, 0, 0, 22, 0, 225 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 226 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 227 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 228 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 229 0, 0, 0, 0, 0, 0, 0, 127, 0, 0, 230 0, 132, 0, 0, 0, 0, 133, 0, 135, 138, 231 0, 0, 141, 0, 0, 0, 0, 0, 0, 134, 232 0, 0, 145, 0, 0, 0, 148, 0, 0, 0, 233 0, 0, 153, 144, 0, 0, 0, 147, 0, 0, 234 0, 0, 158, 0, 0, 161, 0, 0, 0, 0, 235 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 236 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 237 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 238 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 239 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 240 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 241 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 242 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 243 0, 0, 0, 0, 0, 0, 0, 40 }; 244 static YYCONST yytabelem yypact[]={ 245 246 -9,-10000000, 271, 279,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, 247 -10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, 248 -10000000,-10000000,-10000000,-10000000, -182,-10000000, -60, -50,-10000000,-10000000, 249 -70, -280, 5, -80,-10000000, -40, -231,-10000000, -260,-10000000, 250 279,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, 251 -10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, 252 -10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, 253 -10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, 254 -10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, 255 4, 1, 3,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, 2, 256 -8,-10000000, -81, -2, -11,-10000000,-10000000, -136,-10000000,-10000000, 257 0, -41, -14,-10000000, -42, -34,-10000000, -230,-10000000,-10000000, 258 -10000000, -52,-10000000,-10000000, 0,-10000000,-10000000, -59, 0, -61, 259 -10000000,-10000000, -62,-10000000, -69, -37,-10000000,-10000000, -71,-10000000, 260 -10000000, -72, -82,-10000000, -114, 1,-10000000, -160, -49,-10000000, 261 -10000000,-10000000,-10000000, -180,-10000000,-10000000,-10000000,-10000000, -181,-10000000, 262 -10000000, -209,-10000000,-10000000,-10000000 }; 263 static YYCONST yytabelem yypgo[]={ 264 265 0, 311, 298, 287, 286, 288, 310, 309, 308, 307, 266 306, 305, 304, 303, 302, 301, 300, 299, 297, 296, 267 295, 292, 291, 290 }; 268 static YYCONST yytabelem yyr1[]={ 269 270 0, 1, 1, 1, 1, 6, 6, 6, 6, 6, 271 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 272 6, 23, 23, 7, 8, 8, 8, 9, 10, 10, 273 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 274 11, 11, 11, 12, 13, 14, 14, 14, 14, 14, 275 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 276 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, 277 17, 17, 17, 18, 19, 19, 19, 19, 19, 19, 278 19, 20, 20, 20, 21, 22, 22, 2, 2, 2, 279 2, 3, 4, 4, 5, 5, 5, 5, 5, 5, 280 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 281 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 282 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 283 5, 5, 5, 5, 5, 5, 5, 5, 5 }; 284 static YYCONST yytabelem yyr2[]={ 285 286 0, 5, 7, 5, 3, 2, 2, 2, 2, 2, 287 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 288 2, 3, 3, 3, 3, 5, 5, 3, 3, 5, 289 5, 5, 7, 9, 11, 13, 3, 5, 5, 5, 290 7, 7, 9, 3, 3, 3, 5, 5, 7, 9, 291 7, 7, 9, 11, 11, 13, 3, 5, 5, 7, 292 3, 5, 3, 5, 5, 5, 5, 7, 7, 9, 293 9, 9, 11, 3, 3, 5, 5, 5, 7, 7, 294 9, 3, 5, 9, 3, 3, 5, 3, 3, 3, 295 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 296 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 297 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 298 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 299 3, 3, 3, 3, 3, 3, 3, 3, 3 }; 300 static YYCONST yytabelem yychk[]={ 301 302 -10000000, -1, -6, 256, -23, -7, -8, -9, -10, -11, 303 -12, -13, -14, -15, -16, -17, -18, -19, -20, -21, 304 -22, 10, 59, 257, 258, 259, 260, 261, 262, 263, 305 264, 265, 266, 267, 268, 269, 270, 271, 272, -23, 306 256, -23, 280, -5, 283, 284, 285, 286, 287, 288, 307 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 308 299, 300, 301, 303, 304, 305, 306, 307, 308, 309, 309 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 310 320, 321, 322, 323, 324, 325, 326, 327, 328, 280, 311 -2, -3, 282, 273, 274, 276, 277, 275, 282, -2, 312 -3, 280, 282, -2, -3, 280, -5, 282, 280, 280, 313 282, -2, -3, 280, -2, -3, 280, -5, 282, -23, 314 280, -4, 278, 279, 280, 280, 280, -4, 280, 282, 315 280, 280, -4, -5, -2, -3, 280, 280, -4, 280, 316 280, -4, 281, 280, -2, -3, 280, -2, -3, 280, 317 280, 280, 280, -4, 280, 280, 280, 280, -4, 280, 318 280, -4, 280, 280, 280 }; 319 static YYCONST yytabelem yydef[]={ 320 321 0, -2, 0, 0, 4, 5, 6, 7, 8, 9, 322 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 323 20, 21, 22, 23, 24, 27, 28, 36, 43, 44, 324 45, 56, 60, 62, 73, 74, 81, 84, 85, 1, 325 0, 3, 25, 26, 94, 95, 96, 97, 98, 99, 326 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 327 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 328 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 329 130, 131, 132, 133, 134, 135, 136, 137, 138, 29, 330 30, 31, 0, 87, 88, 89, 90, 91, 37, 38, 331 39, 46, 47, 0, 0, 57, 58, 0, 61, 63, 332 64, 65, 66, 75, 76, 77, 82, 0, 86, 2, 333 32, 0, 92, 93, 0, 40, 41, 0, 48, 0, 334 50, 51, 0, 59, 0, 0, 67, 68, 0, 78, 335 79, 0, 0, 33, 0, 0, 42, 0, 0, 49, 336 52, 70, 71, 0, 69, 80, 83, 34, 0, 53, 337 54, 0, 72, 35, 55 }; 338 typedef struct 339 #ifdef __cplusplus 340 yytoktype 341 #endif 342 { 343 #ifdef __cplusplus 344 const 345 #endif 346 char *t_name; int t_val; } yytoktype; 347 #ifndef YYDEBUG 348 # define YYDEBUG 0 /* don't allow debugging */ 349 #endif 350 351 #if YYDEBUG 352 353 yytoktype yytoks[] = 354 { 355 "CANCEL", 257, 356 "CLEAR", 258, 357 "COMMIT", 259, 358 "CREATE", 260, 359 "DESTROY", 261, 360 "END", 262, 361 "EXIT", 263, 362 "EXPORT", 264, 363 "GET", 265, 364 "HELP", 266, 365 "LIST", 267, 366 "REVERT", 268, 367 "SELECT", 269, 368 "SET", 270, 369 "VERIFY", 271, 370 "WALKPROP", 272, 371 "LOC", 273, 372 "NCP", 274, 373 "NCU", 275, 374 "ENM", 276, 375 "WLAN", 277, 376 "PHYS", 278, 377 "IP", 279, 378 "TOKEN", 280, 379 "EQUAL", 281, 380 "OPTION", 282, 381 "UNKNOWN", 283, 382 "ACTIVATION_MODE", 284, 383 "CONDITIONS", 285, 384 "ENABLED", 286, 385 "TYPE", 287, 386 "CLASS", 288, 387 "PARENT", 289, 388 "PRIORITY_GROUP", 290, 389 "PRIORITY_MODE", 291, 390 "LINK_MACADDR", 292, 391 "LINK_AUTOPUSH", 293, 392 "LINK_MTU", 294, 393 "IP_VERSION", 295, 394 "IPV4_ADDRSRC", 296, 395 "IPV4_ADDR", 297, 396 "IPV4_DEFAULT_ROUTE", 298, 397 "IPV6_ADDRSRC", 299, 398 "IPV6_ADDR", 300, 399 "IPV6_DEFAULT_ROUTE", 301, 400 "ENM_STATE", 302, 401 "ENM_FMRI", 303, 402 "ENM_START", 304, 403 "ENM_STOP", 305, 404 "LOC_NAMESERVICES", 306, 405 "LOC_NAMESERVICES_CONFIG", 307, 406 "LOC_DNS_CONFIGSRC", 308, 407 "LOC_DNS_DOMAIN", 309, 408 "LOC_DNS_SERVERS", 310, 409 "LOC_DNS_SEARCH", 311, 410 "LOC_NIS_CONFIGSRC", 312, 411 "LOC_NIS_SERVERS", 313, 412 "LOC_LDAP_CONFIGSRC", 314, 413 "LOC_LDAP_SERVERS", 315, 414 "LOC_DEFAULT_DOMAIN", 316, 415 "LOC_NFSV4_DOMAIN", 317, 416 "LOC_IPF_CONFIG", 318, 417 "LOC_IPF_V6_CONFIG", 319, 418 "LOC_IPNAT_CONFIG", 320, 419 "LOC_IPPOOL_CONFIG", 321, 420 "LOC_IKE_CONFIG", 322, 421 "LOC_IPSECPOL_CONFIG", 323, 422 "WLAN_BSSIDS", 324, 423 "WLAN_PRIORITY", 325, 424 "WLAN_KEYNAME", 326, 425 "WLAN_KEYSLOT", 327, 426 "WLAN_SECURITY_MODE", 328, 427 "-unknown-", -1 /* ends search */ 428 }; 429 430 #ifdef __cplusplus 431 const 432 #endif 433 char * yyreds[] = 434 { 435 "-no such reduction-", 436 "commands : command terminator", 437 "commands : command error terminator", 438 "commands : error terminator", 439 "commands : terminator", 440 "command : cancel_command", 441 "command : clear_command", 442 "command : commit_command", 443 "command : create_command", 444 "command : destroy_command", 445 "command : end_command", 446 "command : exit_command", 447 "command : export_command", 448 "command : get_command", 449 "command : help_command", 450 "command : list_command", 451 "command : revert_command", 452 "command : select_command", 453 "command : set_command", 454 "command : verify_command", 455 "command : walkprop_command", 456 "terminator : '\n'", 457 "terminator : ';'", 458 "cancel_command : CANCEL", 459 "clear_command : CLEAR", 460 "clear_command : CLEAR TOKEN", 461 "clear_command : CLEAR property_type", 462 "commit_command : COMMIT", 463 "create_command : CREATE", 464 "create_command : CREATE TOKEN", 465 "create_command : CREATE resource1_type", 466 "create_command : CREATE resource2_type", 467 "create_command : CREATE resource1_type TOKEN", 468 "create_command : CREATE resource2_type ncu_class_type TOKEN", 469 "create_command : CREATE OPTION TOKEN resource1_type TOKEN", 470 "create_command : CREATE OPTION TOKEN resource2_type ncu_class_type TOKEN", 471 "destroy_command : DESTROY", 472 "destroy_command : DESTROY OPTION", 473 "destroy_command : DESTROY resource1_type", 474 "destroy_command : DESTROY resource2_type", 475 "destroy_command : DESTROY resource1_type TOKEN", 476 "destroy_command : DESTROY resource2_type TOKEN", 477 "destroy_command : DESTROY resource2_type ncu_class_type TOKEN", 478 "end_command : END", 479 "exit_command : EXIT", 480 "export_command : EXPORT", 481 "export_command : EXPORT TOKEN", 482 "export_command : EXPORT OPTION", 483 "export_command : EXPORT OPTION TOKEN", 484 "export_command : EXPORT OPTION OPTION TOKEN", 485 "export_command : EXPORT resource1_type TOKEN", 486 "export_command : EXPORT resource2_type TOKEN", 487 "export_command : EXPORT resource2_type ncu_class_type TOKEN", 488 "export_command : EXPORT OPTION TOKEN resource1_type TOKEN", 489 "export_command : EXPORT OPTION TOKEN resource2_type TOKEN", 490 "export_command : EXPORT OPTION TOKEN resource2_type ncu_class_type TOKEN", 491 "get_command : GET", 492 "get_command : GET TOKEN", 493 "get_command : GET property_type", 494 "get_command : GET OPTION property_type", 495 "help_command : HELP", 496 "help_command : HELP TOKEN", 497 "list_command : LIST", 498 "list_command : LIST TOKEN", 499 "list_command : LIST OPTION", 500 "list_command : LIST resource1_type", 501 "list_command : LIST resource2_type", 502 "list_command : LIST resource1_type TOKEN", 503 "list_command : LIST resource2_type TOKEN", 504 "list_command : LIST resource2_type ncu_class_type TOKEN", 505 "list_command : LIST OPTION resource1_type TOKEN", 506 "list_command : LIST OPTION resource2_type TOKEN", 507 "list_command : LIST OPTION resource2_type ncu_class_type TOKEN", 508 "revert_command : REVERT", 509 "select_command : SELECT", 510 "select_command : SELECT TOKEN", 511 "select_command : SELECT resource1_type", 512 "select_command : SELECT resource2_type", 513 "select_command : SELECT resource1_type TOKEN", 514 "select_command : SELECT resource2_type TOKEN", 515 "select_command : SELECT resource2_type ncu_class_type TOKEN", 516 "set_command : SET", 517 "set_command : SET TOKEN", 518 "set_command : SET property_type EQUAL TOKEN", 519 "verify_command : VERIFY", 520 "walkprop_command : WALKPROP", 521 "walkprop_command : WALKPROP OPTION", 522 "resource1_type : LOC", 523 "resource1_type : NCP", 524 "resource1_type : ENM", 525 "resource1_type : WLAN", 526 "resource2_type : NCU", 527 "ncu_class_type : PHYS", 528 "ncu_class_type : IP", 529 "property_type : UNKNOWN", 530 "property_type : ACTIVATION_MODE", 531 "property_type : CONDITIONS", 532 "property_type : ENABLED", 533 "property_type : TYPE", 534 "property_type : CLASS", 535 "property_type : PARENT", 536 "property_type : PRIORITY_GROUP", 537 "property_type : PRIORITY_MODE", 538 "property_type : LINK_MACADDR", 539 "property_type : LINK_AUTOPUSH", 540 "property_type : LINK_MTU", 541 "property_type : IP_VERSION", 542 "property_type : IPV4_ADDRSRC", 543 "property_type : IPV4_ADDR", 544 "property_type : IPV4_DEFAULT_ROUTE", 545 "property_type : IPV6_ADDRSRC", 546 "property_type : IPV6_ADDR", 547 "property_type : IPV6_DEFAULT_ROUTE", 548 "property_type : ENM_FMRI", 549 "property_type : ENM_START", 550 "property_type : ENM_STOP", 551 "property_type : LOC_NAMESERVICES", 552 "property_type : LOC_NAMESERVICES_CONFIG", 553 "property_type : LOC_DNS_CONFIGSRC", 554 "property_type : LOC_DNS_DOMAIN", 555 "property_type : LOC_DNS_SERVERS", 556 "property_type : LOC_DNS_SEARCH", 557 "property_type : LOC_NIS_CONFIGSRC", 558 "property_type : LOC_NIS_SERVERS", 559 "property_type : LOC_LDAP_CONFIGSRC", 560 "property_type : LOC_LDAP_SERVERS", 561 "property_type : LOC_DEFAULT_DOMAIN", 562 "property_type : LOC_NFSV4_DOMAIN", 563 "property_type : LOC_IPF_CONFIG", 564 "property_type : LOC_IPF_V6_CONFIG", 565 "property_type : LOC_IPNAT_CONFIG", 566 "property_type : LOC_IPPOOL_CONFIG", 567 "property_type : LOC_IKE_CONFIG", 568 "property_type : LOC_IPSECPOL_CONFIG", 569 "property_type : WLAN_BSSIDS", 570 "property_type : WLAN_PRIORITY", 571 "property_type : WLAN_KEYNAME", 572 "property_type : WLAN_KEYSLOT", 573 "property_type : WLAN_SECURITY_MODE", 574 }; 575 #endif /* YYDEBUG */ 576 # line 1 "/usr/share/lib/ccs/yaccpar" 577 /* 578 * CDDL HEADER START 579 * 580 * The contents of this file are subject to the terms of the 581 * Common Development and Distribution License, Version 1.0 only 582 * (the "License"). You may not use this file except in compliance 583 * with the License. 584 * 585 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 586 * or http://www.opensolaris.org/os/licensing. 587 * See the License for the specific language governing permissions 588 * and limitations under the License. 589 * 590 * When distributing Covered Code, include this CDDL HEADER in each 591 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 592 * If applicable, add the following below this CDDL HEADER, with the 593 * fields enclosed by brackets "[]" replaced with your own identifying 594 * information: Portions Copyright [yyyy] [name of copyright owner] 595 * 596 * CDDL HEADER END 597 */ 598 /* 599 * Copyright 1993 Sun Microsystems, Inc. All rights reserved. 600 * Use is subject to license terms. 601 */ 602 603 /* Copyright (c) 1988 AT&T */ 604 /* All Rights Reserved */ 605 606 #pragma ident "%Z%%M% %I% %E% SMI" 607 608 /* 609 ** Skeleton parser driver for yacc output 610 */ 611 612 /* 613 ** yacc user known macros and defines 614 */ 615 #define YYERROR goto yyerrlab 616 #define YYACCEPT return(0) 617 #define YYABORT return(1) 618 #define YYBACKUP( newtoken, newvalue )\ 619 {\ 620 if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\ 621 {\ 622 yyerror( "syntax error - cannot backup" );\ 623 goto yyerrlab;\ 624 }\ 625 yychar = newtoken;\ 626 yystate = *yyps;\ 627 yylval = newvalue;\ 628 goto yynewstate;\ 629 } 630 #define YYRECOVERING() (!!yyerrflag) 631 #define YYNEW(type) malloc(sizeof(type) * yynewmax) 632 #define YYCOPY(to, from, type) \ 633 (type *) memcpy(to, (char *) from, yymaxdepth * sizeof (type)) 634 #define YYENLARGE( from, type) \ 635 (type *) realloc((char *) from, yynewmax * sizeof(type)) 636 #ifndef YYDEBUG 637 # define YYDEBUG 1 /* make debugging available */ 638 #endif 639 640 /* 641 ** user known globals 642 */ 643 int yydebug; /* set to 1 to get debugging */ 644 645 /* 646 ** driver internal defines 647 */ 648 #define YYFLAG (-10000000) 649 650 /* 651 ** global variables used by the parser 652 */ 653 YYSTYPE *yypv; /* top of value stack */ 654 int *yyps; /* top of state stack */ 655 656 int yystate; /* current state */ 657 int yytmp; /* extra var (lasts between blocks) */ 658 659 int yynerrs; /* number of errors */ 660 int yyerrflag; /* error recovery flag */ 661 int yychar; /* current input token number */ 662 663 664 665 #ifdef YYNMBCHARS 666 #define YYLEX() yycvtok(yylex()) 667 /* 668 ** yycvtok - return a token if i is a wchar_t value that exceeds 255. 669 ** If i<255, i itself is the token. If i>255 but the neither 670 ** of the 30th or 31st bit is on, i is already a token. 671 */ 672 #if defined(__STDC__) || defined(__cplusplus) 673 int yycvtok(int i) 674 #else 675 int yycvtok(i) int i; 676 #endif 677 { 678 int first = 0; 679 int last = YYNMBCHARS - 1; 680 int mid; 681 wchar_t j; 682 683 if(i&0x60000000){/*Must convert to a token. */ 684 if( yymbchars[last].character < i ){ 685 return i;/*Giving up*/ 686 } 687 while ((last>=first)&&(first>=0)) {/*Binary search loop*/ 688 mid = (first+last)/2; 689 j = yymbchars[mid].character; 690 if( j==i ){/*Found*/ 691 return yymbchars[mid].tvalue; 692 }else if( j<i ){ 693 first = mid + 1; 694 }else{ 695 last = mid -1; 696 } 697 } 698 /*No entry in the table.*/ 699 return i;/* Giving up.*/ 700 }else{/* i is already a token. */ 701 return i; 702 } 703 } 704 #else/*!YYNMBCHARS*/ 705 #define YYLEX() yylex() 706 #endif/*!YYNMBCHARS*/ 707 708 /* 709 ** yyparse - return 0 if worked, 1 if syntax error not recovered from 710 */ 711 #if defined(__STDC__) || defined(__cplusplus) 712 int yyparse(void) 713 #else 714 int yyparse() 715 #endif 716 { 717 register YYSTYPE *yypvt = 0; /* top of value stack for $vars */ 718 719 #if defined(__cplusplus) || defined(lint) 720 /* 721 hacks to please C++ and lint - goto's inside 722 switch should never be executed 723 */ 724 static int __yaccpar_lint_hack__ = 0; 725 switch (__yaccpar_lint_hack__) 726 { 727 case 1: goto yyerrlab; 728 case 2: goto yynewstate; 729 } 730 #endif 731 732 /* 733 ** Initialize externals - yyparse may be called more than once 734 */ 735 yypv = &yyv[-1]; 736 yyps = &yys[-1]; 737 yystate = 0; 738 yytmp = 0; 739 yynerrs = 0; 740 yyerrflag = 0; 741 yychar = -1; 742 743 #if YYMAXDEPTH <= 0 744 if (yymaxdepth <= 0) 745 { 746 if ((yymaxdepth = YYEXPAND(0)) <= 0) 747 { 748 yyerror("yacc initialization error"); 749 YYABORT; 750 } 751 } 752 #endif 753 754 { 755 register YYSTYPE *yy_pv; /* top of value stack */ 756 register int *yy_ps; /* top of state stack */ 757 register int yy_state; /* current state */ 758 register int yy_n; /* internal state number info */ 759 goto yystack; /* moved from 6 lines above to here to please C++ */ 760 761 /* 762 ** get globals into registers. 763 ** branch to here only if YYBACKUP was called. 764 */ 765 yynewstate: 766 yy_pv = yypv; 767 yy_ps = yyps; 768 yy_state = yystate; 769 goto yy_newstate; 770 771 /* 772 ** get globals into registers. 773 ** either we just started, or we just finished a reduction 774 */ 775 yystack: 776 yy_pv = yypv; 777 yy_ps = yyps; 778 yy_state = yystate; 779 780 /* 781 ** top of for (;;) loop while no reductions done 782 */ 783 yy_stack: 784 /* 785 ** put a state and value onto the stacks 786 */ 787 #if YYDEBUG 788 /* 789 ** if debugging, look up token value in list of value vs. 790 ** name pairs. 0 and negative (-1) are special values. 791 ** Note: linear search is used since time is not a real 792 ** consideration while debugging. 793 */ 794 if ( yydebug ) 795 { 796 register int yy_i; 797 798 printf( "State %d, token ", yy_state ); 799 if ( yychar == 0 ) 800 printf( "end-of-file\n" ); 801 else if ( yychar < 0 ) 802 printf( "-none-\n" ); 803 else 804 { 805 for ( yy_i = 0; yytoks[yy_i].t_val >= 0; 806 yy_i++ ) 807 { 808 if ( yytoks[yy_i].t_val == yychar ) 809 break; 810 } 811 printf( "%s\n", yytoks[yy_i].t_name ); 812 } 813 } 814 #endif /* YYDEBUG */ 815 if ( ++yy_ps >= &yys[ yymaxdepth ] ) /* room on stack? */ 816 { 817 /* 818 ** reallocate and recover. Note that pointers 819 ** have to be reset, or bad things will happen 820 */ 821 long yyps_index = (yy_ps - yys); 822 long yypv_index = (yy_pv - yyv); 823 long yypvt_index = (yypvt - yyv); 824 int yynewmax; 825 #ifdef YYEXPAND 826 yynewmax = YYEXPAND(yymaxdepth); 827 #else 828 yynewmax = 2 * yymaxdepth; /* double table size */ 829 if (yymaxdepth == YYMAXDEPTH) /* first time growth */ 830 { 831 char *newyys = (char *)YYNEW(int); 832 char *newyyv = (char *)YYNEW(YYSTYPE); 833 if (newyys != 0 && newyyv != 0) 834 { 835 yys = YYCOPY(newyys, yys, int); 836 yyv = YYCOPY(newyyv, yyv, YYSTYPE); 837 } 838 else 839 yynewmax = 0; /* failed */ 840 } 841 else /* not first time */ 842 { 843 yys = YYENLARGE(yys, int); 844 yyv = YYENLARGE(yyv, YYSTYPE); 845 if (yys == 0 || yyv == 0) 846 yynewmax = 0; /* failed */ 847 } 848 #endif 849 if (yynewmax <= yymaxdepth) /* tables not expanded */ 850 { 851 yyerror( "yacc stack overflow" ); 852 YYABORT; 853 } 854 yymaxdepth = yynewmax; 855 856 yy_ps = yys + yyps_index; 857 yy_pv = yyv + yypv_index; 858 yypvt = yyv + yypvt_index; 859 } 860 *yy_ps = yy_state; 861 *++yy_pv = yyval; 862 863 /* 864 ** we have a new state - find out what to do 865 */ 866 yy_newstate: 867 if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG ) 868 goto yydefault; /* simple state */ 869 #if YYDEBUG 870 /* 871 ** if debugging, need to mark whether new token grabbed 872 */ 873 yytmp = yychar < 0; 874 #endif 875 if ( ( yychar < 0 ) && ( ( yychar = YYLEX() ) < 0 ) ) 876 yychar = 0; /* reached EOF */ 877 #if YYDEBUG 878 if ( yydebug && yytmp ) 879 { 880 register int yy_i; 881 882 printf( "Received token " ); 883 if ( yychar == 0 ) 884 printf( "end-of-file\n" ); 885 else if ( yychar < 0 ) 886 printf( "-none-\n" ); 887 else 888 { 889 for ( yy_i = 0; yytoks[yy_i].t_val >= 0; 890 yy_i++ ) 891 { 892 if ( yytoks[yy_i].t_val == yychar ) 893 break; 894 } 895 printf( "%s\n", yytoks[yy_i].t_name ); 896 } 897 } 898 #endif /* YYDEBUG */ 899 if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) ) 900 goto yydefault; 901 if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar ) /*valid shift*/ 902 { 903 yychar = -1; 904 yyval = yylval; 905 yy_state = yy_n; 906 if ( yyerrflag > 0 ) 907 yyerrflag--; 908 goto yy_stack; 909 } 910 911 yydefault: 912 if ( ( yy_n = yydef[ yy_state ] ) == -2 ) 913 { 914 #if YYDEBUG 915 yytmp = yychar < 0; 916 #endif 917 if ( ( yychar < 0 ) && ( ( yychar = YYLEX() ) < 0 ) ) 918 yychar = 0; /* reached EOF */ 919 #if YYDEBUG 920 if ( yydebug && yytmp ) 921 { 922 register int yy_i; 923 924 printf( "Received token " ); 925 if ( yychar == 0 ) 926 printf( "end-of-file\n" ); 927 else if ( yychar < 0 ) 928 printf( "-none-\n" ); 929 else 930 { 931 for ( yy_i = 0; 932 yytoks[yy_i].t_val >= 0; 933 yy_i++ ) 934 { 935 if ( yytoks[yy_i].t_val 936 == yychar ) 937 { 938 break; 939 } 940 } 941 printf( "%s\n", yytoks[yy_i].t_name ); 942 } 943 } 944 #endif /* YYDEBUG */ 945 /* 946 ** look through exception table 947 */ 948 { 949 register YYCONST int *yyxi = yyexca; 950 951 while ( ( *yyxi != -1 ) || 952 ( yyxi[1] != yy_state ) ) 953 { 954 yyxi += 2; 955 } 956 while ( ( *(yyxi += 2) >= 0 ) && 957 ( *yyxi != yychar ) ) 958 ; 959 if ( ( yy_n = yyxi[1] ) < 0 ) 960 YYACCEPT; 961 } 962 } 963 964 /* 965 ** check for syntax error 966 */ 967 if ( yy_n == 0 ) /* have an error */ 968 { 969 /* no worry about speed here! */ 970 switch ( yyerrflag ) 971 { 972 case 0: /* new error */ 973 yyerror( "syntax error" ); 974 goto skip_init; 975 yyerrlab: 976 /* 977 ** get globals into registers. 978 ** we have a user generated syntax type error 979 */ 980 yy_pv = yypv; 981 yy_ps = yyps; 982 yy_state = yystate; 983 skip_init: 984 yynerrs++; 985 /* FALLTHRU */ 986 case 1: 987 case 2: /* incompletely recovered error */ 988 /* try again... */ 989 yyerrflag = 3; 990 /* 991 ** find state where "error" is a legal 992 ** shift action 993 */ 994 while ( yy_ps >= yys ) 995 { 996 yy_n = yypact[ *yy_ps ] + YYERRCODE; 997 if ( yy_n >= 0 && yy_n < YYLAST && 998 yychk[yyact[yy_n]] == YYERRCODE) { 999 /* 1000 ** simulate shift of "error" 1001 */ 1002 yy_state = yyact[ yy_n ]; 1003 goto yy_stack; 1004 } 1005 /* 1006 ** current state has no shift on 1007 ** "error", pop stack 1008 */ 1009 #if YYDEBUG 1010 # define _POP_ "Error recovery pops state %d, uncovers state %d\n" 1011 if ( yydebug ) 1012 printf( _POP_, *yy_ps, 1013 yy_ps[-1] ); 1014 # undef _POP_ 1015 #endif 1016 yy_ps--; 1017 yy_pv--; 1018 } 1019 /* 1020 ** there is no state on stack with "error" as 1021 ** a valid shift. give up. 1022 */ 1023 YYABORT; 1024 case 3: /* no shift yet; eat a token */ 1025 #if YYDEBUG 1026 /* 1027 ** if debugging, look up token in list of 1028 ** pairs. 0 and negative shouldn't occur, 1029 ** but since timing doesn't matter when 1030 ** debugging, it doesn't hurt to leave the 1031 ** tests here. 1032 */ 1033 if ( yydebug ) 1034 { 1035 register int yy_i; 1036 1037 printf( "Error recovery discards " ); 1038 if ( yychar == 0 ) 1039 printf( "token end-of-file\n" ); 1040 else if ( yychar < 0 ) 1041 printf( "token -none-\n" ); 1042 else 1043 { 1044 for ( yy_i = 0; 1045 yytoks[yy_i].t_val >= 0; 1046 yy_i++ ) 1047 { 1048 if ( yytoks[yy_i].t_val 1049 == yychar ) 1050 { 1051 break; 1052 } 1053 } 1054 printf( "token %s\n", 1055 yytoks[yy_i].t_name ); 1056 } 1057 } 1058 #endif /* YYDEBUG */ 1059 if ( yychar == 0 ) /* reached EOF. quit */ 1060 YYABORT; 1061 yychar = -1; 1062 goto yy_newstate; 1063 } 1064 }/* end if ( yy_n == 0 ) */ 1065 /* 1066 ** reduction by production yy_n 1067 ** put stack tops, etc. so things right after switch 1068 */ 1069 #if YYDEBUG 1070 /* 1071 ** if debugging, print the string that is the user's 1072 ** specification of the reduction which is just about 1073 ** to be done. 1074 */ 1075 if ( yydebug ) 1076 printf( "Reduce by (%d) \"%s\"\n", 1077 yy_n, yyreds[ yy_n ] ); 1078 #endif 1079 yytmp = yy_n; /* value to switch over */ 1080 yypvt = yy_pv; /* $vars top of value stack */ 1081 /* 1082 ** Look in goto table for next state 1083 ** Sorry about using yy_state here as temporary 1084 ** register variable, but why not, if it works... 1085 ** If yyr2[ yy_n ] doesn't have the low order bit 1086 ** set, then there is no action to be done for 1087 ** this reduction. So, no saving & unsaving of 1088 ** registers done. The only difference between the 1089 ** code just after the if and the body of the if is 1090 ** the goto yy_stack in the body. This way the test 1091 ** can be made before the choice of what to do is needed. 1092 */ 1093 { 1094 /* length of production doubled with extra bit */ 1095 register int yy_len = yyr2[ yy_n ]; 1096 1097 if ( !( yy_len & 01 ) ) 1098 { 1099 yy_len >>= 1; 1100 yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */ 1101 yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] + 1102 *( yy_ps -= yy_len ) + 1; 1103 if ( yy_state >= YYLAST || 1104 yychk[ yy_state = 1105 yyact[ yy_state ] ] != -yy_n ) 1106 { 1107 yy_state = yyact[ yypgo[ yy_n ] ]; 1108 } 1109 goto yy_stack; 1110 } 1111 yy_len >>= 1; 1112 yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */ 1113 yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] + 1114 *( yy_ps -= yy_len ) + 1; 1115 if ( yy_state >= YYLAST || 1116 yychk[ yy_state = yyact[ yy_state ] ] != -yy_n ) 1117 { 1118 yy_state = yyact[ yypgo[ yy_n ] ]; 1119 } 1120 } 1121 /* save until reenter driver code */ 1122 yystate = yy_state; 1123 yyps = yy_ps; 1124 yypv = yy_pv; 1125 } 1126 /* 1127 ** code supplied by user is placed in this switch 1128 */ 1129 switch( yytmp ) 1130 { 1131 1132 case 1: 1133 # line 111 "nwamcfg_grammar.y" 1134 { 1135 if (yypvt[-1].cmd != NULL) { 1136 if (yypvt[-1].cmd->cmd_handler != NULL) 1137 if (check_scope(yypvt[-1].cmd->cmd_num)) 1138 yypvt[-1].cmd->cmd_handler(yypvt[-1].cmd); 1139 free_cmd(yypvt[-1].cmd); 1140 } 1141 return (0); 1142 } break; 1143 case 2: 1144 # line 121 "nwamcfg_grammar.y" 1145 { 1146 if (yypvt[-2].cmd != NULL) 1147 free_cmd(yypvt[-2].cmd); 1148 if (YYRECOVERING()) 1149 YYABORT; 1150 yyclearin; 1151 yyerrok; 1152 } break; 1153 case 3: 1154 # line 130 "nwamcfg_grammar.y" 1155 { 1156 if (YYRECOVERING()) 1157 YYABORT; 1158 yyclearin; 1159 yyerrok; 1160 } break; 1161 case 4: 1162 # line 137 "nwamcfg_grammar.y" 1163 { 1164 return (0); 1165 } break; 1166 case 21: 1167 # line 158 "nwamcfg_grammar.y" 1168 { newline_terminated = B_TRUE; } break; 1169 case 22: 1170 # line 159 "nwamcfg_grammar.y" 1171 { newline_terminated = B_FALSE; } break; 1172 case 23: 1173 # line 162 "nwamcfg_grammar.y" 1174 { 1175 if ((yyval.cmd = alloc_cmd()) == NULL) 1176 YYERROR; 1177 cmd = yyval.cmd; 1178 yyval.cmd->cmd_num = CMD_CANCEL; 1179 yyval.cmd->cmd_handler = &cancel_func; 1180 yyval.cmd->cmd_argc = 0; 1181 yyval.cmd->cmd_argv[0] = NULL; 1182 } break; 1183 case 24: 1184 # line 173 "nwamcfg_grammar.y" 1185 { 1186 command_usage(CMD_CLEAR); 1187 YYERROR; 1188 } break; 1189 case 25: 1190 # line 178 "nwamcfg_grammar.y" 1191 { 1192 properr(yypvt[-0].strval); 1193 YYERROR; 1194 } break; 1195 case 26: 1196 # line 183 "nwamcfg_grammar.y" 1197 { 1198 /* clear prop */ 1199 if ((yyval.cmd = alloc_cmd()) == NULL) 1200 YYERROR; 1201 cmd = yyval.cmd; 1202 yyval.cmd->cmd_num = CMD_CLEAR; 1203 yyval.cmd->cmd_handler = &clear_func; 1204 yyval.cmd->cmd_prop_type = yypvt[-0].ival; 1205 yyval.cmd->cmd_argc = 0; 1206 yyval.cmd->cmd_argv[0] = NULL; 1207 } break; 1208 case 27: 1209 # line 196 "nwamcfg_grammar.y" 1210 { 1211 if ((yyval.cmd = alloc_cmd()) == NULL) 1212 YYERROR; 1213 cmd = yyval.cmd; 1214 yyval.cmd->cmd_num = CMD_COMMIT; 1215 yyval.cmd->cmd_handler = &commit_func; 1216 yyval.cmd->cmd_argc = 0; 1217 yyval.cmd->cmd_argv[0] = NULL; 1218 } break; 1219 case 28: 1220 # line 207 "nwamcfg_grammar.y" 1221 { 1222 command_usage(CMD_CREATE); 1223 YYERROR; 1224 } break; 1225 case 29: 1226 # line 212 "nwamcfg_grammar.y" 1227 { 1228 command_usage(CMD_CREATE); 1229 YYERROR; 1230 } break; 1231 case 30: 1232 # line 217 "nwamcfg_grammar.y" 1233 { 1234 command_usage(CMD_CREATE); 1235 YYERROR; 1236 } break; 1237 case 31: 1238 # line 222 "nwamcfg_grammar.y" 1239 { 1240 command_usage(CMD_CREATE); 1241 YYERROR; 1242 } break; 1243 case 32: 1244 # line 227 "nwamcfg_grammar.y" 1245 { 1246 /* create enm/loc/ncp test */ 1247 if ((yyval.cmd = alloc_cmd()) == NULL) 1248 YYERROR; 1249 cmd = yyval.cmd; 1250 yyval.cmd->cmd_num = CMD_CREATE; 1251 yyval.cmd->cmd_handler = &create_func; 1252 yyval.cmd->cmd_res1_type = yypvt[-1].ival; 1253 yyval.cmd->cmd_argc = 1; 1254 yyval.cmd->cmd_argv[0] = yypvt[-0].strval; 1255 yyval.cmd->cmd_argv[1] = NULL; 1256 } break; 1257 case 33: 1258 # line 240 "nwamcfg_grammar.y" 1259 { 1260 /* create ncu ip/phys test */ 1261 if ((yyval.cmd = alloc_cmd()) == NULL) 1262 YYERROR; 1263 cmd = yyval.cmd; 1264 yyval.cmd->cmd_num = CMD_CREATE; 1265 yyval.cmd->cmd_handler = &create_func; 1266 yyval.cmd->cmd_res1_type = RT1_NCP; 1267 yyval.cmd->cmd_res2_type = yypvt[-2].ival; 1268 yyval.cmd->cmd_ncu_class_type = yypvt[-1].ival; 1269 yyval.cmd->cmd_argc = 1; 1270 yyval.cmd->cmd_argv[0] = yypvt[-0].strval; 1271 yyval.cmd->cmd_argv[1] = NULL; 1272 } break; 1273 case 34: 1274 # line 255 "nwamcfg_grammar.y" 1275 { 1276 /* create -t old enm/loc/ncp test */ 1277 if ((yyval.cmd = alloc_cmd()) == NULL) 1278 YYERROR; 1279 cmd = yyval.cmd; 1280 yyval.cmd->cmd_num = CMD_CREATE; 1281 yyval.cmd->cmd_handler = &create_func; 1282 yyval.cmd->cmd_res1_type = yypvt[-1].ival; 1283 yyval.cmd->cmd_argc = 3; 1284 yyval.cmd->cmd_argv[0] = yypvt[-3].strval; 1285 yyval.cmd->cmd_argv[1] = yypvt[-2].strval; 1286 yyval.cmd->cmd_argv[2] = yypvt[-0].strval; 1287 yyval.cmd->cmd_argv[3] = NULL; 1288 } break; 1289 case 35: 1290 # line 270 "nwamcfg_grammar.y" 1291 { 1292 /* create -t old ncu ip/phys test */ 1293 if ((yyval.cmd = alloc_cmd()) == NULL) 1294 YYERROR; 1295 cmd = yyval.cmd; 1296 yyval.cmd->cmd_num = CMD_CREATE; 1297 yyval.cmd->cmd_handler = &create_func; 1298 yyval.cmd->cmd_res1_type = RT1_NCP; 1299 yyval.cmd->cmd_res2_type = yypvt[-2].ival; 1300 yyval.cmd->cmd_ncu_class_type = yypvt[-1].ival; 1301 yyval.cmd->cmd_argc = 3; 1302 yyval.cmd->cmd_argv[0] = yypvt[-4].strval; 1303 yyval.cmd->cmd_argv[1] = yypvt[-3].strval; 1304 yyval.cmd->cmd_argv[2] = yypvt[-0].strval; 1305 yyval.cmd->cmd_argv[3] = NULL; 1306 } break; 1307 case 36: 1308 # line 288 "nwamcfg_grammar.y" 1309 { 1310 command_usage(CMD_DESTROY); 1311 YYERROR; 1312 } break; 1313 case 37: 1314 # line 293 "nwamcfg_grammar.y" 1315 { 1316 /* destroy -a */ 1317 if ((yyval.cmd = alloc_cmd()) == NULL) 1318 YYERROR; 1319 cmd = yyval.cmd; 1320 yyval.cmd->cmd_num = CMD_DESTROY; 1321 yyval.cmd->cmd_handler = &destroy_func; 1322 yyval.cmd->cmd_res1_type = -1; /* special value */ 1323 yyval.cmd->cmd_argc = 1; 1324 yyval.cmd->cmd_argv[0] = yypvt[-0].strval; 1325 yyval.cmd->cmd_argv[1] = NULL; 1326 } break; 1327 case 38: 1328 # line 306 "nwamcfg_grammar.y" 1329 { 1330 command_usage(CMD_DESTROY); 1331 YYERROR; 1332 } break; 1333 case 39: 1334 # line 311 "nwamcfg_grammar.y" 1335 { 1336 command_usage(CMD_DESTROY); 1337 YYERROR; 1338 } break; 1339 case 40: 1340 # line 316 "nwamcfg_grammar.y" 1341 { 1342 /* destroy enm/loc/ncp test */ 1343 if ((yyval.cmd = alloc_cmd()) == NULL) 1344 YYERROR; 1345 cmd = yyval.cmd; 1346 yyval.cmd->cmd_num = CMD_DESTROY; 1347 yyval.cmd->cmd_handler = &destroy_func; 1348 yyval.cmd->cmd_res1_type = yypvt[-1].ival; 1349 yyval.cmd->cmd_argc = 1; 1350 yyval.cmd->cmd_argv[0] = yypvt[-0].strval; 1351 yyval.cmd->cmd_argv[1] = NULL; 1352 } break; 1353 case 41: 1354 # line 329 "nwamcfg_grammar.y" 1355 { 1356 /* destroy ncu test (class inferred) */ 1357 if ((yyval.cmd = alloc_cmd()) == NULL) 1358 YYERROR; 1359 cmd = yyval.cmd; 1360 yyval.cmd->cmd_num = CMD_DESTROY; 1361 yyval.cmd->cmd_handler = &destroy_func; 1362 yyval.cmd->cmd_res1_type = RT1_NCP; 1363 yyval.cmd->cmd_res2_type = yypvt[-1].ival; 1364 yyval.cmd->cmd_ncu_class_type = NCU_CLASS_ANY; 1365 yyval.cmd->cmd_argc = 1; 1366 yyval.cmd->cmd_argv[0] = yypvt[-0].strval; 1367 yyval.cmd->cmd_argv[1] = NULL; 1368 } break; 1369 case 42: 1370 # line 344 "nwamcfg_grammar.y" 1371 { 1372 /* destroy ncu ip/phys test */ 1373 if ((yyval.cmd = alloc_cmd()) == NULL) 1374 YYERROR; 1375 cmd = yyval.cmd; 1376 yyval.cmd->cmd_num = CMD_DESTROY; 1377 yyval.cmd->cmd_handler = &destroy_func; 1378 yyval.cmd->cmd_res1_type = RT1_NCP; 1379 yyval.cmd->cmd_res2_type = yypvt[-2].ival; 1380 yyval.cmd->cmd_ncu_class_type = yypvt[-1].ival; 1381 yyval.cmd->cmd_argc = 1; 1382 yyval.cmd->cmd_argv[0] = yypvt[-0].strval; 1383 yyval.cmd->cmd_argv[1] = NULL; 1384 } break; 1385 case 43: 1386 # line 360 "nwamcfg_grammar.y" 1387 { 1388 if ((yyval.cmd = alloc_cmd()) == NULL) 1389 YYERROR; 1390 cmd = yyval.cmd; 1391 yyval.cmd->cmd_num = CMD_END; 1392 yyval.cmd->cmd_handler = &end_func; 1393 yyval.cmd->cmd_argc = 0; 1394 yyval.cmd->cmd_argv[0] = NULL; 1395 } break; 1396 case 44: 1397 # line 371 "nwamcfg_grammar.y" 1398 { 1399 if ((yyval.cmd = alloc_cmd()) == NULL) 1400 YYERROR; 1401 cmd = yyval.cmd; 1402 yyval.cmd->cmd_num = CMD_EXIT; 1403 yyval.cmd->cmd_handler = &exit_func; 1404 yyval.cmd->cmd_argc = 0; 1405 yyval.cmd->cmd_argv[0] = NULL; 1406 } break; 1407 case 45: 1408 # line 382 "nwamcfg_grammar.y" 1409 { 1410 if ((yyval.cmd = alloc_cmd()) == NULL) 1411 YYERROR; 1412 cmd = yyval.cmd; 1413 yyval.cmd->cmd_num = CMD_EXPORT; 1414 yyval.cmd->cmd_handler = &export_func; 1415 yyval.cmd->cmd_argc = 0; 1416 yyval.cmd->cmd_argv[0] = NULL; 1417 } break; 1418 case 46: 1419 # line 392 "nwamcfg_grammar.y" 1420 { 1421 command_usage(CMD_EXPORT); 1422 YYERROR; 1423 } break; 1424 case 47: 1425 # line 397 "nwamcfg_grammar.y" 1426 { 1427 /* export -d */ 1428 if ((yyval.cmd = alloc_cmd()) == NULL) 1429 YYERROR; 1430 cmd = yyval.cmd; 1431 yyval.cmd->cmd_num = CMD_EXPORT; 1432 yyval.cmd->cmd_handler = &export_func; 1433 yyval.cmd->cmd_argc = 1; 1434 yyval.cmd->cmd_argv[0] = yypvt[-0].strval; 1435 yyval.cmd->cmd_argv[1] = NULL; 1436 } break; 1437 case 48: 1438 # line 409 "nwamcfg_grammar.y" 1439 { 1440 /* export -f file */ 1441 if ((yyval.cmd = alloc_cmd()) == NULL) 1442 YYERROR; 1443 cmd = yyval.cmd; 1444 yyval.cmd->cmd_num = CMD_EXPORT; 1445 yyval.cmd->cmd_handler = &export_func; 1446 yyval.cmd->cmd_argc = 2; 1447 yyval.cmd->cmd_argv[0] = yypvt[-1].strval; 1448 yyval.cmd->cmd_argv[1] = yypvt[-0].strval; 1449 yyval.cmd->cmd_argv[2] = NULL; 1450 } break; 1451 case 49: 1452 # line 422 "nwamcfg_grammar.y" 1453 { 1454 /* export -d -f file */ 1455 if ((yyval.cmd = alloc_cmd()) == NULL) 1456 YYERROR; 1457 cmd = yyval.cmd; 1458 yyval.cmd->cmd_num = CMD_EXPORT; 1459 yyval.cmd->cmd_handler = &export_func; 1460 yyval.cmd->cmd_argc = 3; 1461 yyval.cmd->cmd_argv[0] = yypvt[-2].strval; 1462 yyval.cmd->cmd_argv[1] = yypvt[-1].strval; 1463 yyval.cmd->cmd_argv[2] = yypvt[-0].strval; 1464 yyval.cmd->cmd_argv[3] = NULL; 1465 } break; 1466 case 50: 1467 # line 436 "nwamcfg_grammar.y" 1468 { 1469 /* export enm/loc/ncp test */ 1470 if ((yyval.cmd = alloc_cmd()) == NULL) 1471 YYERROR; 1472 cmd = yyval.cmd; 1473 yyval.cmd->cmd_num = CMD_EXPORT; 1474 yyval.cmd->cmd_handler = &export_func; 1475 yyval.cmd->cmd_res1_type = yypvt[-1].ival; 1476 yyval.cmd->cmd_argc = 1; 1477 yyval.cmd->cmd_argv[0] = yypvt[-0].strval; 1478 yyval.cmd->cmd_argv[1] = NULL; 1479 } break; 1480 case 51: 1481 # line 449 "nwamcfg_grammar.y" 1482 { 1483 /* export ncu test (all ncu's named test) */ 1484 if ((yyval.cmd = alloc_cmd()) == NULL) 1485 YYERROR; 1486 cmd = yyval.cmd; 1487 yyval.cmd->cmd_num = CMD_EXPORT; 1488 yyval.cmd->cmd_handler = &export_func; 1489 yyval.cmd->cmd_res1_type = RT1_NCP; 1490 yyval.cmd->cmd_res2_type = yypvt[-1].ival; 1491 yyval.cmd->cmd_ncu_class_type = NCU_CLASS_ANY; 1492 yyval.cmd->cmd_argc = 1; 1493 yyval.cmd->cmd_argv[0] = yypvt[-0].strval; 1494 yyval.cmd->cmd_argv[1] = NULL; 1495 } break; 1496 case 52: 1497 # line 464 "nwamcfg_grammar.y" 1498 { 1499 /* export ncu ip/phys test */ 1500 if ((yyval.cmd = alloc_cmd()) == NULL) 1501 YYERROR; 1502 cmd = yyval.cmd; 1503 yyval.cmd->cmd_num = CMD_EXPORT; 1504 yyval.cmd->cmd_handler = &export_func; 1505 yyval.cmd->cmd_res1_type = RT1_NCP; 1506 yyval.cmd->cmd_res2_type = yypvt[-2].ival; 1507 yyval.cmd->cmd_ncu_class_type = yypvt[-1].ival; 1508 yyval.cmd->cmd_argc = 1; 1509 yyval.cmd->cmd_argv[0] = yypvt[-0].strval; 1510 yyval.cmd->cmd_argv[1] = NULL; 1511 } break; 1512 case 53: 1513 # line 479 "nwamcfg_grammar.y" 1514 { 1515 /* export -f file enm/loc/ncp test */ 1516 if ((yyval.cmd = alloc_cmd()) == NULL) 1517 YYERROR; 1518 cmd = yyval.cmd; 1519 yyval.cmd->cmd_num = CMD_EXPORT; 1520 yyval.cmd->cmd_handler = &export_func; 1521 yyval.cmd->cmd_res1_type = yypvt[-1].ival; 1522 yyval.cmd->cmd_argc = 3; 1523 yyval.cmd->cmd_argv[0] = yypvt[-3].strval; 1524 yyval.cmd->cmd_argv[1] = yypvt[-2].strval; 1525 yyval.cmd->cmd_argv[2] = yypvt[-0].strval; 1526 yyval.cmd->cmd_argv[3] = NULL; 1527 } break; 1528 case 54: 1529 # line 494 "nwamcfg_grammar.y" 1530 { 1531 /* export -f file ncu test (all ncu's named test) */ 1532 if ((yyval.cmd = alloc_cmd()) == NULL) 1533 YYERROR; 1534 cmd = yyval.cmd; 1535 yyval.cmd->cmd_num = CMD_EXPORT; 1536 yyval.cmd->cmd_handler = &export_func; 1537 yyval.cmd->cmd_res1_type = RT1_NCP; 1538 yyval.cmd->cmd_res2_type = yypvt[-1].ival; 1539 yyval.cmd->cmd_ncu_class_type = NCU_CLASS_ANY; 1540 yyval.cmd->cmd_argc = 3; 1541 yyval.cmd->cmd_argv[0] = yypvt[-3].strval; 1542 yyval.cmd->cmd_argv[1] = yypvt[-2].strval; 1543 yyval.cmd->cmd_argv[2] = yypvt[-0].strval; 1544 yyval.cmd->cmd_argv[3] = NULL; 1545 } break; 1546 case 55: 1547 # line 511 "nwamcfg_grammar.y" 1548 { 1549 /* export -f file ncu ip/phys test */ 1550 if ((yyval.cmd = alloc_cmd()) == NULL) 1551 YYERROR; 1552 cmd = yyval.cmd; 1553 yyval.cmd->cmd_num = CMD_EXPORT; 1554 yyval.cmd->cmd_handler = &export_func; 1555 yyval.cmd->cmd_res1_type = RT1_NCP; 1556 yyval.cmd->cmd_res2_type = yypvt[-2].ival; 1557 yyval.cmd->cmd_ncu_class_type = yypvt[-1].ival; 1558 yyval.cmd->cmd_argc = 3; 1559 yyval.cmd->cmd_argv[0] = yypvt[-4].strval; 1560 yyval.cmd->cmd_argv[1] = yypvt[-3].strval; 1561 yyval.cmd->cmd_argv[2] = yypvt[-0].strval; 1562 yyval.cmd->cmd_argv[3] = NULL; 1563 } break; 1564 case 56: 1565 # line 529 "nwamcfg_grammar.y" 1566 { 1567 command_usage(CMD_GET); 1568 YYERROR; 1569 } break; 1570 case 57: 1571 # line 534 "nwamcfg_grammar.y" 1572 { 1573 properr(yypvt[-0].strval); 1574 YYERROR; 1575 } break; 1576 case 58: 1577 # line 539 "nwamcfg_grammar.y" 1578 { 1579 /* get prop */ 1580 if ((yyval.cmd = alloc_cmd()) == NULL) 1581 YYERROR; 1582 cmd = yyval.cmd; 1583 yyval.cmd->cmd_num = CMD_GET; 1584 yyval.cmd->cmd_handler = &get_func; 1585 yyval.cmd->cmd_prop_type = yypvt[-0].ival; 1586 yyval.cmd->cmd_argc = 0; 1587 yyval.cmd->cmd_argv[0] = NULL; 1588 } break; 1589 case 59: 1590 # line 551 "nwamcfg_grammar.y" 1591 { 1592 /* get -V prop */ 1593 if ((yyval.cmd = alloc_cmd()) == NULL) 1594 YYERROR; 1595 cmd = yyval.cmd; 1596 yyval.cmd->cmd_num = CMD_GET; 1597 yyval.cmd->cmd_handler = &get_func; 1598 yyval.cmd->cmd_prop_type = yypvt[-0].ival; 1599 yyval.cmd->cmd_argc = 1; 1600 yyval.cmd->cmd_argv[0] = yypvt[-1].strval; 1601 yyval.cmd->cmd_argv[1] = NULL; 1602 } break; 1603 case 60: 1604 # line 565 "nwamcfg_grammar.y" 1605 { 1606 if ((yyval.cmd = alloc_cmd()) == NULL) 1607 YYERROR; 1608 cmd = yyval.cmd; 1609 yyval.cmd->cmd_num = CMD_HELP; 1610 yyval.cmd->cmd_handler = &help_func; 1611 yyval.cmd->cmd_argc = 0; 1612 yyval.cmd->cmd_argv[0] = NULL; 1613 } break; 1614 case 61: 1615 # line 575 "nwamcfg_grammar.y" 1616 { 1617 /* help command */ 1618 if ((yyval.cmd = alloc_cmd()) == NULL) 1619 YYERROR; 1620 cmd = yyval.cmd; 1621 yyval.cmd->cmd_num = CMD_HELP; 1622 yyval.cmd->cmd_handler = &help_func; 1623 yyval.cmd->cmd_argc = 1; 1624 yyval.cmd->cmd_argv[0] = yypvt[-0].strval; 1625 yyval.cmd->cmd_argv[1] = NULL; 1626 } break; 1627 case 62: 1628 # line 588 "nwamcfg_grammar.y" 1629 { 1630 if ((yyval.cmd = alloc_cmd()) == NULL) 1631 YYERROR; 1632 cmd = yyval.cmd; 1633 yyval.cmd->cmd_num = CMD_LIST; 1634 yyval.cmd->cmd_handler = &list_func; 1635 yyval.cmd->cmd_argc = 0; 1636 yyval.cmd->cmd_argv[0] = NULL; 1637 } break; 1638 case 63: 1639 # line 598 "nwamcfg_grammar.y" 1640 { 1641 command_usage(CMD_LIST); 1642 YYERROR; 1643 } break; 1644 case 64: 1645 # line 603 "nwamcfg_grammar.y" 1646 { 1647 /* list -a */ 1648 if ((yyval.cmd = alloc_cmd()) == NULL) 1649 YYERROR; 1650 cmd = yyval.cmd; 1651 yyval.cmd->cmd_num = CMD_LIST; 1652 yyval.cmd->cmd_handler = &list_func; 1653 yyval.cmd->cmd_res1_type = -1; /* special value */ 1654 yyval.cmd->cmd_argc = 1; 1655 yyval.cmd->cmd_argv[0] = yypvt[-0].strval; 1656 yyval.cmd->cmd_argv[1] = NULL; 1657 } break; 1658 case 65: 1659 # line 616 "nwamcfg_grammar.y" 1660 { 1661 command_usage(CMD_LIST); 1662 YYERROR; 1663 } break; 1664 case 66: 1665 # line 621 "nwamcfg_grammar.y" 1666 { 1667 command_usage(CMD_LIST); 1668 YYERROR; 1669 } break; 1670 case 67: 1671 # line 626 "nwamcfg_grammar.y" 1672 { 1673 /* list enm/loc/ncp test */ 1674 if ((yyval.cmd = alloc_cmd()) == NULL) 1675 YYERROR; 1676 cmd = yyval.cmd; 1677 yyval.cmd->cmd_num = CMD_LIST; 1678 yyval.cmd->cmd_handler = &list_func; 1679 yyval.cmd->cmd_res1_type = yypvt[-1].ival; 1680 yyval.cmd->cmd_argc = 1; 1681 yyval.cmd->cmd_argv[0] = yypvt[-0].strval; 1682 yyval.cmd->cmd_argv[1] = NULL; 1683 } break; 1684 case 68: 1685 # line 639 "nwamcfg_grammar.y" 1686 { 1687 /* list ncu test (all ncu's named test) */ 1688 if ((yyval.cmd = alloc_cmd()) == NULL) 1689 YYERROR; 1690 cmd = yyval.cmd; 1691 yyval.cmd->cmd_num = CMD_LIST; 1692 yyval.cmd->cmd_handler = &list_func; 1693 yyval.cmd->cmd_res1_type = RT1_NCP; 1694 yyval.cmd->cmd_res2_type = yypvt[-1].ival; 1695 yyval.cmd->cmd_ncu_class_type = NCU_CLASS_ANY; 1696 yyval.cmd->cmd_argc = 1; 1697 yyval.cmd->cmd_argv[0] = yypvt[-0].strval; 1698 yyval.cmd->cmd_argv[1] = NULL; 1699 } break; 1700 case 69: 1701 # line 654 "nwamcfg_grammar.y" 1702 { 1703 /* list ncu ip/phys test */ 1704 if ((yyval.cmd = alloc_cmd()) == NULL) 1705 YYERROR; 1706 cmd = yyval.cmd; 1707 yyval.cmd->cmd_num = CMD_LIST; 1708 yyval.cmd->cmd_handler = &list_func; 1709 yyval.cmd->cmd_res1_type = RT1_NCP; 1710 yyval.cmd->cmd_res2_type = yypvt[-2].ival; 1711 yyval.cmd->cmd_ncu_class_type = yypvt[-1].ival; 1712 yyval.cmd->cmd_argc = 1; 1713 yyval.cmd->cmd_argv[0] = yypvt[-0].strval; 1714 yyval.cmd->cmd_argv[1] = NULL; 1715 } break; 1716 case 70: 1717 # line 669 "nwamcfg_grammar.y" 1718 { 1719 /* list -a enm/loc/ncp test */ 1720 if ((yyval.cmd = alloc_cmd()) == NULL) 1721 YYERROR; 1722 cmd = yyval.cmd; 1723 yyval.cmd->cmd_num = CMD_LIST; 1724 yyval.cmd->cmd_handler = &list_func; 1725 yyval.cmd->cmd_res1_type = yypvt[-1].ival; 1726 yyval.cmd->cmd_argc = 2; 1727 yyval.cmd->cmd_argv[0] = yypvt[-0].strval; 1728 yyval.cmd->cmd_argv[1] = yypvt[-2].strval; 1729 yyval.cmd->cmd_argv[2] = NULL; 1730 } break; 1731 case 71: 1732 # line 683 "nwamcfg_grammar.y" 1733 { 1734 /* list -a ncu test (all ncu's named test) */ 1735 if ((yyval.cmd = alloc_cmd()) == NULL) 1736 YYERROR; 1737 cmd = yyval.cmd; 1738 yyval.cmd->cmd_num = CMD_LIST; 1739 yyval.cmd->cmd_handler = &list_func; 1740 yyval.cmd->cmd_res1_type = RT1_NCP; 1741 yyval.cmd->cmd_res2_type = yypvt[-1].ival; 1742 yyval.cmd->cmd_ncu_class_type = NCU_CLASS_ANY; 1743 yyval.cmd->cmd_argc = 2; 1744 yyval.cmd->cmd_argv[0] = yypvt[-0].strval; 1745 yyval.cmd->cmd_argv[1] = yypvt[-2].strval; 1746 yyval.cmd->cmd_argv[2] = NULL; 1747 } break; 1748 case 72: 1749 # line 699 "nwamcfg_grammar.y" 1750 { 1751 /* list -a ncu ip/phys test */ 1752 if ((yyval.cmd = alloc_cmd()) == NULL) 1753 YYERROR; 1754 cmd = yyval.cmd; 1755 yyval.cmd->cmd_num = CMD_LIST; 1756 yyval.cmd->cmd_handler = &list_func; 1757 yyval.cmd->cmd_res1_type = RT1_NCP; 1758 yyval.cmd->cmd_res2_type = yypvt[-2].ival; 1759 yyval.cmd->cmd_ncu_class_type = yypvt[-1].ival; 1760 yyval.cmd->cmd_argc = 2; 1761 yyval.cmd->cmd_argv[0] = yypvt[-0].strval; 1762 yyval.cmd->cmd_argv[1] = yypvt[-3].strval; 1763 yyval.cmd->cmd_argv[2] = NULL; 1764 } break; 1765 case 73: 1766 # line 716 "nwamcfg_grammar.y" 1767 { 1768 if ((yyval.cmd = alloc_cmd()) == NULL) 1769 YYERROR; 1770 cmd = yyval.cmd; 1771 yyval.cmd->cmd_num = CMD_REVERT; 1772 yyval.cmd->cmd_handler = &revert_func; 1773 yyval.cmd->cmd_argc = 0; 1774 yyval.cmd->cmd_argv[0] = NULL; 1775 } break; 1776 case 74: 1777 # line 727 "nwamcfg_grammar.y" 1778 { 1779 command_usage(CMD_SELECT); 1780 YYERROR; 1781 } break; 1782 case 75: 1783 # line 732 "nwamcfg_grammar.y" 1784 { 1785 command_usage(CMD_SELECT); 1786 YYERROR; 1787 } break; 1788 case 76: 1789 # line 737 "nwamcfg_grammar.y" 1790 { 1791 command_usage(CMD_SELECT); 1792 YYERROR; 1793 } break; 1794 case 77: 1795 # line 742 "nwamcfg_grammar.y" 1796 { 1797 command_usage(CMD_SELECT); 1798 YYERROR; 1799 } break; 1800 case 78: 1801 # line 747 "nwamcfg_grammar.y" 1802 { 1803 /* select enm/loc/ncp test */ 1804 if ((yyval.cmd = alloc_cmd()) == NULL) 1805 YYERROR; 1806 cmd = yyval.cmd; 1807 yyval.cmd->cmd_num = CMD_SELECT; 1808 yyval.cmd->cmd_handler = &select_func; 1809 yyval.cmd->cmd_res1_type = yypvt[-1].ival; 1810 yyval.cmd->cmd_argc = 1; 1811 yyval.cmd->cmd_argv[0] = yypvt[-0].strval; 1812 yyval.cmd->cmd_argv[1] = NULL; 1813 } break; 1814 case 79: 1815 # line 760 "nwamcfg_grammar.y" 1816 { 1817 /* select ncu test (class inferred) */ 1818 if ((yyval.cmd = alloc_cmd()) == NULL) 1819 YYERROR; 1820 cmd = yyval.cmd; 1821 yyval.cmd->cmd_num = CMD_SELECT; 1822 yyval.cmd->cmd_handler = &select_func; 1823 yyval.cmd->cmd_res1_type = RT1_NCP; 1824 yyval.cmd->cmd_res2_type = yypvt[-1].ival; 1825 yyval.cmd->cmd_ncu_class_type = NCU_CLASS_ANY; 1826 yyval.cmd->cmd_argc = 1; 1827 yyval.cmd->cmd_argv[0] = yypvt[-0].strval; 1828 yyval.cmd->cmd_argv[1] = NULL; 1829 } break; 1830 case 80: 1831 # line 775 "nwamcfg_grammar.y" 1832 { 1833 /* select ncu ip/phys test */ 1834 if ((yyval.cmd = alloc_cmd()) == NULL) 1835 YYERROR; 1836 cmd = yyval.cmd; 1837 yyval.cmd->cmd_num = CMD_SELECT; 1838 yyval.cmd->cmd_handler = &select_func; 1839 yyval.cmd->cmd_res1_type = RT1_NCP; 1840 yyval.cmd->cmd_res2_type = yypvt[-2].ival; 1841 yyval.cmd->cmd_ncu_class_type = yypvt[-1].ival; 1842 yyval.cmd->cmd_argc = 1; 1843 yyval.cmd->cmd_argv[0] = yypvt[-0].strval; 1844 yyval.cmd->cmd_argv[1] = NULL; 1845 } break; 1846 case 81: 1847 # line 791 "nwamcfg_grammar.y" 1848 { 1849 command_usage(CMD_SET); 1850 YYERROR; 1851 } break; 1852 case 82: 1853 # line 796 "nwamcfg_grammar.y" 1854 { 1855 properr(yypvt[-0].strval); 1856 YYERROR; 1857 } break; 1858 case 83: 1859 # line 801 "nwamcfg_grammar.y" 1860 { 1861 /* set prop=value */ 1862 if ((yyval.cmd = alloc_cmd()) == NULL) 1863 YYERROR; 1864 cmd = yyval.cmd; 1865 yyval.cmd->cmd_num = CMD_SET; 1866 yyval.cmd->cmd_handler = &set_func; 1867 yyval.cmd->cmd_prop_type = yypvt[-2].ival; 1868 yyval.cmd->cmd_argc = 1; 1869 yyval.cmd->cmd_argv[0] = yypvt[-0].strval; 1870 yyval.cmd->cmd_argv[1] = NULL; 1871 } break; 1872 case 84: 1873 # line 815 "nwamcfg_grammar.y" 1874 { 1875 if ((yyval.cmd = alloc_cmd()) == NULL) 1876 YYERROR; 1877 cmd = yyval.cmd; 1878 yyval.cmd->cmd_num = CMD_VERIFY; 1879 yyval.cmd->cmd_handler = &verify_func; 1880 yyval.cmd->cmd_argc = 0; 1881 yyval.cmd->cmd_argv[0] = NULL; 1882 } break; 1883 case 85: 1884 # line 826 "nwamcfg_grammar.y" 1885 { 1886 if ((yyval.cmd = alloc_cmd()) == NULL) 1887 YYERROR; 1888 cmd = yyval.cmd; 1889 yyval.cmd->cmd_num = CMD_WALKPROP; 1890 yyval.cmd->cmd_handler = &walkprop_func; 1891 yyval.cmd->cmd_argc = 0; 1892 yyval.cmd->cmd_argv[0] = NULL; 1893 } break; 1894 case 86: 1895 # line 836 "nwamcfg_grammar.y" 1896 { 1897 /* walkprop -a */ 1898 if ((yyval.cmd = alloc_cmd()) == NULL) 1899 YYERROR; 1900 cmd = yyval.cmd; 1901 yyval.cmd->cmd_num = CMD_WALKPROP; 1902 yyval.cmd->cmd_handler = &walkprop_func; 1903 yyval.cmd->cmd_argc = 1; 1904 yyval.cmd->cmd_argv[0] = yypvt[-0].strval; 1905 yyval.cmd->cmd_argv[1] = NULL; 1906 } break; 1907 case 87: 1908 # line 848 "nwamcfg_grammar.y" 1909 { yyval.ival = RT1_LOC; } break; 1910 case 88: 1911 # line 849 "nwamcfg_grammar.y" 1912 { yyval.ival = RT1_NCP; } break; 1913 case 89: 1914 # line 850 "nwamcfg_grammar.y" 1915 { yyval.ival = RT1_ENM; } break; 1916 case 90: 1917 # line 851 "nwamcfg_grammar.y" 1918 { yyval.ival = RT1_WLAN; } break; 1919 case 91: 1920 # line 853 "nwamcfg_grammar.y" 1921 { yyval.ival = RT2_NCU; } break; 1922 case 92: 1923 # line 855 "nwamcfg_grammar.y" 1924 { yyval.ival = NCU_CLASS_PHYS; } break; 1925 case 93: 1926 # line 856 "nwamcfg_grammar.y" 1927 { yyval.ival = NCU_CLASS_IP; } break; 1928 case 94: 1929 # line 858 "nwamcfg_grammar.y" 1930 { yyval.ival = PT_UNKNOWN; } break; 1931 case 95: 1932 # line 859 "nwamcfg_grammar.y" 1933 { yyval.ival = PT_ACTIVATION_MODE; } break; 1934 case 96: 1935 # line 860 "nwamcfg_grammar.y" 1936 { yyval.ival = PT_CONDITIONS; } break; 1937 case 97: 1938 # line 861 "nwamcfg_grammar.y" 1939 { yyval.ival = PT_ENABLED; } break; 1940 case 98: 1941 # line 862 "nwamcfg_grammar.y" 1942 { yyval.ival = PT_TYPE; } break; 1943 case 99: 1944 # line 863 "nwamcfg_grammar.y" 1945 { yyval.ival = PT_CLASS; } break; 1946 case 100: 1947 # line 864 "nwamcfg_grammar.y" 1948 { yyval.ival = PT_PARENT; } break; 1949 case 101: 1950 # line 865 "nwamcfg_grammar.y" 1951 { yyval.ival = PT_PRIORITY_GROUP; } break; 1952 case 102: 1953 # line 866 "nwamcfg_grammar.y" 1954 { yyval.ival = PT_PRIORITY_MODE; } break; 1955 case 103: 1956 # line 867 "nwamcfg_grammar.y" 1957 { yyval.ival = PT_LINK_MACADDR; } break; 1958 case 104: 1959 # line 868 "nwamcfg_grammar.y" 1960 { yyval.ival = PT_LINK_AUTOPUSH; } break; 1961 case 105: 1962 # line 869 "nwamcfg_grammar.y" 1963 { yyval.ival = PT_LINK_MTU; } break; 1964 case 106: 1965 # line 870 "nwamcfg_grammar.y" 1966 { yyval.ival = PT_IP_VERSION; } break; 1967 case 107: 1968 # line 871 "nwamcfg_grammar.y" 1969 { yyval.ival = PT_IPV4_ADDRSRC; } break; 1970 case 108: 1971 # line 872 "nwamcfg_grammar.y" 1972 { yyval.ival = PT_IPV4_ADDR; } break; 1973 case 109: 1974 # line 873 "nwamcfg_grammar.y" 1975 { yyval.ival = PT_IPV4_DEFAULT_ROUTE; } break; 1976 case 110: 1977 # line 874 "nwamcfg_grammar.y" 1978 { yyval.ival = PT_IPV6_ADDRSRC; } break; 1979 case 111: 1980 # line 875 "nwamcfg_grammar.y" 1981 { yyval.ival = PT_IPV6_ADDR; } break; 1982 case 112: 1983 # line 876 "nwamcfg_grammar.y" 1984 { yyval.ival = PT_IPV6_DEFAULT_ROUTE; } break; 1985 case 113: 1986 # line 877 "nwamcfg_grammar.y" 1987 { yyval.ival = PT_ENM_FMRI; } break; 1988 case 114: 1989 # line 878 "nwamcfg_grammar.y" 1990 { yyval.ival = PT_ENM_START; } break; 1991 case 115: 1992 # line 879 "nwamcfg_grammar.y" 1993 { yyval.ival = PT_ENM_STOP; } break; 1994 case 116: 1995 # line 880 "nwamcfg_grammar.y" 1996 { yyval.ival = PT_LOC_NAMESERVICES; } break; 1997 case 117: 1998 # line 881 "nwamcfg_grammar.y" 1999 { yyval.ival = PT_LOC_NAMESERVICES_CONFIG; } break; 2000 case 118: 2001 # line 882 "nwamcfg_grammar.y" 2002 { yyval.ival = PT_LOC_DNS_CONFIGSRC; } break; 2003 case 119: 2004 # line 883 "nwamcfg_grammar.y" 2005 { yyval.ival = PT_LOC_DNS_DOMAIN; } break; 2006 case 120: 2007 # line 884 "nwamcfg_grammar.y" 2008 { yyval.ival = PT_LOC_DNS_SERVERS; } break; 2009 case 121: 2010 # line 885 "nwamcfg_grammar.y" 2011 { yyval.ival = PT_LOC_DNS_SEARCH; } break; 2012 case 122: 2013 # line 886 "nwamcfg_grammar.y" 2014 { yyval.ival = PT_LOC_NIS_CONFIGSRC; } break; 2015 case 123: 2016 # line 887 "nwamcfg_grammar.y" 2017 { yyval.ival = PT_LOC_NIS_SERVERS; } break; 2018 case 124: 2019 # line 888 "nwamcfg_grammar.y" 2020 { yyval.ival = PT_LOC_LDAP_CONFIGSRC; } break; 2021 case 125: 2022 # line 889 "nwamcfg_grammar.y" 2023 { yyval.ival = PT_LOC_LDAP_SERVERS; } break; 2024 case 126: 2025 # line 890 "nwamcfg_grammar.y" 2026 { yyval.ival = PT_LOC_DEFAULT_DOMAIN; } break; 2027 case 127: 2028 # line 891 "nwamcfg_grammar.y" 2029 { yyval.ival = PT_LOC_NFSV4_DOMAIN; } break; 2030 case 128: 2031 # line 892 "nwamcfg_grammar.y" 2032 { yyval.ival = PT_LOC_IPF_CONFIG; } break; 2033 case 129: 2034 # line 893 "nwamcfg_grammar.y" 2035 { yyval.ival = PT_LOC_IPF_V6_CONFIG; } break; 2036 case 130: 2037 # line 894 "nwamcfg_grammar.y" 2038 { yyval.ival = PT_LOC_IPNAT_CONFIG; } break; 2039 case 131: 2040 # line 895 "nwamcfg_grammar.y" 2041 { yyval.ival = PT_LOC_IPPOOL_CONFIG; } break; 2042 case 132: 2043 # line 896 "nwamcfg_grammar.y" 2044 { yyval.ival = PT_LOC_IKE_CONFIG; } break; 2045 case 133: 2046 # line 897 "nwamcfg_grammar.y" 2047 { yyval.ival = PT_LOC_IPSECPOL_CONFIG; } break; 2048 case 134: 2049 # line 898 "nwamcfg_grammar.y" 2050 { yyval.ival = PT_WLAN_BSSIDS; } break; 2051 case 135: 2052 # line 899 "nwamcfg_grammar.y" 2053 { yyval.ival = PT_WLAN_PRIORITY; } break; 2054 case 136: 2055 # line 900 "nwamcfg_grammar.y" 2056 { yyval.ival = PT_WLAN_KEYNAME; } break; 2057 case 137: 2058 # line 901 "nwamcfg_grammar.y" 2059 { yyval.ival = PT_WLAN_KEYSLOT; } break; 2060 case 138: 2061 # line 902 "nwamcfg_grammar.y" 2062 { yyval.ival = PT_WLAN_SECURITY_MODE; } break; 2063 # line 556 "/usr/share/lib/ccs/yaccpar" 2064 } 2065 goto yystack; /* reset registers in driver code */ 2066 } 2067 2068