?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Changes to attempt to silence bcc64x
[ACE_TAO.git] / TAO / TAO_IDL / be / be_visitor_ccm_pre_proc.cpp
blob014fd2f28ce09bc8305758c3b1cef583b1876e9a
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_ (nullptr),
78 already_connected_ (nullptr),
79 invalid_connection_ (nullptr),
80 no_connection_ (nullptr),
81 exceeded_connection_limit_ (nullptr),
82 create_failure_ (nullptr),
83 remove_failure_ (nullptr),
84 finder_failure_ (nullptr),
85 invalid_key_ (nullptr),
86 unknown_key_value_ (nullptr),
87 duplicate_key_value_ (nullptr),
88 comp_ (nullptr),
89 home_ (nullptr),
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 = nullptr;
216 UTL_ScopedName *op_name =
217 this->create_scoped_name (prefix.c_str (),
218 node->local_name ()->get_string (),
219 nullptr,
220 comp_);
221 ACE_NEW_RETURN (provides_op,
222 be_operation (node->provides_type (),
223 AST_Operation::OP_noflags,
224 nullptr,
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 (nullptr == 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 == nullptr)
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 == nullptr)
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) == nullptr)
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 == nullptr)
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 nullptr,
538 comp_);
539 be_operation *op = nullptr;
540 ACE_NEW_RETURN (op,
541 be_operation (be_global->void_type (),
542 AST_Operation::OP_noflags,
543 nullptr,
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 nullptr);
553 be_argument *arg = nullptr;
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 = nullptr;
563 ACE_NEW_RETURN (tail,
564 UTL_ExceptList (this->invalid_connection_,
565 nullptr),
566 -1);
567 UTL_ExceptList *connect_single = nullptr;
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 (nullptr == 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 nullptr,
594 comp_);
595 be_operation *op = nullptr;
596 ACE_NEW_RETURN (op,
597 be_operation (node->uses_type (),
598 AST_Operation::OP_noflags,
599 nullptr,
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 = nullptr;
607 ACE_NEW_RETURN (disconnect_single,
608 UTL_ExceptList (this->no_connection_,
609 nullptr),
610 -1);
611 op->be_add_exceptions (disconnect_single);
612
613 if (nullptr == 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 nullptr,
633 comp_);
634 be_operation *op = nullptr;
635 ACE_NEW_RETURN (op,
636 be_operation (node->uses_type (),
637 AST_Operation::OP_noflags,
638 nullptr,
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 (nullptr == 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 nullptr,
666 comp_);
667
668 be_operation *op = nullptr;
669 ACE_NEW_RETURN (op,
670 be_operation (this->cookie_,
671 AST_Operation::OP_noflags,
672 nullptr,
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 nullptr);
682 be_argument *arg = nullptr;
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 = nullptr;
691 ACE_NEW_RETURN (tail,
692 UTL_ExceptList (this->invalid_connection_,
693 nullptr),
694 -1);
695 UTL_ExceptList *connect_multiple = nullptr;
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 (nullptr == 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 nullptr,
722 comp_);
723 be_operation *op = nullptr;
724 ACE_NEW_RETURN (op,
725 be_operation (node->uses_type (),
726 AST_Operation::OP_noflags,
727 nullptr,
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 nullptr);
737 be_argument *arg = nullptr;
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 = nullptr;
746 ACE_NEW_RETURN (disconnect_multiple,
747 UTL_ExceptList (this->invalid_connection_,
748 nullptr),
749 -1);
750 op->be_add_exceptions (disconnect_multiple);
751
752 if (nullptr == 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 nullptr,
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 nullptr);
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 = nullptr;
790 ACE_NEW_RETURN (op,
791 be_operation (td,
792 AST_Operation::OP_noflags,
793 nullptr,
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 (nullptr == 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 nullptr,
819 consumer);
820 be_operation *push_op = nullptr;
821 ACE_NEW_RETURN (push_op,
822 be_operation (be_global->void_type (),
823 AST_Operation::OP_noflags,
824 nullptr,
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 nullptr,
833 false);
834 arg_string += node->local_name ();
835 Identifier arg_id (arg_string.fast_rep ());
836 UTL_ScopedName arg_name (&arg_id,
837 nullptr);
838 be_argument *arg = nullptr;
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 (nullptr == 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 nullptr,
867 comp_);
868 be_operation *op = nullptr;
869 ACE_NEW_RETURN (op,
870 be_operation (this->cookie_,
871 AST_Operation::OP_noflags,
872 nullptr,
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 == nullptr)
883 {
884 op->destroy ();
885 delete op;
886 op = nullptr;
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 nullptr);
898 be_argument *arg = nullptr;
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 = nullptr;
906 ACE_NEW_RETURN (subscribe,
907 UTL_ExceptList (this->exceeded_connection_limit_,
908 nullptr),
909 -1);
910 op->be_add_exceptions (subscribe);
911
912 if (nullptr == 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 == nullptr)
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 nullptr,
943 comp_);
944 be_operation *op = nullptr;
945 ACE_NEW_RETURN (op,
946 be_operation (i,
947 AST_Operation::OP_noflags,
948 nullptr,
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 nullptr);
958 be_argument *arg = nullptr;
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 = nullptr;
966 ACE_NEW_RETURN (unsubscribe,
967 UTL_ExceptList (this->invalid_connection_,
968 nullptr),
969 -1);
970 op->be_add_exceptions (unsubscribe);
971
972 if (nullptr == 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 nullptr,
992 comp_);
993 be_operation *op = nullptr;
994 ACE_NEW_RETURN (op,
995 be_operation (be_global->void_type (),
996 AST_Operation::OP_noflags,
997 nullptr,
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 == nullptr)
1007 {
1008 op->destroy ();
1009 delete op;
1010 op = nullptr;
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 nullptr);
1022 be_argument *arg = nullptr;
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 = nullptr;
1030 ACE_NEW_RETURN (emits_connect,
1031 UTL_ExceptList (this->already_connected_,
1032 nullptr),
1033 -1);
1034 op->be_add_exceptions (emits_connect);
1035
1036 if (nullptr == 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 == nullptr)
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 nullptr,
1067 comp_);
1068 be_operation *op = nullptr;
1069 ACE_NEW_RETURN (op,
1070 be_operation (i,
1071 AST_Operation::OP_noflags,
1072 nullptr,
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 = nullptr;
1080 ACE_NEW_RETURN (emits_disconnect,
1081 UTL_ExceptList (this->no_connection_,
1082 nullptr),
1083 -1);
1084 op->be_add_exceptions (emits_disconnect);
1085
1086 if (nullptr == 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 == nullptr)
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 nullptr,
1117 comp_);
1118 be_operation *op = nullptr;
1119 ACE_NEW_RETURN (op,
1120 be_operation (i,
1121 AST_Operation::OP_noflags,
1122 nullptr,
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 (nullptr == 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 (nullptr,
1143 "create",
1144 nullptr,
1145 implicit);
1146 be_operation *op = nullptr;
1147 ACE_NEW_RETURN (op,
1148 be_operation (node->managed_component (),
1149 AST_Operation::OP_noflags,
1150 nullptr,
1151 0,
1152 0),
1153 -1);
1154 op->set_name (op_name);
1155 AST_Type *pk = node->primary_key ();
1156 UTL_ExceptList *exceps = nullptr;
1157 ACE_NEW_RETURN (exceps,
1158 UTL_ExceptList (this->create_failure_,
1159 nullptr),
1160 -1);
1161
1162 if (pk != nullptr && !be_global->gen_lwccm ())
1163 {
1164 Identifier arg_id ("key");
1165 UTL_ScopedName arg_name (&arg_id,
1166 nullptr);
1167 AST_Argument *arg = nullptr;
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 = nullptr;
1177 ACE_NEW_RETURN (tail,
1178 UTL_ExceptList (this->invalid_key_,
1179 nullptr),
1180 -1);
1181 UTL_ExceptList *middle = nullptr;
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 (nullptr == 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 (nullptr,
1206 "find_by_primary_key",
1207 nullptr,
1208 implicit);
1209 be_operation *op = nullptr;
1210 ACE_NEW_RETURN (op,
1211 be_operation (node->managed_component (),
1212 AST_Operation::OP_noflags,
1213 nullptr,
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 nullptr);
1222 AST_Argument *arg = nullptr;
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 = nullptr;
1232 UTL_ExceptList *middle = nullptr;
1233
1234 if (!be_global->gen_lwccm ())
1235 {
1236 ACE_NEW_RETURN (tail,
1237 UTL_ExceptList (this->invalid_key_,
1238 nullptr),
1239 -1);
1240 ACE_NEW_RETURN (middle,
1241 UTL_ExceptList (this->unknown_key_value_,
1242 tail),
1243 -1);
1244 }
1245
1246 UTL_ExceptList *exceps = nullptr;
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 (nullptr == 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 (nullptr,
1268 "remove",
1269 nullptr,
1270 implicit);
1271 be_operation *op = nullptr;
1272 ACE_NEW_RETURN (op,
1273 be_operation (be_global->void_type (),
1274 AST_Operation::OP_noflags,
1275 nullptr,
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 nullptr);
1284 AST_Argument *arg = nullptr;
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 = nullptr;
1294 UTL_ExceptList *middle = nullptr;
1295
1296 if (!be_global->gen_lwccm ())
1297 {
1298 ACE_NEW_RETURN (tail,
1299 UTL_ExceptList (this->invalid_key_,
1300 nullptr),
1301 -1);
1302 ACE_NEW_RETURN (middle,
1303 UTL_ExceptList (this->unknown_key_value_,
1304 tail),
1305 -1);
1306 }
1307
1308 UTL_ExceptList *exceps = nullptr;
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 (nullptr == 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 (nullptr,
1330 "get_primary_key",
1331 nullptr,
1332 implicit);
1333 be_operation *op = nullptr;
1334 ACE_NEW_RETURN (op,
1335 be_operation (node->primary_key (),
1336 AST_Operation::OP_noflags,
1337 nullptr,
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 nullptr);
1345 AST_Argument *arg = nullptr;
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 (nullptr == 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_ == nullptr)
1383 {
1384 Identifier local_id ("Cookie");
1385 UTL_ScopedName local_name (&local_id,
1386 nullptr);
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 == nullptr)
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_ == nullptr)
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 nullptr);
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 == nullptr)
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 == nullptr)
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 UTL_Scope *s = node->defined_in ();
1491
1492 UTL_ScopedName *consumer_name =
1493 this->create_scoped_name (nullptr,
1494 node->local_name (),
1495 "Consumer",
1496 ScopeAsDecl (node->defined_in ()));
1497
1498 /// We need to create event consumers even for forward
1499 /// declared eventtypes. Since forward declarations can
1500 /// appear any number of times, we need to check that this
1501 /// event consumer hasn't already been created.
1502 if (s->lookup_by_name (consumer_name, true) != nullptr)
1503 {
1504 return 0;
1505 }
1506
1507 AST_Interface *event_consumer = nullptr;
1508 AST_Module *m = dynamic_cast<AST_Module*> (s);
1509
1510 // We're at global scope here so we need to fool the scope stack
1511 // for a minute so the correct repo id can be calculated at
1512 // interface construction time.
1513 idl_global->scopes ().push (s);
1514
1515 Identifier parent_id ("EventConsumerBase");
1516 UTL_ScopedName parent_local_name (&parent_id,
1517 nullptr);
1518 UTL_ScopedName parent_full_name (&this->module_id_,
1519 &parent_local_name);
1520 UTL_NameList parent_list (&parent_full_name,
1521 nullptr);
1522 FE_InterfaceHeader header (consumer_name,
1523 &parent_list,
1524 false,
1525 false,
1526 true);
1527 ACE_NEW_RETURN (event_consumer,
1528 be_interface (header.name (),
1529 header.inherits (),
1530 header.n_inherits (),
1531 header.inherits_flat (),
1532 header.n_inherits_flat (),
1533 false,
1534 false),
1535 -1);
1536 parent_id.destroy ();
1537
1538 // Back to reality.
1539 idl_global->scopes ().pop ();
1540
1541 event_consumer->set_defined_in (s);
1542 event_consumer->set_imported (node->imported ());
1543 event_consumer->set_name (consumer_name);
1544 be_interface *bec =
1545 dynamic_cast<be_interface*> (event_consumer);
1546 bec->original_interface (node);
1547
1548 // Set repo id to 0, so it will be recomputed on the next access,
1549 // and set the prefix to the eventtype's prefix. All this is
1550 // necessary in case the eventtype's prefix was modified after
1551 // its declaration. We assume 'implied IDL' means that the
1552 // derived event consumer interface should have the same prefix.
1553 event_consumer->repoID (nullptr);
1554 event_consumer->prefix (const_cast<char*> (node->prefix ()));
1555
1556 dynamic_cast<be_type*> (event_consumer)->gen_fwd_helper_name ();
1557 m->be_add_interface (event_consumer);
1558 return this->gen_push_op (node,
1559 event_consumer);
1560 }
1561
1562 AST_Interface *
1563 be_visitor_ccm_pre_proc::lookup_consumer (be_field *node)
1564 {
1565 AST_Type *impl = node->field_type ();
1566 ACE_CString rettype_string (impl->local_name ()->get_string ());
1567 rettype_string += "Consumer";
1568 Identifier rettype_id (rettype_string.fast_rep ());
1569 AST_Decl *d =
1570 impl->defined_in ()->lookup_by_name_local (&rettype_id, false);
1571 rettype_id.destroy ();
1572
1573 if (d == nullptr)
1574 {
1575 return nullptr;
1576 }
1577
1578 AST_Interface *i = dynamic_cast<AST_Interface*> (d);
1579
1580 if (i == nullptr)
1581 {
1582 idl_global->err ()->interface_expected (d);
1583 return nullptr;
1584 }
1585
1586 return i;
1587 }
1588
1589 AST_Interface *
1590 be_visitor_ccm_pre_proc::create_explicit (be_home *node)
1591 {
1592 be_visitor_xplicit_pre_proc v (this->ctx_);
1593
1594 if (v.visit_home (node) != 0)
1595 {
1596 ACE_ERROR_RETURN ((LM_ERROR,
1597 ACE_TEXT ("be_visitor_ccm_pre_proc::")
1598 ACE_TEXT ("create_explicit - ")
1599 ACE_TEXT ("home xplicit visitor failed\n")),
1600 0);
1601 }
1602
1603 return v.xplicit ();
1604 }
1605
1606 AST_Interface *
1607 be_visitor_ccm_pre_proc::create_implicit (be_home *node)
1608 {
1609 Identifier *parent_id = nullptr;
1610 ACE_NEW_RETURN (parent_id,
1611 Identifier ("KeylessCCMHome"),
1612 nullptr);
1613
1614 UTL_ScopedName *parent_local_name = nullptr;
1615 ACE_NEW_RETURN (parent_local_name,
1616 UTL_ScopedName (parent_id, nullptr),
1617 nullptr);
1618
1619 UTL_ScopedName *parent_full_name = nullptr;
1620 ACE_NEW_RETURN (parent_full_name,
1621 UTL_ScopedName (this->module_id_.copy (),
1622 parent_local_name),
1623 nullptr);
1624
1625 UTL_NameList parent_list (parent_full_name, nullptr);
1626
1627 UTL_NameList *parent_list_ptr = nullptr;
1628
1629 if (node->primary_key () == nullptr)
1630 {
1631 parent_list_ptr = &parent_list;
1632 }
1633
1634 FE_InterfaceHeader header (nullptr,
1635 parent_list_ptr,
1636 false,
1637 false,
1638 true);
1639
1640 // We're at global scope here so we need to fool the scope stack
1641 // for a minute so the correct repo id can be calculated at
1642 // interface construction time.
1643 idl_global->scopes ().push (node->defined_in ());
1644
1645 UTL_ScopedName *implicit_name =
1646 this->create_scoped_name (nullptr,
1647 node->local_name (),
1648 "Implicit",
1649 ScopeAsDecl (node->defined_in ()));
1650
1651 be_interface *i = nullptr;
1652 ACE_NEW_RETURN (i,
1653 be_interface (implicit_name,
1654 header.inherits (),
1655 header.n_inherits (),
1656 header.inherits_flat (),
1657 header.n_inherits_flat (),
1658 false,
1659 false),
1660 nullptr);
1661
1662 // Back to reality.
1663 idl_global->scopes ().pop ();
1664
1665 header.destroy ();
1666 parent_list.destroy ();
1667
1668 // So we can generate the proper typecode.
1669 i->home_equiv (true);
1670
1671 i->set_name (implicit_name);
1672 i->set_defined_in (node->defined_in ());
1673 i->set_imported (node->imported ());
1674
1675 i->gen_fwd_helper_name ();
1676 i->original_interface (node);
1677 AST_Module *m = dynamic_cast<AST_Module*> (node->defined_in ());
1678 m->be_add_interface (i);
1679
1680 return i;
1681 }
1682
1683 AST_Interface *
1684 be_visitor_ccm_pre_proc::create_equivalent (be_home *node,
1685 AST_Interface *xplicit,
1686 AST_Interface *implicit)
1687 {
1688 UTL_Scope *s = node->defined_in ();
1689 UTL_ScopedName *equiv_name =
1690 this->create_scoped_name (nullptr,
1691 node->local_name (),
1692 nullptr,
1693 ScopeAsDecl (s));
1694 UTL_NameList tail (implicit->name (),
1695 nullptr);
1696 UTL_NameList parent_list (xplicit->name (),
1697 &tail);
1698 FE_InterfaceHeader header (nullptr,
1699 &parent_list,
1700 false,
1701 false,
1702 true);
1703
1704 // We're at global scope here so we need to fool the scope stack
1705 // for a minute so the correct repo id can be calculated at
1706 // interface construction time.
1707 idl_global->scopes ().push (node->defined_in ());
1708
1709 be_interface *retval = nullptr;
1710 ACE_NEW_RETURN (retval,
1711 be_interface (equiv_name,
1712 header.inherits (),
1713 header.n_inherits (),
1714 header.inherits_flat (),
1715 header.n_inherits_flat (),
1716 false,
1717 false),
1718 nullptr);
1719
1720 // Back to reality.
1721 idl_global->scopes ().pop ();
1722
1723 // So we can generate the proper typecode.
1724 retval->home_equiv (true);
1725
1726 retval->set_name (equiv_name);
1727 retval->set_defined_in (s);
1728 retval->set_imported (node->imported ());
1729 retval->gen_fwd_helper_name ();
1730 retval->original_interface (node);
1731
1732 UTL_ScopedName *unmangled_name =
1733 static_cast<UTL_ScopedName *> (node->name ()->copy ());
1734 UTL_ScopedName *mangled_name =
1735 this->create_scoped_name (nullptr,
1736 node->local_name (),
1737 "_tao_home_name_extension",
1738 ScopeAsDecl (s));
1739 node->set_name (mangled_name);
1740 AST_Module *m = dynamic_cast<AST_Module*> (s);
1741
1742 /// Calling be_add_interface() here calls add_to_referenced(),
1743 /// which will give a redef error.
1744 m->add_to_scope (retval);
1745
1746 node->set_name (unmangled_name);
1747 return retval;
1748 }
1749
1750 UTL_ScopedName *
1751 be_visitor_ccm_pre_proc::create_scoped_name (const char *prefix,
1752 const char *local_name,
1753 const char *suffix,
1754 AST_Decl *parent)
1755 {
1756 ACE_CString local_string (prefix,
1757 nullptr,
1758 false);
1759 local_string += local_name;
1760 local_string += suffix;
1761 Identifier *local_id = nullptr;
1762 ACE_NEW_RETURN (local_id,
1763 Identifier (local_string.fast_rep ()),
1764 nullptr);
1765 UTL_ScopedName *last_segment = nullptr;
1766 ACE_NEW_RETURN (last_segment,
1767 UTL_ScopedName (local_id,
1768 nullptr),
1769 nullptr);
1770 UTL_ScopedName *full_name =
1771 static_cast<UTL_ScopedName *> (parent->name ()->copy ());
1772 full_name->nconc (last_segment);
1773 return full_name;
1774 }
1775
1776 UTL_NameList *
1777 be_visitor_ccm_pre_proc::compute_inheritance (be_home *node)
1778 {
1779 UTL_NameList *retval = nullptr;
1780
1781 if (node->base_home () == nullptr)
1782 {
1783 Identifier *local_id = nullptr;
1784 ACE_NEW_RETURN (local_id,
1785 Identifier ("CCMHome"),
1786 nullptr);
1787 UTL_ScopedName *local_name = nullptr;
1788 ACE_NEW_RETURN (local_name,
1789 UTL_ScopedName (local_id,
1790 nullptr),
1791 nullptr);
1792 UTL_ScopedName *full_name = nullptr;
1793 ACE_NEW_RETURN (full_name,
1794 UTL_ScopedName (this->module_id_.copy (),
1795 local_name),
1796 nullptr);
1797 ACE_NEW_RETURN (retval,
1798 UTL_NameList (full_name,
1799 nullptr),
1800 nullptr);
1801 }
1802 else
1803 {
1804 ACE_CString new_local (
1805 node->base_home ()->local_name ()->get_string ()
1806 );
1807 new_local += "Explicit";
1808 UTL_ScopedName *parent_name =
1809 static_cast<UTL_ScopedName *> (node->base_home ()->name ()->copy ());
1810 parent_name->last_component ()->replace_string (new_local.c_str ());
1811 ACE_NEW_RETURN (retval,
1812 UTL_NameList (parent_name,
1813 nullptr),
1814 nullptr);
1815 }
1816
1817 long n_supports = node->n_inherits ();
1818 UTL_ScopedName *supported_name = nullptr;
1819 UTL_NameList *conc_value = nullptr;
1820
1821 for (long i = 0; i < n_supports; ++i)
1822 {
1823 supported_name =
1824 static_cast<UTL_ScopedName *> (node->inherits ()[i]->name ()->copy ());
1825 ACE_NEW_RETURN (conc_value,
1826 UTL_NameList (supported_name,
1827 nullptr),
1828 nullptr);
1829 retval->nconc (conc_value);
1830 }
1831
1832 return retval;
1833 }
1834
1835 int
1836 be_visitor_ccm_pre_proc::generate_ami4ccm_uses ()
1837 {
1838 /// The interfaces in the list below are from this IDL file,
1839 /// which then must be processed with the -GC option, so we
1840 /// know we'll get here - a good place to generate the *A.idl
1841 /// file containing the local interfaces and connector
1842 /// associated with each interface in the list.
1843
1844 ACE_Unbounded_Queue<char *> &ccm_ami_receps =
1845 idl_global->ciao_ami_recep_names ();
1846
1847 /// If the queue is empty, we're done.
1848 if (ccm_ami_receps.size () == 0)
1849 {
1850 return 0;
1851 }
1852
1853 for (ACE_Unbounded_Queue<char *>::CONST_ITERATOR i (
1854 ccm_ami_receps);
1855 ! i.done ();
1856 i.advance ())
1857 {
1858 char **item = nullptr;
1859 i.next (item);
1860
1861 UTL_ScopedName *sn =
1862 FE_Utils::string_to_scoped_name (*item);
1863
1864 UTL_Scope *s =
1865 idl_global->scopes ().top_non_null ();
1866
1867 AST_Decl *d = s->lookup_by_name (sn, true);
1868
1869 if (d == nullptr)
1870 {
1871 idl_global->err ()->lookup_error (sn);
1872
1873 sn->destroy ();
1874 delete sn;
1875 sn = nullptr;
1876
1877 continue;
1878 }
1879
1880 sn->destroy ();
1881 delete sn;
1882 sn = nullptr;
1883
1884 be_uses *u = dynamic_cast<be_uses*> (d);
1885
1886 if (u == nullptr)
1887 {
1888 ACE_ERROR_RETURN ((LM_ERROR,
1889 ACE_TEXT ("be_visitor_ccm_pre_proc")
1890 ACE_TEXT ("::generate_ami4ccm_uses - ")
1891 ACE_TEXT ("narrow to receptacle ")
1892 ACE_TEXT ("failed\n")),
1893 -1);
1894 }
1895
1896 be_interface *iface =
1897 dynamic_cast<be_interface*> (u->uses_type ());
1898
1899 /// The real AMI_xxx exists only in the *A.idl file, so
1900 /// we create a dummy as the uses type for the implied
1901 /// receptacle created below, but only if it hasn't
1902 /// already been created for this uses type.
1903
1904 be_interface *ami_iface =
1905 dynamic_cast<be_interface*> (iface->ami4ccm_uses ());
1906
1907 if (ami_iface == nullptr)
1908 {
1909 ACE_CString iname ("AMI4CCM_");
1910
1911 iname += iface->local_name ();
1912 Identifier itmp_id (iname.c_str ());
1913 UTL_ScopedName itmp_sn (&itmp_id, nullptr);
1914
1915 s = iface->defined_in ();
1916 idl_global->scopes ().push (s);
1917 ACE_NEW_RETURN (ami_iface,
1918 be_interface (&itmp_sn,
1919 nullptr,
1920 0,
1921 nullptr,
1922 0,
1923 true,
1924 false),
1925 -1);
1926
1927 idl_global->scopes ().pop ();
1928
1929 /// Make it imported so it doesn't trigger
1930 /// any unwanted code generation.
1931 ami_iface->set_imported (true);
1932
1933 s->add_to_scope (ami_iface);
1934 iface->ami4ccm_uses (ami_iface);
1935 }
1936
1937 /// Now create the receptacle, passing in
1938 /// the local interface created above as the
1939 /// uses type. We don't generate anything
1940 /// in the main IDL file from the interface's
1941 /// contents, so it's ok that it's empty.
1942
1943 ACE_CString uname ("sendc_");
1944 uname += u->local_name ()->get_string ();
1945 Identifier utmp_id (uname.c_str ());
1946 UTL_ScopedName utmp_sn (&utmp_id, nullptr);
1947
1948 s = u->defined_in ();
1949 idl_global->scopes ().push (s);
1950 be_uses *ami_uses = nullptr;
1951 ACE_NEW_RETURN (ami_uses,
1952 be_uses (&utmp_sn,
1953 ami_iface,
1954 u->is_multiple ()),
1955 -1);
1956
1957 s->add_to_scope (ami_uses);
1958 idl_global->scopes ().pop ();
1959
1960 if (u->is_multiple ())
1961 {
1962 /*
1963 AST_Type *t = u->uses_type ();
1964 ACE_CString fname (t->file_name ());
1965 char *dummy = 0;
1966 char *path = ACE_OS::realpath (fname.c_str (), dummy);
1967 ACE_DEBUG ((LM_DEBUG, "utype file: %s\n", path));
1968 */
1969 // Grammar ensures this narrowing will never be 0.
1970 AST_Component *c =
1971 dynamic_cast<AST_Component*> (s);
1972 FE_Utils::create_uses_multiple_stuff (c, ami_uses);
1973 }
1974 }
1975
1976 return 0;
1977 }
1978