1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
// ============================================================================
//
// = LIBRARY
// TAO IDL
//
// = FILENAME
// be_sequence.h
//
// = DESCRIPTION
// Extension of class AST_Sequence that provides additional means for C++
// mapping.
//
// = AUTHOR
// Copyright 1994-1995 by Sun Microsystems, Inc.
// and
// Aniruddha Gokhale
//
// ============================================================================
#if !defined (BE_SEQUENCE_H)
#define BE_SEQUENCE_H
/*
* BE_Sequence
*/
class be_typedef;
// A sequence in OMG IDL does not define a scoping construct just as a struct
// or union or an interface do. However, in the C++ mapping, a sequence becomes
// a class. If the base type of a sequence is another anonymous sequence, then
// the base type is defined in the scope of this sequence. Hence we define
// be_sequence to possess the additional characteristics of a scope
class be_sequence : public virtual AST_Sequence,
public virtual be_scope,
public virtual be_type
{
public:
enum MANAGED_TYPE
{
MNG_UNKNOWN ,
MNG_NONE,
MNG_STRING,
MNG_OBJREF
};
// =Operations
be_sequence (void);
// default constructor
be_sequence (AST_Expression *v, AST_Type *bt);
// constructor
virtual int create_name (be_typedef *node=0);
// create a name for ourselves. If we are typedefed, then we get the name of
// the typedef node, else we generate a name for ourselves
virtual int gen_client_header (void);
// Generates the client-side header information for the sequence
virtual int gen_client_stubs (void);
// Generates the client-side stubs for the sequence
virtual int gen_server_header (void);
// Generates the server-side header information for the sequence
virtual int gen_server_skeletons (void);
// Generates the server-side skeletons for the sequence
virtual int gen_client_inline (void);
// Generates the client-side inline for the sequence
virtual int gen_server_inline (void);
// Generates the server-side inlines for the sequence
virtual int gen_var_defn (void);
// generate the _var class definition
virtual int gen_var_impl (void);
// generate the implementation for the _var class
virtual int gen_out_defn (void);
// generate the _out class definition
virtual int gen_out_impl (void);
// generate the _out implementation
virtual int gen_managed_type_ch (void);
// generate code for managed types in header
virtual int gen_managed_type_ci (void);
// generate code for managed types in inlined file
virtual int gen_managed_type_cs (void);
// generate code for managed types in impl file
virtual int gen_typecode (void);
// generate the typecode
virtual int gen_encapsulation (void);
// encapsulation for parameters
virtual long tc_size (void);
// return typecode size
virtual long tc_encap_len (void);
// return length of encapsulation
virtual MANAGED_TYPE managed_type (void);
// return the managed type
virtual idl_bool unbounded (void) const;
// is this sequence bounded or not
// =Scope management functions
be_sequence *fe_add_sequence (be_sequence *);
virtual be_decl *decl (void);
// overridden method on the be_scope class
virtual int write_as_return (TAO_OutStream *stream,
be_type *type);
// write the mapping as a return value on the stream.
// Visiting
virtual int accept (be_visitor *visitor);
// Narrowing
DEF_NARROW_METHODS3 (be_sequence, AST_Sequence, be_scope, be_type);
DEF_NARROW_FROM_DECL (be_sequence);
protected:
virtual char *gen_name (void);
// helper to create_name
private:
idl_bool unbounded_;
// whether we are bounded or unbounded
MANAGED_TYPE mt_;
// our managed type
};
#endif
|
