ACE/ace/Svc_Conf.y

   1 %{
   2 #include "ace/Svc_Conf.h"
   3
   4 #if (ACE_USES_CLASSIC_SVC_CONF == 1)
   5
   6 #include "ace/Module.h"
   7 #include "ace/Stream.h"
   8 #include "ace/Service_Types.h"
   9 #include "ace/ace_wchar.h"
  10
  11 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  12
  13 // Prototypes.
  14
  15 static ACE_Module_Type *
  16   ace_get_module (ACE_Service_Type const * sr,
  17                   ACE_TCHAR const * svc_name,
  18                   int & ace_yyerrno);
  19
  20 #define YYDEBUG_LEXER_TEXT (yytext[yyleng] = '\0', yytext)
  21
  22 // Force the pretty debugging code to compile.
  23 // #define YYDEBUG 1
  24
  25 // Bison 2.3 template contains switch statement with a "default:", but
  26 // without a "case:" label. Suppressing a compiler warning for Visual
  27 // C++.
  28 #if defined (_MSC_VER)
  29 #   pragma warning ( disable : 4065 )
  30 #endif
  31
  32 // Normalize the message literal's type to match yyerror() prototype
  33 #define YY_ ACE_TEXT
  34
  35 // Prevent yacc(1) from declaring a trivial YYSTYPE just because
  36 // YYSTYPE is not a macro definition. On the other hand we want
  37 // YYSTYPE_IS_DECLARED to be as localized as possible to avoid
  38 // poluting the global namespace - there may be other yacc(1) parsers
  39 // that want to play nice with ACE
  40 #define YYSTYPE_IS_DECLARED
  41
  42 ACE_END_VERSIONED_NAMESPACE_DECL
  43
  44 %}
  45
  46 %token ACE_DYNAMIC ACE_STATIC ACE_SUSPEND ACE_RESUME ACE_REMOVE ACE_USTREAM
  47 %token ACE_MODULE_T ACE_STREAM_T ACE_SVC_OBJ_T ACE_ACTIVE ACE_INACTIVE
  48 %token ACE_PATHNAME ACE_IDENT ACE_STRING
  49
  50 %start svc_config_entries
  51
  52 %type <ident_> ACE_IDENT ACE_STRING ACE_PATHNAME pathname parameters_opt
  53 %type <type_> type status
  54 %type <parse_node_> dynamic static suspend resume remove module_list stream
  55 %type <parse_node_> stream_modules module svc_config_entry
  56 %type <static_node_> stream_ops
  57 %type <svc_record_> svc_location
  58 %type <location_node_> svc_initializer
  59
  60 // Generate a pure (reentrant) parser -- GNU Bison only
  61 %pure_parser
  62
  63 %%
  64
  65 svc_config_entries
  66   : svc_config_entries svc_config_entry
  67     {
  68       if ($2 != 0)
  69       {
  70         $2->apply (ACE_SVC_CONF_PARAM->config, ACE_SVC_CONF_PARAM->yyerrno);
  71         delete $2;
  72       }
  73       ACE_SVC_CONF_PARAM->obstack.release ();
  74     }
  75   | svc_config_entries error
  76     {
  77       ACE_SVC_CONF_PARAM->obstack.release ();
  78     }
  79   | /* EMPTY */
  80   ;
  81
  82 svc_config_entry
  83   : dynamic
  84   | static
  85   | suspend
  86   | resume
  87   | remove
  88   | stream
  89   ;
  90
  91 dynamic
  92   : ACE_DYNAMIC svc_location parameters_opt
  93     {
  94       if ($2 != 0)
  95         $$ = new ACE_Dynamic_Node ($2, $3);
  96       else
  97         $$ = 0;
  98     }
  99   ;
 100
 101 static
 102   : ACE_STATIC ACE_IDENT parameters_opt
 103     {
 104       $$ = new ACE_Static_Node ($2, $3);
 105     }
 106   ;
 107
 108 suspend
 109   : ACE_SUSPEND ACE_IDENT
 110     {
 111       $$ = new ACE_Suspend_Node ($2);
 112     }
 113   ;
 114
 115 resume
 116   : ACE_RESUME ACE_IDENT
 117     {
 118       $$ = new ACE_Resume_Node ($2);
 119     }
 120   ;
 121
 122 remove
 123   : ACE_REMOVE ACE_IDENT
 124     {
 125       $$ = new ACE_Remove_Node ($2);
 126     }
 127   ;
 128
 129 stream
 130   : ACE_USTREAM stream_ops stream_modules
 131     {
 132       $$ = new ACE_Stream_Node ($2, $3);
 133     }
 134   | ACE_USTREAM ACE_IDENT { $<static_node_>$ = new ACE_Static_Node ($2); } stream_modules
 135     {
 136       $$ = new ACE_Dummy_Node ($<static_node_>3, $4);
 137     }
 138   ;
 139
 140 stream_ops
 141   : dynamic
 142     {
 143     }
 144   | static
 145     {
 146     }
 147   ;
 148
 149 stream_modules
 150   : '{'
 151     {
 152       // Initialize left context...
 153       $<static_node_>$ = $<static_node_>0;
 154     }
 155    module_list '}'
 156     {
 157       ACE_UNUSED_ARG ($2);
 158       $$ = $3;
 159     }
 160   | /* EMPTY */ { $$ = 0; }
 161   ;
 162
 163 module_list
 164   : module_list module
 165     {
 166       if ($2 != 0)
 167         {
 168           $2->link ($1);
 169           $$ = $2;
 170         }
 171     }
 172   | /* EMPTY */ { $$ = 0; }
 173   ;
 174
 175 module
 176   : dynamic
 177     {
 178             }
 179   | static
 180     {
 181       ACE_Static_Node *sn = $<static_node_>-1;
 182       ACE_Module_Type *mt = ace_get_module (sn->record (ACE_SVC_CONF_PARAM->config),
 183                                             $<static_node_>1->name (),
 184                                             ACE_SVC_CONF_PARAM->yyerrno);
 185
 186       if (((ACE_Stream_Type *) sn->record (ACE_SVC_CONF_PARAM->config)->type ())->push (mt) == -1)
 187         {
 188           ACE_ERROR ((LM_ERROR,
 189                       ACE_TEXT ("Problem with static\n")));
 190           ACE_SVC_CONF_PARAM->yyerrno++;
 191         }
 192     }
 193   | suspend
 194     {
 195       ACE_Static_Node *sn = $<static_node_>-1;
 196       ACE_Module_Type *mt = ace_get_module (sn->record (ACE_SVC_CONF_PARAM->config),
 197                                             sn->name (),
 198                                             ACE_SVC_CONF_PARAM->yyerrno);
 199       if (mt != 0)
 200         mt->suspend ();
 201     }
 202   | resume
 203     {
 204       ACE_Static_Node *sn = $<static_node_>-1;
 205       ACE_Module_Type *mt = ace_get_module (sn->record (ACE_SVC_CONF_PARAM->config),
 206                                             $<static_node_>1->name (),
 207                                             ACE_SVC_CONF_PARAM->yyerrno);
 208       if (mt != 0)
 209         mt->resume ();
 210     }
 211   | remove
 212     {
 213       ACE_Static_Node *stream = $<static_node_>-1;
 214       ACE_Static_Node *module = $<static_node_>1;
 215       ACE_Module_Type *mt = ace_get_module (stream->record (ACE_SVC_CONF_PARAM->config),
 216                                             module->name (),
 217                                             ACE_SVC_CONF_PARAM->yyerrno);
 218
 219       ACE_Stream_Type *st =
 220         dynamic_cast<ACE_Stream_Type *> (const_cast<ACE_Service_Type_Impl *> (stream->record (ACE_SVC_CONF_PARAM->config)->type ()));
 221       if (!st || (mt != 0 && st->remove (mt) == -1))
 222         {
 223           ACE_ERROR ((LM_ERROR,
 224                       ACE_TEXT ("cannot remove Module_Type %s from STREAM_Type %s\n"),
 225                       module->name (),
 226                       stream->name ()));
 227           ACE_SVC_CONF_PARAM->yyerrno++;
 228         }
 229     }
 230   ;
 231
 232 svc_location
 233   : ACE_IDENT type svc_initializer status
 234     {
 235       $$ = new ACE_Service_Type_Factory ($1, $2, $3, $4);
 236     }
 237   ;
 238
 239 status
 240   : ACE_ACTIVE
 241     {
 242       $$ = 1;
 243     }
 244   | ACE_INACTIVE
 245     {
 246       $$ = 0;
 247     }
 248   | /* EMPTY */
 249     {
 250       $$ = 1;
 251     }
 252   ;
 253
 254 svc_initializer
 255   : pathname ':' ACE_IDENT
 256     {
 257       $$ = new ACE_Object_Node ($1, $3);
 258     }
 259   | pathname ':' ACE_IDENT '(' ')'
 260     {
 261       $$ = new ACE_Function_Node ($1, $3);
 262     }
 263   | ':' ACE_IDENT '(' ')'
 264     {
 265       $$ = new ACE_Static_Function_Node ($2);
 266     }
 267   ;
 268
 269 type
 270   : ACE_MODULE_T '*'
 271     {
 272       $$ = ACE_MODULE_T;
 273     }
 274   | ACE_SVC_OBJ_T '*'
 275     {
 276       $$ = ACE_SVC_OBJ_T;
 277     }
 278   | ACE_STREAM_T '*'
 279     {
 280       $$ = ACE_STREAM_T;
 281     }
 282   ;
 283
 284 parameters_opt
 285   : ACE_STRING
 286   | /* EMPTY */ { $$ = 0; }
 287   ;
 288
 289 pathname
 290   : ACE_PATHNAME
 291   | ACE_IDENT
 292   | ACE_STRING
 293   ;
 294
 295 %%
 296
 297 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 298
 299 // Prints the error string to standard output.  Cleans up the error
 300 // messages.
 301
 302 void
 303 yyerror (int yyerrno, int yylineno, ACE_TCHAR const * s)
 304 {
 305 #if defined (ACE_NLOGGING)
 306   ACE_UNUSED_ARG (yyerrno);
 307   ACE_UNUSED_ARG (yylineno);
 308   ACE_UNUSED_ARG (s);
 309 #endif /* ACE_NLOGGING */
 310
 311   ACE_ERROR ((LM_ERROR,
 312               ACE_TEXT ("ACE (%P|%t) [error %d] on line %d: %C\n"),
 313               yyerrno,
 314               yylineno,
 315               s));
 316 }
 317
 318 void
 319 yyerror (ACE_TCHAR const * s)
 320 {
 321   yyerror (-1, -1, s);
 322 }
 323
 324 // Note that SRC_REC represents left context, which is the STREAM *
 325 // record.
 326
 327 static ACE_Module_Type *
 328 ace_get_module (ACE_Service_Type const * sr,
 329                 ACE_TCHAR const * svc_name,
 330                 int & yyerrno)
 331 {
 332   ACE_Stream_Type const * const st =
 333     (sr == 0
 334      ? 0
 335      : dynamic_cast<ACE_Stream_Type const *> (sr->type ()));
 336   ACE_Module_Type const * const mt = (st == 0 ? 0 : st->find (svc_name));
 337
 338   if (sr == 0 || st == 0 || mt == 0)
 339     {
 340       ACE_ERROR ((LM_ERROR,
 341                   ACE_TEXT ("cannot locate Module_Type %s ")
 342                   ACE_TEXT ("in STREAM_Type %s\n"),
 343                   svc_name,
 344                   (sr ? sr->name () : ACE_TEXT ("(nil)"))));
 345       ++yyerrno;
 346     }
 347
 348   return const_cast<ACE_Module_Type *> (mt);
 349 }
 350
 351 #if defined (SVC_CONF_Y_DEBUGGING)
 352 // Main driver program.
 353
 354 int
 355 ACE_TMAIN (int argc, ACE_TCHAR *argv[])
 356 {
 357   ACE_Svc_Conf_Param param (0, stdin);
 358
 359   // Try to reopen any filename argument to use YYIN.
 360   if (argc > 1 && (yyin = freopen (argv[1], "r", stdin)) == 0)
 361     (void) ACE_OS::fprintf (stderr, ACE_TEXT ("usage: %s [file]\n"), argv[0]), ACE_OS::exit (1);
 362
 363   return ::yyparse (&param);
 364 }
 365 #endif /* SVC_CONF_Y_DEBUGGING */
 366
 367 ACE_END_VERSIONED_NAMESPACE_DECL
 368
 369 #endif  /* ACE_USES_CLASSIC_SVC_CONF == 1 */