← Back to branch summary

~clint-fewbar/ubuntu/precise/erlang/merge-15b

« back to all changes in this revision

Viewing changes to lib/asn1/test/asn1_SUITE_data/ROSE.asn1

  • Committer: Bazaar Package Importer
  • Author(s): Clint Byrum
  • Date: 2011-05-05 15:48:43 UTC
  • mfrom: (3.5.13 sid)
  • Revision ID: james.westby@ubuntu.com-20110505154843-0om6ekzg6m7ugj27
Tags: 1:14.b.2-dfsg-3ubuntu1
* Merge from debian unstable.  Remaining changes:
  - Drop libwxgtk2.8-dev build dependency. Wx isn't in main, and not
    supposed to.
  - Drop erlang-wx binary.
  - Drop erlang-wx dependency from -megaco, -common-test, and -reltool, they
    do not really need wx. Also drop it from -debugger; the GUI needs wx,
    but it apparently has CLI bits as well, and is also needed by -megaco,
    so let's keep the package for now.
  - debian/patches/series: Do what I meant, and enable build-options.patch
    instead.
* Additional changes:
  - Drop erlang-wx from -et
* Dropped Changes:
  - patches/pcre-crash.patch: CVE-2008-2371: outer level option with
    alternatives caused crash. (Applied Upstream)
  - fix for ssl certificate verification in newSSL: 
    ssl_cacertfile_fix.patch (Applied Upstream)
  - debian/patches/series: Enable native.patch again, to get stripped beam
    files and reduce the package size again. (build-options is what
    actually accomplished this)
  - Remove build-options.patch on advice from upstream and because it caused
    odd build failures.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/asn1/test/asn1_SUITE_data/ROSE.asn1
 
1
ROSE DEFINITIONS IMPLICIT TAGS ::=
 
2
 
 
3
 
 
4
BEGIN
 
5
 
 
6
OPERATION ::= CLASS
 
7
{
 
8
    &ArgumentType OPTIONAL,
 
9
    &argumentTypeOptional BOOLEAN OPTIONAL,
 
10
    &returnResult BOOLEAN DEFAULT TRUE,
 
11
    &ResultType OPTIONAL,
 
12
    &resultTypeOptional BOOLEAN OPTIONAL,
 
13
    &Errors ERROR OPTIONAL,
 
14
    &Linked OPERATION OPTIONAL,
 
15
  &synchronous BOOLEAN DEFAULT FALSE,
 
16
  &idempotent  BOOLEAN  DEFAULT FALSE,
 
17
    &alwaysReturns BOOLEAN DEFAULT TRUE,
 
18
    &InvokePriority Priority OPTIONAL,
 
19
    &ResultPriority Priority OPTIONAL,
 
20
    &operationCode Code UNIQUE OPTIONAL
 
21
    }
 
22
WITH SYNTAX
 
23
 {
 
24
   [ARGUMENT &ArgumentType [OPTIONAL &argumentTypeOptional]]
 
25
   [RESULT &ResultType [OPTIONAL &resultTypeOptional]]
 
26
   [RETURN RESULT &returnResult]
 
27
   [ERRORS &Errors]
 
28
   [LINKED &Linked]
 
29
   [SYNCHRONOUS &synchronous]
 
30
   [IDEMPOTENT &idempotent]
 
31
   [ALWAYS RESPONDS &alwaysReturns]
 
32
   [INVOKE PRIORITY &InvokePriority]
 
33
   [RESULT-PRIORITY &ResultPriority]
 
34
   [CODE &operationCode]
 
35
 }
 
36
 
 
37
ERROR ::= CLASS
 
38
{
 
39
    &ParameterType OPTIONAL,
 
40
    &parameterTypeOptional BOOLEAN OPTIONAL,
 
41
    &ErrorPriority Priority OPTIONAL,
 
42
    &errorCode Code UNIQUE OPTIONAL
 
43
    }
 
44
WITH SYNTAX
 
45
{
 
46
    [PARAMETER &ParameterType [OPTIONAL &parameterTypeOptional]]
 
47
    [PRIORITY &ErrorPriority]
 
48
    [CODE &errorCode]
 
49
    }
 
50
 
 
51
OPERATION-PACKAGE ::= CLASS
 
52
{
 
53
    &Both OPERATION OPTIONAL,
 
54
    &Consumer OPERATION OPTIONAL,
 
55
    &Supplier OPERATION OPTIONAL,
 
56
    &id OBJECT IDENTIFIER UNIQUE OPTIONAL
 
57
    }
 
58
WITH SYNTAX
 
59
{
 
60
    [OPERATIONS &Both]
 
61
    [CONSUMER INVOKES &Supplier]
 
62
    [SUPPLIER INVOKES &Consumer]
 
63
    [ID &id]
 
64
    }
 
65
 
 
66
CONNECTION-PACKAGE ::= CLASS
 
67
{
 
68
    &bind OPERATION DEFAULT emptyBind,
 
69
    &unbind OPERATION DEFAULT emptyUnbind,
 
70
    &responderCanUnbind BOOLEAN DEFAULT FALSE,
 
71
    &unbindCanFail BOOLEAN DEFAULT FALSE,
 
72
    &id OBJECT IDENTIFIER UNIQUE OPTIONAL
 
73
    }
 
74
WITH SYNTAX
 
75
{
 
76
    [BIND &bind]
 
77
    [UNBIND &unbind]
 
78
    [RESPONDER UNBIND &responderCanUnbind]
 
79
    [FAILURE TO UNBIND &unbindCanFail]
 
80
    [ID &id]
 
81
    }
 
82
 
 
83
CONTRACT ::= CLASS
 
84
{
 
85
    &connection CONNECTION-PACKAGE OPTIONAL,
 
86
    &OperationsOf OPERATION-PACKAGE OPTIONAL,
 
87
    &InitiatorConsumerOf OPERATION-PACKAGE OPTIONAL,
 
88
    &InitiatorSupplierOf OPERATION-PACKAGE OPTIONAL,
 
89
    &id OBJECT IDENTIFIER UNIQUE OPTIONAL
 
90
    }
 
91
WITH SYNTAX
 
92
{
 
93
    [CONNECTION &connection]
 
94
    [OPERATIONS OF &OperationsOf]
 
95
    [INITIATOR CONSUMER OF &InitiatorConsumerOf]
 
96
    [RESPONDER CONSUMER OF &InitiatorSupplierOf]
 
97
    [ID &id]
 
98
}
 
99
 
 
100
ROS-OBJECT-CLASS ::= CLASS
 
101
{
 
102
    &Is ROS-OBJECT-CLASS OPTIONAL,
 
103
    &Initiates CONTRACT OPTIONAL,
 
104
    &Responds CONTRACT OPTIONAL,
 
105
    &InitiatesAndResponds CONTRACT OPTIONAL,
 
106
    &id OBJECT IDENTIFIER UNIQUE
 
107
    }
 
108
WITH SYNTAX
 
109
{
 
110
    [IS &Is]
 
111
    [BOTH &InitiatesAndResponds]
 
112
    [INITIATES &Initiates]
 
113
    [RESPONDS &Responds]
 
114
    ID &id
 
115
    }
 
116
 
 
117
Code ::= CHOICE
 
118
{
 
119
    local INTEGER,
 
120
    global OBJECT IDENTIFIER
 
121
    }
 
122
 
 
123
Priority ::= INTEGER (0..MAX)
 
124
 
 
125
ROS {InvokeId:InvokeIdSet,OPERATION:Invokable,OPERATION:Returnable} ::= CHOICE
 
126
 {
 
127
   invoke [1] Invoke {{InvokeIdSet}, {Invokable}},
 
128
   returnResult [2] ReturnResult {{Returnable}},
 
129
   returnError [3] ReturnError {{Errors{{Returnable}}}},
 
130
   reject [4] Reject
 
131
 }
 
132
(CONSTRAINED BY {-- must conform to the above definition --}
 
133
 ! RejectProblem : general-unrecognizedPDU)
 
134
 
 
135
Invoke {InvokeId:InvokeIdSet, OPERATION:Operations} ::= SEQUENCE
 
136
{
 
137
  invokeId InvokeId (InvokeIdSet)
 
138
  (CONSTRAINED BY {-- must be unambiguous --}
 
139
   ! RejectProblem : invoke-duplicateInvocation),
 
140
  linkedId CHOICE {
 
141
    present [0] IMPLICIT present < InvokeId,
 
142
    absent [1] IMPLICIT NULL
 
143
  }
 
144
    (CONSTRAINED BY {-- must identify an outstanding operation --}
 
145
    ! RejectProblem : invoke-unrecognizedLinkedId)
 
146
    (CONSTRAINED BY {-- which has one or more linked operations--}
 
147
    ! RejectProblem : invoke-linkedResponseUnexpected)
 
148
    OPTIONAL,
 
149
    opcode OPERATION.&operationCode
 
150
    ({Operations}
 
151
    ! RejectProblem : invoke-unrecognizedOperation),
 
152
    argument OPERATION.&ArgumentType
 
153
    ({Operations} {@opcode}
 
154
    ! RejectProblem : invoke-mistypedArgument)
 
155
    OPTIONAL
 
156
    }
 
157
(CONSTRAINED BY {-- must conform to the above definition --}
 
158
 ! RejectProblem : general-mistypedPDU)
 
159
(
 
160
WITH COMPONENTS
 
161
{...,
 
162
    linkedId ABSENT
 
163
    }
 
164
| WITH COMPONENTS
 
165
{...,
 
166
    linkedId PRESENT,
 
167
    opcode
 
168
    (CONSTRAINED BY {-- must be in the &Linked field of the associated operation --
 
169
        }
 
170
    ! RejectProblem : invoke-unexpectedLinkedOperation)
 
171
    }
 
172
)
 
173
 
 
174
ReturnResult {OPERATION:Operations}::= SEQUENCE
 
175
{
 
176
    invokeId InvokeId
 
177
    (CONSTRAINED BY {-- must be that for an outstanding operation --}
 
178
     ! RejectProblem:returnResult-unrecognizedInvocation)
 
179
  (CONSTRAINED BY {-- which returns a result --}
 
180
   ! RejectProblem:returnResult-resultResponseUnexpected),
 
181
  result SEQUENCE
 
182
   {
 
183
     opcode OPERATION.&operationCode
 
184
     ({Operations})(CONSTRAINED BY {-- identified by invokeId --}
 
185
                    ! RejectProblem:returnResult-unrecognizedInvocation),
 
186
     result OPERATION.&ResultType     ({Operations} {@.opcode}
 
187
        ! RejectProblem:returnResult-mistypedResult)
 
188
        }
 
189
    OPTIONAL
 
190
    }
 
191
(CONSTRAINED BY {-- must conform to the above definition --
 
192
    }
 
193
! RejectProblem:general-mistypedPDU)
 
194
 
 
195
ReturnError {ERROR:Errors} ::= SEQUENCE
 
196
{
 
197
    invokeId InvokeId
 
198
    (CONSTRAINED BY {-- must be that for an outstanding operation --
 
199
        }
 
200
    ! RejectProblem : returnError-unrecognizedInvocation)
 
201
    (CONSTRAINED BY {-- which returns an error --
 
202
        }
 
203
    ! RejectProblem : returnError-errorResponseUnexpected),
 
204
    errcode ERROR.&errorCode
 
205
    ({Errors}
 
206
    ! RejectProblem : returnError-unrecognizedError)
 
207
    (CONSTRAINED BY {-- must be in the &Errors field of the associated operation --
 
208
        }
 
209
    ! RejectProblem : returnError-unexpectedError),
 
210
    parameter ERROR.&ParameterType
 
211
    ({Errors}{@errcode}
 
212
    ! RejectProblem : returnError-mistypedParameter) OPTIONAL
 
213
    }
 
214
(CONSTRAINED BY {-- must conform to the above definition --
 
215
    }
 
216
! RejectProblem : general-mistypedPDU)
 
217
 
 
218
Reject ::= SEQUENCE
 
219
{
 
220
    invokeId InvokeId,
 
221
    problem CHOICE
 
222
    {
 
223
        general [0] GeneralProblem,
 
224
        invoke [1] InvokeProblem,
 
225
        returnResult [2] ReturnResultProblem,
 
226
        returnError [3] ReturnErrorProblem
 
227
        }
 
228
    }
 
229
(CONSTRAINED BY {-- must conform to the above definition --
 
230
    }
 
231
! RejectProblem : general-mistypedPDU)
 
232
 
 
233
GeneralProblem ::= INTEGER
 
234
{
 
235
    unrecognizedPDU (0),
 
236
    mistypedPDU (1),
 
237
    badlyStructuredPDU (2)
 
238
    }
 
239
 
 
240
InvokeProblem ::= INTEGER
 
241
{
 
242
    duplicateInvocation (0),
 
243
    unrecognizedOperation (1),
 
244
    mistypedArgument (2),
 
245
    resourceLimitation (3),
 
246
    releaseInProgress (4),
 
247
    unrecognizedLinkedId (5),
 
248
    linkedResponseUnexpected (6),
 
249
    unexpectedLinkedOperation (7)
 
250
    }
 
251
 
 
252
ReturnResultProblem ::= INTEGER
 
253
{
 
254
    unrecognizedInvocation (0),
 
255
    resultResponseUnexpected (1),
 
256
    mistypedResult (2)
 
257
    }
 
258
 
 
259
ReturnErrorProblem ::= INTEGER
 
260
{
 
261
    unrecognizedInvocation (0),
 
262
    errorResponseUnexpected (1),
 
263
    unrecognizedError (2),
 
264
    unexpectedError (3),
 
265
    mistypedParameter (4)
 
266
    }
 
267
 
 
268
RejectProblem ::= INTEGER
 
269
{
 
270
    general-unrecognizedPDU (0),
 
271
    general-mistypedPDU (1),
 
272
    general-badlyStructuredPDU (2),
 
273
    invoke-duplicateInvocation (10),
 
274
    invoke-unrecognizedOperation (11),
 
275
    invoke-mistypedArgument (12),
 
276
    invoke-resourceLimitation (13),
 
277
    invoke-releaseInProgress (14),
 
278
    invoke-unrecognizedLinkedId (15),
 
279
    invoke-linkedResponseUnexpected (16),
 
280
    invoke-unexpectedLinkedOperation (17),
 
281
    returnResult-unrecognizedInvocation (20),
 
282
    returnResult-resultResponseUnexpected (21),
 
283
    returnResult-mistypedResult (22),
 
284
    returnError-unrecognizedInvocation (30),
 
285
    returnError-errorResponseUnexpected (31),
 
286
    returnError-unrecognizedError (32),
 
287
    returnError-unexpectedError (33),
 
288
    returnError-mistypedParameter (34)
 
289
    }
 
290
 
 
291
InvokeId ::= CHOICE
 
292
{
 
293
    present INTEGER,
 
294
    absent NULL
 
295
    }
 
296
 
 
297
noInvokeId InvokeId ::= absent:NULL
 
298
 
 
299
NoInvokeId InvokeId ::= {noInvokeId}
 
300
 
 
301
Errors {OPERATION:Operations} ERROR ::= {Operations.&Errors}
 
302
 
 
303
Bind {OPERATION:operation} ::= CHOICE
 
304
{
 
305
    bind-invoke [16] OPERATION.&ArgumentType({operation}),
 
306
    bind-result [17] OPERATION.&ResultType ({operation}),
 
307
    bind-error [18] OPERATION.&Errors.&ParameterType ({operation})
 
308
    }
 
309
 
 
310
Unbind {OPERATION:operation} ::= CHOICE
 
311
{
 
312
    unbind-invoke [19] OPERATION.&ArgumentType({operation}),
 
313
    unbind-result [20] OPERATION.&ResultType ({operation}),
 
314
    unbind-error [21] OPERATION.&Errors.&ParameterType ({operation})
 
315
    }
 
316
 
 
317
emptyBind OPERATION ::= {ERRORS {refuse} SYNCHRONOUS TRUE}
 
318
 
 
319
emptyUnbind OPERATION ::= { SYNCHRONOUS TRUE }
 
320
 
 
321
refuse ERROR ::= {CODE local:-1}
 
322
 
 
323
no-op OPERATION ::=
 
324
 {
 
325
   IDEMPOTENT TRUE
 
326
   ALWAYS RESPONDS FALSE
 
327
   CODE local:-1
 
328
 }
 
329
 
 
330
Forward {OPERATION:OperationSet} OPERATION ::=
 
331
{
 
332
    OperationSet |
 
333
    OperationSet.&Linked.&Linked |
 
334
    OperationSet.&Linked.&Linked.&Linked.&Linked
 
335
    }
 
336
 
 
337
Reverse {OPERATION:OperationSet} OPERATION ::=
 
338
{Forward{{OperationSet.&Linked}}}
 
339
 
 
340
ConsumerPerforms {OPERATION-PACKAGE:package} OPERATION ::=
 
341
{
 
342
    Forward{{package.&Consumer}} |
 
343
    Forward{{package.&Both}} |
 
344
    Reverse{{package.&Supplier}} |
 
345
    Reverse{{package.&Both}}
 
346
    }
 
347
 
 
348
SupplierPerforms {OPERATION-PACKAGE:package} OPERATION ::=
 
349
{
 
350
    Forward{{package.&Supplier}} |
 
351
    Forward{{package.&Both}} |
 
352
    Reverse{{package.&Consumer}} |
 
353
    Reverse{{package.&Both}}
 
354
    }
 
355
 
 
356
AllOperations {OPERATION-PACKAGE:package} OPERATION ::=
 
357
{
 
358
    ConsumerPerforms {package} |
 
359
    SupplierPerforms {package}
 
360
    }
 
361
 
 
362
recode {OPERATION:operation, Code:code} OPERATION ::=
 
363
{
 
364
    ARGUMENT operation.&ArgumentType
 
365
    OPTIONAL operation.&argumentTypeOptional
 
366
    RESULT operation.&ResultType
 
367
    OPTIONAL operation.&resultTypeOptional
 
368
    RETURN RESULT operation.&returnResult
 
369
    ERRORS {operation.&Errors}
 
370
    LINKED {operation.&Linked}
 
371
    SYNCHRONOUS operation.&synchronous
 
372
    ALWAYS RESPONDS operation.&alwaysReturns
 
373
    INVOKE PRIORITY {operation.&InvokePriority}
 
374
    RESULT-PRIORITY {operation.&ResultPriority}
 
375
    CODE code
 
376
    }
 
377
 
 
378
switch {OPERATION-PACKAGE:package, OBJECT IDENTIFIER:id} OPERATION-PACKAGE ::=
 
379
{
 
380
    OPERATIONS {package.&Both}
 
381
    CONSUMER INVOKES {package.&Consumer}
 
382
    SUPPLIER INVOKES {package.&Supplier}
 
383
    ID id
 
384
    }
 
385
 
 
386
combine {OPERATION-PACKAGE:ConsumerConsumes,OPERATION-PACKAGE:ConsumerSupplies,
 
387
    OPERATION-PACKAGE:base
 
388
    } OPERATION-PACKAGE ::=
 
389
{
 
390
    OPERATIONS {ConsumerConsumes.&Both | ConsumerSupplies.&Both}
 
391
    CONSUMER INVOKES {ConsumerConsumes.&Consumer | ConsumerSupplies.&Supplier}
 
392
    SUPPLIER INVOKES {ConsumerConsumes.&Supplier | ConsumerSupplies.&Consumer}
 
393
    ID base.&id
 
394
    }
 
395
 
 
396
ROS-SingleAS {InvokeId:InvokeIdSet, OPERATION-PACKAGE:package} ::= ROS
 
397
{{InvokeIdSet}, {AllOperations{package}}, {AllOperations{package}}}
 
398
 
 
399
ROS-ConsumerAS {InvokeId:InvokeIdSet, OPERATION-PACKAGE:package} ::= ROS
 
400
{{InvokeIdSet}, {ConsumerPerforms{package}}, {SupplierPerforms{package}}}
 
401
 
 
402
ROS-SupplierAS {InvokeId:InvokeIdSet, OPERATION-PACKAGE:package} ::= ROS
 
403
{{InvokeIdSet}, {SupplierPerforms{package}}, {ConsumerPerforms{package}}}
 
404
 
 
405
probe OPERATION ::= 
 
406
 { 
 
407
   ARGUMENT SEQUENCE 
 
408
    { 
 
409
      invokeId [0] InvokeId 
 
410
    } 
 
411
   RESULT ENUMERATED{running(0), finished(1), unknown(2), ...} 
 
412
   IDEMPOTENT TRUE 
 
413
   CODE local:-2 
 
414
 } 
 
415
 
 
416
acknowledge OPERATION ::= 
 
417
 { 
 
418
   ARGUMENT InvokeId 
 
419
   RESULT ENUMERATED{acknowledged(0), unknown(1), ...} 
 
420
   IDEMPOTENT TRUE 
 
421
   CODE local:-3 
 
422
 } 
 
423
 
 
424
ProbeAndAcknowledge OPERATION ::= {probe | acknowledge} 
 
425
 
 
426
cancel OPERATION ::= 
 
427
 { 
 
428
   ARGUMENT InvokeId 
 
429
   ERRORS {cancelFailed} 
 
430
   IDEMPOTENT TRUE 
 
431
   CODE local:-4 
 
432
 } 
 
433
 
 
434
cancelFailed ERROR ::= 
 
435
 { 
 
436
   PARAMETER SET 
 
437
    { 
 
438
      problem [0] CancelProblem, 
 
439
      operation [1] InvokeId 
 
440
    } 
 
441
   CODE local:-2 
 
442
 } 
 
443
 
 
444
CancelProblem ::= ENUMERATED 
 
445
{unknownOperation(0), tooLate(1), operationNotCancellable(2), ...} 
 
446
 
 
447
cancelled ERROR ::= {CODE local:-3}
 
448
 
 
449
END -- end of useful definitions.