?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove redundant void from tao_idl
[ACE_TAO.git] / TAO / TAO_IDL / be / be_visitor_ccm_pre_proc.cpp
blobb2ce62ec6a3a6da56b66e344aa15f08f79d2f550
1 /**
2 * @file be_visitor_ccm_pre_proc.cpp
3 *
4 * @author Jeff Parsons
5 */
6 //=============================================================================
7
8 #include "be_visitor_ccm_pre_proc.h"
9 #include "be_visitor_context.h"
10 #include "be_visitor_xplicit_pre_proc.h"
11 #include "be_root.h"
12 #include "be_operation.h"
13 #include "be_argument.h"
14 #include "be_exception.h"
15 #include "be_structure.h"
16 #include "be_sequence.h"
17 #include "be_valuetype.h"
18 #include "be_module.h"
19 #include "be_template_module.h"
20 #include "be_template_module_inst.h"
21 #include "be_field.h"
22 #include "be_typedef.h"
23 #include "be_connector.h"
24 #include "be_provides.h"
25 #include "be_uses.h"
26 #include "be_publishes.h"
27 #include "be_emits.h"
28 #include "be_consumes.h"
29 #include "be_extended_port.h"
30 #include "be_porttype.h"
31 #include "be_eventtype.h"
32 #include "be_eventtype_fwd.h"
33 #include "be_home.h"
34 #include "be_finder.h"
35 #include "be_extern.h"
36
37 #include "ast_generator.h"
38
39 #include "utl_exceptlist.h"
40 #include "utl_namelist.h"
41 #include "utl_err.h"
42
43 #include "fe_interface_header.h"
44 #include "global_extern.h"
45 #include "nr_extern.h"
46
47 const char *LW_EXCEP_NAMES[] =
48 {
49 "AlreadyConnected",
50 "InvalidConnection",
51 "NoConnection",
52 "ExceededConnectionLimit",
53 "CreateFailure",
54 "RemoveFailure",
55 "FinderFailure"
56 };
57
58 const char *ADDL_EXCEP_NAMES[] =
59 {
60 "InvalidKey",
61 "UnknownKeyValue",
62 "DuplicateKeyValue"
63 };
64
65 const int N_LW_EXCEPS =
66 sizeof (LW_EXCEP_NAMES) / sizeof (char *);
67 const int N_ADDL_EXCEPS =
68 sizeof (ADDL_EXCEP_NAMES) / sizeof (char *);
69
70 be_exception *LW_EXCEPS[N_LW_EXCEPS];
71 be_exception *ADDL_EXCEPS[N_ADDL_EXCEPS];
72
73 be_visitor_ccm_pre_proc::be_visitor_ccm_pre_proc (
74 be_visitor_context *ctx)
75 : be_visitor_component_scope (ctx),
76 module_id_ ("Components"),
77 cookie_ (0),
78 already_connected_ (0),
79 invalid_connection_ (0),
80 no_connection_ (0),
81 exceeded_connection_limit_ (0),
82 create_failure_ (0),
83 remove_failure_ (0),
84 finder_failure_ (0),
85 invalid_key_ (0),
86 unknown_key_value_ (0),
87 duplicate_key_value_ (0),
88 comp_ (0),
89 home_ (0),
90 ccm_lookups_done_ (false)
91 {
92 }
93
94 be_visitor_ccm_pre_proc::~be_visitor_ccm_pre_proc ()
95 {
96 this->module_id_.destroy ();
97 }
98
99 int
100 be_visitor_ccm_pre_proc::visit_root (be_root *node)
101 {
102 /// Do this before traversing the tree so the traversal
103 /// will pick up the implied uses nodes we add, if any.
104 /// No need to check for the -GM option here - what's
105 /// generated by this call depends only on the contents
106 /// of the ciao_ami_recep_names_ queue.
107 int const status = this->generate_ami4ccm_uses ();
108
109 if (status == -1)
110 {
111 ACE_ERROR_RETURN ((LM_ERROR,
112 ACE_TEXT ("be_visitor_ccm_pre_proc::")
113 ACE_TEXT ("visit_root - ")
114 ACE_TEXT ("generate_ami4ccm_uses() ")
115 ACE_TEXT ("failed\n")),
116 -1);
117 }
118
119 if (this->visit_scope (node) == -1)
120 {
121 ACE_ERROR_RETURN ((LM_ERROR,
122 ACE_TEXT ("be_visitor_ccm_pre_proc::")
123 ACE_TEXT ("visit_root - ")
124 ACE_TEXT ("visit scope failed\n")),
125 -1);
126 }
127
128 return 0;
129 }
130
131 int
132 be_visitor_ccm_pre_proc::visit_module (be_module *node)
133 {
134 if (this->visit_scope (node) == -1)
135 {
136 ACE_ERROR_RETURN ((LM_ERROR,
137 ACE_TEXT ("be_visitor_ccm_pre_proc::")
138 ACE_TEXT ("visit_module - ")
139 ACE_TEXT ("visit scope failed\n")),
140 -1);
141 }
142
143 return 0;
144 }
145
146 int
147 be_visitor_ccm_pre_proc::visit_component (be_component *node)
148 {
149 /// Waiting to do this until a component is seen will ensure
150 /// that Components.idl is present and the lookups will
151 /// succeed. The flag ensures that the lookup is done only
152 /// once.
153 if (!this->ccm_lookups_done_)
154 {
155 if (this->lookup_cookie () == -1)
156 {
157 ACE_ERROR_RETURN ((LM_ERROR,
158 ACE_TEXT ("be_visitor_ccm_pre_proc::")
159 ACE_TEXT ("visit_root - ")
160 ACE_TEXT ("Components::Cookie ")
161 ACE_TEXT ("lookup failed\n")),
162 -1);
163 }
164
165 if (this->lookup_exceptions () == -1)
166 {
167 ACE_ERROR_RETURN ((LM_ERROR,
168 ACE_TEXT ("be_visitor_ccm_pre_proc::")
169 ACE_TEXT ("visit_root - ")
170 ACE_TEXT ("component exception ")
171 ACE_TEXT ("lookups failed\n")),
172 -1);
173 }
174
175 this->ccm_lookups_done_ = true;
176 }
177
178 // Set working node for all port code generation.
179 this->comp_ = node;
180
181 if (this->visit_scope (node) == -1)
182 {
183 ACE_ERROR_RETURN ((LM_ERROR,
184 ACE_TEXT ("be_visitor_ccm_pre_proc::")
185 ACE_TEXT ("visit_component - ")
186 ACE_TEXT ("code generation for ")
187 ACE_TEXT ("scope3 failed\n")),
188 -1);
189 }
190
191 return 0;
192 }
193
194 int
195 be_visitor_ccm_pre_proc::visit_connector (be_connector *node)
196 {
197 return this->visit_component (node);
198 }
199
200 int
201 be_visitor_ccm_pre_proc::visit_provides (be_provides *node)
202 {
203 if (node->provides_type ()->is_local ())
204 {
205 return 0;
206 }
207
208 if (!be_global->gen_lwccm ())
209 {
210 // If this facet comes from a porttype, the instantiated
211 // port/mirrorport name is prefixed to the facet name.
212 ACE_CString prefix ("provide_");
213 prefix += this->ctx_->port_prefix ();
214
215 AST_Operation *provides_op = 0;
216 UTL_ScopedName *op_name =
217 this->create_scoped_name (prefix.c_str (),
218 node->local_name ()->get_string (),
219 0,
220 comp_);
221 ACE_NEW_RETURN (provides_op,
222 be_operation (node->provides_type (),
223 AST_Operation::OP_noflags,
224 0,
225 0,
226 0),
227 -1);
228
229 provides_op->set_defined_in (comp_);
230 provides_op->set_imported (comp_->imported ());
231 provides_op->set_name (op_name);
232
233 if (0 == comp_->be_add_operation (provides_op))
234 {
235 ACE_ERROR_RETURN ((LM_ERROR,
236 ACE_TEXT ("be_visitor_ccm_pre_proc::")
237 ACE_TEXT ("visit_provides - ")
238 ACE_TEXT ("be_add_operation() failed\n")),
239 -1);
240 }
241 }
242
243 return 0;
244 }
245
246 int
247 be_visitor_ccm_pre_proc::visit_uses (be_uses *node)
248 {
249 if (node->uses_type ()->is_local ())
250 {
251 return 0;
252 }
253
254 if (!be_global->gen_lwccm ())
255 {
256 if (node->is_multiple ())
257 {
258 if (this->gen_connect_multiple (node) == -1)
259 {
260 ACE_ERROR_RETURN ((LM_ERROR,
261 ACE_TEXT ("be_visitor_ccm_pre_proc::")
262 ACE_TEXT ("visit_uses - ")
263 ACE_TEXT ("gen_connect_multiple failed\n")),
264 -1);
265 }
266
267 if (this->gen_disconnect_multiple (node) == -1)
268 {
269 ACE_ERROR_RETURN ((LM_ERROR,
270 ACE_TEXT ("be_visitor_ccm_pre_proc::")
271 ACE_TEXT ("visit_uses - ")
272 ACE_TEXT ("gen_disconnect_multiple failed\n")),
273 -1);
274 }
275
276 if (this->gen_get_connection_multiple (node) == -1)
277 {
278 ACE_ERROR_RETURN ((LM_ERROR,
279 ACE_TEXT ("be_visitor_ccm_pre_proc::")
280 ACE_TEXT ("visit_uses - ")
281 ACE_TEXT ("gen_get_connection_single failed\n")),
282 -1);
283 }
284 }
285 else
286 {
287 if (this->gen_connect_single (node) == -1)
288 {
289 ACE_ERROR_RETURN ((LM_ERROR,
290 ACE_TEXT ("be_visitor_ccm_pre_proc::")
291 ACE_TEXT ("visit_uses - ")
292 ACE_TEXT ("gen_connect_single failed\n")),
293 -1);
294 }
295
296 if (this->gen_disconnect_single (node) == -1)
297 {
298 ACE_ERROR_RETURN ((LM_ERROR,
299 ACE_TEXT ("be_visitor_ccm_pre_proc::")
300 ACE_TEXT ("visit_uses - ")
301 ACE_TEXT ("gen_disconnect_single failed\n")),
302 -1);
303 }
304
305 if (this->gen_get_connection_single (node) == -1)
306 {
307 ACE_ERROR_RETURN ((LM_ERROR,
308 ACE_TEXT ("be_visitor_ccm_pre_proc::")
309 ACE_TEXT ("visit_uses - ")
310 ACE_TEXT ("gen_get_connection_single failed\n")),
311 -1);
312 }
313 }
314 }
315
316 return 0;
317 }
318
319 int
320 be_visitor_ccm_pre_proc::visit_publishes (be_publishes *node)
321 {
322 if (!be_global->gen_noeventccm ())
323 {
324 if (this->gen_subscribe (node) == -1)
325 {
326 ACE_ERROR_RETURN ((LM_ERROR,
327 ACE_TEXT ("be_visitor_ccm_pre_proc::")
328 ACE_TEXT ("visit_publishes - ")
329 ACE_TEXT ("gen_subscribe failed\n")),
330 -1);
331 }
332
333 if (this->gen_unsubscribe (node) == -1)
334 {
335 ACE_ERROR_RETURN ((LM_ERROR,
336 ACE_TEXT ("be_visitor_ccm_pre_proc::")
337 ACE_TEXT ("visit_publishes - ")
338 ACE_TEXT ("gen_unsubscribe failed\n")),
339 -1);
340 }
341 }
342 return 0;
343 }
344
345 int
346 be_visitor_ccm_pre_proc::visit_emits (be_emits *node)
347 {
348 if (!be_global->gen_noeventccm ())
349 {
350 if (this->gen_emits_connect (node) == -1)
351 {
352 ACE_ERROR_RETURN ((LM_ERROR,
353 ACE_TEXT ("be_visitor_ccm_pre_proc::")
354 ACE_TEXT ("visit_emits - ")
355 ACE_TEXT ("gen_emits_connect failed\n")),
356 -1);
357 }
358
359 if (this->gen_emits_disconnect (node) == -1)
360 {
361 ACE_ERROR_RETURN ((LM_ERROR,
362 ACE_TEXT ("be_visitor_ccm_pre_proc::")
363 ACE_TEXT ("visit_emits - ")
364 ACE_TEXT ("gen_emits_disconnect failed\n")),
365 -1);
366 }
367 }
368 return 0;
369 }
370
371 int
372 be_visitor_ccm_pre_proc::visit_consumes (be_consumes *node)
373 {
374 if (!be_global->gen_noeventccm ())
375 {
376 if (this->gen_get_consumer (node) == -1)
377 {
378 ACE_ERROR_RETURN ((LM_ERROR,
379 ACE_TEXT ("be_visitor_ccm_pre_proc::")
380 ACE_TEXT ("visit_comsumes - ")
381 ACE_TEXT ("gen_get_consumer failed\n")),
382 -1);
383 }
384 }
385 return 0;
386 }
387
388 int
389 be_visitor_ccm_pre_proc::visit_home (be_home *node)
390 {
391 AST_Interface *xplicit = this->create_explicit (node);
392
393 if (xplicit == 0)
394 {
395 ACE_ERROR_RETURN ((LM_ERROR,
396 ACE_TEXT ("be_visitor_ccm_pre_proc::")
397 ACE_TEXT ("visit_home - code generation ")
398 ACE_TEXT ("for explicit interface failed\n")),
399 -1);
400 }
401
402 AST_Interface *implicit = this->create_implicit (node);
403
404 if (implicit == 0)
405 {
406 ACE_ERROR_RETURN ((LM_ERROR,
407 ACE_TEXT ("be_visitor_ccm_pre_proc::")
408 ACE_TEXT ("visit_home - code generation ")
409 ACE_TEXT ("for implicit interface failed\n")),
410 -1);
411 }
412
413 if (this->gen_implicit_ops (node, implicit) == -1)
414 {
415 ACE_ERROR_RETURN ((LM_ERROR,
416 ACE_TEXT ("be_visitor_ccm_pre_proc::")
417 ACE_TEXT ("visit_home - ")
418 ACE_TEXT ("code generation for primary key ")
419 ACE_TEXT ("operations failed\n")),
420 -1);
421 }
422
423 if (this->create_equivalent (node, xplicit, implicit) == 0)
424 {
425 ACE_ERROR_RETURN ((LM_ERROR,
426 ACE_TEXT ("be_visitor_ccm_pre_proc::")
427 ACE_TEXT ("visit_home - code generation ")
428 ACE_TEXT ("for equivalent interface failed\n")),
429 -1);
430 }
431
432 return 0;
433 }
434
435 int
436 be_visitor_ccm_pre_proc::visit_eventtype (be_eventtype *node)
437 {
438 if (!be_global->gen_noeventccm ())
439 {
440 if (node->ccm_pre_proc_gen ())
441 {
442 return 0;
443 }
444
445 if (this->create_event_consumer (node) == -1)
446 {
447 ACE_ERROR_RETURN ((LM_ERROR,
448 ACE_TEXT ("be_visitor_ccm_pre_proc::")
449 ACE_TEXT ("visit_eventtype - code generation ")
450 ACE_TEXT ("for consumer failed\n")),
451 -1);
452 }
453
454 node->ccm_pre_proc_gen (true);
455 }
456 return 0;
457 }
458
459 int
460 be_visitor_ccm_pre_proc::visit_eventtype_fwd (be_eventtype_fwd *node)
461 {
462 be_eventtype *fd =
463 dynamic_cast<be_eventtype*> (node->full_definition ());
464
465 return this->visit_eventtype (fd);
466 }
467
468 int
469 be_visitor_ccm_pre_proc::gen_implicit_ops (be_home *node,
470 AST_Interface *implicit)
471 {
472 if (this->gen_create (node, implicit) == -1)
473 {
474 ACE_ERROR_RETURN ((LM_ERROR,
475 ACE_TEXT ("be_visitor_ccm_pre_proc::")
476 ACE_TEXT ("gen_implicit_ops - ")
477 ACE_TEXT ("gen_create failed\n")),
478 -1);
479 }
480
481 AST_Type *pk = node->primary_key ();
482
483 if (pk == 0)
484 {
485 return 0;
486 }
487
488 if (!be_global->gen_lwccm ())
489 {
490 if (this->gen_find_by_primary_key (node, implicit) == -1)
491 {
492 ACE_ERROR_RETURN ((LM_ERROR,
493 ACE_TEXT ("be_visitor_ccm_pre_proc::")
494 ACE_TEXT ("gen_implicit_ops - ")
495 ACE_TEXT ("gen_find_by_primary_key failed\n")),
496 -1);
497 }
498 }
499
500 if (this->gen_remove (node, implicit) == -1)
501 {
502 ACE_ERROR_RETURN ((LM_ERROR,
503 ACE_TEXT ("be_visitor_ccm_pre_proc::")
504 ACE_TEXT ("gen_implicit_ops - ")
505 ACE_TEXT ("gen_remove failed\n")),
506 -1);
507 }
508
509 if (!be_global->gen_lwccm ())
510 {
511 if (this->gen_get_primary_key (node, implicit) == -1)
512 {
513 ACE_ERROR_RETURN ((LM_ERROR,
514 ACE_TEXT ("be_visitor_ccm_pre_proc::")
515 ACE_TEXT ("gen_implicit_ops - ")
516 ACE_TEXT ("gen_get_primary_key failed\n")),
517 -1);
518 }
519 }
520
521 return 0;
522 }
523
524 // **************************************************************
525
526 int
527 be_visitor_ccm_pre_proc::gen_connect_single (be_uses *node)
528 {
529 // If this facet comes from a porttype, the instantiated
530 // port/mirrorport name is prefixed to the receptacle name.
531 ACE_CString prefix ("connect_");
532 prefix += this->ctx_->port_prefix ();
533
534 UTL_ScopedName *op_full_name =
535 this->create_scoped_name (prefix.c_str (),
536 node->local_name ()->get_string (),
537 0,
538 comp_);
539 be_operation *op = 0;
540 ACE_NEW_RETURN (op,
541 be_operation (be_global->void_type (),
542 AST_Operation::OP_noflags,
543 0,
544 0,
545 0),
546 -1);
547 op->set_defined_in (comp_);
548 op->set_imported (comp_->imported ());
549 op->set_name (op_full_name);
550 Identifier arg_id ("conxn");
551 UTL_ScopedName arg_name (&arg_id,
552 0);
553 be_argument *arg = 0;
554 ACE_NEW_RETURN (arg,
555 be_argument (AST_Argument::dir_IN,
556 node->uses_type (),
557 &arg_name),
558 -1);
559 arg_id.destroy ();
560 op->be_add_argument (arg);
561
562 UTL_ExceptList *tail = 0;
563 ACE_NEW_RETURN (tail,
564 UTL_ExceptList (this->invalid_connection_,
565 0),
566 -1);
567 UTL_ExceptList *connect_single = 0;
568 ACE_NEW_RETURN (connect_single,
569 UTL_ExceptList (this->already_connected_,
570 tail),
571 -1);
572 op->be_add_exceptions (connect_single);
573
574 if (0 == comp_->be_add_operation (op))
575 {
576 return -1;
577 }
578
579 return 0;
580 }
581
582 int
583 be_visitor_ccm_pre_proc::gen_disconnect_single (be_uses *node)
584 {
585 // If this facet comes from a porttype, the instantiated
586 // port/mirrorport name is prefixed to the receptacle name.
587 ACE_CString prefix ("disconnect_");
588 prefix += this->ctx_->port_prefix ();
589
590 UTL_ScopedName *op_full_name =
591 this->create_scoped_name (prefix.c_str (),
592 node->local_name ()->get_string (),
593 0,
594 comp_);
595 be_operation *op = 0;
596 ACE_NEW_RETURN (op,
597 be_operation (node->uses_type (),
598 AST_Operation::OP_noflags,
599 0,
600 0,
601 0),
602 -1);
603 op->set_name (op_full_name);
604 op->set_defined_in (comp_);
605 op->set_imported (comp_->imported ());
606 UTL_ExceptList *disconnect_single = 0;
607 ACE_NEW_RETURN (disconnect_single,
608 UTL_ExceptList (this->no_connection_,
609 0),
610 -1);
611 op->be_add_exceptions (disconnect_single);
612
613 if (0 == comp_->be_add_operation (op))
614 {
615 return -1;
616 }
617
618 return 0;
619 }
620
621 int
622 be_visitor_ccm_pre_proc::gen_get_connection_single (be_uses *node)
623 {
624 // If this facet comes from a porttype, the instantiated
625 // port/mirrorport name is prefixed to the receptacle name.
626 ACE_CString prefix ("get_connection_");
627 prefix += this->ctx_->port_prefix ();
628
629 UTL_ScopedName *op_full_name =
630 this->create_scoped_name (prefix.c_str (),
631 node->local_name ()->get_string (),
632 0,
633 comp_);
634 be_operation *op = 0;
635 ACE_NEW_RETURN (op,
636 be_operation (node->uses_type (),
637 AST_Operation::OP_noflags,
638 0,
639 0,
640 0),
641 -1);
642 op->set_name (op_full_name);
643 op->set_defined_in (comp_);
644 op->set_imported (comp_->imported ());
645
646 if (0 == comp_->be_add_operation (op))
647 {
648 return -1;
649 }
650
651 return 0;
652 }
653
654 int
655 be_visitor_ccm_pre_proc::gen_connect_multiple (be_uses *node)
656 {
657 // If this facet comes from a porttype, the instantiated
658 // port/mirrorport name is prefixed to the receptacle name.
659 ACE_CString prefix ("connect_");
660 prefix += this->ctx_->port_prefix ();
661
662 UTL_ScopedName *op_full_name =
663 this->create_scoped_name (prefix.c_str (),
664 node->local_name ()->get_string (),
665 0,
666 comp_);
667
668 be_operation *op = 0;
669 ACE_NEW_RETURN (op,
670 be_operation (this->cookie_,
671 AST_Operation::OP_noflags,
672 0,
673 0,
674 0),
675 -1);
676 op->set_name (op_full_name);
677 op->set_defined_in (comp_);
678 op->set_imported (comp_->imported ());
679 Identifier arg_id ("connection");
680 UTL_ScopedName arg_name (&arg_id,
681 0);
682 be_argument *arg = 0;
683 ACE_NEW_RETURN (arg,
684 be_argument (AST_Argument::dir_IN,
685 node->uses_type (),
686 &arg_name),
687 -1);
688 arg_id.destroy ();
689 op->be_add_argument (arg);
690 UTL_ExceptList *tail = 0;
691 ACE_NEW_RETURN (tail,
692 UTL_ExceptList (this->invalid_connection_,
693 0),
694 -1);
695 UTL_ExceptList *connect_multiple = 0;
696 ACE_NEW_RETURN (connect_multiple,
697 UTL_ExceptList (this->exceeded_connection_limit_,
698 tail),
699 -1);
700 op->be_add_exceptions (connect_multiple);
701
702 if (0 == comp_->be_add_operation (op))
703 {
704 return -1;
705 }
706
707 return 0;
708 }
709
710 int
711 be_visitor_ccm_pre_proc::gen_disconnect_multiple (be_uses *node)
712 {
713 // If this facet comes from a porttype, the instantiated
714 // port/mirrorport name is prefixed to the receptacle name.
715 ACE_CString prefix ("disconnect_");
716 prefix += this->ctx_->port_prefix ();
717
718 UTL_ScopedName *op_full_name =
719 this->create_scoped_name (prefix.c_str (),
720 node->local_name ()->get_string (),
721 0,
722 comp_);
723 be_operation *op = 0;
724 ACE_NEW_RETURN (op,
725 be_operation (node->uses_type (),
726 AST_Operation::OP_noflags,
727 0,
728 0,
729 0),
730 -1);
731 op->set_name (op_full_name);
732 op->set_defined_in (comp_);
733 op->set_imported (comp_->imported ());
734 Identifier arg_id ("ck");
735 UTL_ScopedName arg_name (&arg_id,
736 0);
737 be_argument *arg = 0;
738 ACE_NEW_RETURN (arg,
739 be_argument (AST_Argument::dir_IN,
740 this->cookie_,
741 &arg_name),
742 -1);
743 arg_id.destroy ();
744 op->be_add_argument (arg);
745 UTL_ExceptList *disconnect_multiple = 0;
746 ACE_NEW_RETURN (disconnect_multiple,
747 UTL_ExceptList (this->invalid_connection_,
748 0),
749 -1);
750 op->be_add_exceptions (disconnect_multiple);
751
752 if (0 == comp_->be_add_operation (op))
753 {
754 return -1;
755 }
756
757 return 0;
758 }
759
760 int
761 be_visitor_ccm_pre_proc::gen_get_connection_multiple (be_uses *node)
762 {
763 // If this facet comes from a porttype, the instantiated
764 // port/mirrorport name is prefixed to the receptacle name.
765 ACE_CString prefix ("get_connections_");
766 prefix += this->ctx_->port_prefix ();
767
768 UTL_ScopedName *op_full_name =
769 this->create_scoped_name (prefix.c_str (),
770 node->local_name ()->get_string (),
771 0,
772 comp_);
773
774 // Look up the implied IDL typedef created in the front end.
775 // It will be the return type of the created operation. The
776 // sequence was originally created with the port prefix (if
777 // any) in its name, so we must use it here.
778 ACE_CString connections_string (this->ctx_->port_prefix ());
779 connections_string += node->local_name ()->get_string ();
780 connections_string += "Connections";
781 Identifier connections_id (connections_string.c_str ());
782 UTL_ScopedName connections_name (&connections_id,
783 0);
784 AST_Decl *d = comp_->lookup_by_name (&connections_name,
785 true);
786 be_typedef *td = dynamic_cast<be_typedef*> (d);
787 connections_id.destroy ();
788
789 be_operation *op = 0;
790 ACE_NEW_RETURN (op,
791 be_operation (td,
792 AST_Operation::OP_noflags,
793 0,
794 0,
795 0),
796 -1);
797 op->set_name (op_full_name);
798 op->set_defined_in (comp_);
799 op->set_imported (comp_->imported ());
800
801 if (0 == comp_->be_add_operation (op))
802 {
803 return -1;
804 }
805
806 return 0;
807 }
808
809 int
810 be_visitor_ccm_pre_proc::gen_push_op (be_eventtype *node,
811 AST_Interface *consumer)
812 {
813 if (!be_global->gen_noeventccm ())
814 {
815 UTL_ScopedName *op_full_name =
816 this->create_scoped_name ("push_",
817 node->local_name (),
818 0,
819 consumer);
820 be_operation *push_op = 0;
821 ACE_NEW_RETURN (push_op,
822 be_operation (be_global->void_type (),
823 AST_Operation::OP_noflags,
824 0,
825 false,
826 false),
827 -1);
828 push_op->set_defined_in (consumer);
829 push_op->set_imported (node->imported ());
830 push_op->set_name (op_full_name);
831 ACE_CString arg_string ("the_",
832 0,
833 false);
834 arg_string += node->local_name ();
835 Identifier arg_id (arg_string.fast_rep ());
836 UTL_ScopedName arg_name (&arg_id,
837 0);
838 be_argument *arg = 0;
839 ACE_NEW_RETURN (arg,
840 be_argument (AST_Argument::dir_IN,
841 node,
842 &arg_name),
843 -1);
844 arg_id.destroy ();
845 push_op->be_add_argument (arg);
846
847 if (0 == consumer->be_add_operation (push_op))
848 {
849 return -1;
850 }
851 }
852 return 0;
853 }
854
855 int
856 be_visitor_ccm_pre_proc::gen_subscribe (be_publishes *node)
857 {
858 if ((be_global->gen_lwccm ()) ||(be_global->gen_noeventccm ()))
859 {
860 return 0;
861 }
862
863 UTL_ScopedName *op_name =
864 this->create_scoped_name ("subscribe_",
865 node->local_name ()->get_string (),
866 0,
867 comp_);
868 be_operation *op = 0;
869 ACE_NEW_RETURN (op,
870 be_operation (this->cookie_,
871 AST_Operation::OP_noflags,
872 0,
873 0,
874 0),
875 -1);
876 op->set_defined_in (comp_);
877 op->set_imported (comp_->imported ());
878 op->set_name (op_name);
879
880 AST_Interface *i = this->lookup_consumer (node);
881
882 if (i == 0)
883 {
884 op->destroy ();
885 delete op;
886 op = 0;
887
888 ACE_ERROR_RETURN ((LM_ERROR,
889 ACE_TEXT ("be_visitor_ccm_pre_proc::")
890 ACE_TEXT ("gen_subscribe - ")
891 ACE_TEXT ("consumer lookup failed\n")),
892 -1);
893 }
894
895 Identifier arg_id ("consumer");
896 UTL_ScopedName arg_name (&arg_id,
897 0);
898 be_argument *arg = 0;
899 ACE_NEW_RETURN (arg,
900 be_argument (AST_Argument::dir_IN,
901 i,
902 &arg_name),
903 -1);
904 op->be_add_argument (arg);
905 UTL_ExceptList *subscribe = 0;
906 ACE_NEW_RETURN (subscribe,
907 UTL_ExceptList (this->exceeded_connection_limit_,
908 0),
909 -1);
910 op->be_add_exceptions (subscribe);
911
912 if (0 == comp_->be_add_operation (op))
913 {
914 return -1;
915 }
916
917 return 0;
918 }
919
920 int
921 be_visitor_ccm_pre_proc::gen_unsubscribe (be_publishes *node)
922 {
923 if (be_global->gen_lwccm () ||be_global->gen_noeventccm ())
924 {
925 return 0;
926 }
927
928 AST_Interface *i = this->lookup_consumer (node);
929
930 if (i == 0)
931 {
932 ACE_ERROR_RETURN ((LM_ERROR,
933 ACE_TEXT ("be_visitor_ccm_pre_proc::")
934 ACE_TEXT ("gen_unsubscribe - ")
935 ACE_TEXT ("consumer lookup failed\n")),
936 -1);
937 }
938
939 UTL_ScopedName *op_name =
940 this->create_scoped_name ("unsubscribe_",
941 node->local_name ()->get_string (),
942 0,
943 comp_);
944 be_operation *op = 0;
945 ACE_NEW_RETURN (op,
946 be_operation (i,
947 AST_Operation::OP_noflags,
948 0,
949 0,
950 0),
951 -1);
952 op->set_defined_in (comp_);
953 op->set_imported (comp_->imported ());
954 op->set_name (op_name);
955 Identifier arg_id ("ck");
956 UTL_ScopedName arg_name (&arg_id,
957 0);
958 be_argument *arg = 0;
959 ACE_NEW_RETURN (arg,
960 be_argument (AST_Argument::dir_IN,
961 this->cookie_,
962 &arg_name),
963 -1);
964 op->be_add_argument (arg);
965 UTL_ExceptList *unsubscribe = 0;
966 ACE_NEW_RETURN (unsubscribe,
967 UTL_ExceptList (this->invalid_connection_,
968 0),
969 -1);
970 op->be_add_exceptions (unsubscribe);
971
972 if (0 == comp_->be_add_operation (op))
973 {
974 return -1;
975 }
976
977 return 0;
978 }
979
980 int
981 be_visitor_ccm_pre_proc::gen_emits_connect (be_emits *node)
982 {
983 if ((be_global->gen_lwccm ()) ||(be_global->gen_noeventccm ()))
984 {
985 return 0;
986 }
987
988 UTL_ScopedName *op_name =
989 this->create_scoped_name ("connect_",
990 node->local_name ()->get_string (),
991 0,
992 comp_);
993 be_operation *op = 0;
994 ACE_NEW_RETURN (op,
995 be_operation (be_global->void_type (),
996 AST_Operation::OP_noflags,
997 0,
998 0,
999 0),
1000 -1);
1001 op->set_name (op_name);
1002 op->set_defined_in (comp_);
1003 op->set_imported (comp_->imported ());
1004 AST_Interface *i = this->lookup_consumer (node);
1005
1006 if (i == 0)
1007 {
1008 op->destroy ();
1009 delete op;
1010 op = 0;
1011
1012 ACE_ERROR_RETURN ((LM_ERROR,
1013 ACE_TEXT ("be_visitor_ccm_pre_proc::")
1014 ACE_TEXT ("gen_emits_connect - ")
1015 ACE_TEXT ("consumer lookup failed\n")),
1016 -1);
1017 }
1018
1019 Identifier arg_id ("consumer");
1020 UTL_ScopedName arg_name (&arg_id,
1021 0);
1022 be_argument *arg = 0;
1023 ACE_NEW_RETURN (arg,
1024 be_argument (AST_Argument::dir_IN,
1025 i,
1026 &arg_name),
1027 -1);
1028 op->be_add_argument (arg);
1029 UTL_ExceptList *emits_connect = 0;
1030 ACE_NEW_RETURN (emits_connect,
1031 UTL_ExceptList (this->already_connected_,
1032 0),
1033 -1);
1034 op->be_add_exceptions (emits_connect);
1035
1036 if (0 == comp_->be_add_operation (op))
1037 {
1038 return -1;
1039 }
1040
1041 return 0;
1042 }
1043
1044 int
1045 be_visitor_ccm_pre_proc::gen_emits_disconnect (be_emits *node)
1046 {
1047 if ((be_global->gen_lwccm ()) ||(be_global->gen_noeventccm ()))
1048 {
1049 return 0;
1050 }
1051
1052 AST_Interface *i = this->lookup_consumer (node);
1053
1054 if (i == 0)
1055 {
1056 ACE_ERROR_RETURN ((LM_ERROR,
1057 ACE_TEXT ("be_visitor_ccm_pre_proc::")
1058 ACE_TEXT ("gen_emits_disconnect - ")
1059 ACE_TEXT ("consumer lookup failed\n")),
1060 -1);
1061 }
1062
1063 UTL_ScopedName *op_name =
1064 this->create_scoped_name ("disconnect_",
1065 node->local_name ()->get_string (),
1066 0,
1067 comp_);
1068 be_operation *op = 0;
1069 ACE_NEW_RETURN (op,
1070 be_operation (i,
1071 AST_Operation::OP_noflags,
1072 0,
1073 0,
1074 0),
1075 -1);
1076 op->set_name (op_name);
1077 op->set_defined_in (comp_);
1078 op->set_imported (comp_->imported ());
1079 UTL_ExceptList *emits_disconnect = 0;
1080 ACE_NEW_RETURN (emits_disconnect,
1081 UTL_ExceptList (this->no_connection_,
1082 0),
1083 -1);
1084 op->be_add_exceptions (emits_disconnect);
1085
1086 if (0 == comp_->be_add_operation (op))
1087 {
1088 return -1;
1089 }
1090
1091 return 0;
1092 }
1093
1094 int
1095 be_visitor_ccm_pre_proc::gen_get_consumer (be_consumes *node)
1096 {
1097 if (be_global->gen_lwccm () || be_global->gen_noeventccm ())
1098 {
1099 return 0;
1100 }
1101
1102 AST_Interface *i = this->lookup_consumer (node);
1103
1104 if (i == 0)
1105 {
1106 ACE_ERROR_RETURN ((LM_ERROR,
1107 ACE_TEXT ("be_visitor_ccm_pre_proc::")
1108 ACE_TEXT ("gen_get_consumer - ")
1109 ACE_TEXT ("consumer lookup failed\n")),
1110 -1);
1111 }
1112
1113 UTL_ScopedName *op_name =
1114 this->create_scoped_name ("get_consumer_",
1115 node->local_name ()->get_string (),
1116 0,
1117 comp_);
1118 be_operation *op = 0;
1119 ACE_NEW_RETURN (op,
1120 be_operation (i,
1121 AST_Operation::OP_noflags,
1122 0,
1123 0,
1124 0),
1125 -1);
1126 op->set_name (op_name);
1127 op->set_defined_in (comp_);
1128 op->set_imported (comp_->imported ());
1129
1130 if (0 == comp_->be_add_operation (op))
1131 {
1132 return -1;
1133 }
1134
1135 return 0;
1136 }
1137
1138 int
1139 be_visitor_ccm_pre_proc::gen_create (be_home *node,
1140 AST_Interface *implicit)
1141 {
1142 UTL_ScopedName *op_name = this->create_scoped_name (0,
1143 "create",
1144 0,
1145 implicit);
1146 be_operation *op = 0;
1147 ACE_NEW_RETURN (op,
1148 be_operation (node->managed_component (),
1149 AST_Operation::OP_noflags,
1150 0,
1151 0,
1152 0),
1153 -1);
1154 op->set_name (op_name);
1155 AST_Type *pk = node->primary_key ();
1156 UTL_ExceptList *exceps = 0;
1157 ACE_NEW_RETURN (exceps,
1158 UTL_ExceptList (this->create_failure_,
1159 0),
1160 -1);
1161
1162 if (pk != 0 && !be_global->gen_lwccm ())
1163 {
1164 Identifier arg_id ("key");
1165 UTL_ScopedName arg_name (&arg_id,
1166 0);
1167 AST_Argument *arg = 0;
1168 ACE_NEW_RETURN (arg,
1169 be_argument (AST_Argument::dir_IN,
1170 pk,
1171 &arg_name),
1172 -1);
1173 arg_id.destroy ();
1174 op->be_add_argument (arg);
1175
1176 UTL_ExceptList *tail = 0;
1177 ACE_NEW_RETURN (tail,
1178 UTL_ExceptList (this->invalid_key_,
1179 0),
1180 -1);
1181 UTL_ExceptList *middle = 0;
1182 ACE_NEW_RETURN (middle,
1183 UTL_ExceptList (this->duplicate_key_value_,
1184 tail),
1185 -1);
1186 exceps->nconc (middle);
1187 }
1188
1189 op->be_add_exceptions (exceps);
1190 op->set_defined_in (implicit);
1191 op->set_imported (node->imported ());
1192
1193 if (0 == implicit->be_add_operation (op))
1194 {
1195 return -1;
1196 }
1197
1198 return 0;
1199 }
1200
1201 int
1202 be_visitor_ccm_pre_proc::gen_find_by_primary_key (be_home *node,
1203 AST_Interface *implicit)
1204 {
1205 UTL_ScopedName *op_name = this->create_scoped_name (0,
1206 "find_by_primary_key",
1207 0,
1208 implicit);
1209 be_operation *op = 0;
1210 ACE_NEW_RETURN (op,
1211 be_operation (node->managed_component (),
1212 AST_Operation::OP_noflags,
1213 0,
1214 0,
1215 0),
1216 -1);
1217 op->set_name (op_name);
1218 AST_Type *pk = node->primary_key ();
1219 Identifier arg_id ("key");
1220 UTL_ScopedName arg_name (&arg_id,
1221 0);
1222 AST_Argument *arg = 0;
1223 ACE_NEW_RETURN (arg,
1224 be_argument (AST_Argument::dir_IN,
1225 pk,
1226 &arg_name),
1227 -1);
1228 arg_id.destroy ();
1229 op->be_add_argument (arg);
1230
1231 UTL_ExceptList *tail = 0;
1232 UTL_ExceptList *middle = 0;
1233
1234 if (!be_global->gen_lwccm ())
1235 {
1236 ACE_NEW_RETURN (tail,
1237 UTL_ExceptList (this->invalid_key_,
1238 0),
1239 -1);
1240 ACE_NEW_RETURN (middle,
1241 UTL_ExceptList (this->unknown_key_value_,
1242 tail),
1243 -1);
1244 }
1245
1246 UTL_ExceptList *exceps = 0;
1247 ACE_NEW_RETURN (exceps,
1248 UTL_ExceptList (this->finder_failure_,
1249 middle),
1250 -1);
1251 op->be_add_exceptions (exceps);
1252 op->set_defined_in (implicit);
1253 op->set_imported (node->imported ());
1254
1255 if (0 == implicit->be_add_operation (op))
1256 {
1257 return -1;
1258 }
1259
1260 return 0;
1261 }
1262
1263 int
1264 be_visitor_ccm_pre_proc::gen_remove (be_home *node,
1265 AST_Interface *implicit)
1266 {
1267 UTL_ScopedName *op_name = this->create_scoped_name (0,
1268 "remove",
1269 0,
1270 implicit);
1271 be_operation *op = 0;
1272 ACE_NEW_RETURN (op,
1273 be_operation (be_global->void_type (),
1274 AST_Operation::OP_noflags,
1275 0,
1276 0,
1277 0),
1278 -1);
1279 op->set_name (op_name);
1280 AST_Type *pk = node->primary_key ();
1281 Identifier arg_id ("key");
1282 UTL_ScopedName arg_name (&arg_id,
1283 0);
1284 AST_Argument *arg = 0;
1285 ACE_NEW_RETURN (arg,
1286 be_argument (AST_Argument::dir_IN,
1287 pk,
1288 &arg_name),
1289 -1);
1290 arg_id.destroy ();
1291 op->be_add_argument (arg);
1292
1293 UTL_ExceptList *tail = 0;
1294 UTL_ExceptList *middle = 0;
1295
1296 if (!be_global->gen_lwccm ())
1297 {
1298 ACE_NEW_RETURN (tail,
1299 UTL_ExceptList (this->invalid_key_,
1300 0),
1301 -1);
1302 ACE_NEW_RETURN (middle,
1303 UTL_ExceptList (this->unknown_key_value_,
1304 tail),
1305 -1);
1306 }
1307
1308 UTL_ExceptList *exceps = 0;
1309 ACE_NEW_RETURN (exceps,
1310 UTL_ExceptList (this->remove_failure_,
1311 middle),
1312 -1);
1313 op->be_add_exceptions (exceps);
1314 op->set_defined_in (implicit);
1315 op->set_imported (node->imported ());
1316
1317 if (0 == implicit->be_add_operation (op))
1318 {
1319 return -1;
1320 }
1321
1322 return 0;
1323 }
1324
1325 int
1326 be_visitor_ccm_pre_proc::gen_get_primary_key (be_home *node,
1327 AST_Interface *implicit)
1328 {
1329 UTL_ScopedName *op_name = this->create_scoped_name (0,
1330 "get_primary_key",
1331 0,
1332 implicit);
1333 be_operation *op = 0;
1334 ACE_NEW_RETURN (op,
1335 be_operation (node->primary_key (),
1336 AST_Operation::OP_noflags,
1337 0,
1338 0,
1339 0),
1340 -1);
1341 op->set_name (op_name);
1342 Identifier arg_id ("comp");
1343 UTL_ScopedName arg_name (&arg_id,
1344 0);
1345 AST_Argument *arg = 0;
1346 ACE_NEW_RETURN (arg,
1347 be_argument (AST_Argument::dir_IN,
1348 node->managed_component (),
1349 &arg_name),
1350 -1);
1351 arg_id.destroy ();
1352 op->be_add_argument (arg);
1353 op->set_defined_in (implicit);
1354 op->set_imported (node->imported ());
1355
1356 if (0 == implicit->be_add_operation (op))
1357 {
1358 return -1;
1359 }
1360
1361 return 0;
1362 }
1363
1364 int
1365 be_visitor_ccm_pre_proc::gen_extended_port (be_porttype *pt)
1366 {
1367 if (this->visit_scope (pt) == -1)
1368 {
1369 ACE_ERROR_RETURN ((LM_ERROR,
1370 ACE_TEXT ("be_visitor_ccm_pre_proc::")
1371 ACE_TEXT ("gen_extended_port - ")
1372 ACE_TEXT ("visit_scope for porttype failed\n")),
1373 -1);
1374 }
1375
1376 return 0;
1377 }
1378
1379 int
1380 be_visitor_ccm_pre_proc::lookup_cookie ()
1381 {
1382 if (this->cookie_ == 0)
1383 {
1384 Identifier local_id ("Cookie");
1385 UTL_ScopedName local_name (&local_id,
1386 0);
1387 UTL_ScopedName cookie_name (&this->module_id_,
1388 &local_name);
1389 AST_Decl *d =
1390 idl_global->root ()->lookup_by_name (&cookie_name,
1391 true);
1392 local_id.destroy ();
1393
1394 if (d == 0)
1395 {
1396 idl_global->err ()->lookup_error (&cookie_name);
1397 return -1;
1398 }
1399
1400 this->cookie_ = dynamic_cast<be_valuetype*> (d);
1401
1402 if (this->cookie_ == 0)
1403 {
1404 idl_global->err ()->valuetype_expected (d);
1405 return -1;
1406 }
1407 }
1408
1409 return 0;
1410 }
1411
1412 int
1413 be_visitor_ccm_pre_proc::lookup_exceptions ()
1414 {
1415 int status = 0;
1416
1417 for (int i = 0; i < N_LW_EXCEPS; ++i)
1418 {
1419 status = this->lookup_one_exception (LW_EXCEP_NAMES[i],
1420 LW_EXCEPS[i]);
1421
1422 if (status == -1)
1423 {
1424 return -1;
1425 }
1426 }
1427
1428 this->already_connected_ = LW_EXCEPS[0];
1429 this->invalid_connection_ = LW_EXCEPS[1];
1430 this->no_connection_ = LW_EXCEPS[2];
1431 this->exceeded_connection_limit_ = LW_EXCEPS[3];
1432 this->create_failure_ = LW_EXCEPS[4];
1433 this->remove_failure_ = LW_EXCEPS[5];
1434 this->finder_failure_ = LW_EXCEPS[6];
1435
1436 if (!be_global->gen_lwccm ())
1437 {
1438 for (int j = 0; j < N_ADDL_EXCEPS; ++j)
1439 {
1440 status = this->lookup_one_exception (ADDL_EXCEP_NAMES[j],
1441 ADDL_EXCEPS[j]);
1442
1443 if (status == -1)
1444 {
1445 return -1;
1446 }
1447 }
1448
1449 this->invalid_key_ = ADDL_EXCEPS[0];
1450 this->unknown_key_value_ = ADDL_EXCEPS[1];
1451 this->duplicate_key_value_ = ADDL_EXCEPS[2];
1452 }
1453
1454 return 0;
1455 }
1456
1457 int
1458 be_visitor_ccm_pre_proc::lookup_one_exception (const char *name,
1459 be_exception *&result)
1460 {
1461 Identifier id (name);
1462 UTL_ScopedName local_name (&id,
1463 0);
1464 UTL_ScopedName scoped_name (&this->module_id_,
1465 &local_name);
1466 AST_Decl *d =
1467 idl_global->root ()->lookup_by_name (&scoped_name,
1468 true);
1469 id.destroy ();
1470
1471 if (d == 0)
1472 {
1473 idl_global->err ()->lookup_error (&scoped_name);
1474 return -1;
1475 }
1476
1477 result = dynamic_cast<be_exception*> (d);
1478
1479 if (result == 0)
1480 {
1481 return -1;
1482 }
1483
1484 return 0;
1485 }
1486
1487 int
1488 be_visitor_ccm_pre_proc::create_event_consumer (be_eventtype *node)
1489 {
1490
1491 UTL_Scope *s = node->defined_in ();
1492
1493 UTL_ScopedName *consumer_name =
1494 this->create_scoped_name (0,
1495 node->local_name (),
1496 "Consumer",
1497 ScopeAsDecl (node->defined_in ()));
1498
1499 /// We need to create event consumers even for forward
1500 /// declared eventtypes. Since forward declarations can
1501 /// appear any number of times, we need to check that this
1502 /// event consumer hasn't already been created.
1503 if (s->lookup_by_name (consumer_name, true) != 0)
1504 {
1505 return 0;
1506 }
1507
1508 AST_Interface *event_consumer = 0;
1509 AST_Module *m = dynamic_cast<AST_Module*> (s);
1510
1511 // We're at global scope here so we need to fool the scope stack
1512 // for a minute so the correct repo id can be calculated at
1513 // interface construction time.
1514 idl_global->scopes ().push (s);
1515
1516 Identifier parent_id ("EventConsumerBase");
1517 UTL_ScopedName parent_local_name (&parent_id,
1518 0);
1519 UTL_ScopedName parent_full_name (&this->module_id_,
1520 &parent_local_name);
1521 UTL_NameList parent_list (&parent_full_name,
1522 0);
1523 FE_InterfaceHeader header (consumer_name,
1524 &parent_list,
1525 false,
1526 false,
1527 true);
1528 ACE_NEW_RETURN (event_consumer,
1529 be_interface (header.name (),
1530 header.inherits (),
1531 header.n_inherits (),
1532 header.inherits_flat (),
1533 header.n_inherits_flat (),
1534 false,
1535 false),
1536 -1);
1537 parent_id.destroy ();
1538
1539 // Back to reality.
1540 idl_global->scopes ().pop ();
1541
1542 event_consumer->set_defined_in (s);
1543 event_consumer->set_imported (node->imported ());
1544 event_consumer->set_name (consumer_name);
1545 be_interface *bec =
1546 dynamic_cast<be_interface*> (event_consumer);
1547 bec->original_interface (node);
1548
1549 // Set repo id to 0, so it will be recomputed on the next access,
1550 // and set the prefix to the eventtype's prefix. All this is
1551 // necessary in case the eventtype's prefix was modified after
1552 // its declaration. We assume 'implied IDL' means that the
1553 // derived event consumer interface should have the same prefix.
1554 event_consumer->repoID (0);
1555 event_consumer->prefix (const_cast<char*> (node->prefix ()));
1556
1557 dynamic_cast<be_type*> (event_consumer)->gen_fwd_helper_name ();
1558 m->be_add_interface (event_consumer);
1559 return this->gen_push_op (node,
1560 event_consumer);
1561 }
1562
1563 AST_Interface *
1564 be_visitor_ccm_pre_proc::lookup_consumer (be_field *node)
1565 {
1566 AST_Type *impl = node->field_type ();
1567 ACE_CString rettype_string (impl->local_name ()->get_string ());
1568 rettype_string += "Consumer";
1569 Identifier rettype_id (rettype_string.fast_rep ());
1570 AST_Decl *d =
1571 impl->defined_in ()->lookup_by_name_local (&rettype_id, false);
1572 rettype_id.destroy ();
1573
1574 if (d == 0)
1575 {
1576 return 0;
1577 }
1578
1579 AST_Interface *i = dynamic_cast<AST_Interface*> (d);
1580
1581 if (i == 0)
1582 {
1583 idl_global->err ()->interface_expected (d);
1584 return 0;
1585 }
1586
1587 return i;
1588 }
1589
1590 AST_Interface *
1591 be_visitor_ccm_pre_proc::create_explicit (be_home *node)
1592 {
1593 be_visitor_xplicit_pre_proc v (this->ctx_);
1594
1595 if (v.visit_home (node) != 0)
1596 {
1597 ACE_ERROR_RETURN ((LM_ERROR,
1598 ACE_TEXT ("be_visitor_ccm_pre_proc::")
1599 ACE_TEXT ("create_explicit - ")
1600 ACE_TEXT ("home xplicit visitor failed\n")),
1601 0);
1602 }
1603
1604 return v.xplicit ();
1605 }
1606
1607 AST_Interface *
1608 be_visitor_ccm_pre_proc::create_implicit (be_home *node)
1609 {
1610 Identifier *parent_id = 0;
1611 ACE_NEW_RETURN (parent_id,
1612 Identifier ("KeylessCCMHome"),
1613 0);
1614
1615 UTL_ScopedName *parent_local_name = 0;
1616 ACE_NEW_RETURN (parent_local_name,
1617 UTL_ScopedName (parent_id, 0),
1618 0);
1619
1620 UTL_ScopedName *parent_full_name = 0;
1621 ACE_NEW_RETURN (parent_full_name,
1622 UTL_ScopedName (this->module_id_.copy (),
1623 parent_local_name),
1624 0);
1625
1626 UTL_NameList parent_list (parent_full_name, 0);
1627
1628 UTL_NameList *parent_list_ptr = 0;
1629
1630 if (node->primary_key () == 0)
1631 {
1632 parent_list_ptr = &parent_list;
1633 }
1634
1635 FE_InterfaceHeader header (0,
1636 parent_list_ptr,
1637 false,
1638 false,
1639 true);
1640
1641 // We're at global scope here so we need to fool the scope stack
1642 // for a minute so the correct repo id can be calculated at
1643 // interface construction time.
1644 idl_global->scopes ().push (node->defined_in ());
1645
1646 UTL_ScopedName *implicit_name =
1647 this->create_scoped_name (0,
1648 node->local_name (),
1649 "Implicit",
1650 ScopeAsDecl (node->defined_in ()));
1651
1652 be_interface *i = 0;
1653 ACE_NEW_RETURN (i,
1654 be_interface (implicit_name,
1655 header.inherits (),
1656 header.n_inherits (),
1657 header.inherits_flat (),
1658 header.n_inherits_flat (),
1659 false,
1660 false),
1661 0);
1662
1663 // Back to reality.
1664 idl_global->scopes ().pop ();
1665
1666 header.destroy ();
1667 parent_list.destroy ();
1668
1669 // So we can generate the proper typecode.
1670 i->home_equiv (true);
1671
1672 i->set_name (implicit_name);
1673 i->set_defined_in (node->defined_in ());
1674 i->set_imported (node->imported ());
1675
1676 i->gen_fwd_helper_name ();
1677 i->original_interface (node);
1678 AST_Module *m = dynamic_cast<AST_Module*> (node->defined_in ());
1679 m->be_add_interface (i);
1680
1681 return i;
1682 }
1683
1684 AST_Interface *
1685 be_visitor_ccm_pre_proc::create_equivalent (be_home *node,
1686 AST_Interface *xplicit,
1687 AST_Interface *implicit)
1688 {
1689 UTL_Scope *s = node->defined_in ();
1690 UTL_ScopedName *equiv_name =
1691 this->create_scoped_name (0,
1692 node->local_name (),
1693 0,
1694 ScopeAsDecl (s));
1695 UTL_NameList tail (implicit->name (),
1696 0);
1697 UTL_NameList parent_list (xplicit->name (),
1698 &tail);
1699 FE_InterfaceHeader header (0,
1700 &parent_list,
1701 false,
1702 false,
1703 true);
1704
1705 // We're at global scope here so we need to fool the scope stack
1706 // for a minute so the correct repo id can be calculated at
1707 // interface construction time.
1708 idl_global->scopes ().push (node->defined_in ());
1709
1710 be_interface *retval = 0;
1711 ACE_NEW_RETURN (retval,
1712 be_interface (equiv_name,
1713 header.inherits (),
1714 header.n_inherits (),
1715 header.inherits_flat (),
1716 header.n_inherits_flat (),
1717 false,
1718 false),
1719 0);
1720
1721 // Back to reality.
1722 idl_global->scopes ().pop ();
1723
1724 // So we can generate the proper typecode.
1725 retval->home_equiv (true);
1726
1727 retval->set_name (equiv_name);
1728 retval->set_defined_in (s);
1729 retval->set_imported (node->imported ());
1730 retval->gen_fwd_helper_name ();
1731 retval->original_interface (node);
1732
1733 UTL_ScopedName *unmangled_name =
1734 static_cast<UTL_ScopedName *> (node->name ()->copy ());
1735 UTL_ScopedName *mangled_name =
1736 this->create_scoped_name (0,
1737 node->local_name (),
1738 "_tao_home_name_extension",
1739 ScopeAsDecl (s));
1740 node->set_name (mangled_name);
1741 AST_Module *m = dynamic_cast<AST_Module*> (s);
1742
1743 /// Calling be_add_interface() here calls add_to_referenced(),
1744 /// which will give a redef error.
1745 m->add_to_scope (retval);
1746
1747 node->set_name (unmangled_name);
1748 return retval;
1749 }
1750
1751 UTL_ScopedName *
1752 be_visitor_ccm_pre_proc::create_scoped_name (const char *prefix,
1753 const char *local_name,
1754 const char *suffix,
1755 AST_Decl *parent)
1756 {
1757 ACE_CString local_string (prefix,
1758 0,
1759 false);
1760 local_string += local_name;
1761 local_string += suffix;
1762 Identifier *local_id = 0;
1763 ACE_NEW_RETURN (local_id,
1764 Identifier (local_string.fast_rep ()),
1765 0);
1766 UTL_ScopedName *last_segment = 0;
1767 ACE_NEW_RETURN (last_segment,
1768 UTL_ScopedName (local_id,
1769 0),
1770 0);
1771 UTL_ScopedName *full_name =
1772 static_cast<UTL_ScopedName *> (parent->name ()->copy ());
1773 full_name->nconc (last_segment);
1774 return full_name;
1775 }
1776
1777 UTL_NameList *
1778 be_visitor_ccm_pre_proc::compute_inheritance (be_home *node)
1779 {
1780 UTL_NameList *retval = 0;
1781
1782 if (node->base_home () == 0)
1783 {
1784 Identifier *local_id = 0;
1785 ACE_NEW_RETURN (local_id,
1786 Identifier ("CCMHome"),
1787 0);
1788 UTL_ScopedName *local_name = 0;
1789 ACE_NEW_RETURN (local_name,
1790 UTL_ScopedName (local_id,
1791 0),
1792 0);
1793 UTL_ScopedName *full_name = 0;
1794 ACE_NEW_RETURN (full_name,
1795 UTL_ScopedName (this->module_id_.copy (),
1796 local_name),
1797 0);
1798 ACE_NEW_RETURN (retval,
1799 UTL_NameList (full_name,
1800 0),
1801 0);
1802
1803 }
1804 else
1805 {
1806 ACE_CString new_local (
1807 node->base_home ()->local_name ()->get_string ()
1808 );
1809 new_local += "Explicit";
1810 UTL_ScopedName *parent_name =
1811 static_cast<UTL_ScopedName *> (node->base_home ()->name ()->copy ());
1812 parent_name->last_component ()->replace_string (new_local.c_str ());
1813 ACE_NEW_RETURN (retval,
1814 UTL_NameList (parent_name,
1815 0),
1816 0);
1817 }
1818
1819 long n_supports = node->n_inherits ();
1820 UTL_ScopedName *supported_name = 0;
1821 UTL_NameList *conc_value = 0;
1822
1823 for (long i = 0; i < n_supports; ++i)
1824 {
1825 supported_name =
1826 static_cast<UTL_ScopedName *> (node->inherits ()[i]->name ()->copy ());
1827 ACE_NEW_RETURN (conc_value,
1828 UTL_NameList (supported_name,
1829 0),
1830 0);
1831 retval->nconc (conc_value);
1832 }
1833
1834 return retval;
1835 }
1836
1837 int
1838 be_visitor_ccm_pre_proc::generate_ami4ccm_uses ()
1839 {
1840 /// The interfaces in the list below are from this IDL file,
1841 /// which then must be processed with the -GC option, so we
1842 /// know we'll get here - a good place to generate the *A.idl
1843 /// file containing the local interfaces and connector
1844 /// associated with each interface in the list.
1845
1846 ACE_Unbounded_Queue<char *> &ccm_ami_receps =
1847 idl_global->ciao_ami_recep_names ();
1848
1849 /// If the queue is empty, we're done.
1850 if (ccm_ami_receps.size () == 0)
1851 {
1852 return 0;
1853 }
1854
1855 for (ACE_Unbounded_Queue<char *>::CONST_ITERATOR i (
1856 ccm_ami_receps);
1857 ! i.done ();
1858 i.advance ())
1859 {
1860 char **item = 0;
1861 i.next (item);
1862
1863 UTL_ScopedName *sn =
1864 FE_Utils::string_to_scoped_name (*item);
1865
1866 UTL_Scope *s =
1867 idl_global->scopes ().top_non_null ();
1868
1869 AST_Decl *d = s->lookup_by_name (sn, true);
1870
1871 if (d == 0)
1872 {
1873 idl_global->err ()->lookup_error (sn);
1874
1875 sn->destroy ();
1876 delete sn;
1877 sn = 0;
1878
1879 continue;
1880 }
1881
1882 sn->destroy ();
1883 delete sn;
1884 sn = 0;
1885
1886 be_uses *u = dynamic_cast<be_uses*> (d);
1887
1888 if (u == 0)
1889 {
1890 ACE_ERROR_RETURN ((LM_ERROR,
1891 ACE_TEXT ("be_visitor_ccm_pre_proc")
1892 ACE_TEXT ("::generate_ami4ccm_uses - ")
1893 ACE_TEXT ("narrow to receptacle ")
1894 ACE_TEXT ("failed\n")),
1895 -1);
1896 }
1897
1898 be_interface *iface =
1899 dynamic_cast<be_interface*> (u->uses_type ());
1900
1901 /// The real AMI_xxx exists only in the *A.idl file, so
1902 /// we create a dummy as the uses type for the implied
1903 /// receptacle created below, but only if it hasn't
1904 /// already been created for this uses type.
1905
1906 be_interface *ami_iface =
1907 dynamic_cast<be_interface*> (iface->ami4ccm_uses ());
1908
1909 if (ami_iface == 0)
1910 {
1911 ACE_CString iname ("AMI4CCM_");
1912
1913 iname += iface->local_name ();
1914 Identifier itmp_id (iname.c_str ());
1915 UTL_ScopedName itmp_sn (&itmp_id, 0);
1916
1917 s = iface->defined_in ();
1918 idl_global->scopes ().push (s);
1919 ACE_NEW_RETURN (ami_iface,
1920 be_interface (&itmp_sn,
1921 0,
1922 0,
1923 0,
1924 0,
1925 true,
1926 false),
1927 -1);
1928
1929 idl_global->scopes ().pop ();
1930
1931 /// Make it imported so it doesn't trigger
1932 /// any unwanted code generation.
1933 ami_iface->set_imported (true);
1934
1935 s->add_to_scope (ami_iface);
1936 iface->ami4ccm_uses (ami_iface);
1937 }
1938
1939 /// Now create the receptacle, passing in
1940 /// the local interface created above as the
1941 /// uses type. We don't generate anything
1942 /// in the main IDL file from the interface's
1943 /// contents, so it's ok that it's empty.
1944
1945 ACE_CString uname ("sendc_");
1946 uname += u->local_name ()->get_string ();
1947 Identifier utmp_id (uname.c_str ());
1948 UTL_ScopedName utmp_sn (&utmp_id, 0);
1949
1950 s = u->defined_in ();
1951 idl_global->scopes ().push (s);
1952 be_uses *ami_uses = 0;
1953 ACE_NEW_RETURN (ami_uses,
1954 be_uses (&utmp_sn,
1955 ami_iface,
1956 u->is_multiple ()),
1957 -1);
1958
1959 s->add_to_scope (ami_uses);
1960 idl_global->scopes ().pop ();
1961
1962 if (u->is_multiple ())
1963 {
1964 /*
1965 AST_Type *t = u->uses_type ();
1966 ACE_CString fname (t->file_name ());
1967 char *dummy = 0;
1968 char *path = ACE_OS::realpath (fname.c_str (), dummy);
1969 ACE_DEBUG ((LM_DEBUG, "utype file: %s\n", path));
1970 */
1971 // Grammar ensures this narrowing will never be 0.
1972 AST_Component *c =
1973 dynamic_cast<AST_Component*> (s);
1974 FE_Utils::create_uses_multiple_stuff (c, ami_uses);
1975 }
1976 }
1977
1978 return 0;
1979 }
1980