00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047 #define YYBISON 1
00048
00049
00050 #define YYBISON_VERSION "2.3"
00051
00052
00053 #define YYSKELETON_NAME "yacc.c"
00054
00055
00056 #define YYPURE 1
00057
00058
00059 #define YYLSP_NEEDED 0
00060
00061
00062
00063
00064 #ifndef YYTOKENTYPE
00065 # define YYTOKENTYPE
00066
00067
00068 enum ace_yytokentype {
00069 ACE_DYNAMIC = 258,
00070 ACE_STATIC = 259,
00071 ACE_SUSPEND = 260,
00072 ACE_RESUME = 261,
00073 ACE_REMOVE = 262,
00074 ACE_USTREAM = 263,
00075 ACE_MODULE_T = 264,
00076 ACE_STREAM_T = 265,
00077 ACE_SVC_OBJ_T = 266,
00078 ACE_ACTIVE = 267,
00079 ACE_INACTIVE = 268,
00080 ACE_PATHNAME = 269,
00081 ACE_IDENT = 270,
00082 ACE_STRING = 271
00083 };
00084 #endif
00085
00086 #define ACE_DYNAMIC 258
00087 #define ACE_STATIC 259
00088 #define ACE_SUSPEND 260
00089 #define ACE_RESUME 261
00090 #define ACE_REMOVE 262
00091 #define ACE_USTREAM 263
00092 #define ACE_MODULE_T 264
00093 #define ACE_STREAM_T 265
00094 #define ACE_SVC_OBJ_T 266
00095 #define ACE_ACTIVE 267
00096 #define ACE_INACTIVE 268
00097 #define ACE_PATHNAME 269
00098 #define ACE_IDENT 270
00099 #define ACE_STRING 271
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109 #include "ace/Svc_Conf.h"
00110
00111 #if (ACE_USES_CLASSIC_SVC_CONF == 1)
00112
00113 #include "ace/Module.h"
00114 #include "ace/Stream.h"
00115 #include "ace/Service_Types.h"
00116 #include "ace/ace_wchar.h"
00117
00118 ACE_RCSID (ace,
00119 Svc_Conf_y,
00120 "$Id: Svc_Conf_y.cpp 81326 2008-04-10 14:57:51Z iliyan $")
00121
00122 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00123
00124
00125
00126 static ACE_Module_Type *
00127 ace_get_module (ACE_Service_Type const * sr,
00128 ACE_TCHAR const * svc_name,
00129 int & ace_ace_yyerrno);
00130
00131 #define YYDEBUG_LEXER_TEXT (ace_yytext[ace_yyleng] = '\0', ace_yytext)
00132
00133
00134
00135
00136
00137
00138
00139 #if defined (_MSC_VER)
00140 # pragma warning ( disable : 4065 )
00141 #endif
00142
00143
00144 #define YY_ ACE_TEXT
00145
00146
00147
00148
00149
00150
00151 #define YYSTYPE_IS_DECLARED
00152
00153 ACE_END_VERSIONED_NAMESPACE_DECL
00154
00155
00156
00157
00158 #ifndef YYDEBUG
00159 # define YYDEBUG 0
00160 #endif
00161
00162
00163 #ifdef YYERROR_VERBOSE
00164 # undef YYERROR_VERBOSE
00165 # define YYERROR_VERBOSE 1
00166 #else
00167 # define YYERROR_VERBOSE 0
00168 #endif
00169
00170
00171 #ifndef YYTOKEN_TABLE
00172 # define YYTOKEN_TABLE 0
00173 #endif
00174
00175 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
00176 typedef int YYSTYPE;
00177 # define ace_yystype YYSTYPE
00178 # define YYSTYPE_IS_DECLARED 1
00179 # define YYSTYPE_IS_TRIVIAL 1
00180 #endif
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190 #ifdef short
00191 # undef short
00192 #endif
00193
00194 #ifdef YYTYPE_UINT8
00195 typedef YYTYPE_UINT8 ace_yytype_uint8;
00196 #else
00197 typedef unsigned char ace_yytype_uint8;
00198 #endif
00199
00200 #ifdef YYTYPE_INT8
00201 typedef YYTYPE_INT8 ace_yytype_int8;
00202 #elif (defined __STDC__ || defined __C99__FUNC__ \
00203 || defined __cplusplus || defined _MSC_VER)
00204 typedef signed char ace_yytype_int8;
00205 #else
00206 typedef short int ace_yytype_int8;
00207 #endif
00208
00209 #ifdef YYTYPE_UINT16
00210 typedef YYTYPE_UINT16 ace_yytype_uint16;
00211 #else
00212 typedef unsigned short int ace_yytype_uint16;
00213 #endif
00214
00215 #ifdef YYTYPE_INT16
00216 typedef YYTYPE_INT16 ace_yytype_int16;
00217 #else
00218 typedef short int ace_yytype_int16;
00219 #endif
00220
00221 #ifndef YYSIZE_T
00222 # ifdef __SIZE_TYPE__
00223 # define YYSIZE_T __SIZE_TYPE__
00224 # elif defined size_t
00225 # define YYSIZE_T size_t
00226 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
00227 || defined __cplusplus || defined _MSC_VER)
00228 # include <stddef.h>
00229 # define YYSIZE_T size_t
00230 # else
00231 # define YYSIZE_T unsigned int
00232 # endif
00233 #endif
00234
00235 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
00236
00237 #ifndef YY_
00238 # if YYENABLE_NLS
00239 # if ENABLE_NLS
00240 # include <libintl.h>
00241 # define YY_(msgid) dgettext ("bison-runtime", msgid)
00242 # endif
00243 # endif
00244 # ifndef YY_
00245 # define YY_(msgid) msgid
00246 # endif
00247 #endif
00248
00249
00250 #if ! defined lint || defined __GNUC__
00251 # define YYUSE(e) ((void) (e))
00252 #else
00253 # define YYUSE(e)
00254 #endif
00255
00256
00257 #ifndef lint
00258 # define YYID(n) (n)
00259 #else
00260 #if (defined __STDC__ || defined __C99__FUNC__ \
00261 || defined __cplusplus || defined _MSC_VER)
00262 static int
00263 YYID (int i)
00264 #else
00265 static int
00266 YYID (i)
00267 int i;
00268 #endif
00269 {
00270 return i;
00271 }
00272 #endif
00273
00274 #if ! defined ace_yyoverflow || YYERROR_VERBOSE
00275
00276
00277
00278 # ifdef YYSTACK_USE_ALLOCA
00279 # if YYSTACK_USE_ALLOCA
00280 # ifdef __GNUC__
00281 # define YYSTACK_ALLOC __builtin_alloca
00282 # elif defined __BUILTIN_VA_ARG_INCR
00283 # include <alloca.h>
00284 # elif defined _AIX
00285 # define YYSTACK_ALLOC __alloca
00286 # elif defined _MSC_VER
00287 # include <malloc.h>
00288 # define alloca _alloca
00289 # else
00290 # define YYSTACK_ALLOC alloca
00291 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00292 || defined __cplusplus || defined _MSC_VER)
00293 # include <stdlib.h>
00294 # ifndef _STDLIB_H
00295 # define _STDLIB_H 1
00296 # endif
00297 # endif
00298 # endif
00299 # endif
00300 # endif
00301
00302 # ifdef YYSTACK_ALLOC
00303
00304 # define YYSTACK_FREE(Ptr) do { ; } while (YYID (0))
00305 # ifndef YYSTACK_ALLOC_MAXIMUM
00306
00307
00308
00309
00310 # define YYSTACK_ALLOC_MAXIMUM 4032
00311 # endif
00312 # else
00313 # define YYSTACK_ALLOC YYMALLOC
00314 # define YYSTACK_FREE YYFREE
00315 # ifndef YYSTACK_ALLOC_MAXIMUM
00316 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
00317 # endif
00318 # if (defined __cplusplus && ! defined _STDLIB_H \
00319 && ! ((defined YYMALLOC || defined malloc) \
00320 && (defined YYFREE || defined free)))
00321 # include <stdlib.h>
00322 # ifndef _STDLIB_H
00323 # define _STDLIB_H 1
00324 # endif
00325 # endif
00326 # ifndef YYMALLOC
00327 # define YYMALLOC malloc
00328 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00329 || defined __cplusplus || defined _MSC_VER)
00330 void *malloc (YYSIZE_T);
00331 # endif
00332 # endif
00333 # ifndef YYFREE
00334 # define YYFREE free
00335 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00336 || defined __cplusplus || defined _MSC_VER)
00337 void free (void *);
00338 # endif
00339 # endif
00340 # endif
00341 #endif
00342
00343
00344 #if (! defined ace_yyoverflow \
00345 && (! defined __cplusplus \
00346 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
00347
00348
00349 union ace_yyalloc
00350 {
00351 ace_yytype_int16 ace_yyss;
00352 YYSTYPE ace_yyvs;
00353 };
00354
00355
00356 # define YYSTACK_GAP_MAXIMUM (sizeof (union ace_yyalloc) - 1)
00357
00358
00359
00360 # define YYSTACK_BYTES(N) \
00361 ((N) * (sizeof (ace_yytype_int16) + sizeof (YYSTYPE)) \
00362 + YYSTACK_GAP_MAXIMUM)
00363
00364
00365
00366 # ifndef YYCOPY
00367 # if defined __GNUC__ && 1 < __GNUC__
00368 # define YYCOPY(To, From, Count) \
00369 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
00370 # else
00371 # define YYCOPY(To, From, Count) \
00372 do \
00373 { \
00374 YYSIZE_T ace_yyi; \
00375 for (ace_yyi = 0; ace_yyi < (Count); ace_yyi++) \
00376 (To)[ace_yyi] = (From)[ace_yyi]; \
00377 } \
00378 while (YYID (0))
00379 # endif
00380 # endif
00381
00382
00383
00384
00385
00386
00387 # define YYSTACK_RELOCATE(Stack) \
00388 do \
00389 { \
00390 YYSIZE_T ace_yynewbytes; \
00391 YYCOPY (&ace_yyptr->Stack, Stack, ace_yysize); \
00392 Stack = &ace_yyptr->Stack; \
00393 ace_yynewbytes = ace_yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
00394 ace_yyptr += ace_yynewbytes / sizeof (*ace_yyptr); \
00395 } \
00396 while (YYID (0))
00397
00398 #endif
00399
00400
00401 #define YYFINAL 2
00402
00403 #define YYLAST 62
00404
00405
00406 #define YYNTOKENS 23
00407
00408 #define YYNNTS 21
00409
00410 #define YYNRULES 45
00411
00412 #define YYNSTATES 66
00413
00414
00415 #define YYUNDEFTOK 2
00416 #define YYMAXUTOK 271
00417
00418 #define YYTRANSLATE(YYX) \
00419 ((unsigned int) (YYX) <= YYMAXUTOK ? ace_yytranslate[YYX] : YYUNDEFTOK)
00420
00421
00422 static const ace_yytype_uint8 ace_yytranslate[] =
00423 {
00424 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00425 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00426 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00427 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00428 20, 21, 22, 2, 2, 2, 2, 2, 2, 2,
00429 2, 2, 2, 2, 2, 2, 2, 2, 19, 2,
00430 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00431 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00432 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00433 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00434 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00435 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00436 2, 2, 2, 17, 2, 18, 2, 2, 2, 2,
00437 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00438 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00439 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00440 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00441 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00442 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00443 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00444 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00445 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00446 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00447 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00448 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00449 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
00450 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
00451 15, 16
00452 };
00453
00454 #if YYDEBUG
00455
00456
00457 static const ace_yytype_uint8 ace_yyprhs[] =
00458 {
00459 0, 0, 3, 6, 9, 10, 12, 14, 16, 18,
00460 20, 22, 26, 30, 33, 36, 39, 43, 44, 49,
00461 51, 53, 54, 59, 60, 63, 64, 66, 68, 70,
00462 72, 74, 79, 81, 83, 84, 88, 94, 99, 102,
00463 105, 108, 110, 111, 113, 115
00464 };
00465
00466
00467 static const ace_yytype_int8 ace_yyrhs[] =
00468 {
00469 24, 0, -1, 24, 25, -1, 24, 1, -1, -1,
00470 26, -1, 27, -1, 28, -1, 29, -1, 30, -1,
00471 31, -1, 3, 38, 42, -1, 4, 15, 42, -1,
00472 5, 15, -1, 6, 15, -1, 7, 15, -1, 8,
00473 33, 34, -1, -1, 8, 15, 32, 34, -1, 26,
00474 -1, 27, -1, -1, 17, 35, 36, 18, -1, -1,
00475 36, 37, -1, -1, 26, -1, 27, -1, 28, -1,
00476 29, -1, 30, -1, 15, 41, 40, 39, -1, 12,
00477 -1, 13, -1, -1, 43, 19, 15, -1, 43, 19,
00478 15, 20, 21, -1, 19, 15, 20, 21, -1, 9,
00479 22, -1, 11, 22, -1, 10, 22, -1, 16, -1,
00480 -1, 14, -1, 15, -1, 16, -1
00481 };
00482
00483
00484 static const ace_yytype_uint16 ace_yyrline[] =
00485 {
00486 0, 72, 72, 81, 85, 89, 90, 91, 92, 93,
00487 94, 98, 108, 115, 122, 129, 136, 140, 140, 147,
00488 150, 157, 156, 166, 170, 178, 182, 185, 199, 208,
00489 217, 239, 246, 250, 255, 261, 265, 269, 276, 280,
00490 284, 291, 292, 296, 297, 298
00491 };
00492 #endif
00493
00494 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
00495
00496
00497 static const char *const ace_yytname[] =
00498 {
00499 "$end", "error", "$undefined", "ACE_DYNAMIC", "ACE_STATIC",
00500 "ACE_SUSPEND", "ACE_RESUME", "ACE_REMOVE", "ACE_USTREAM", "ACE_MODULE_T",
00501 "ACE_STREAM_T", "ACE_SVC_OBJ_T", "ACE_ACTIVE", "ACE_INACTIVE",
00502 "ACE_PATHNAME", "ACE_IDENT", "ACE_STRING", "'{'", "'}'", "':'", "'('",
00503 "')'", "'*'", "$accept", "svc_config_entries", "svc_config_entry",
00504 "dynamic", "static", "suspend", "resume", "remove", "stream", "@1",
00505 "stream_ops", "stream_modules", "@2", "module_list", "module",
00506 "svc_location", "status", "svc_initializer", "type", "parameters_opt",
00507 "pathname", 0
00508 };
00509 #endif
00510
00511 # ifdef YYPRINT
00512
00513
00514 static const ace_yytype_uint16 ace_yytoknum[] =
00515 {
00516 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
00517 265, 266, 267, 268, 269, 270, 271, 123, 125, 58,
00518 40, 41, 42
00519 };
00520 # endif
00521
00522
00523 static const ace_yytype_uint8 ace_yyr1[] =
00524 {
00525 0, 23, 24, 24, 24, 25, 25, 25, 25, 25,
00526 25, 26, 27, 28, 29, 30, 31, 32, 31, 33,
00527 33, 35, 34, 34, 36, 36, 37, 37, 37, 37,
00528 37, 38, 39, 39, 39, 40, 40, 40, 41, 41,
00529 41, 42, 42, 43, 43, 43
00530 };
00531
00532
00533 static const ace_yytype_uint8 ace_yyr2[] =
00534 {
00535 0, 2, 2, 2, 0, 1, 1, 1, 1, 1,
00536 1, 3, 3, 2, 2, 2, 3, 0, 4, 1,
00537 1, 0, 4, 0, 2, 0, 1, 1, 1, 1,
00538 1, 4, 1, 1, 0, 3, 5, 4, 2, 2,
00539 2, 1, 0, 1, 1, 1
00540 };
00541
00542
00543
00544
00545 static const ace_yytype_uint8 ace_yydefact[] =
00546 {
00547 4, 0, 1, 3, 0, 0, 0, 0, 0, 0,
00548 2, 5, 6, 7, 8, 9, 10, 0, 42, 42,
00549 13, 14, 15, 17, 19, 20, 23, 0, 0, 0,
00550 0, 41, 11, 12, 23, 21, 16, 38, 40, 39,
00551 43, 44, 45, 0, 34, 0, 18, 25, 0, 32,
00552 33, 31, 0, 0, 0, 35, 22, 26, 27, 28,
00553 29, 30, 24, 37, 0, 36
00554 };
00555
00556
00557 static const ace_yytype_int8 ace_yydefgoto[] =
00558 {
00559 -1, 1, 10, 11, 12, 13, 14, 15, 16, 34,
00560 26, 36, 47, 53, 62, 18, 51, 44, 30, 32,
00561 45
00562 };
00563
00564
00565
00566 #define YYPACT_NINF -13
00567 static const ace_yytype_int8 ace_yypact[] =
00568 {
00569 -13, 20, -13, -13, 1, 3, 7, 14, 18, 4,
00570 -13, -13, -13, -13, -13, -13, -13, 21, 19, 19,
00571 -13, -13, -13, -13, -13, -13, -2, 12, 15, 16,
00572 -5, -13, -13, -13, -2, -13, -13, -13, -13, -13,
00573 -13, -13, -13, 24, 0, 17, -13, -13, 22, -13,
00574 -13, -13, 25, -1, 26, 23, -13, -13, -13, -13,
00575 -13, -13, -13, -13, 27, -13
00576 };
00577
00578
00579 static const ace_yytype_int8 ace_yypgoto[] =
00580 {
00581 -13, -13, -13, -9, -8, -12, -7, -4, -13, -13,
00582 -13, 28, -13, -13, -13, -13, -13, -13, -13, 31,
00583 -13
00584 };
00585
00586
00587
00588
00589
00590 #define YYTABLE_NINF -1
00591 static const ace_yytype_uint8 ace_yytable[] =
00592 {
00593 24, 25, 4, 5, 6, 7, 8, 4, 5, 40,
00594 41, 42, 49, 50, 43, 35, 17, 56, 19, 23,
00595 2, 3, 20, 4, 5, 6, 7, 8, 9, 21,
00596 27, 28, 29, 22, 37, 31, 52, 38, 39, 48,
00597 55, 59, 54, 64, 57, 58, 60, 63, 65, 61,
00598 33, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00599 0, 0, 46
00600 };
00601
00602 static const ace_yytype_int8 ace_yycheck[] =
00603 {
00604 9, 9, 3, 4, 5, 6, 7, 3, 4, 14,
00605 15, 16, 12, 13, 19, 17, 15, 18, 15, 15,
00606 0, 1, 15, 3, 4, 5, 6, 7, 8, 15,
00607 9, 10, 11, 15, 22, 16, 19, 22, 22, 15,
00608 15, 53, 20, 20, 53, 53, 53, 21, 21, 53,
00609 19, -1, -1, -1, -1, -1, -1, -1, -1, -1,
00610 -1, -1, 34
00611 };
00612
00613
00614
00615 static const ace_yytype_uint8 ace_yystos[] =
00616 {
00617 0, 24, 0, 1, 3, 4, 5, 6, 7, 8,
00618 25, 26, 27, 28, 29, 30, 31, 15, 38, 15,
00619 15, 15, 15, 15, 26, 27, 33, 9, 10, 11,
00620 41, 16, 42, 42, 32, 17, 34, 22, 22, 22,
00621 14, 15, 16, 19, 40, 43, 34, 35, 15, 12,
00622 13, 39, 19, 36, 20, 15, 18, 26, 27, 28,
00623 29, 30, 37, 21, 20, 21
00624 };
00625
00626 #define ace_yyerrok (ace_yyerrstatus = 0)
00627 #define ace_yyclearin (ace_yychar = YYEMPTY)
00628 #define YYEMPTY (-2)
00629 #define YYEOF 0
00630
00631 #define YYACCEPT goto ace_yyacceptlab
00632 #define YYABORT goto ace_yyabortlab
00633 #define YYERROR goto ace_yyerrorlab
00634
00635
00636
00637
00638
00639
00640 #define YYFAIL goto ace_yyerrlab
00641
00642 #define YYRECOVERING() (!!ace_yyerrstatus)
00643
00644 #define YYBACKUP(Token, Value) \
00645 do \
00646 if (ace_yychar == YYEMPTY && ace_yylen == 1) \
00647 { \
00648 ace_yychar = (Token); \
00649 ace_yylval = (Value); \
00650 ace_yytoken = YYTRANSLATE (ace_yychar); \
00651 YYPOPSTACK (1); \
00652 goto ace_yybackup; \
00653 } \
00654 else \
00655 { \
00656 ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, YY_("syntax error: cannot back up")); \
00657 YYERROR; \
00658 } \
00659 while (YYID (0))
00660
00661
00662 #define YYTERROR 1
00663 #define YYERRCODE 256
00664
00665
00666
00667
00668
00669
00670 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
00671 #ifndef YYLLOC_DEFAULT
00672 # define YYLLOC_DEFAULT(Current, Rhs, N) \
00673 do \
00674 if (YYID (N)) \
00675 { \
00676 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
00677 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
00678 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
00679 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
00680 } \
00681 else \
00682 { \
00683 (Current).first_line = (Current).last_line = \
00684 YYRHSLOC (Rhs, 0).last_line; \
00685 (Current).first_column = (Current).last_column = \
00686 YYRHSLOC (Rhs, 0).last_column; \
00687 } \
00688 while (YYID (0))
00689 #endif
00690
00691
00692
00693
00694
00695
00696 #ifndef YY_LOCATION_PRINT
00697 # if YYLTYPE_IS_TRIVIAL
00698 # define YY_LOCATION_PRINT(File, Loc) \
00699 ACE_OS::fprintf (File, "%d.%d-%d.%d", \
00700 (Loc).first_line, (Loc).first_column, \
00701 (Loc).last_line, (Loc).last_column)
00702 # else
00703 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
00704 # endif
00705 #endif
00706
00707
00708
00709
00710 #ifdef YYLEX_PARAM
00711 # define YYLEX ace_yylex (&ace_yylval, YYLEX_PARAM)
00712 #else
00713 # define YYLEX ace_yylex (&ace_yylval)
00714 #endif
00715
00716
00717 #if YYDEBUG
00718
00719 # ifndef YYFPRINTF
00720 # include <stdio.h>
00721 # define YYFPRINTF ACE_OS::fprintf
00722 # endif
00723
00724 # define YYDPRINTF(Args) \
00725 do { \
00726 if (ace_yydebug) \
00727 YYFPRINTF Args; \
00728 } while (YYID (0))
00729
00730 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
00731 do { \
00732 if (ace_yydebug) \
00733 { \
00734 YYFPRINTF (stderr, "%s ", Title); \
00735 ace_yy_symbol_print (stderr, \
00736 Type, Value); \
00737 YYFPRINTF (stderr, "\n"); \
00738 } \
00739 } while (YYID (0))
00740
00741
00742
00743
00744
00745
00746
00747 #if (defined __STDC__ || defined __C99__FUNC__ \
00748 || defined __cplusplus || defined _MSC_VER)
00749 static void
00750 ace_yy_symbol_value_print (FILE *ace_yyoutput, int ace_yytype, YYSTYPE const * const ace_yyvaluep)
00751 #else
00752 static void
00753 ace_yy_symbol_value_print (ace_yyoutput, ace_yytype, ace_yyvaluep)
00754 FILE *ace_yyoutput;
00755 int ace_yytype;
00756 YYSTYPE const * const ace_yyvaluep;
00757 #endif
00758 {
00759 if (!ace_yyvaluep)
00760 return;
00761 # ifdef YYPRINT
00762 if (ace_yytype < YYNTOKENS)
00763 YYPRINT (ace_yyoutput, ace_yytoknum[ace_yytype], *ace_yyvaluep);
00764 # else
00765 YYUSE (ace_yyoutput);
00766 # endif
00767 switch (ace_yytype)
00768 {
00769 default:
00770 break;
00771 }
00772 }
00773
00774
00775
00776
00777
00778
00779 #if (defined __STDC__ || defined __C99__FUNC__ \
00780 || defined __cplusplus || defined _MSC_VER)
00781 static void
00782 ace_yy_symbol_print (FILE *ace_yyoutput, int ace_yytype, YYSTYPE const * const ace_yyvaluep)
00783 #else
00784 static void
00785 ace_yy_symbol_print (ace_yyoutput, ace_yytype, ace_yyvaluep)
00786 FILE *ace_yyoutput;
00787 int ace_yytype;
00788 YYSTYPE const * const ace_yyvaluep;
00789 #endif
00790 {
00791 if (ace_yytype < YYNTOKENS)
00792 YYFPRINTF (ace_yyoutput, "token %s (", ace_yytname[ace_yytype]);
00793 else
00794 YYFPRINTF (ace_yyoutput, "nterm %s (", ace_yytname[ace_yytype]);
00795
00796 ace_yy_symbol_value_print (ace_yyoutput, ace_yytype, ace_yyvaluep);
00797 YYFPRINTF (ace_yyoutput, ")");
00798 }
00799
00800
00801
00802
00803
00804
00805 #if (defined __STDC__ || defined __C99__FUNC__ \
00806 || defined __cplusplus || defined _MSC_VER)
00807 static void
00808 ace_yy_stack_print (ace_yytype_int16 *bottom, ace_yytype_int16 *top)
00809 #else
00810 static void
00811 ace_yy_stack_print (bottom, top)
00812 ace_yytype_int16 *bottom;
00813 ace_yytype_int16 *top;
00814 #endif
00815 {
00816 YYFPRINTF (stderr, "Stack now");
00817 for (; bottom <= top; ++bottom)
00818 YYFPRINTF (stderr, " %d", *bottom);
00819 YYFPRINTF (stderr, "\n");
00820 }
00821
00822 # define YY_STACK_PRINT(Bottom, Top) \
00823 do { \
00824 if (ace_yydebug) \
00825 ace_yy_stack_print ((Bottom), (Top)); \
00826 } while (YYID (0))
00827
00828
00829
00830
00831
00832
00833 #if (defined __STDC__ || defined __C99__FUNC__ \
00834 || defined __cplusplus || defined _MSC_VER)
00835 static void
00836 ace_yy_reduce_print (YYSTYPE *ace_yyvsp, int ace_yyrule)
00837 #else
00838 static void
00839 ace_yy_reduce_print (ace_yyvsp, ace_yyrule)
00840 YYSTYPE *ace_yyvsp;
00841 int ace_yyrule;
00842 #endif
00843 {
00844 int ace_yynrhs = ace_yyr2[ace_yyrule];
00845 int ace_yyi;
00846 unsigned long int ace_yylno = ace_yyrline[ace_yyrule];
00847 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
00848 ace_yyrule - 1, ace_yylno);
00849
00850 for (ace_yyi = 0; ace_yyi < ace_yynrhs; ace_yyi++)
00851 {
00852 ACE_OS::fprintf (stderr, " $%d = ", ace_yyi + 1);
00853 ace_yy_symbol_print (stderr, ace_yyrhs[ace_yyprhs[ace_yyrule] + ace_yyi],
00854 &(ace_yyvsp[(ace_yyi + 1) - (ace_yynrhs)])
00855 );
00856 ACE_OS::fprintf (stderr, "\n");
00857 }
00858 }
00859
00860 # define YY_REDUCE_PRINT(Rule) \
00861 do { \
00862 if (ace_yydebug) \
00863 ace_yy_reduce_print (ace_yyvsp, Rule); \
00864 } while (YYID (0))
00865
00866
00867
00868 int ace_yydebug;
00869 #else
00870 # define YYDPRINTF(Args)
00871 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
00872 # define YY_STACK_PRINT(Bottom, Top)
00873 # define YY_REDUCE_PRINT(Rule)
00874 #endif
00875
00876
00877
00878 #ifndef YYINITDEPTH
00879 # define YYINITDEPTH 200
00880 #endif
00881
00882
00883
00884
00885
00886
00887
00888
00889 #ifndef YYMAXDEPTH
00890 # define YYMAXDEPTH 10000
00891 #endif
00892
00893
00894
00895 #if YYERROR_VERBOSE
00896
00897 # ifndef ace_yystrlen
00898 # if defined __GLIBC__ && defined _STRING_H
00899 # define ace_yystrlen strlen
00900 # else
00901
00902 #if (defined __STDC__ || defined __C99__FUNC__ \
00903 || defined __cplusplus || defined _MSC_VER)
00904 static YYSIZE_T
00905 ace_yystrlen (const char *ace_yystr)
00906 #else
00907 static YYSIZE_T
00908 ace_yystrlen (ace_yystr)
00909 const char *ace_yystr;
00910 #endif
00911 {
00912 YYSIZE_T ace_yylen;
00913 for (ace_yylen = 0; ace_yystr[ace_yylen]; ace_yylen++)
00914 continue;
00915 return ace_yylen;
00916 }
00917 # endif
00918 # endif
00919
00920 # ifndef ace_yystpcpy
00921 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
00922 # define ace_yystpcpy stpcpy
00923 # else
00924
00925
00926 #if (defined __STDC__ || defined __C99__FUNC__ \
00927 || defined __cplusplus || defined _MSC_VER)
00928 static char *
00929 ace_yystpcpy (char *ace_yydest, const char *ace_yysrc)
00930 #else
00931 static char *
00932 ace_yystpcpy (ace_yydest, ace_yysrc)
00933 char *ace_yydest;
00934 const char *ace_yysrc;
00935 #endif
00936 {
00937 char *ace_yyd = ace_yydest;
00938 const char *ace_yys = ace_yysrc;
00939
00940 while ((*ace_yyd++ = *ace_yys++) != '\0')
00941 continue;
00942
00943 return ace_yyd - 1;
00944 }
00945 # endif
00946 # endif
00947
00948 # ifndef ace_yytnamerr
00949
00950
00951
00952
00953
00954
00955
00956 static YYSIZE_T
00957 ace_yytnamerr (char *ace_yyres, const char *ace_yystr)
00958 {
00959 if (*ace_yystr == '"')
00960 {
00961 YYSIZE_T ace_yyn = 0;
00962 char const *ace_yyp = ace_yystr;
00963
00964 for (;;)
00965 switch (*++ace_yyp)
00966 {
00967 case '\'':
00968 case ',':
00969 goto do_not_strip_quotes;
00970
00971 case '\\':
00972 if (*++ace_yyp != '\\')
00973 goto do_not_strip_quotes;
00974
00975 default:
00976 if (ace_yyres)
00977 ace_yyres[ace_yyn] = *ace_yyp;
00978 ace_yyn++;
00979 break;
00980
00981 case '"':
00982 if (ace_yyres)
00983 ace_yyres[ace_yyn] = '\0';
00984 return ace_yyn;
00985 }
00986 do_not_strip_quotes: ;
00987 }
00988
00989 if (! ace_yyres)
00990 return ace_yystrlen (ace_yystr);
00991
00992 return ace_yystpcpy (ace_yyres, ace_yystr) - ace_yyres;
00993 }
00994 # endif
00995
00996
00997
00998
00999
01000
01001
01002
01003 static YYSIZE_T
01004 ace_yysyntax_error (char *ace_yyresult, int ace_yystate, int ace_yychar)
01005 {
01006 int ace_yyn = ace_yypact[ace_yystate];
01007
01008 if (! (YYPACT_NINF < ace_yyn && ace_yyn <= YYLAST))
01009 return 0;
01010 else
01011 {
01012 int ace_yytype = YYTRANSLATE (ace_yychar);
01013 YYSIZE_T ace_yysize0 = ace_yytnamerr (0, ace_yytname[ace_yytype]);
01014 YYSIZE_T ace_yysize = ace_yysize0;
01015 YYSIZE_T ace_yysize1;
01016 int ace_yysize_overflow = 0;
01017 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
01018 char const *ace_yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
01019 int ace_yyx;
01020
01021 # if 0
01022
01023
01024 YY_("syntax error, unexpected %s");
01025 YY_("syntax error, unexpected %s, expecting %s");
01026 YY_("syntax error, unexpected %s, expecting %s or %s");
01027 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
01028 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
01029 # endif
01030 char *ace_yyfmt;
01031 char const *ace_yyf;
01032 static char const ace_yyunexpected[] = "syntax error, unexpected %s";
01033 static char const ace_yyexpecting[] = ", expecting %s";
01034 static char const ace_yyor[] = " or %s";
01035 char ace_yyformat[sizeof ace_yyunexpected
01036 + sizeof ace_yyexpecting - 1
01037 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
01038 * (sizeof ace_yyor - 1))];
01039 char const *ace_yyprefix = ace_yyexpecting;
01040
01041
01042
01043 int ace_yyxbegin = ace_yyn < 0 ? -ace_yyn : 0;
01044
01045
01046 int ace_yychecklim = YYLAST - ace_yyn + 1;
01047 int ace_yyxend = ace_yychecklim < YYNTOKENS ? ace_yychecklim : YYNTOKENS;
01048 int ace_yycount = 1;
01049
01050 ace_yyarg[0] = ace_yytname[ace_yytype];
01051 ace_yyfmt = ace_yystpcpy (ace_yyformat, ace_yyunexpected);
01052
01053 for (ace_yyx = ace_yyxbegin; ace_yyx < ace_yyxend; ++ace_yyx)
01054 if (ace_yycheck[ace_yyx + ace_yyn] == ace_yyx && ace_yyx != YYTERROR)
01055 {
01056 if (ace_yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
01057 {
01058 ace_yycount = 1;
01059 ace_yysize = ace_yysize0;
01060 ace_yyformat[sizeof ace_yyunexpected - 1] = '\0';
01061 break;
01062 }
01063 ace_yyarg[ace_yycount++] = ace_yytname[ace_yyx];
01064 ace_yysize1 = ace_yysize + ace_yytnamerr (0, ace_yytname[ace_yyx]);
01065 ace_yysize_overflow |= (ace_yysize1 < ace_yysize);
01066 ace_yysize = ace_yysize1;
01067 ace_yyfmt = ace_yystpcpy (ace_yyfmt, ace_yyprefix);
01068 ace_yyprefix = ace_yyor;
01069 }
01070
01071 ace_yyf = YY_(ace_yyformat);
01072 ace_yysize1 = ace_yysize + ace_yystrlen (ace_yyf);
01073 ace_yysize_overflow |= (ace_yysize1 < ace_yysize);
01074 ace_yysize = ace_yysize1;
01075
01076 if (ace_yysize_overflow)
01077 return YYSIZE_MAXIMUM;
01078
01079 if (ace_yyresult)
01080 {
01081
01082
01083
01084 char *ace_yyp = ace_yyresult;
01085 int ace_yyi = 0;
01086 while ((*ace_yyp = *ace_yyf) != '\0')
01087 {
01088 if (*ace_yyp == '%' && ace_yyf[1] == 's' && ace_yyi < ace_yycount)
01089 {
01090 ace_yyp += ace_yytnamerr (ace_yyp, ace_yyarg[ace_yyi++]);
01091 ace_yyf += 2;
01092 }
01093 else
01094 {
01095 ace_yyp++;
01096 ace_yyf++;
01097 }
01098 }
01099 }
01100 return ace_yysize;
01101 }
01102 }
01103 #endif
01104
01105
01106
01107
01108
01109
01110
01111 #if (defined __STDC__ || defined __C99__FUNC__ \
01112 || defined __cplusplus || defined _MSC_VER)
01113 static void
01114 ace_yydestruct (const char *ace_yymsg, int ace_yytype, YYSTYPE *ace_yyvaluep)
01115 #else
01116 static void
01117 ace_yydestruct (ace_yymsg, ace_yytype, ace_yyvaluep)
01118 const char *ace_yymsg;
01119 int ace_yytype;
01120 YYSTYPE *ace_yyvaluep;
01121 #endif
01122 {
01123 YYUSE (ace_yyvaluep);
01124
01125 if (!ace_yymsg)
01126 ace_yymsg = "Deleting";
01127 YY_SYMBOL_PRINT (ace_yymsg, ace_yytype, ace_yyvaluep, ace_yylocationp);
01128
01129 switch (ace_yytype)
01130 {
01131
01132 default:
01133 break;
01134 }
01135 }
01136
01137
01138
01139
01140 #ifdef YYPARSE_PARAM
01141 #if defined __STDC__ || defined __cplusplus
01142 int ace_yyparse (void *YYPARSE_PARAM);
01143 #else
01144 int ace_yyparse ();
01145 #endif
01146 #else
01147 #if defined __STDC__ || defined __cplusplus
01148 int ace_yyparse (void);
01149 #else
01150 int ace_yyparse ();
01151 #endif
01152 #endif
01153
01154
01155
01156
01157
01158
01159
01160
01161
01162
01163 #ifdef YYPARSE_PARAM
01164 #if (defined __STDC__ || defined __C99__FUNC__ \
01165 || defined __cplusplus || defined _MSC_VER)
01166 int
01167 ace_yyparse (void *YYPARSE_PARAM)
01168 #else
01169 int
01170 ace_yyparse (YYPARSE_PARAM)
01171 void *YYPARSE_PARAM;
01172 #endif
01173 #else
01174 #if (defined __STDC__ || defined __C99__FUNC__ \
01175 || defined __cplusplus || defined _MSC_VER)
01176 int
01177 ace_yyparse (void)
01178 #else
01179 int
01180 ace_yyparse ()
01181
01182 #endif
01183 #endif
01184 {
01185
01186 int ace_yychar;
01187
01188
01189 YYSTYPE ace_yylval;
01190
01191
01192 int ace_yynerrs;
01193
01194 int ace_yystate;
01195 int ace_yyn;
01196 int ace_yyresult;
01197
01198 int ace_yyerrstatus;
01199
01200 int ace_yytoken = 0;
01201 #if YYERROR_VERBOSE
01202
01203 char ace_yymsgbuf[128];
01204 char *ace_yymsg = ace_yymsgbuf;
01205 YYSIZE_T ace_yymsg_alloc = sizeof ace_yymsgbuf;
01206 #endif
01207
01208
01209
01210
01211
01212
01213
01214
01215
01216
01217 ace_yytype_int16 ace_yyssa[YYINITDEPTH];
01218 ace_yytype_int16 *ace_yyss = ace_yyssa;
01219 ace_yytype_int16 *ace_yyssp;
01220
01221
01222 YYSTYPE ace_yyvsa[YYINITDEPTH];
01223 YYSTYPE *ace_yyvs = ace_yyvsa;
01224 YYSTYPE *ace_yyvsp;
01225
01226
01227
01228 #define YYPOPSTACK(N) (ace_yyvsp -= (N), ace_yyssp -= (N))
01229
01230 YYSIZE_T ace_yystacksize = YYINITDEPTH;
01231
01232
01233
01234 YYSTYPE ace_yyval;
01235
01236
01237
01238
01239 int ace_yylen = 0;
01240
01241 YYDPRINTF ((stderr, "Starting parse\n"));
01242
01243 ace_yystate = 0;
01244 ace_yyerrstatus = 0;
01245 ace_yynerrs = 0;
01246 ace_yychar = YYEMPTY;
01247
01248
01249
01250
01251
01252
01253 ace_yyssp = ace_yyss;
01254 ace_yyvsp = ace_yyvs;
01255
01256 goto ace_yysetstate;
01257
01258
01259
01260
01261 ace_yynewstate:
01262
01263
01264 ace_yyssp++;
01265
01266 ace_yysetstate:
01267 *ace_yyssp = ace_yystate;
01268
01269 if (ace_yyss + ace_yystacksize - 1 <= ace_yyssp)
01270 {
01271
01272 YYSIZE_T ace_yysize = ace_yyssp - ace_yyss + 1;
01273
01274 #ifdef ace_yyoverflow
01275 {
01276
01277
01278
01279 YYSTYPE *ace_yyvs1 = ace_yyvs;
01280 ace_yytype_int16 *ace_yyss1 = ace_yyss;
01281
01282
01283
01284
01285
01286
01287 ace_yyoverflow (YY_("memory exhausted"),
01288 &ace_yyss1, ace_yysize * sizeof (*ace_yyssp),
01289 &ace_yyvs1, ace_yysize * sizeof (*ace_yyvsp),
01290
01291 &ace_yystacksize);
01292
01293 ace_yyss = ace_yyss1;
01294 ace_yyvs = ace_yyvs1;
01295 }
01296 #else
01297 # ifndef YYSTACK_RELOCATE
01298 goto ace_yyexhaustedlab;
01299 # else
01300
01301 if (YYMAXDEPTH <= ace_yystacksize)
01302 goto ace_yyexhaustedlab;
01303 ace_yystacksize *= 2;
01304 if (YYMAXDEPTH < ace_yystacksize)
01305 ace_yystacksize = YYMAXDEPTH;
01306
01307 {
01308 ace_yytype_int16 *ace_yyss1 = ace_yyss;
01309 union ace_yyalloc *ace_yyptr =
01310 (union ace_yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (ace_yystacksize));
01311 if (! ace_yyptr)
01312 goto ace_yyexhaustedlab;
01313 YYSTACK_RELOCATE (ace_yyss);
01314 YYSTACK_RELOCATE (ace_yyvs);
01315
01316 # undef YYSTACK_RELOCATE
01317 if (ace_yyss1 != ace_yyssa)
01318 YYSTACK_FREE (ace_yyss1);
01319 }
01320 # endif
01321 #endif
01322
01323 ace_yyssp = ace_yyss + ace_yysize - 1;
01324 ace_yyvsp = ace_yyvs + ace_yysize - 1;
01325
01326
01327 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
01328 (unsigned long int) ace_yystacksize));
01329
01330 if (ace_yyss + ace_yystacksize - 1 <= ace_yyssp)
01331 YYABORT;
01332 }
01333
01334 YYDPRINTF ((stderr, "Entering state %d\n", ace_yystate));
01335
01336 goto ace_yybackup;
01337
01338
01339
01340
01341 ace_yybackup:
01342
01343
01344
01345
01346
01347 ace_yyn = ace_yypact[ace_yystate];
01348 if (ace_yyn == YYPACT_NINF)
01349 goto ace_yydefault;
01350
01351
01352
01353
01354 if (ace_yychar == YYEMPTY)
01355 {
01356 YYDPRINTF ((stderr, "Reading a token: "));
01357 ace_yychar = YYLEX;
01358 }
01359
01360 if (ace_yychar <= YYEOF)
01361 {
01362 ace_yychar = ace_yytoken = YYEOF;
01363 YYDPRINTF ((stderr, "Now at end of input.\n"));
01364 }
01365 else
01366 {
01367 ace_yytoken = YYTRANSLATE (ace_yychar);
01368 YY_SYMBOL_PRINT ("Next token is", ace_yytoken, &ace_yylval, &ace_yylloc);
01369 }
01370
01371
01372
01373 ace_yyn += ace_yytoken;
01374 if (ace_yyn < 0 || YYLAST < ace_yyn || ace_yycheck[ace_yyn] != ace_yytoken)
01375 goto ace_yydefault;
01376 ace_yyn = ace_yytable[ace_yyn];
01377 if (ace_yyn <= 0)
01378 {
01379 if (ace_yyn == 0 || ace_yyn == YYTABLE_NINF)
01380 goto ace_yyerrlab;
01381 ace_yyn = -ace_yyn;
01382 goto ace_yyreduce;
01383 }
01384
01385 if (ace_yyn == YYFINAL)
01386 YYACCEPT;
01387
01388
01389
01390 if (ace_yyerrstatus)
01391 ace_yyerrstatus--;
01392
01393
01394 YY_SYMBOL_PRINT ("Shifting", ace_yytoken, &ace_yylval, &ace_yylloc);
01395
01396
01397 if (ace_yychar != YYEOF)
01398 ace_yychar = YYEMPTY;
01399
01400 ace_yystate = ace_yyn;
01401 *++ace_yyvsp = ace_yylval;
01402
01403 goto ace_yynewstate;
01404
01405
01406
01407
01408
01409 ace_yydefault:
01410 ace_yyn = ace_yydefact[ace_yystate];
01411 if (ace_yyn == 0)
01412 goto ace_yyerrlab;
01413 goto ace_yyreduce;
01414
01415
01416
01417
01418
01419 ace_yyreduce:
01420
01421 ace_yylen = ace_yyr2[ace_yyn];
01422
01423
01424
01425
01426
01427
01428
01429
01430
01431 ace_yyval = ace_yyvsp[1-ace_yylen];
01432
01433
01434 YY_REDUCE_PRINT (ace_yyn);
01435 switch (ace_yyn)
01436 {
01437 case 2:
01438
01439 {
01440 if ((ace_yyvsp[(2) - (2)].parse_node_) != 0)
01441 {
01442 (ace_yyvsp[(2) - (2)].parse_node_)->apply (ACE_SVC_CONF_PARAM->config, ACE_SVC_CONF_PARAM->yyerrno);
01443 delete (ace_yyvsp[(2) - (2)].parse_node_);
01444 }
01445 ACE_SVC_CONF_PARAM->obstack.release ();
01446 ;}
01447 break;
01448
01449 case 3:
01450
01451 {
01452 ACE_SVC_CONF_PARAM->obstack.release ();
01453 ;}
01454 break;
01455
01456 case 11:
01457
01458 {
01459 if ((ace_yyvsp[(2) - (3)].svc_record_) != 0)
01460 (ace_yyval.parse_node_) = new ACE_Dynamic_Node ((ace_yyvsp[(2) - (3)].svc_record_), (ace_yyvsp[(3) - (3)].ident_));
01461 else
01462 (ace_yyval.parse_node_) = 0;
01463 ;}
01464 break;
01465
01466 case 12:
01467
01468 {
01469 (ace_yyval.parse_node_) = new ACE_Static_Node ((ace_yyvsp[(2) - (3)].ident_), (ace_yyvsp[(3) - (3)].ident_));
01470 ;}
01471 break;
01472
01473 case 13:
01474
01475 {
01476 (ace_yyval.parse_node_) = new ACE_Suspend_Node ((ace_yyvsp[(2) - (2)].ident_));
01477 ;}
01478 break;
01479
01480 case 14:
01481
01482 {
01483 (ace_yyval.parse_node_) = new ACE_Resume_Node ((ace_yyvsp[(2) - (2)].ident_));
01484 ;}
01485 break;
01486
01487 case 15:
01488
01489 {
01490 (ace_yyval.parse_node_) = new ACE_Remove_Node ((ace_yyvsp[(2) - (2)].ident_));
01491 ;}
01492 break;
01493
01494 case 16:
01495
01496 {
01497 (ace_yyval.parse_node_) = new ACE_Stream_Node ((ace_yyvsp[(2) - (3)].static_node_), (ace_yyvsp[(3) - (3)].parse_node_));
01498 ;}
01499 break;
01500
01501 case 17:
01502
01503 { (ace_yyval.static_node_) = new ACE_Static_Node ((ace_yyvsp[(2) - (2)].ident_)); ;}
01504 break;
01505
01506 case 18:
01507
01508 {
01509 (ace_yyval.parse_node_) = new ACE_Dummy_Node ((ace_yyvsp[(3) - (4)].static_node_), (ace_yyvsp[(4) - (4)].parse_node_));
01510 ;}
01511 break;
01512
01513 case 19:
01514
01515 {
01516 ;}
01517 break;
01518
01519 case 20:
01520
01521 {
01522 ;}
01523 break;
01524
01525 case 21:
01526
01527 {
01528
01529 (ace_yyval.static_node_) = (ace_yyvsp[(0) - (1)].static_node_);
01530 ;}
01531 break;
01532
01533 case 22:
01534
01535 {
01536 ACE_UNUSED_ARG ((ace_yyvsp[(2) - (4)]));
01537 (ace_yyval.parse_node_) = (ace_yyvsp[(3) - (4)].parse_node_);
01538 ;}
01539 break;
01540
01541 case 23:
01542
01543 { (ace_yyval.parse_node_) = 0; ;}
01544 break;
01545
01546 case 24:
01547
01548 {
01549 if ((ace_yyvsp[(2) - (2)].parse_node_) != 0)
01550 {
01551 (ace_yyvsp[(2) - (2)].parse_node_)->link ((ace_yyvsp[(1) - (2)].parse_node_));
01552 (ace_yyval.parse_node_) = (ace_yyvsp[(2) - (2)].parse_node_);
01553 }
01554 ;}
01555 break;
01556
01557 case 25:
01558
01559 { (ace_yyval.parse_node_) = 0; ;}
01560 break;
01561
01562 case 26:
01563
01564 {
01565 ;}
01566 break;
01567
01568 case 27:
01569
01570 {
01571 ACE_Static_Node *sn = (ace_yyvsp[(-1) - (1)].static_node_);
01572 ACE_Module_Type *mt = ace_get_module (sn->record (ACE_SVC_CONF_PARAM->config),
01573 (ace_yyvsp[(1) - (1)].static_node_)->name (),
01574 ACE_SVC_CONF_PARAM->yyerrno);
01575
01576 if (((ACE_Stream_Type *) sn->record (ACE_SVC_CONF_PARAM->config)->type ())->push (mt) == -1)
01577 {
01578 ACE_ERROR ((LM_ERROR,
01579 ACE_TEXT ("Problem with static\n")));
01580 ACE_SVC_CONF_PARAM->yyerrno++;
01581 }
01582 ;}
01583 break;
01584
01585 case 28:
01586
01587 {
01588 ACE_Static_Node *sn = (ace_yyvsp[(-1) - (1)].static_node_);
01589 ACE_Module_Type *mt = ace_get_module (sn->record (ACE_SVC_CONF_PARAM->config),
01590 sn->name (),
01591 ACE_SVC_CONF_PARAM->yyerrno);
01592 if (mt != 0)
01593 mt->suspend ();
01594 ;}
01595 break;
01596
01597 case 29:
01598
01599 {
01600 ACE_Static_Node *sn = (ace_yyvsp[(-1) - (1)].static_node_);
01601 ACE_Module_Type *mt = ace_get_module (sn->record (ACE_SVC_CONF_PARAM->config),
01602 (ace_yyvsp[(1) - (1)].static_node_)->name (),
01603 ACE_SVC_CONF_PARAM->yyerrno);
01604 if (mt != 0)
01605 mt->resume ();
01606 ;}
01607 break;
01608
01609 case 30:
01610
01611 {
01612 ACE_Static_Node *stream = (ace_yyvsp[(-1) - (1)].static_node_);
01613 ACE_Static_Node *module = (ace_yyvsp[(1) - (1)].static_node_);
01614 ACE_Module_Type *mt = ace_get_module (stream->record (ACE_SVC_CONF_PARAM->config),
01615 module->name (),
01616 ACE_SVC_CONF_PARAM->yyerrno);
01617
01618 ACE_Stream_Type *st =
01619 dynamic_cast<ACE_Stream_Type *> (const_cast<ACE_Service_Type_Impl *> (stream->record (ACE_SVC_CONF_PARAM->config)->type ()));
01620 if (!st || (mt != 0 && st->remove (mt) == -1))
01621 {
01622 ACE_ERROR ((LM_ERROR,
01623 ACE_TEXT ("cannot remove Module_Type %s from STREAM_Type %s\n"),
01624 module->name (),
01625 stream->name ()));
01626 ACE_SVC_CONF_PARAM->yyerrno++;
01627 }
01628 ;}
01629 break;
01630
01631 case 31:
01632
01633 {
01634 (ace_yyval.svc_record_) = new ACE_Service_Type_Factory ((ace_yyvsp[(1) - (4)].ident_), (ace_yyvsp[(2) - (4)].type_), (ace_yyvsp[(3) - (4)].location_node_), (ace_yyvsp[(4) - (4)].type_));
01635 ;}
01636 break;
01637
01638 case 32:
01639
01640 {
01641 (ace_yyval.type_) = 1;
01642 ;}
01643 break;
01644
01645 case 33:
01646
01647 {
01648 (ace_yyval.type_) = 0;
01649 ;}
01650 break;
01651
01652 case 34:
01653
01654 {
01655 (ace_yyval.type_) = 1;
01656 ;}
01657 break;
01658
01659 case 35:
01660
01661 {
01662 (ace_yyval.location_node_) = new ACE_Object_Node ((ace_yyvsp[(1) - (3)].ident_), (ace_yyvsp[(3) - (3)].ident_));
01663 ;}
01664 break;
01665
01666 case 36:
01667
01668 {
01669 (ace_yyval.location_node_) = new ACE_Function_Node ((ace_yyvsp[(1) - (5)].ident_), (ace_yyvsp[(3) - (5)].ident_));
01670 ;}
01671 break;
01672
01673 case 37:
01674
01675 {
01676 (ace_yyval.location_node_) = new ACE_Static_Function_Node ((ace_yyvsp[(2) - (4)].ident_));
01677 ;}
01678 break;
01679
01680 case 38:
01681
01682 {
01683 (ace_yyval.type_) = ACE_MODULE_T;
01684 ;}
01685 break;
01686
01687 case 39:
01688
01689 {
01690 (ace_yyval.type_) = ACE_SVC_OBJ_T;
01691 ;}
01692 break;
01693
01694 case 40:
01695
01696 {
01697 (ace_yyval.type_) = ACE_STREAM_T;
01698 ;}
01699 break;
01700
01701 case 42:
01702
01703 { (ace_yyval.ident_) = 0; ;}
01704 break;
01705
01706
01707
01708
01709 default: break;
01710 }
01711 YY_SYMBOL_PRINT ("-> $$ =", ace_yyr1[ace_yyn], &ace_yyval, &ace_yyloc);
01712
01713 YYPOPSTACK (ace_yylen);
01714 ace_yylen = 0;
01715 YY_STACK_PRINT (ace_yyss, ace_yyssp);
01716
01717 *++ace_yyvsp = ace_yyval;
01718
01719
01720
01721
01722
01723
01724 ace_yyn = ace_yyr1[ace_yyn];
01725
01726 ace_yystate = ace_yypgoto[ace_yyn - YYNTOKENS] + *ace_yyssp;
01727 if (0 <= ace_yystate && ace_yystate <= YYLAST && ace_yycheck[ace_yystate] == *ace_yyssp)
01728 ace_yystate = ace_yytable[ace_yystate];
01729 else
01730 ace_yystate = ace_yydefgoto[ace_yyn - YYNTOKENS];
01731
01732 goto ace_yynewstate;
01733
01734
01735
01736
01737
01738 ace_yyerrlab:
01739
01740 if (!ace_yyerrstatus)
01741 {
01742 ++ace_yynerrs;
01743 #if ! YYERROR_VERBOSE
01744 ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, YY_("syntax error"));
01745 #else
01746 {
01747 YYSIZE_T ace_yysize = ace_yysyntax_error (0, ace_yystate, ace_yychar);
01748 if (ace_yymsg_alloc < ace_yysize && ace_yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
01749 {
01750 YYSIZE_T ace_yyalloc = 2 * ace_yysize;
01751 if (! (ace_yysize <= ace_yyalloc && ace_yyalloc <= YYSTACK_ALLOC_MAXIMUM))
01752 ace_yyalloc = YYSTACK_ALLOC_MAXIMUM;
01753 if (ace_yymsg != ace_yymsgbuf)
01754 YYSTACK_FREE (ace_yymsg);
01755 ace_yymsg = (char *) YYSTACK_ALLOC (ace_yyalloc);
01756 if (ace_yymsg)
01757 ace_yymsg_alloc = ace_yyalloc;
01758 else
01759 {
01760 ace_yymsg = ace_yymsgbuf;
01761 ace_yymsg_alloc = sizeof ace_yymsgbuf;
01762 }
01763 }
01764
01765 if (0 < ace_yysize && ace_yysize <= ace_yymsg_alloc)
01766 {
01767 (void) ace_yysyntax_error (ace_yymsg, ace_yystate, ace_yychar);
01768 ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, ace_yymsg);
01769 }
01770 else
01771 {
01772 ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, YY_("syntax error"));
01773 if (ace_yysize != 0)
01774 goto ace_yyexhaustedlab;
01775 }
01776 }
01777 #endif
01778 }
01779
01780
01781
01782 if (ace_yyerrstatus == 3)
01783 {
01784
01785
01786
01787 if (ace_yychar <= YYEOF)
01788 {
01789
01790 if (ace_yychar == YYEOF)
01791 YYABORT;
01792 }
01793 else
01794 {
01795 ace_yydestruct ("Error: discarding",
01796 ace_yytoken, &ace_yylval);
01797 ace_yychar = YYEMPTY;
01798 }
01799 }
01800
01801
01802
01803 goto ace_yyerrlab1;
01804
01805
01806
01807
01808
01809 ace_yyerrorlab:
01810
01811
01812
01813
01814 if ( 0)
01815 goto ace_yyerrorlab;
01816
01817
01818
01819 YYPOPSTACK (ace_yylen);
01820 ace_yylen = 0;
01821 YY_STACK_PRINT (ace_yyss, ace_yyssp);
01822 ace_yystate = *ace_yyssp;
01823 goto ace_yyerrlab1;
01824
01825
01826
01827
01828
01829 ace_yyerrlab1:
01830 ace_yyerrstatus = 3;
01831
01832 for (;;)
01833 {
01834 ace_yyn = ace_yypact[ace_yystate];
01835 if (ace_yyn != YYPACT_NINF)
01836 {
01837 ace_yyn += YYTERROR;
01838 if (0 <= ace_yyn && ace_yyn <= YYLAST && ace_yycheck[ace_yyn] == YYTERROR)
01839 {
01840 ace_yyn = ace_yytable[ace_yyn];
01841 if (0 < ace_yyn)
01842 break;
01843 }
01844 }
01845
01846
01847 if (ace_yyssp == ace_yyss)
01848 YYABORT;
01849
01850
01851 ace_yydestruct ("Error: popping",
01852 ace_yystos[ace_yystate], ace_yyvsp);
01853 YYPOPSTACK (1);
01854 ace_yystate = *ace_yyssp;
01855 YY_STACK_PRINT (ace_yyss, ace_yyssp);
01856 }
01857
01858 if (ace_yyn == YYFINAL)
01859 YYACCEPT;
01860
01861 *++ace_yyvsp = ace_yylval;
01862
01863
01864
01865 YY_SYMBOL_PRINT ("Shifting", ace_yystos[ace_yyn], ace_yyvsp, ace_yylsp);
01866
01867 ace_yystate = ace_yyn;
01868 goto ace_yynewstate;
01869
01870
01871
01872
01873
01874 ace_yyacceptlab:
01875 ace_yyresult = 0;
01876 goto ace_yyreturn;
01877
01878
01879
01880
01881 ace_yyabortlab:
01882 ace_yyresult = 1;
01883 goto ace_yyreturn;
01884
01885 #ifndef ace_yyoverflow
01886
01887
01888
01889 ace_yyexhaustedlab:
01890 ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, YY_("memory exhausted"));
01891 ace_yyresult = 2;
01892
01893 #endif
01894
01895 ace_yyreturn:
01896 if (ace_yychar != YYEOF && ace_yychar != YYEMPTY)
01897 ace_yydestruct ("Cleanup: discarding lookahead",
01898 ace_yytoken, &ace_yylval);
01899
01900
01901 YYPOPSTACK (ace_yylen);
01902 YY_STACK_PRINT (ace_yyss, ace_yyssp);
01903 while (ace_yyssp != ace_yyss)
01904 {
01905 ace_yydestruct ("Cleanup: popping",
01906 ace_yystos[*ace_yyssp], ace_yyvsp);
01907 YYPOPSTACK (1);
01908 }
01909 #ifndef ace_yyoverflow
01910 if (ace_yyss != ace_yyssa)
01911 YYSTACK_FREE (ace_yyss);
01912 #endif
01913 #if YYERROR_VERBOSE
01914 if (ace_yymsg != ace_yymsgbuf)
01915 YYSTACK_FREE (ace_yymsg);
01916 #endif
01917
01918 return YYID (ace_yyresult);
01919 }
01920
01921
01922
01923
01924
01925 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
01926
01927
01928
01929
01930 void
01931 ace_yyerror (int ace_yyerrno, int ace_yylineno, ACE_TCHAR const * s)
01932 {
01933 #if defined (ACE_NLOGGING)
01934 ACE_UNUSED_ARG (ace_yyerrno);
01935 ACE_UNUSED_ARG (ace_yylineno);
01936 ACE_UNUSED_ARG (s);
01937 #endif
01938
01939 ACE_ERROR ((LM_ERROR,
01940 ACE_TEXT ("ACE (%P|%t) [error %d] on line %d: %C\n"),
01941 ace_yyerrno,
01942 ace_yylineno,
01943 s));
01944 }
01945
01946 void
01947 ace_yyerror (ACE_TCHAR const * s)
01948 {
01949 ace_yyerror (-1, -1, s);
01950 }
01951
01952
01953
01954
01955 static ACE_Module_Type *
01956 ace_get_module (ACE_Service_Type const * sr,
01957 ACE_TCHAR const * svc_name,
01958 int & ace_yyerrno)
01959 {
01960 ACE_Service_Type_Impl const * const type = sr->type ();
01961 ACE_Stream_Type const * const st =
01962 (sr == 0
01963 ? 0
01964 : dynamic_cast<ACE_Stream_Type const *> (type));
01965 ACE_Module_Type const * const mt = (st == 0 ? 0 : st->find (svc_name));
01966
01967 if (sr == 0 || st == 0 || mt == 0)
01968 {
01969 ACE_ERROR ((LM_ERROR,
01970 ACE_TEXT ("cannot locate Module_Type %s ")
01971 ACE_TEXT ("in STREAM_Type %s\n"),
01972 svc_name,
01973 (sr ? sr->name () : ACE_TEXT ("(nil)"))));
01974 ++ace_yyerrno;
01975 }
01976
01977 return const_cast<ACE_Module_Type *> (mt);
01978 }
01979
01980 #if defined (SVC_CONF_Y_DEBUGGING)
01981
01982
01983 int
01984 main (int argc, char *argv[])
01985 {
01986 ACE_Svc_Conf_Param param (0, stdin);
01987
01988
01989 if (argc > 1 && (ace_yyin = freopen (argv[1], "r", stdin)) == 0)
01990 (void) ACE_OS::ACE_OS::fprintf (stderr, ACE_TEXT ("usage: %s [file]\n"), argv[0]), ACE_OS::exit (1);
01991
01992 return ::ace_yyparse (¶m);
01993 }
01994 #endif
01995
01996 ACE_END_VERSIONED_NAMESPACE_DECL
01997
01998 #endif
01999