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 #define ACE_YYBISON 1
00038
00039
00040 #define ACE_YYSKELETON_NAME "yacc.c"
00041
00042
00043 #define ACE_YYPURE 1
00044
00045
00046 #define ACE_YYLSP_NEEDED 0
00047
00048
00049 #if defined (__HP_aCC) && defined (__ia64)
00050 # pragma diag_suppress 2111
00051 #endif
00052
00053
00054 #ifndef ACE_YYTOKENTYPE
00055 # define ACE_YYTOKENTYPE
00056
00057
00058 enum ace_yytokentype {
00059 ACE_DYNAMIC = 258,
00060 ACE_STATIC = 259,
00061 ACE_SUSPEND = 260,
00062 ACE_RESUME = 261,
00063 ACE_REMOVE = 262,
00064 ACE_USTREAM = 263,
00065 ACE_MODULE_T = 264,
00066 ACE_STREAM_T = 265,
00067 ACE_SVC_OBJ_T = 266,
00068 ACE_ACTIVE = 267,
00069 ACE_INACTIVE = 268,
00070 ACE_PATHNAME = 269,
00071 ACE_IDENT = 270,
00072 ACE_STRING = 271
00073 };
00074 #endif
00075 #define ACE_DYNAMIC 258
00076 #define ACE_STATIC 259
00077 #define ACE_SUSPEND 260
00078 #define ACE_RESUME 261
00079 #define ACE_REMOVE 262
00080 #define ACE_USTREAM 263
00081 #define ACE_MODULE_T 264
00082 #define ACE_STREAM_T 265
00083 #define ACE_SVC_OBJ_T 266
00084 #define ACE_ACTIVE 267
00085 #define ACE_INACTIVE 268
00086 #define ACE_PATHNAME 269
00087 #define ACE_IDENT 270
00088 #define ACE_STRING 271
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098 #include "ace/Svc_Conf.h"
00099
00100 #if (ACE_USES_CLASSIC_SVC_CONF == 1)
00101
00102 #include "ace/ARGV.h"
00103 #include "ace/Module.h"
00104 #include "ace/Stream.h"
00105 #include "ace/Service_Types.h"
00106 #include "ace/OS_NS_string.h"
00107
00108
00109 #include "ace/ace_wchar.h"
00110
00111 ACE_RCSID (ace,
00112 Svc_Conf_y,
00113 "$Id: Svc_Conf_y.cpp 79341 2007-08-14 18:09:18Z sowayaa $")
00114
00115 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00116
00117
00118
00119 static ACE_Module_Type *ace_get_module (const ACE_Service_Type *sr,
00120 const ACE_Service_Type *sv,
00121 int & ace_ace_yyerrno);
00122
00123 static ACE_Module_Type *ace_get_module (const ACE_Service_Type *sr,
00124 const ACE_TCHAR *svc_name,
00125 int & ace_ace_yyerrno);
00126
00127 #define ACE_YYDEBUG_LEXER_TEXT (ace_yytext[ace_yyleng] = '\0', ace_yytext)
00128
00129
00130
00131
00132 ACE_END_VERSIONED_NAMESPACE_DECL
00133
00134
00135
00136 #ifndef ACE_YYDEBUG
00137 # define ACE_YYDEBUG 0
00138 #endif
00139
00140
00141 #ifdef ACE_YYERROR_VERBOSE
00142 # undef ACE_YYERROR_VERBOSE
00143 # define ACE_YYERROR_VERBOSE 1
00144 #else
00145 # define ACE_YYERROR_VERBOSE 0
00146 #endif
00147
00148 #if ! defined (ACE_YYSTYPE) && ! defined (ACE_YYSTYPE_IS_DECLARED)
00149 typedef int ACE_YYSTYPE;
00150 # define ace_yystype ACE_YYSTYPE
00151 # define ACE_YYSTYPE_IS_DECLARED 1
00152 # define ACE_YYSTYPE_IS_TRIVIAL 1
00153 #endif
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163 #if ! defined (ace_yyoverflow) || ACE_YYERROR_VERBOSE
00164
00165 # ifndef ACE_YYFREE
00166 # define ACE_YYFREE free
00167 # endif
00168 # ifndef ACE_YYMALLOC
00169 # define ACE_YYMALLOC malloc
00170 # endif
00171
00172
00173
00174 # ifdef ACE_YYSTACK_USE_ALLOCA
00175 # if ACE_YYSTACK_USE_ALLOCA
00176 # ifdef __GNUC__
00177 # define ACE_YYSTACK_ALLOC __builtin_alloca
00178 # else
00179 # define ACE_YYSTACK_ALLOC alloca
00180 # endif
00181 # endif
00182 # endif
00183
00184 # ifdef ACE_YYSTACK_ALLOC
00185
00186 # define ACE_YYSTACK_FREE(Ptr) do { ; } while (0)
00187 # else
00188 # if defined (__STDC__) || defined (__cplusplus)
00189 # include <stdlib.h>
00190 # define ACE_YYSIZE_T size_t
00191 # endif
00192 # define ACE_YYSTACK_ALLOC ACE_YYMALLOC
00193 # define ACE_YYSTACK_FREE ACE_YYFREE
00194 # endif
00195 #endif
00196
00197
00198 #if (! defined (ace_yyoverflow) \
00199 && (! defined (__cplusplus) \
00200 || (defined (ACE_YYSTYPE_IS_TRIVIAL) && ACE_YYSTYPE_IS_TRIVIAL)))
00201
00202
00203 union ace_yyalloc
00204 {
00205 short int ace_yyss;
00206 ACE_YYSTYPE ace_yyvs;
00207 };
00208
00209
00210 # define ACE_YYSTACK_GAP_MAXIMUM (sizeof (union ace_yyalloc) - 1)
00211
00212
00213
00214 # define ACE_YYSTACK_BYTES(N) \
00215 ((N) * (sizeof (short int) + sizeof (ACE_YYSTYPE)) \
00216 + ACE_YYSTACK_GAP_MAXIMUM)
00217
00218
00219
00220 # ifndef ACE_YYCOPY
00221 # if defined (__GNUC__) && 1 < __GNUC__
00222 # define ACE_YYCOPY(To, From, Count) \
00223 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
00224 # else
00225 # define ACE_YYCOPY(To, From, Count) \
00226 do \
00227 { \
00228 register ACE_YYSIZE_T ace_yyi; \
00229 for (ace_yyi = 0; ace_yyi < (Count); ace_yyi++) \
00230 (To)[ace_yyi] = (From)[ace_yyi]; \
00231 } \
00232 while (0)
00233 # endif
00234 # endif
00235
00236
00237
00238
00239
00240
00241 # define ACE_YYSTACK_RELOCATE(Stack) \
00242 do \
00243 { \
00244 ACE_YYSIZE_T ace_yynewbytes; \
00245 ACE_YYCOPY (&ace_yyptr->Stack, Stack, ace_yysize); \
00246 Stack = &ace_yyptr->Stack; \
00247 ace_yynewbytes = ace_yystacksize * sizeof (*Stack) + ACE_YYSTACK_GAP_MAXIMUM; \
00248 ace_yyptr += ace_yynewbytes / sizeof (*ace_yyptr); \
00249 } \
00250 while (0)
00251
00252 #endif
00253
00254 #if defined (__STDC__) || defined (__cplusplus)
00255 typedef signed char ace_yysigned_char;
00256 #else
00257 typedef short int ace_yysigned_char;
00258 #endif
00259
00260
00261 #define ACE_YYFINAL 2
00262
00263 #define ACE_YYLAST 62
00264
00265
00266 #define ACE_YYNTOKENS 23
00267
00268 #define ACE_YYNNTS 21
00269
00270 #define ACE_YYNRULES 45
00271
00272 #define ACE_YYNSTATES 66
00273
00274
00275 #define ACE_YYUNDEFTOK 2
00276 #define ACE_YYMAXUTOK 271
00277
00278 #define ACE_YYTRANSLATE(ACE_YYX) \
00279 ((unsigned int) (ACE_YYX) <= ACE_YYMAXUTOK ? ace_yytranslate[ACE_YYX] : ACE_YYUNDEFTOK)
00280
00281
00282 static const unsigned char ace_yytranslate[] =
00283 {
00284 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00285 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00286 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00287 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00288 20, 21, 22, 2, 2, 2, 2, 2, 2, 2,
00289 2, 2, 2, 2, 2, 2, 2, 2, 19, 2,
00290 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00291 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00292 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00293 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00294 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00295 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00296 2, 2, 2, 17, 2, 18, 2, 2, 2, 2,
00297 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00298 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00299 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00300 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00301 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00302 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00303 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00304 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00305 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00306 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00307 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00308 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00309 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
00310 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
00311 15, 16
00312 };
00313
00314 #if ACE_YYDEBUG
00315
00316
00317 static const unsigned char ace_yyprhs[] =
00318 {
00319 0, 0, 3, 6, 9, 10, 12, 14, 16, 18,
00320 20, 22, 26, 30, 33, 36, 39, 43, 44, 49,
00321 51, 53, 54, 59, 60, 63, 64, 66, 68, 70,
00322 72, 74, 79, 81, 83, 84, 88, 94, 99, 102,
00323 105, 108, 110, 111, 113, 115
00324 };
00325
00326
00327 static const ace_yysigned_char ace_yyrhs[] =
00328 {
00329 24, 0, -1, 24, 25, -1, 24, 1, -1, -1,
00330 26, -1, 27, -1, 28, -1, 29, -1, 30, -1,
00331 31, -1, 3, 38, 42, -1, 4, 15, 42, -1,
00332 5, 15, -1, 6, 15, -1, 7, 15, -1, 8,
00333 33, 34, -1, -1, 8, 15, 32, 34, -1, 26,
00334 -1, 27, -1, -1, 17, 35, 36, 18, -1, -1,
00335 36, 37, -1, -1, 26, -1, 27, -1, 28, -1,
00336 29, -1, 30, -1, 15, 41, 40, 39, -1, 12,
00337 -1, 13, -1, -1, 43, 19, 15, -1, 43, 19,
00338 15, 20, 21, -1, 19, 15, 20, 21, -1, 9,
00339 22, -1, 11, 22, -1, 10, 22, -1, 16, -1,
00340 -1, 14, -1, 15, -1, 16, -1
00341 };
00342
00343
00344 static const unsigned short int ace_yyrline[] =
00345 {
00346 0, 62, 62, 71, 75, 79, 80, 81, 82, 83,
00347 84, 88, 98, 105, 112, 119, 126, 130, 130, 137,
00348 140, 147, 146, 155, 159, 167, 171, 196, 210, 219,
00349 228, 250, 257, 261, 266, 272, 276, 280, 287, 291,
00350 295, 302, 303, 307, 308, 309
00351 };
00352 #endif
00353
00354 #if ACE_YYDEBUG || ACE_YYERROR_VERBOSE
00355
00356
00357 static const char *const ace_yytname[] =
00358 {
00359 "$end", "error", "$undefined", "ACE_DYNAMIC", "ACE_STATIC",
00360 "ACE_SUSPEND", "ACE_RESUME", "ACE_REMOVE", "ACE_USTREAM", "ACE_MODULE_T",
00361 "ACE_STREAM_T", "ACE_SVC_OBJ_T", "ACE_ACTIVE", "ACE_INACTIVE",
00362 "ACE_PATHNAME", "ACE_IDENT", "ACE_STRING", "'{'", "'}'", "':'", "'('",
00363 "')'", "'*'", "$accept", "svc_config_entries", "svc_config_entry",
00364 "dynamic", "static", "suspend", "resume", "remove", "stream", "@1",
00365 "stream_ops", "stream_modules", "@2", "module_list", "module",
00366 "svc_location", "status", "svc_initializer", "type", "parameters_opt",
00367 "pathname", 0
00368 };
00369 #endif
00370
00371 # ifdef ACE_YYPRINT
00372
00373
00374 static const unsigned short int ace_yytoknum[] =
00375 {
00376 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
00377 265, 266, 267, 268, 269, 270, 271, 123, 125, 58,
00378 40, 41, 42
00379 };
00380 # endif
00381
00382
00383 static const unsigned char ace_yyr1[] =
00384 {
00385 0, 23, 24, 24, 24, 25, 25, 25, 25, 25,
00386 25, 26, 27, 28, 29, 30, 31, 32, 31, 33,
00387 33, 35, 34, 34, 36, 36, 37, 37, 37, 37,
00388 37, 38, 39, 39, 39, 40, 40, 40, 41, 41,
00389 41, 42, 42, 43, 43, 43
00390 };
00391
00392
00393 static const unsigned char ace_yyr2[] =
00394 {
00395 0, 2, 2, 2, 0, 1, 1, 1, 1, 1,
00396 1, 3, 3, 2, 2, 2, 3, 0, 4, 1,
00397 1, 0, 4, 0, 2, 0, 1, 1, 1, 1,
00398 1, 4, 1, 1, 0, 3, 5, 4, 2, 2,
00399 2, 1, 0, 1, 1, 1
00400 };
00401
00402
00403
00404
00405 static const unsigned char ace_yydefact[] =
00406 {
00407 4, 0, 1, 3, 0, 0, 0, 0, 0, 0,
00408 2, 5, 6, 7, 8, 9, 10, 0, 42, 42,
00409 13, 14, 15, 17, 19, 20, 23, 0, 0, 0,
00410 0, 41, 11, 12, 23, 21, 16, 38, 40, 39,
00411 43, 44, 45, 0, 34, 0, 18, 25, 0, 32,
00412 33, 31, 0, 0, 0, 35, 22, 26, 27, 28,
00413 29, 30, 24, 37, 0, 36
00414 };
00415
00416
00417 static const ace_yysigned_char ace_yydefgoto[] =
00418 {
00419 -1, 1, 10, 11, 12, 13, 14, 15, 16, 34,
00420 26, 36, 47, 53, 62, 18, 51, 44, 30, 32,
00421 45
00422 };
00423
00424
00425
00426 #define ACE_YYPACT_NINF -13
00427 static const ace_yysigned_char ace_yypact[] =
00428 {
00429 -13, 20, -13, -13, 1, 3, 7, 14, 18, 4,
00430 -13, -13, -13, -13, -13, -13, -13, 21, 19, 19,
00431 -13, -13, -13, -13, -13, -13, -2, 12, 15, 16,
00432 -5, -13, -13, -13, -2, -13, -13, -13, -13, -13,
00433 -13, -13, -13, 24, 0, 17, -13, -13, 22, -13,
00434 -13, -13, 25, -1, 26, 23, -13, -13, -13, -13,
00435 -13, -13, -13, -13, 27, -13
00436 };
00437
00438
00439 static const ace_yysigned_char ace_yypgoto[] =
00440 {
00441 -13, -13, -13, -9, -8, -12, -7, -4, -13, -13,
00442 -13, 28, -13, -13, -13, -13, -13, -13, -13, 31,
00443 -13
00444 };
00445
00446
00447
00448
00449
00450 #define ACE_YYTABLE_NINF -1
00451 static const unsigned char ace_yytable[] =
00452 {
00453 24, 25, 4, 5, 6, 7, 8, 4, 5, 40,
00454 41, 42, 49, 50, 43, 35, 17, 56, 19, 23,
00455 2, 3, 20, 4, 5, 6, 7, 8, 9, 21,
00456 27, 28, 29, 22, 37, 31, 52, 38, 39, 48,
00457 55, 59, 54, 64, 57, 58, 60, 63, 65, 61,
00458 33, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00459 0, 0, 46
00460 };
00461
00462 static const ace_yysigned_char ace_yycheck[] =
00463 {
00464 9, 9, 3, 4, 5, 6, 7, 3, 4, 14,
00465 15, 16, 12, 13, 19, 17, 15, 18, 15, 15,
00466 0, 1, 15, 3, 4, 5, 6, 7, 8, 15,
00467 9, 10, 11, 15, 22, 16, 19, 22, 22, 15,
00468 15, 53, 20, 20, 53, 53, 53, 21, 21, 53,
00469 19, -1, -1, -1, -1, -1, -1, -1, -1, -1,
00470 -1, -1, 34
00471 };
00472
00473
00474
00475 static const unsigned char ace_yystos[] =
00476 {
00477 0, 24, 0, 1, 3, 4, 5, 6, 7, 8,
00478 25, 26, 27, 28, 29, 30, 31, 15, 38, 15,
00479 15, 15, 15, 15, 26, 27, 33, 9, 10, 11,
00480 41, 16, 42, 42, 32, 17, 34, 22, 22, 22,
00481 14, 15, 16, 19, 40, 43, 34, 35, 15, 12,
00482 13, 39, 19, 36, 20, 15, 18, 26, 27, 28,
00483 29, 30, 37, 21, 20, 21
00484 };
00485
00486 #if ! defined (ACE_YYSIZE_T) && defined (__SIZE_TYPE__)
00487 # define ACE_YYSIZE_T __SIZE_TYPE__
00488 #endif
00489 #if ! defined (ACE_YYSIZE_T) && defined (size_t)
00490 # define ACE_YYSIZE_T size_t
00491 #endif
00492 #if ! defined (ACE_YYSIZE_T)
00493 # if defined (__STDC__) || defined (__cplusplus)
00494 # include <stddef.h>
00495 # define ACE_YYSIZE_T size_t
00496 # endif
00497 #endif
00498 #if ! defined (ACE_YYSIZE_T)
00499 # define ACE_YYSIZE_T unsigned int
00500 #endif
00501
00502 #define ace_yyerrok (ace_yyerrstatus = 0)
00503 #define ace_yyclearin (ace_yychar = ACE_YYEMPTY)
00504 #define ACE_YYEMPTY (-2)
00505 #define ACE_YYEOF 0
00506
00507 #define ACE_YYACCEPT goto ace_yyacceptlab
00508 #define ACE_YYABORT goto ace_yyabortlab
00509 #define ACE_YYERROR goto ace_yyerrorlab
00510
00511
00512
00513
00514
00515
00516 #define ACE_YYFAIL goto ace_yyerrlab
00517
00518 #define ACE_YYRECOVERING() (!!ace_yyerrstatus)
00519
00520 #define ACE_YYBACKUP(Token, Value) \
00521 do \
00522 if (ace_yychar == ACE_YYEMPTY && ace_yylen == 1) \
00523 { \
00524 ace_yychar = (Token); \
00525 ace_yylval = (Value); \
00526 ace_yytoken = ACE_YYTRANSLATE (ace_yychar); \
00527 ACE_YYPOPSTACK; \
00528 goto ace_yybackup; \
00529 } \
00530 else \
00531 { \
00532 ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, "syntax error: cannot back up");\
00533 ACE_YYERROR; \
00534 } \
00535 while (0)
00536
00537
00538 #define ACE_YYTERROR 1
00539 #define ACE_YYERRCODE 256
00540
00541
00542
00543
00544
00545
00546 #define ACE_YYRHSLOC(Rhs, K) ((Rhs)[K])
00547 #ifndef ACE_YYLLOC_DEFAULT
00548 # define ACE_YYLLOC_DEFAULT(Current, Rhs, N) \
00549 do \
00550 if (N) \
00551 { \
00552 (Current).first_line = ACE_YYRHSLOC (Rhs, 1).first_line; \
00553 (Current).first_column = ACE_YYRHSLOC (Rhs, 1).first_column; \
00554 (Current).last_line = ACE_YYRHSLOC (Rhs, N).last_line; \
00555 (Current).last_column = ACE_YYRHSLOC (Rhs, N).last_column; \
00556 } \
00557 else \
00558 { \
00559 (Current).first_line = (Current).last_line = \
00560 ACE_YYRHSLOC (Rhs, 0).last_line; \
00561 (Current).first_column = (Current).last_column = \
00562 ACE_YYRHSLOC (Rhs, 0).last_column; \
00563 } \
00564 while (0)
00565 #endif
00566
00567
00568
00569
00570
00571
00572 #ifndef ACE_YY_LOCATION_PRINT
00573 # if ACE_YYLTYPE_IS_TRIVIAL
00574 # define ACE_YY_LOCATION_PRINT(File, Loc) \
00575 ACE_OS::fprintf (File, "%d.%d-%d.%d", \
00576 (Loc).first_line, (Loc).first_column, \
00577 (Loc).last_line, (Loc).last_column)
00578 # else
00579 # define ACE_YY_LOCATION_PRINT(File, Loc) ((void) 0)
00580 # endif
00581 #endif
00582
00583
00584
00585
00586 #ifdef ACE_YYLEX_PARAM
00587 # define ACE_YYLEX ace_yylex (&ace_yylval, ACE_YYLEX_PARAM)
00588 #else
00589 # define ACE_YYLEX ace_yylex (&ace_yylval)
00590 #endif
00591
00592
00593 #if ACE_YYDEBUG
00594
00595 # ifndef ACE_YYFPRINTF
00596 # include <stdio.h>
00597 # define ACE_YYFPRINTF ACE_OS::fprintf
00598 # endif
00599
00600 # define ACE_YYDPRINTF(Args) \
00601 do \
00602 { \
00603 if (ace_yydebug) \
00604 ACE_YYFPRINTF Args; \
00605 } \
00606 while (0)
00607
00608 # define ACE_YY_SYMBOL_PRINT(Title, Type, Value, Location) \
00609 do \
00610 { \
00611 if (ace_yydebug) \
00612 { \
00613 ACE_YYFPRINTF (stderr, "%s ", Title); \
00614 ace_yysymprint (stderr, \
00615 Type, Value); \
00616 ACE_YYFPRINTF (stderr, "\n"); \
00617 } \
00618 } \
00619 while (0)
00620
00621
00622
00623
00624
00625
00626 #if defined (__STDC__) || defined (__cplusplus)
00627 static void
00628 ace_yy_stack_print (short int *bottom, short int *top)
00629 #else
00630 static void
00631 ace_yy_stack_print (bottom, top)
00632 short int *bottom;
00633 short int *top;
00634 #endif
00635 {
00636 ACE_YYFPRINTF (stderr, "Stack now");
00637 for (; bottom <= top; ++bottom)
00638 ACE_YYFPRINTF (stderr, " %d", *bottom);
00639 ACE_YYFPRINTF (stderr, "\n");
00640 }
00641
00642 # define ACE_YY_STACK_PRINT(Bottom, Top) \
00643 do \
00644 { \
00645 if (ace_yydebug) \
00646 ace_yy_stack_print ((Bottom), (Top)); \
00647 } \
00648 while (0)
00649
00650
00651
00652
00653
00654
00655 #if defined (__STDC__) || defined (__cplusplus)
00656 static void
00657 ace_yy_reduce_print (int ace_yyrule)
00658 #else
00659 static void
00660 ace_yy_reduce_print (ace_yyrule)
00661 int ace_yyrule;
00662 #endif
00663 {
00664 int ace_yyi;
00665 unsigned int ace_yylno = ace_yyrline[ace_yyrule];
00666 ACE_YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
00667 ace_yyrule - 1, ace_yylno);
00668
00669 for (ace_yyi = ace_yyprhs[ace_yyrule]; 0 <= ace_yyrhs[ace_yyi]; ace_yyi++)
00670 ACE_YYFPRINTF (stderr, "%s ", ace_yytname [ace_yyrhs[ace_yyi]]);
00671 ACE_YYFPRINTF (stderr, "-> %s\n", ace_yytname [ace_yyr1[ace_yyrule]]);
00672 }
00673
00674 # define ACE_YY_REDUCE_PRINT(Rule) \
00675 do \
00676 { \
00677 if (ace_yydebug) \
00678 ace_yy_reduce_print (Rule); \
00679 } \
00680 while (0)
00681
00682
00683
00684 int ace_yydebug;
00685 #else
00686 # define ACE_YYDPRINTF(Args)
00687 # define ACE_YY_SYMBOL_PRINT(Title, Type, Value, Location)
00688 # define ACE_YY_STACK_PRINT(Bottom, Top)
00689 # define ACE_YY_REDUCE_PRINT(Rule)
00690 #endif
00691
00692
00693
00694 #ifndef ACE_YYINITDEPTH
00695 # define ACE_YYINITDEPTH 200
00696 #endif
00697
00698
00699
00700
00701
00702
00703
00704
00705 #ifndef ACE_YYMAXDEPTH
00706 # define ACE_YYMAXDEPTH 10000
00707 #endif
00708
00709
00710
00711 #if ACE_YYERROR_VERBOSE
00712
00713 # ifndef ace_yystrlen
00714 # if defined (__GLIBC__) && defined (_STRING_H)
00715 # define ace_yystrlen strlen
00716 # else
00717
00718 static ACE_YYSIZE_T
00719 # if defined (__STDC__) || defined (__cplusplus)
00720 ace_yystrlen (const char *ace_yystr)
00721 # else
00722 ace_yystrlen (ace_yystr)
00723 const char *ace_yystr;
00724 # endif
00725 {
00726 register const char *ace_yys = ace_yystr;
00727
00728 while (*ace_yys++ != '\0')
00729 continue;
00730
00731 return ace_yys - ace_yystr - 1;
00732 }
00733 # endif
00734 # endif
00735
00736 # ifndef ace_yystpcpy
00737 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
00738 # define ace_yystpcpy stpcpy
00739 # else
00740
00741
00742 static char *
00743 # if defined (__STDC__) || defined (__cplusplus)
00744 ace_yystpcpy (ACE_TCHAR *ace_yydest, const char *ace_yysrc)
00745 # else
00746 ace_yystpcpy (ace_yydest, ace_yysrc)
00747 char *ace_yydest;
00748 const char *ace_yysrc;
00749 # endif
00750 {
00751 register char *ace_yyd = ace_yydest;
00752 register const char *ace_yys = ace_yysrc;
00753
00754 while ((*ace_yyd++ = *ace_yys++) != '\0')
00755 continue;
00756
00757 return ace_yyd - 1;
00758 }
00759 # endif
00760 # endif
00761
00762 #endif
00763
00764
00765
00766 #if ACE_YYDEBUG
00767
00768
00769
00770
00771 #if defined (__STDC__) || defined (__cplusplus)
00772 static void
00773 ace_yysymprint (FILE *ace_yyoutput, int ace_yytype, ACE_YYSTYPE *ace_yyvaluep)
00774 #else
00775 static void
00776 ace_yysymprint (ace_yyoutput, ace_yytype, ace_yyvaluep)
00777 FILE *ace_yyoutput;
00778 int ace_yytype;
00779 ACE_YYSTYPE *ace_yyvaluep;
00780 #endif
00781 {
00782
00783 (void) ace_yyvaluep;
00784
00785 if (ace_yytype < ACE_YYNTOKENS)
00786 ACE_YYFPRINTF (ace_yyoutput, "token %s (", ace_yytname[ace_yytype]);
00787 else
00788 ACE_YYFPRINTF (ace_yyoutput, "nterm %s (", ace_yytname[ace_yytype]);
00789
00790
00791 # ifdef ACE_YYPRINT
00792 if (ace_yytype < ACE_YYNTOKENS)
00793 ACE_YYPRINT (ace_yyoutput, ace_yytoknum[ace_yytype], *ace_yyvaluep);
00794 # endif
00795 switch (ace_yytype)
00796 {
00797 default:
00798 break;
00799 }
00800 ACE_YYFPRINTF (ace_yyoutput, ")");
00801 }
00802
00803 #endif
00804
00805
00806
00807
00808 #if defined (__STDC__) || defined (__cplusplus)
00809 static void
00810 ace_yydestruct (const char *ace_yymsg, int ace_yytype, ACE_YYSTYPE *ace_yyvaluep)
00811 #else
00812 static void
00813 ace_yydestruct (ace_yymsg, ace_yytype, ace_yyvaluep)
00814 const char *ace_yymsg;
00815 int ace_yytype;
00816 ACE_YYSTYPE *ace_yyvaluep;
00817 #endif
00818 {
00819
00820 (void) ace_yyvaluep;
00821 (void) ace_yytype;
00822
00823 if (!ace_yymsg)
00824 ace_yymsg = "Deleting";
00825 ACE_YY_SYMBOL_PRINT (ace_yymsg, ace_yytype, ace_yyvaluep, ace_yylocationp);
00826 }
00827
00828
00829 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00830
00831
00832
00833 #ifdef ACE_YYPARSE_PARAM
00834 # if defined (__STDC__) || defined (__cplusplus)
00835 int ace_yyparse (void *ACE_YYPARSE_PARAM);
00836 # else
00837 int ace_yyparse ();
00838 # endif
00839 #else
00840 #if defined (__STDC__) || defined (__cplusplus)
00841 int ace_yyparse (void);
00842 #else
00843 int ace_yyparse ();
00844 #endif
00845 #endif
00846
00847
00848
00849
00850
00851
00852 #ifdef ACE_YYPARSE_PARAM
00853 # if defined (__STDC__) || defined (__cplusplus)
00854 int ace_yyparse (void *ACE_YYPARSE_PARAM)
00855 # else
00856 int ace_yyparse (ACE_YYPARSE_PARAM)
00857 void *ACE_YYPARSE_PARAM;
00858 # endif
00859 #else
00860 #if defined (__STDC__) || defined (__cplusplus)
00861 int
00862 ace_yyparse (void)
00863 #else
00864 int
00865 ace_yyparse ()
00866
00867 #endif
00868 #endif
00869 {
00870
00871 int ace_yychar;
00872
00873
00874 ACE_YYSTYPE ace_yylval;
00875
00876 #if defined (ACE_YYSTYPE_IS_TRIVIAL)
00877 ace_yylval = 0;
00878 #else
00879 ace_yylval.type_ = 0;
00880 #endif
00881
00882
00883 int ace_yynerrs;
00884
00885 register int ace_yystate;
00886 register int ace_yyn;
00887 int ace_yyresult;
00888
00889 int ace_yyerrstatus;
00890
00891 int ace_yytoken = 0;
00892
00893
00894
00895
00896
00897
00898
00899
00900
00901
00902 short int ace_yyssa[ACE_YYINITDEPTH];
00903 short int *ace_yyss = ace_yyssa;
00904 register short int *ace_yyssp;
00905
00906
00907 ACE_YYSTYPE ace_yyvsa[ACE_YYINITDEPTH];
00908 ACE_YYSTYPE *ace_yyvs = ace_yyvsa;
00909 register ACE_YYSTYPE *ace_yyvsp;
00910
00911
00912
00913 #define ACE_YYPOPSTACK (ace_yyvsp--, ace_yyssp--)
00914
00915 ACE_YYSIZE_T ace_yystacksize = ACE_YYINITDEPTH;
00916
00917
00918
00919 ACE_YYSTYPE ace_yyval;
00920
00921
00922
00923
00924 int ace_yylen;
00925
00926 ACE_YYDPRINTF ((stderr, "Starting parse\n"));
00927
00928 ace_yystate = 0;
00929 ace_yyerrstatus = 0;
00930 ace_yynerrs = 0;
00931 ace_yychar = ACE_YYEMPTY;
00932
00933
00934
00935
00936
00937
00938 ace_yyssp = ace_yyss;
00939 ace_yyvsp = ace_yyvs;
00940
00941
00942 ace_yyvsp[0] = ace_yylval;
00943
00944 goto ace_yysetstate;
00945
00946
00947
00948
00949 ace_yynewstate:
00950
00951
00952
00953 ace_yyssp++;
00954
00955 ace_yysetstate:
00956 *ace_yyssp = ace_yystate;
00957
00958 if (ace_yyss + ace_yystacksize - 1 <= ace_yyssp)
00959 {
00960
00961 ACE_YYSIZE_T ace_yysize = ace_yyssp - ace_yyss + 1;
00962
00963 #ifdef ace_yyoverflow
00964 {
00965
00966
00967
00968 ACE_YYSTYPE *ace_yyvs1 = ace_yyvs;
00969 short int *ace_yyss1 = ace_yyss;
00970
00971
00972
00973
00974
00975
00976 ace_yyoverflow ("parser stack overflow",
00977 &ace_yyss1, ace_yysize * sizeof (*ace_yyssp),
00978 &ace_yyvs1, ace_yysize * sizeof (*ace_yyvsp),
00979
00980 &ace_yystacksize);
00981
00982 ace_yyss = ace_yyss1;
00983 ace_yyvs = ace_yyvs1;
00984 }
00985 #else
00986 # ifndef ACE_YYSTACK_RELOCATE
00987 goto ace_yyoverflowlab;
00988 # else
00989
00990 if (ACE_YYMAXDEPTH <= ace_yystacksize)
00991 goto ace_yyoverflowlab;
00992 ace_yystacksize *= 2;
00993 if (ACE_YYMAXDEPTH < ace_yystacksize)
00994 ace_yystacksize = ACE_YYMAXDEPTH;
00995
00996 {
00997 short int *ace_yyss1 = ace_yyss;
00998 union ace_yyalloc *ace_yyptr =
00999 (union ace_yyalloc *) ACE_YYSTACK_ALLOC (ACE_YYSTACK_BYTES (ace_yystacksize));
01000 if (! ace_yyptr)
01001 goto ace_yyoverflowlab;
01002 ACE_YYSTACK_RELOCATE (ace_yyss);
01003 ACE_YYSTACK_RELOCATE (ace_yyvs);
01004
01005 # undef ACE_YYSTACK_RELOCATE
01006 if (ace_yyss1 != ace_yyssa)
01007 ACE_YYSTACK_FREE (ace_yyss1);
01008 }
01009 # endif
01010 #endif
01011
01012 ace_yyssp = ace_yyss + ace_yysize - 1;
01013 ace_yyvsp = ace_yyvs + ace_yysize - 1;
01014
01015
01016 ACE_YYDPRINTF ((stderr, "Stack size increased to %lu\n",
01017 (unsigned long int) ace_yystacksize));
01018
01019 if (ace_yyss + ace_yystacksize - 1 <= ace_yyssp)
01020 ACE_YYABORT;
01021 }
01022
01023 ACE_YYDPRINTF ((stderr, "Entering state %d\n", ace_yystate));
01024
01025 goto ace_yybackup;
01026
01027
01028
01029
01030 ace_yybackup:
01031
01032
01033
01034
01035
01036
01037
01038 ace_yyn = ace_yypact[ace_yystate];
01039 if (ace_yyn == ACE_YYPACT_NINF)
01040 goto ace_yydefault;
01041
01042
01043
01044
01045 if (ace_yychar == ACE_YYEMPTY)
01046 {
01047 ACE_YYDPRINTF ((stderr, "Reading a token: "));
01048 ace_yychar = ACE_YYLEX;
01049 }
01050
01051 if (ace_yychar <= ACE_YYEOF)
01052 {
01053 ace_yychar = ace_yytoken = ACE_YYEOF;
01054 ACE_YYDPRINTF ((stderr, "Now at end of input.\n"));
01055 }
01056 else
01057 {
01058 ace_yytoken = ACE_YYTRANSLATE (ace_yychar);
01059 ACE_YY_SYMBOL_PRINT ("Next token is", ace_yytoken, &ace_yylval, &ace_yylloc);
01060 }
01061
01062
01063
01064 ace_yyn += ace_yytoken;
01065 if (ace_yyn < 0 || ACE_YYLAST < ace_yyn || ace_yycheck[ace_yyn] != ace_yytoken)
01066 goto ace_yydefault;
01067 ace_yyn = ace_yytable[ace_yyn];
01068 if (ace_yyn <= 0)
01069 {
01070 if (ace_yyn == 0 || ace_yyn == ACE_YYTABLE_NINF)
01071 goto ace_yyerrlab;
01072 ace_yyn = -ace_yyn;
01073 goto ace_yyreduce;
01074 }
01075
01076 if (ace_yyn == ACE_YYFINAL)
01077 ACE_YYACCEPT;
01078
01079
01080 ACE_YY_SYMBOL_PRINT ("Shifting", ace_yytoken, &ace_yylval, &ace_yylloc);
01081
01082
01083 if (ace_yychar != ACE_YYEOF)
01084 ace_yychar = ACE_YYEMPTY;
01085
01086 *++ace_yyvsp = ace_yylval;
01087
01088
01089
01090
01091 if (ace_yyerrstatus)
01092 ace_yyerrstatus--;
01093
01094 ace_yystate = ace_yyn;
01095 goto ace_yynewstate;
01096
01097
01098
01099
01100
01101 ace_yydefault:
01102 ace_yyn = ace_yydefact[ace_yystate];
01103 if (ace_yyn == 0)
01104 goto ace_yyerrlab;
01105 goto ace_yyreduce;
01106
01107
01108
01109
01110
01111 ace_yyreduce:
01112
01113 ace_yylen = ace_yyr2[ace_yyn];
01114
01115
01116
01117
01118
01119
01120
01121
01122
01123 ace_yyval = ace_yyvsp[1-ace_yylen];
01124
01125
01126 ACE_YY_REDUCE_PRINT (ace_yyn);
01127 switch (ace_yyn)
01128 {
01129 case 2:
01130
01131 {
01132 if ((ace_yyvsp[0].parse_node_) != 0)
01133 {
01134 (ace_yyvsp[0].parse_node_)->apply (ACE_SVC_CONF_PARAM->config, ACE_SVC_CONF_PARAM->yyerrno);
01135 delete (ace_yyvsp[0].parse_node_);
01136 }
01137 ACE_SVC_CONF_PARAM->obstack.release ();
01138 ;}
01139 break;
01140
01141 case 3:
01142
01143 {
01144 ACE_SVC_CONF_PARAM->obstack.release ();
01145 ;}
01146 break;
01147
01148 case 11:
01149
01150 {
01151 if ((ace_yyvsp[-1].svc_record_) != 0)
01152 (ace_yyval.parse_node_) = new ACE_Dynamic_Node ((ace_yyvsp[-1].svc_record_), (ace_yyvsp[0].ident_));
01153 else
01154 (ace_yyval.parse_node_) = 0;
01155 ;}
01156 break;
01157
01158 case 12:
01159
01160 {
01161 (ace_yyval.parse_node_) = new ACE_Static_Node ((ace_yyvsp[-1].ident_), (ace_yyvsp[0].ident_));
01162 ;}
01163 break;
01164
01165 case 13:
01166
01167 {
01168 (ace_yyval.parse_node_) = new ACE_Suspend_Node ((ace_yyvsp[0].ident_));
01169 ;}
01170 break;
01171
01172 case 14:
01173
01174 {
01175 (ace_yyval.parse_node_) = new ACE_Resume_Node ((ace_yyvsp[0].ident_));
01176 ;}
01177 break;
01178
01179 case 15:
01180
01181 {
01182 (ace_yyval.parse_node_) = new ACE_Remove_Node ((ace_yyvsp[0].ident_));
01183 ;}
01184 break;
01185
01186 case 16:
01187
01188 {
01189 (ace_yyval.parse_node_) = new ACE_Stream_Node ((ace_yyvsp[-1].static_node_), (ace_yyvsp[0].parse_node_));
01190 ;}
01191 break;
01192
01193 case 17:
01194
01195 { (ace_yyval.static_node_) = new ACE_Static_Node ((ace_yyvsp[0].ident_)); ;}
01196 break;
01197
01198 case 18:
01199
01200 {
01201 (ace_yyval.parse_node_) = new ACE_Dummy_Node ((ace_yyvsp[-1].static_node_), (ace_yyvsp[0].parse_node_));
01202 ;}
01203 break;
01204
01205 case 19:
01206
01207 {
01208 ;}
01209 break;
01210
01211 case 20:
01212
01213 {
01214 ;}
01215 break;
01216
01217 case 21:
01218
01219 {
01220
01221 (ace_yyval.static_node_) = (ace_yyvsp[-1].static_node_);
01222 ;}
01223 break;
01224
01225 case 22:
01226
01227 {
01228 (ace_yyval.parse_node_) = (ace_yyvsp[-1].parse_node_);
01229 ;}
01230 break;
01231
01232 case 23:
01233
01234 { (ace_yyval.parse_node_) = 0; ;}
01235 break;
01236
01237 case 24:
01238
01239 {
01240 if ((ace_yyvsp[0].parse_node_) != 0)
01241 {
01242 (ace_yyvsp[0].parse_node_)->link ((ace_yyvsp[-1].parse_node_));
01243 (ace_yyval.parse_node_) = (ace_yyvsp[0].parse_node_);
01244 }
01245 ;}
01246 break;
01247
01248 case 25:
01249
01250 { (ace_yyval.parse_node_) = 0; ;}
01251 break;
01252
01253 case 26:
01254
01255 {
01256 ACE_Static_Node *svc_type = (ace_yyvsp[0].static_node_);
01257
01258 if (svc_type != 0)
01259 {
01260 ACE_Static_Node *module = (ace_yyvsp[-2].static_node_);
01261
01262 ACE_ARGV args (svc_type->parameters ());
01263 ACE_Module_Type *mt = ace_get_module (module->record (ACE_SVC_CONF_PARAM->config),
01264 svc_type->record (ACE_SVC_CONF_PARAM->config),
01265 ACE_SVC_CONF_PARAM->yyerrno);
01266 ACE_Stream_Type *st =
01267 dynamic_cast<ACE_Stream_Type *> (const_cast<ACE_Service_Type_Impl *> (module->record (ACE_SVC_CONF_PARAM->config)->type ()));
01268
01269 if (!st
01270 || !mt
01271 || mt->init (args.argc (), args.argv ()) == -1
01272 || st->push (mt) == -1)
01273 {
01274 ACE_ERROR ((LM_ERROR,
01275 ACE_TEXT ("dynamic initialization failed for Module %s\n"),
01276 svc_type->name ()));
01277 ACE_SVC_CONF_PARAM->yyerrno++;
01278 }
01279 }
01280 ;}
01281 break;
01282
01283 case 27:
01284
01285 {
01286 ACE_Static_Node *sn = (ace_yyvsp[-2].static_node_);
01287 ACE_Module_Type *mt = ace_get_module (sn->record (ACE_SVC_CONF_PARAM->config),
01288 (ace_yyvsp[0].static_node_)->name (),
01289 ACE_SVC_CONF_PARAM->yyerrno);
01290
01291 if (((ACE_Stream_Type *) sn->record (ACE_SVC_CONF_PARAM->config)->type ())->push (mt) == -1)
01292 {
01293 ACE_ERROR ((LM_ERROR,
01294 ACE_TEXT ("Problem with static\n")));
01295 ACE_SVC_CONF_PARAM->yyerrno++;
01296 }
01297 ;}
01298 break;
01299
01300 case 28:
01301
01302 {
01303 ACE_Static_Node *sn = (ace_yyvsp[-2].static_node_);
01304 ACE_Module_Type *mt = ace_get_module (sn->record (ACE_SVC_CONF_PARAM->config),
01305 sn->name (),
01306 ACE_SVC_CONF_PARAM->yyerrno);
01307 if (mt != 0)
01308 mt->suspend ();
01309 ;}
01310 break;
01311
01312 case 29:
01313
01314 {
01315 ACE_Static_Node *sn = (ace_yyvsp[-2].static_node_);
01316 ACE_Module_Type *mt = ace_get_module (sn->record (ACE_SVC_CONF_PARAM->config),
01317 (ace_yyvsp[0].static_node_)->name (),
01318 ACE_SVC_CONF_PARAM->yyerrno);
01319 if (mt != 0)
01320 mt->resume ();
01321 ;}
01322 break;
01323
01324 case 30:
01325
01326 {
01327 ACE_Static_Node *stream = (ace_yyvsp[-2].static_node_);
01328 ACE_Static_Node *module = (ace_yyvsp[0].static_node_);
01329 ACE_Module_Type *mt = ace_get_module (stream->record (ACE_SVC_CONF_PARAM->config),
01330 module->name (),
01331 ACE_SVC_CONF_PARAM->yyerrno);
01332
01333 ACE_Stream_Type *st =
01334 dynamic_cast<ACE_Stream_Type *> (const_cast<ACE_Service_Type_Impl *> (stream->record (ACE_SVC_CONF_PARAM->config)->type ()));
01335 if (!st || (mt != 0 && st->remove (mt) == -1))
01336 {
01337 ACE_ERROR ((LM_ERROR,
01338 ACE_TEXT ("cannot remove Module_Type %s from STREAM_Type %s\n"),
01339 module->name (),
01340 stream->name ()));
01341 ACE_SVC_CONF_PARAM->yyerrno++;
01342 }
01343 ;}
01344 break;
01345
01346 case 31:
01347
01348 {
01349 (ace_yyval.svc_record_) = new ACE_Service_Type_Factory ((ace_yyvsp[-3].ident_), (ace_yyvsp[-2].type_), (ace_yyvsp[-1].location_node_), (ace_yyvsp[0].type_));
01350 ;}
01351 break;
01352
01353 case 32:
01354
01355 {
01356 (ace_yyval.type_) = 1;
01357 ;}
01358 break;
01359
01360 case 33:
01361
01362 {
01363 (ace_yyval.type_) = 0;
01364 ;}
01365 break;
01366
01367 case 34:
01368
01369 {
01370 (ace_yyval.type_) = 1;
01371 ;}
01372 break;
01373
01374 case 35:
01375
01376 {
01377 (ace_yyval.location_node_) = new ACE_Object_Node ((ace_yyvsp[-2].ident_), (ace_yyvsp[0].ident_));
01378 ;}
01379 break;
01380
01381 case 36:
01382
01383 {
01384 (ace_yyval.location_node_) = new ACE_Function_Node ((ace_yyvsp[-4].ident_), (ace_yyvsp[-2].ident_));
01385 ;}
01386 break;
01387
01388 case 37:
01389
01390 {
01391 (ace_yyval.location_node_) = new ACE_Static_Function_Node ((ace_yyvsp[-2].ident_));
01392 ;}
01393 break;
01394
01395 case 38:
01396
01397 {
01398 (ace_yyval.type_) = ACE_MODULE_T;
01399 ;}
01400 break;
01401
01402 case 39:
01403
01404 {
01405 (ace_yyval.type_) = ACE_SVC_OBJ_T;
01406 ;}
01407 break;
01408
01409 case 40:
01410
01411 {
01412 (ace_yyval.type_) = ACE_STREAM_T;
01413 ;}
01414 break;
01415
01416 case 42:
01417
01418 { (ace_yyval.ident_) = 0; ;}
01419 break;
01420
01421
01422 }
01423
01424
01425
01426
01427 ace_yyvsp -= ace_yylen;
01428 ace_yyssp -= ace_yylen;
01429
01430
01431 ACE_YY_STACK_PRINT (ace_yyss, ace_yyssp);
01432
01433 *++ace_yyvsp = ace_yyval;
01434
01435
01436
01437
01438
01439
01440 ace_yyn = ace_yyr1[ace_yyn];
01441
01442 ace_yystate = ace_yypgoto[ace_yyn - ACE_YYNTOKENS] + *ace_yyssp;
01443 if (0 <= ace_yystate && ace_yystate <= ACE_YYLAST && ace_yycheck[ace_yystate] == *ace_yyssp)
01444 ace_yystate = ace_yytable[ace_yystate];
01445 else
01446 ace_yystate = ace_yydefgoto[ace_yyn - ACE_YYNTOKENS];
01447
01448 goto ace_yynewstate;
01449
01450
01451
01452
01453
01454 ace_yyerrlab:
01455
01456 if (!ace_yyerrstatus)
01457 {
01458 ++ace_yynerrs;
01459 #if ACE_YYERROR_VERBOSE
01460 ace_yyn = ace_yypact[ace_yystate];
01461
01462 if (ACE_YYPACT_NINF < ace_yyn && ace_yyn < ACE_YYLAST)
01463 {
01464 ACE_YYSIZE_T ace_yysize = 0;
01465 int ace_yytype = ACE_YYTRANSLATE (ace_yychar);
01466 const char* ace_yyprefix;
01467 char *ace_yymsg;
01468 int ace_yyx;
01469
01470
01471
01472 int ace_yyxbegin = ace_yyn < 0 ? -ace_yyn : 0;
01473
01474
01475 int ace_yychecklim = ACE_YYLAST - ace_yyn;
01476 int ace_yyxend = ace_yychecklim < ACE_YYNTOKENS ? ace_yychecklim : ACE_YYNTOKENS;
01477 int ace_yycount = 0;
01478
01479 ace_yyprefix = ", expecting ";
01480 for (ace_yyx = ace_yyxbegin; ace_yyx < ace_yyxend; ++ace_yyx)
01481 if (ace_yycheck[ace_yyx + ace_yyn] == ace_yyx && ace_yyx != ACE_YYTERROR)
01482 {
01483 ace_yysize += ace_yystrlen (ace_yyprefix) + ace_yystrlen (ace_yytname [ace_yyx]);
01484 ace_yycount += 1;
01485 if (ace_yycount == 5)
01486 {
01487 ace_yysize = 0;
01488 break;
01489 }
01490 }
01491 ace_yysize += (sizeof ("syntax error, unexpected ")
01492 + ace_yystrlen (ace_yytname[ace_yytype]));
01493 ace_yymsg = (ACE_TCHAR *) ACE_YYSTACK_ALLOC (ace_yysize);
01494 if (ace_yymsg != 0)
01495 {
01496 char *ace_yyp = ace_yystpcpy (ace_yymsg, "syntax error, unexpected ");
01497 ace_yyp = ace_yystpcpy (ace_yyp, ace_yytname[ace_yytype]);
01498
01499 if (ace_yycount < 5)
01500 {
01501 ace_yyprefix = ", expecting ";
01502 for (ace_yyx = ace_yyxbegin; ace_yyx < ace_yyxend; ++ace_yyx)
01503 if (ace_yycheck[ace_yyx + ace_yyn] == ace_yyx && ace_yyx != ACE_YYTERROR)
01504 {
01505 ace_yyp = ace_yystpcpy (ace_yyp, ace_yyprefix);
01506 ace_yyp = ace_yystpcpy (ace_yyp, ace_yytname[ace_yyx]);
01507 ace_yyprefix = " or ";
01508 }
01509 }
01510 ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, ace_yymsg);
01511 ACE_YYSTACK_FREE (ace_yymsg);
01512 }
01513 else
01514 ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, "syntax error; also virtual memory exhausted");
01515 }
01516 else
01517 #endif
01518 ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, "syntax error");
01519 }
01520
01521
01522
01523 if (ace_yyerrstatus == 3)
01524 {
01525
01526
01527
01528 if (ace_yychar <= ACE_YYEOF)
01529 {
01530
01531
01532 if (ace_yychar == ACE_YYEOF)
01533 for (;;)
01534 {
01535
01536 ACE_YYPOPSTACK;
01537 if (ace_yyssp == ace_yyss)
01538 ACE_YYABORT;
01539 ace_yydestruct ("Error: popping",
01540 ace_yystos[*ace_yyssp], ace_yyvsp);
01541 }
01542 }
01543 else
01544 {
01545 ace_yydestruct ("Error: discarding", ace_yytoken, &ace_yylval);
01546 ace_yychar = ACE_YYEMPTY;
01547 }
01548 }
01549
01550
01551
01552 goto ace_yyerrlab1;
01553
01554
01555
01556
01557
01558 ace_yyerrorlab:
01559
01560 #if defined (__GNUC__) || defined (ACE_WIN32) || defined (__HP_aCC) || defined (__DECCXX)
01561
01562
01563 if (0)
01564 goto ace_yyerrorlab;
01565 #endif
01566
01567 ace_yyvsp -= ace_yylen;
01568 ace_yyssp -= ace_yylen;
01569 ace_yystate = *ace_yyssp;
01570 goto ace_yyerrlab1;
01571
01572
01573
01574
01575
01576 ace_yyerrlab1:
01577 ace_yyerrstatus = 3;
01578
01579 for (;;)
01580 {
01581 ace_yyn = ace_yypact[ace_yystate];
01582 if (ace_yyn != ACE_YYPACT_NINF)
01583 {
01584 ace_yyn += ACE_YYTERROR;
01585 if (0 <= ace_yyn && ace_yyn <= ACE_YYLAST && ace_yycheck[ace_yyn] == ACE_YYTERROR)
01586 {
01587 ace_yyn = ace_yytable[ace_yyn];
01588 if (0 < ace_yyn)
01589 break;
01590 }
01591 }
01592
01593
01594 if (ace_yyssp == ace_yyss)
01595 ACE_YYABORT;
01596
01597
01598 ace_yydestruct ("Error: popping", ace_yystos[ace_yystate], ace_yyvsp);
01599 ACE_YYPOPSTACK;
01600 ace_yystate = *ace_yyssp;
01601 ACE_YY_STACK_PRINT (ace_yyss, ace_yyssp);
01602 }
01603
01604 if (ace_yyn == ACE_YYFINAL)
01605 ACE_YYACCEPT;
01606
01607 *++ace_yyvsp = ace_yylval;
01608
01609
01610
01611 ACE_YY_SYMBOL_PRINT ("Shifting", ace_yystos[ace_yyn], ace_yyvsp, ace_yylsp);
01612
01613 ace_yystate = ace_yyn;
01614 goto ace_yynewstate;
01615
01616
01617
01618
01619
01620 ace_yyacceptlab:
01621 ace_yyresult = 0;
01622 goto ace_yyreturn;
01623
01624
01625
01626
01627 ace_yyabortlab:
01628 ace_yydestruct ("Error: discarding lookahead",
01629 ace_yytoken, &ace_yylval);
01630 ace_yychar = ACE_YYEMPTY;
01631 ace_yyresult = 1;
01632 goto ace_yyreturn;
01633
01634 #ifndef ace_yyoverflow
01635
01636
01637
01638 ace_yyoverflowlab:
01639 ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, "parser stack overflow");
01640 ace_yyresult = 2;
01641
01642 #endif
01643
01644 ace_yyreturn:
01645 #ifndef ace_yyoverflow
01646 if (ace_yyss != ace_yyssa)
01647 ACE_YYSTACK_FREE (ace_yyss);
01648 #endif
01649 return ace_yyresult;
01650 }
01651
01652
01653
01654
01655 void
01656 ace_yyerror (int ace_yyerrno, int ace_yylineno, char const *s)
01657 {
01658 #if defined (ACE_NLOGGING)
01659 ACE_UNUSED_ARG (ace_yyerrno);
01660 ACE_UNUSED_ARG (ace_yylineno);
01661 ACE_UNUSED_ARG (s);
01662 #endif
01663
01664 ACE_ERROR ((LM_ERROR,
01665 ACE_TEXT ("ACE (%P|%t) [error %d] on line %d: %s\n"),
01666 ace_yyerrno,
01667 ace_yylineno,
01668 ACE_TEXT_CHAR_TO_TCHAR (s)));
01669 }
01670
01671
01672
01673
01674 static ACE_Module_Type *
01675 ace_get_module (ACE_Service_Type const * sr,
01676 ACE_TCHAR const * svc_name,
01677 int & ace_yyerrno)
01678 {
01679 ACE_Service_Type_Impl const * const type = sr->type ();
01680 ACE_Stream_Type const * const st =
01681 (sr == 0
01682 ? 0
01683 : dynamic_cast<ACE_Stream_Type const *> (type));
01684 ACE_Module_Type const * const mt = (st == 0 ? 0 : st->find (svc_name));
01685
01686 if (sr == 0 || st == 0 || mt == 0)
01687 {
01688 ACE_ERROR ((LM_ERROR,
01689 ACE_TEXT ("cannot locate Module_Type %s ")
01690 ACE_TEXT ("in STREAM_Type %s\n"),
01691 svc_name,
01692 (sr ? sr->name () : ACE_TEXT ("(nil)"))));
01693 ++ace_yyerrno;
01694 }
01695
01696 return const_cast<ACE_Module_Type *> (mt);
01697 }
01698
01699 static ACE_Module_Type *
01700 ace_get_module (ACE_Service_Type const * sr,
01701 ACE_Service_Type const * sv,
01702 int & ace_yyerrno)
01703 {
01704 ACE_Stream_Type const * const st =
01705 (sr == 0
01706 ? 0
01707 : static_cast<ACE_Stream_Type const *> (sr->type ()));
01708
01709 ACE_Module_Type const * const mt =
01710 static_cast <ACE_Module_Type const *> (sv->type ());
01711
01712 ACE_TCHAR const * const module_type_name =
01713 (mt ? mt->name () : ACE_TEXT ("(nil)"));
01714
01715 if (sr == 0 || st == 0 || mt == 0)
01716 {
01717 ACE_ERROR ((LM_ERROR,
01718 ACE_TEXT ("cannot locate Module_Type %s or STREAM_Type %s\n"),
01719 module_type_name,
01720 (sr ? sr->name () : ACE_TEXT ("(nil)"))));
01721 ++ace_yyerrno;
01722 }
01723
01724
01725
01726 ACE_Module<ACE_SYNCH> * const mp =
01727 static_cast<ACE_Module<ACE_SYNCH> *> (mt ? mt->object () : 0);
01728
01729 if (mp && ACE_OS::strcmp (mp->name (), module_type_name) != 0)
01730 {
01731 ACE_DEBUG ((LM_DEBUG,
01732 ACE_TEXT ("warning: assigning Module_Type name %s to Module %s since names differ\n"),
01733 module_type_name,
01734 mp->name ()));
01735 mp->name (module_type_name);
01736 }
01737
01738 return const_cast<ACE_Module_Type *> (mt);
01739 }
01740
01741 #if defined (DEBUGGING)
01742
01743
01744 int
01745 main (int argc, char *argv[])
01746 {
01747 ACE_Svc_Conf_Param param (stdin);
01748
01749
01750 if (argc > 1 && (ace_yyin = freopen (argv[1], "r", stdin)) == 0)
01751 (void) ACE_OS::ACE_OS::fprintf (stderr, ACE_TEXT ("usage: %s [file]\n"), argv[0]), ACE_OS::exit (1);
01752
01753 return ::ace_yyparse (¶m);
01754 }
01755 #endif
01756
01757 ACE_END_VERSIONED_NAMESPACE_DECL
01758
01759 #endif