ridl 2.2.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,7 @@
1
+ ---
2
+ SHA1:
3
+ metadata.gz: fdf34fc099b40aa14fd02ec34323831225dce823
4
+ data.tar.gz: dd3dcb56caf4338fcf0ba487850d6db251590bc8
5
+ SHA512:
6
+ metadata.gz: 2779b950bf28dded230a3b4a89d127f4663c2b33632df056000a825c5ea17b902970a5e05bd4ec7971052bc2e658e91a41e7a746388a0dd19f4380aceb89bb45
7
+ data.tar.gz: e5f56246051d5083ee5f09e47f2a7841427bd6c471d038f503c12adc2712d6397625aae63e51874945b60dee15a5f3e34502bd1fde83f7a9aa599d703df87527
data/LICENSE ADDED
@@ -0,0 +1,49 @@
1
+ RIDL LICENSE
2
+
3
+ RIDL (Licensed Product) is protected by copyright, and is distributed
4
+ under the following terms.
5
+
6
+ RIDL (Ruby IDL compiler) is an open source tool, developed by Remedy IT and
7
+ written in Ruby. It is designed to provide a flexible parser/compiler
8
+ frontend for OMG standard IDL.
9
+ RIDL provides a generic parser component for OMG IDL and a flexible framework
10
+ for plugging in (code) generation backends.
11
+
12
+ Since RIDL is open source and free of licensing fees, you are free to use,
13
+ modify, and distribute the source code, as long as you include this
14
+ copyright statement.
15
+
16
+ In particular, you can use RIDL to build proprietary software and are
17
+ under no obligation to redistribute any of your source code that is built
18
+ using RIDL. Note, however, that you may not do anything to the RIDL
19
+ code, such as copyrighting it yourself or claiming authorship of the RIDL
20
+ code, that will prevent RIDL from being distributed freely using an open
21
+ source development model.
22
+
23
+ Warranty
24
+
25
+ LICENSED PRODUCT IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING
26
+ THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
27
+ PURPOSE, NON-INFRINGEMENT, OR ARISING FROM A COURSE OF DEALING, USAGE OR
28
+ TRADE PRACTICE.
29
+
30
+ Support
31
+
32
+ LICENSED PRODUCT IS PROVIDED WITH NO SUPPORT AND WITHOUT ANY OBLIGATION ON
33
+ THE PART OF REMEDY IT OR ANY OF ITS SUBSIDIARIES OR AFFILIATES TO ASSIST IN
34
+ ITS USE, CORRECTION, MODIFICATION OR ENHANCEMENT.
35
+
36
+ Remedy IT provides support to users who have agreed on the terms of a support
37
+ contract.
38
+
39
+ Liability
40
+
41
+ REMEDY IT OR ANY OF ITS SUBSIDIARIES OR AFFILIATES SHALL HAVE NO LIABILITY
42
+ WITH RESPECT TO THE INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS
43
+ BY LICENSED PRODUCT OR ANY PART THEREOF.
44
+
45
+ IN NO EVENT WILL REMEDY IT OR ANY OF ITS SUBSIDIARIES OR AFFILIATES BE LIABLE
46
+ FOR ANY LOST REVENUE OR PROFITS OR OTHER SPECIAL, INDIRECT AND CONSEQUENTIAL
47
+ DAMAGES, EVEN IF REMEDY IT HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
48
+
49
+ RIDL is Copyright Remedy IT. Nijkerk, The Netherlands, 2006-2013.
@@ -0,0 +1,42 @@
1
+ = RIDL Compiler
2
+
3
+ home :: https://osportal.remedy.nl/projects/ridl
4
+
5
+ == Description
6
+
7
+ RIDL is a Ruby library implementing an OMG \IDL parser/compiler
8
+ frontend with support for pluggable (and stackable) backends.
9
+
10
+ == Synopsis
11
+
12
+ RIDL provides a framework for implementing compiler/generators for
13
+ OMG standard \IDL interface definitions.
14
+ The framework includes:
15
+
16
+ * a RACC based parser supplemented with a custom scanner/tokenizer
17
+ * a complete AST class hierarchy for representing parsed \IDL specifications
18
+ * a complete Type class hierarchy
19
+ * \IDL constants expression support
20
+ * a builtin \IDL preprocessor expression parser/evaluator
21
+ * a flexible framework for pluggable (and stackable) backends
22
+ * basic support for backend code <b>re</b>generation
23
+
24
+ RIDL is compliant with the latest OMG \IDL standard.
25
+
26
+ == Bugs
27
+
28
+ If you find a bug, please report it at the RIDL project's
29
+ {issues tracker}[https://osportal.remedy.nl/projects/ridl/issues].
30
+
31
+ == License
32
+
33
+ RIDL is Copyright (c) 2007-2013 Remedy IT Expertise BV, The Netherlands.
34
+
35
+ It is free software, and may be redistributed under the terms specified in
36
+ the LICENSE file.
37
+
38
+ == Warranty
39
+
40
+ This software is provided "as is" and without any express or implied
41
+ warranties, including, without limitation, the implied warranties of
42
+ merchantibility and fitness for a particular purpose.
@@ -0,0 +1,28 @@
1
+ /* This file contains OMG IDL from CORBA V2.3.1
2
+ * $Id$
3
+ */
4
+
5
+ #ifndef __BiDirPolicy_IDL
6
+ #define __BiDirPolicy_IDL
7
+
8
+ #include <orb.idl>
9
+
10
+ #pragma prefix "omg.org"
11
+
12
+ // Self contained module for Bi-directional GIOP policy
13
+
14
+ module BiDirPolicy {
15
+
16
+ typedef unsigned short BidirectionalPolicyValue;
17
+
18
+ const BidirectionalPolicyValue NORMAL = 0;
19
+ const BidirectionalPolicyValue BOTH = 1;
20
+
21
+ const CORBA::PolicyType BIDIRECTIONAL_POLICY_TYPE = 37;
22
+
23
+ interface BidirectionalPolicy : CORBA::Policy {
24
+ readonly attribute BidirectionalPolicyValue value;
25
+ };
26
+ };
27
+
28
+ #endif /* __BiDirPolicy_IDL */
@@ -0,0 +1,260 @@
1
+ // $Id$
2
+
3
+ #ifndef COS_NAMING_IDL
4
+ #define COS_NAMING_IDL
5
+
6
+ #pragma prefix "omg.org"
7
+
8
+ /**
9
+ * This module provides interface for using COS Naming Service.
10
+ */
11
+ module CosNaming
12
+ {
13
+ /// Define a typedef for String. Maybe at some point, <Istring> will
14
+ /// be different to support Internationalization.
15
+ typedef string Istring;
16
+
17
+ /*
18
+ * This is a 'simple' name.
19
+ *
20
+ * Both id and kind fields are used in resolving names.
21
+ */
22
+ struct NameComponent
23
+ {
24
+ /// This is the name that is used to identify object references.
25
+ Istring id;
26
+
27
+ /// Stores any additional info about the object reference.
28
+ Istring kind;
29
+ };
30
+
31
+ /// This is a compound name: <c1; c2; c3; cn> where c1 to cn-1 are
32
+ /// the names of the nested contexts, and cn is the name of the
33
+ /// object bound in cn-1.
34
+ typedef sequence <NameComponent> Name;
35
+
36
+ enum BindingType
37
+ {
38
+ /// object binding.
39
+ nobject,
40
+
41
+ /// Naming context binding.
42
+ ncontext
43
+ };
44
+
45
+ struct Binding
46
+ {
47
+ /// Simple name, under which an object is bound in a given context.
48
+ Name binding_name;
49
+
50
+ /// Indicates whether the binding_name identifies a context, and, therefore, can
51
+ /// participate in name resolution.
52
+ BindingType binding_type;
53
+ };
54
+
55
+ typedef sequence <Binding> BindingList;
56
+
57
+ // Forward declaration.
58
+ interface BindingIterator;
59
+
60
+ /// Interface for managing name bindings and naming contexts.
61
+ interface NamingContext
62
+ {
63
+ // = Exceptions.
64
+
65
+ enum NotFoundReason
66
+ {
67
+ missing_node,
68
+ not_context,
69
+ not_object
70
+ };
71
+
72
+ /// Indicates that the name does not identify a binding.
73
+ exception NotFound
74
+ {
75
+
76
+ NotFoundReason why;
77
+ Name rest_of_name;
78
+ };
79
+
80
+ /// Implementation may throw this exception if some reason it cannot
81
+ /// complete the operation. This is currently not used in TAO.
82
+ exception CannotProceed
83
+ {
84
+
85
+ NamingContext cxt;
86
+ Name rest_of_name;
87
+ };
88
+
89
+ /// A name of length 0 is invalid. Implementations may place
90
+ /// further restrictions.
91
+ exception InvalidName
92
+ {
93
+ };
94
+
95
+ /// Indicates that the specified name is already bound to
96
+ /// some object. Only one object can be bound to a
97
+ /// particular name in an context. To change the binding,
98
+ /// <rebind> and <rebind_context> can be used.
99
+ exception AlreadyBound
100
+ {
101
+ };
102
+
103
+ /// Indicates that the context is not empty.
104
+ exception NotEmpty
105
+ {
106
+ };
107
+
108
+ // = Binding operations.
109
+
110
+ /// Create a binding for name <n> and object <obj> in the naming
111
+ /// context. Compound names are treated as follows: ctx->bind
112
+ /// (<c1; c2; c3; cn>, obj) = (ctx->resolve (<c1; c2;
113
+ /// cn-1>))->bind (<cn>, obj) if the there already exists a
114
+ /// binding for the specified name, <AlreadyBound> exception is
115
+ /// thrown. Naming contexts should be bound using <bind_context>
116
+ /// and <rebind_context> in order to participate in name
117
+ /// resolution later.
118
+ void bind (in Name n, in Object obj)
119
+ raises (NotFound, CannotProceed, InvalidName, AlreadyBound);
120
+
121
+ /// This is similar to <bind> operation above, except for when
122
+ /// the binding for the specified name already exists in the
123
+ /// specified context. In that case, the existing binding is
124
+ /// replaced with the new one.
125
+ void rebind (in Name n, in Object obj)
126
+ raises (NotFound, CannotProceed, InvalidName);
127
+
128
+ /// This is the version of <bind> specifically for binding naming
129
+ /// contexts, so that they will participate in name resolution
130
+ /// when compound names are passed to be resolved.
131
+ void bind_context (in Name n, in NamingContext nc)
132
+ raises(NotFound, CannotProceed, InvalidName, AlreadyBound);
133
+
134
+ /// This is a version of <rebind> specifically for naming
135
+ /// contexts, so that they can participate in name resolution
136
+ /// when compound names are passed.
137
+ void rebind_context (in Name n, in NamingContext nc)
138
+ raises (NotFound, CannotProceed, InvalidName);
139
+
140
+ // = Resolving names.
141
+
142
+ /// Return object reference that is bound to the name. Compound
143
+ /// name resolve is defined as follows: ctx->resolve (<c1; c2;
144
+ /// cn>) = ctx->resolve (<c1; c2 cn-1>)->resolve (<cn>) The
145
+ /// naming service does not return the type of the object.
146
+ /// Clients are responsible for "narrowing" the object to the
147
+ /// appropriate type.
148
+ Object resolve (in Name n)
149
+ raises (NotFound, CannotProceed, InvalidName);
150
+
151
+ // = Unbinding names.
152
+
153
+ /// Remove the name binding from the context. When compound
154
+ /// names are used, unbind is defined as follows: ctx->unbind
155
+ /// (<c1; c2; cn>) = (ctx->resolve (<c1; c2; cn-1>))->unbind
156
+ /// (<cn>)
157
+ void unbind (in Name n)
158
+ raises (NotFound, CannotProceed, InvalidName);
159
+
160
+ // = Creating Naming Contexts.
161
+
162
+ /// This operation returns a new naming context implemented by
163
+ /// the same naming server in which the operation was invoked.
164
+ /// The context is not bound.
165
+ NamingContext new_context ();
166
+
167
+ /// This operation creates a new context and binds it to the name
168
+ /// supplied as an argument. The newly-created context is
169
+ /// implemented by the same server as the context in which it was
170
+ /// bound (the name argument excluding the last component).
171
+ NamingContext bind_new_context (in Name n)
172
+ raises (NotFound, AlreadyBound, CannotProceed, InvalidName);
173
+
174
+ // = Deleting contexts.
175
+
176
+ /// Delete the naming context. @note the user should <unbind>
177
+ /// any bindings in which the given context is bound to some
178
+ /// names before invoking <destroy> operation on it.
179
+ void destroy ()
180
+ raises (NotEmpty);
181
+
182
+
183
+ // = Listing the naming context.
184
+
185
+ /// Returns at most the requested number of bindings @a how_many
186
+ /// in @a bl. If the naming context contains additional bindings,
187
+ /// they are returned with a BindingIterator. In the naming
188
+ /// context does not contain any additional bindings @a bi
189
+ /// returned as null.
190
+ void list (in unsigned long how_many,
191
+ out BindingList bl,
192
+ out BindingIterator bi);
193
+ };
194
+
195
+ /// Interface for iterating over Bindings returned with the
196
+ /// <list> operation.
197
+ interface BindingIterator
198
+ {
199
+ /// This operation returns the next binding. If there are no
200
+ /// more bindings false is returned.
201
+ boolean next_one (out Binding b);
202
+
203
+ /// This operation returns at most the requested number of
204
+ /// bindings.
205
+ boolean next_n (in unsigned long how_many,
206
+ out BindingList bl);
207
+
208
+ /// This operation destroys the iterator.
209
+ void destroy ();
210
+ };
211
+
212
+ /// Interface for providing operations required to use URLs and
213
+ /// stringified names.
214
+ ///
215
+ /// Reference to: Document orbos/98-10-11 (Interoperable Naming Joint Revised Submission)
216
+ /// Joint Submission by BEA Systems, DSTC, IONA, and Inprise
217
+ interface NamingContextExt : NamingContext
218
+ {
219
+ /// Stringified form of a Name.
220
+ typedef string StringName;
221
+
222
+ /// URL address such as myhost.xyz.com.
223
+ typedef string Address;
224
+
225
+ /// Stringified form of a URL address componoent.
226
+ typedef string URLString;
227
+
228
+ /// This operation accepts a Name and returns a stringified
229
+ /// name. If the name is invalid, an InvalidName exception is
230
+ /// raised.
231
+ StringName to_string (in Name n)
232
+ raises (InvalidName);
233
+
234
+ /// This operation returns a Name. If the input stringified
235
+ /// name is syntactically malformed or violates an
236
+ /// implementation limit, an InvalidName exception is
237
+ /// raised.
238
+ Name to_name (in StringName sn)
239
+ raises (InvalidName);
240
+
241
+ /// Indicates that the URL address is invalid.
242
+ exception InvalidAddress {
243
+ };
244
+
245
+ /// It performs any escapes necessary on the stringified name
246
+ /// and returns a fully formed URL string. An exception is
247
+ /// raised if either the protocol or name parameters are invalid.
248
+ URLString to_url (in Address addr,
249
+ in StringName sn)
250
+ raises (InvalidAddress, InvalidName);
251
+
252
+ /// This is similar to @c resolve as in the
253
+ /// CosNaming::NamingContext interface, except that it accepts
254
+ /// a stringified name as an argument instead of a Name.
255
+ Object resolve_str (in StringName n)
256
+ raises (NotFound, CannotProceed, InvalidName);
257
+ };
258
+ };
259
+
260
+ #endif /* COS_NAMING_IDL */
@@ -0,0 +1,98 @@
1
+ // $Id$
2
+
3
+ #ifndef _IOP_IDL_
4
+ #define _IOP_IDL_
5
+
6
+ #include <orb.idl>
7
+
8
+ #pragma prefix "omg.org"
9
+
10
+ module IOP
11
+ {
12
+ local interface Codec
13
+ {
14
+ exception InvalidTypeForEncoding {};
15
+ exception FormatMismatch {};
16
+ exception TypeMismatch {};
17
+
18
+ CORBA::OctetSeq encode (in any data) raises (InvalidTypeForEncoding);
19
+ any decode (in CORBA::OctetSeq data) raises (FormatMismatch);
20
+ CORBA::OctetSeq encode_value (in any data) raises (InvalidTypeForEncoding);
21
+ any decode_value (in CORBA::OctetSeq data, in CORBA::TypeCode tc)
22
+ raises (FormatMismatch, TypeMismatch);
23
+ };
24
+
25
+ typedef short EncodingFormat;
26
+ const EncodingFormat ENCODING_CDR_ENCAPS = 0;
27
+
28
+ struct Encoding {
29
+ EncodingFormat format;
30
+ octet major_version;
31
+ octet minor_version;
32
+ };
33
+
34
+ local interface CodecFactory
35
+ {
36
+ exception UnknownEncoding {};
37
+
38
+ Codec create_codec (in Encoding enc) raises (UnknownEncoding);
39
+ };
40
+
41
+ typedef unsigned long ProfileId;
42
+ const ProfileId TAG_INTERNET_IOP = 0;
43
+ const ProfileId TAG_MULTIPLE_COMPONENTS = 1;
44
+
45
+ struct TaggedProfile {
46
+ ProfileId tag;
47
+ CORBA::OctetSeq profile_data;
48
+ };
49
+
50
+ typedef sequence <TaggedProfile> TaggedProfileSeq;
51
+
52
+ struct IOR {
53
+ string type_id;
54
+ TaggedProfileSeq profiles;
55
+ };
56
+
57
+ typedef unsigned long ComponentId;
58
+
59
+ const ComponentId TAG_ORB_TYPE = 0;
60
+ const ComponentId TAG_CODE_SETS= 1;
61
+ const ComponentId TAG_POLICIES= 2;
62
+ const ComponentId TAG_ALTERNATE_IIOP_ADDRESS = 3;
63
+ const ComponentId TAG_ASSOCIATION_OPTIONS = 13;
64
+ const ComponentId TAG_JAVA_CODEBASE = 25;
65
+ // ... others
66
+
67
+ struct TaggedComponent {
68
+ ComponentId tag;
69
+ CORBA::OctetSeq component_data;
70
+ };
71
+
72
+ typedef sequence <TaggedComponent> MultipleComponentProfile;
73
+ typedef sequence<TaggedComponent> TaggedComponentSeq;
74
+
75
+ typedef unsigned long ServiceId;
76
+
77
+ struct ServiceContext {
78
+ ServiceId context_id;
79
+ CORBA::OctetSeq context_data;
80
+ };
81
+ typedef sequence <ServiceContext> ServiceContextList;
82
+
83
+ const ServiceId TransactionService = 0;
84
+ const ServiceId CodeSets = 1;
85
+ const ServiceId ChainBypassCheck = 2;
86
+ const ServiceId ChainBypassInfo = 3;
87
+ const ServiceId LogicalThreadId = 4;
88
+ const ServiceId BI_DIR_IIOP = 5;
89
+ const ServiceId SendingContextRunTime = 6;
90
+ const ServiceId INVOCATION_POLICIES = 7;
91
+ const ServiceId FORWARDED_IDENTITY = 8;
92
+ const ServiceId UnknownExceptionInfo = 9;
93
+ const ServiceId ExceptionDetailMessage = 14;
94
+ const ServiceId SecurityAttributeService = 15;
95
+
96
+ }; // IOP module
97
+
98
+ #endif