diff options
Diffstat (limited to 'lib/asn1/test/asn1_SUITE_data/ROSE.asn1')
| -rw-r--r-- | lib/asn1/test/asn1_SUITE_data/ROSE.asn1 | 449 |
1 files changed, 449 insertions, 0 deletions
diff --git a/lib/asn1/test/asn1_SUITE_data/ROSE.asn1 b/lib/asn1/test/asn1_SUITE_data/ROSE.asn1 new file mode 100644 index 0000000000..2fefae3caf --- /dev/null +++ b/lib/asn1/test/asn1_SUITE_data/ROSE.asn1 @@ -0,0 +1,449 @@ +ROSE DEFINITIONS IMPLICIT TAGS ::= + + +BEGIN + +OPERATION ::= CLASS +{ + &ArgumentType OPTIONAL, + &argumentTypeOptional BOOLEAN OPTIONAL, + &returnResult BOOLEAN DEFAULT TRUE, + &ResultType OPTIONAL, + &resultTypeOptional BOOLEAN OPTIONAL, + &Errors ERROR OPTIONAL, + &Linked OPERATION OPTIONAL, + &synchronous BOOLEAN DEFAULT FALSE, + &idempotent BOOLEAN DEFAULT FALSE, + &alwaysReturns BOOLEAN DEFAULT TRUE, + &InvokePriority Priority OPTIONAL, + &ResultPriority Priority OPTIONAL, + &operationCode Code UNIQUE OPTIONAL + } +WITH SYNTAX + { + [ARGUMENT &ArgumentType [OPTIONAL &argumentTypeOptional]] + [RESULT &ResultType [OPTIONAL &resultTypeOptional]] + [RETURN RESULT &returnResult] + [ERRORS &Errors] + [LINKED &Linked] + [SYNCHRONOUS &synchronous] + [IDEMPOTENT &idempotent] + [ALWAYS RESPONDS &alwaysReturns] + [INVOKE PRIORITY &InvokePriority] + [RESULT-PRIORITY &ResultPriority] + [CODE &operationCode] + } + +ERROR ::= CLASS +{ + &ParameterType OPTIONAL, + ¶meterTypeOptional BOOLEAN OPTIONAL, + &ErrorPriority Priority OPTIONAL, + &errorCode Code UNIQUE OPTIONAL + } +WITH SYNTAX +{ + [PARAMETER &ParameterType [OPTIONAL ¶meterTypeOptional]] + [PRIORITY &ErrorPriority] + [CODE &errorCode] + } + +OPERATION-PACKAGE ::= CLASS +{ + &Both OPERATION OPTIONAL, + &Consumer OPERATION OPTIONAL, + &Supplier OPERATION OPTIONAL, + &id OBJECT IDENTIFIER UNIQUE OPTIONAL + } +WITH SYNTAX +{ + [OPERATIONS &Both] + [CONSUMER INVOKES &Supplier] + [SUPPLIER INVOKES &Consumer] + [ID &id] + } + +CONNECTION-PACKAGE ::= CLASS +{ + &bind OPERATION DEFAULT emptyBind, + &unbind OPERATION DEFAULT emptyUnbind, + &responderCanUnbind BOOLEAN DEFAULT FALSE, + &unbindCanFail BOOLEAN DEFAULT FALSE, + &id OBJECT IDENTIFIER UNIQUE OPTIONAL + } +WITH SYNTAX +{ + [BIND &bind] + [UNBIND &unbind] + [RESPONDER UNBIND &responderCanUnbind] + [FAILURE TO UNBIND &unbindCanFail] + [ID &id] + } + +CONTRACT ::= CLASS +{ + &connection CONNECTION-PACKAGE OPTIONAL, + &OperationsOf OPERATION-PACKAGE OPTIONAL, + &InitiatorConsumerOf OPERATION-PACKAGE OPTIONAL, + &InitiatorSupplierOf OPERATION-PACKAGE OPTIONAL, + &id OBJECT IDENTIFIER UNIQUE OPTIONAL + } +WITH SYNTAX +{ + [CONNECTION &connection] + [OPERATIONS OF &OperationsOf] + [INITIATOR CONSUMER OF &InitiatorConsumerOf] + [RESPONDER CONSUMER OF &InitiatorSupplierOf] + [ID &id] +} + +ROS-OBJECT-CLASS ::= CLASS +{ + &Is ROS-OBJECT-CLASS OPTIONAL, + &Initiates CONTRACT OPTIONAL, + &Responds CONTRACT OPTIONAL, + &InitiatesAndResponds CONTRACT OPTIONAL, + &id OBJECT IDENTIFIER UNIQUE + } +WITH SYNTAX +{ + [IS &Is] + [BOTH &InitiatesAndResponds] + [INITIATES &Initiates] + [RESPONDS &Responds] + ID &id + } + +Code ::= CHOICE +{ + local INTEGER, + global OBJECT IDENTIFIER + } + +Priority ::= INTEGER (0..MAX) + +ROS {InvokeId:InvokeIdSet,OPERATION:Invokable,OPERATION:Returnable} ::= CHOICE + { + invoke [1] Invoke {{InvokeIdSet}, {Invokable}}, + returnResult [2] ReturnResult {{Returnable}}, + returnError [3] ReturnError {{Errors{{Returnable}}}}, + reject [4] Reject + } +(CONSTRAINED BY {-- must conform to the above definition --} + ! RejectProblem : general-unrecognizedPDU) + +Invoke {InvokeId:InvokeIdSet, OPERATION:Operations} ::= SEQUENCE +{ + invokeId InvokeId (InvokeIdSet) + (CONSTRAINED BY {-- must be unambiguous --} + ! RejectProblem : invoke-duplicateInvocation), + linkedId CHOICE { + present [0] IMPLICIT present < InvokeId, + absent [1] IMPLICIT NULL + } + (CONSTRAINED BY {-- must identify an outstanding operation --} + ! RejectProblem : invoke-unrecognizedLinkedId) + (CONSTRAINED BY {-- which has one or more linked operations--} + ! RejectProblem : invoke-linkedResponseUnexpected) + OPTIONAL, + opcode OPERATION.&operationCode + ({Operations} + ! RejectProblem : invoke-unrecognizedOperation), + argument OPERATION.&ArgumentType + ({Operations} {@opcode} + ! RejectProblem : invoke-mistypedArgument) + OPTIONAL + } +(CONSTRAINED BY {-- must conform to the above definition --} + ! RejectProblem : general-mistypedPDU) +( +WITH COMPONENTS +{..., + linkedId ABSENT + } +| WITH COMPONENTS +{..., + linkedId PRESENT, + opcode + (CONSTRAINED BY {-- must be in the &Linked field of the associated operation -- + } + ! RejectProblem : invoke-unexpectedLinkedOperation) + } +) + +ReturnResult {OPERATION:Operations}::= SEQUENCE +{ + invokeId InvokeId + (CONSTRAINED BY {-- must be that for an outstanding operation --} + ! RejectProblem:returnResult-unrecognizedInvocation) + (CONSTRAINED BY {-- which returns a result --} + ! RejectProblem:returnResult-resultResponseUnexpected), + result SEQUENCE + { + opcode OPERATION.&operationCode + ({Operations})(CONSTRAINED BY {-- identified by invokeId --} + ! RejectProblem:returnResult-unrecognizedInvocation), + result OPERATION.&ResultType ({Operations} {@.opcode} + ! RejectProblem:returnResult-mistypedResult) + } + OPTIONAL + } +(CONSTRAINED BY {-- must conform to the above definition -- + } +! RejectProblem:general-mistypedPDU) + +ReturnError {ERROR:Errors} ::= SEQUENCE +{ + invokeId InvokeId + (CONSTRAINED BY {-- must be that for an outstanding operation -- + } + ! RejectProblem : returnError-unrecognizedInvocation) + (CONSTRAINED BY {-- which returns an error -- + } + ! RejectProblem : returnError-errorResponseUnexpected), + errcode ERROR.&errorCode + ({Errors} + ! RejectProblem : returnError-unrecognizedError) + (CONSTRAINED BY {-- must be in the &Errors field of the associated operation -- + } + ! RejectProblem : returnError-unexpectedError), + parameter ERROR.&ParameterType + ({Errors}{@errcode} + ! RejectProblem : returnError-mistypedParameter) OPTIONAL + } +(CONSTRAINED BY {-- must conform to the above definition -- + } +! RejectProblem : general-mistypedPDU) + +Reject ::= SEQUENCE +{ + invokeId InvokeId, + problem CHOICE + { + general [0] GeneralProblem, + invoke [1] InvokeProblem, + returnResult [2] ReturnResultProblem, + returnError [3] ReturnErrorProblem + } + } +(CONSTRAINED BY {-- must conform to the above definition -- + } +! RejectProblem : general-mistypedPDU) + +GeneralProblem ::= INTEGER +{ + unrecognizedPDU (0), + mistypedPDU (1), + badlyStructuredPDU (2) + } + +InvokeProblem ::= INTEGER +{ + duplicateInvocation (0), + unrecognizedOperation (1), + mistypedArgument (2), + resourceLimitation (3), + releaseInProgress (4), + unrecognizedLinkedId (5), + linkedResponseUnexpected (6), + unexpectedLinkedOperation (7) + } + +ReturnResultProblem ::= INTEGER +{ + unrecognizedInvocation (0), + resultResponseUnexpected (1), + mistypedResult (2) + } + +ReturnErrorProblem ::= INTEGER +{ + unrecognizedInvocation (0), + errorResponseUnexpected (1), + unrecognizedError (2), + unexpectedError (3), + mistypedParameter (4) + } + +RejectProblem ::= INTEGER +{ + general-unrecognizedPDU (0), + general-mistypedPDU (1), + general-badlyStructuredPDU (2), + invoke-duplicateInvocation (10), + invoke-unrecognizedOperation (11), + invoke-mistypedArgument (12), + invoke-resourceLimitation (13), + invoke-releaseInProgress (14), + invoke-unrecognizedLinkedId (15), + invoke-linkedResponseUnexpected (16), + invoke-unexpectedLinkedOperation (17), + returnResult-unrecognizedInvocation (20), + returnResult-resultResponseUnexpected (21), + returnResult-mistypedResult (22), + returnError-unrecognizedInvocation (30), + returnError-errorResponseUnexpected (31), + returnError-unrecognizedError (32), + returnError-unexpectedError (33), + returnError-mistypedParameter (34) + } + +InvokeId ::= CHOICE +{ + present INTEGER, + absent NULL + } + +noInvokeId InvokeId ::= absent:NULL + +NoInvokeId InvokeId ::= {noInvokeId} + +Errors {OPERATION:Operations} ERROR ::= {Operations.&Errors} + +Bind {OPERATION:operation} ::= CHOICE +{ + bind-invoke [16] OPERATION.&ArgumentType({operation}), + bind-result [17] OPERATION.&ResultType ({operation}), + bind-error [18] OPERATION.&Errors.&ParameterType ({operation}) + } + +Unbind {OPERATION:operation} ::= CHOICE +{ + unbind-invoke [19] OPERATION.&ArgumentType({operation}), + unbind-result [20] OPERATION.&ResultType ({operation}), + unbind-error [21] OPERATION.&Errors.&ParameterType ({operation}) + } + +emptyBind OPERATION ::= {ERRORS {refuse} SYNCHRONOUS TRUE} + +emptyUnbind OPERATION ::= { SYNCHRONOUS TRUE } + +refuse ERROR ::= {CODE local:-1} + +no-op OPERATION ::= + { + IDEMPOTENT TRUE + ALWAYS RESPONDS FALSE + CODE local:-1 + } + +Forward {OPERATION:OperationSet} OPERATION ::= +{ + OperationSet | + OperationSet.&Linked.&Linked | + OperationSet.&Linked.&Linked.&Linked.&Linked + } + +Reverse {OPERATION:OperationSet} OPERATION ::= +{Forward{{OperationSet.&Linked}}} + +ConsumerPerforms {OPERATION-PACKAGE:package} OPERATION ::= +{ + Forward{{package.&Consumer}} | + Forward{{package.&Both}} | + Reverse{{package.&Supplier}} | + Reverse{{package.&Both}} + } + +SupplierPerforms {OPERATION-PACKAGE:package} OPERATION ::= +{ + Forward{{package.&Supplier}} | + Forward{{package.&Both}} | + Reverse{{package.&Consumer}} | + Reverse{{package.&Both}} + } + +AllOperations {OPERATION-PACKAGE:package} OPERATION ::= +{ + ConsumerPerforms {package} | + SupplierPerforms {package} + } + +recode {OPERATION:operation, Code:code} OPERATION ::= +{ + ARGUMENT operation.&ArgumentType + OPTIONAL operation.&argumentTypeOptional + RESULT operation.&ResultType + OPTIONAL operation.&resultTypeOptional + RETURN RESULT operation.&returnResult + ERRORS {operation.&Errors} + LINKED {operation.&Linked} + SYNCHRONOUS operation.&synchronous + ALWAYS RESPONDS operation.&alwaysReturns + INVOKE PRIORITY {operation.&InvokePriority} + RESULT-PRIORITY {operation.&ResultPriority} + CODE code + } + +switch {OPERATION-PACKAGE:package, OBJECT IDENTIFIER:id} OPERATION-PACKAGE ::= +{ + OPERATIONS {package.&Both} + CONSUMER INVOKES {package.&Consumer} + SUPPLIER INVOKES {package.&Supplier} + ID id + } + +combine {OPERATION-PACKAGE:ConsumerConsumes,OPERATION-PACKAGE:ConsumerSupplies, + OPERATION-PACKAGE:base + } OPERATION-PACKAGE ::= +{ + OPERATIONS {ConsumerConsumes.&Both | ConsumerSupplies.&Both} + CONSUMER INVOKES {ConsumerConsumes.&Consumer | ConsumerSupplies.&Supplier} + SUPPLIER INVOKES {ConsumerConsumes.&Supplier | ConsumerSupplies.&Consumer} + ID base.&id + } + +ROS-SingleAS {InvokeId:InvokeIdSet, OPERATION-PACKAGE:package} ::= ROS +{{InvokeIdSet}, {AllOperations{package}}, {AllOperations{package}}} + +ROS-ConsumerAS {InvokeId:InvokeIdSet, OPERATION-PACKAGE:package} ::= ROS +{{InvokeIdSet}, {ConsumerPerforms{package}}, {SupplierPerforms{package}}} + +ROS-SupplierAS {InvokeId:InvokeIdSet, OPERATION-PACKAGE:package} ::= ROS +{{InvokeIdSet}, {SupplierPerforms{package}}, {ConsumerPerforms{package}}} + +probe OPERATION ::= + { + ARGUMENT SEQUENCE + { + invokeId [0] InvokeId + } + RESULT ENUMERATED{running(0), finished(1), unknown(2), ...} + IDEMPOTENT TRUE + CODE local:-2 + } + +acknowledge OPERATION ::= + { + ARGUMENT InvokeId + RESULT ENUMERATED{acknowledged(0), unknown(1), ...} + IDEMPOTENT TRUE + CODE local:-3 + } + +ProbeAndAcknowledge OPERATION ::= {probe | acknowledge} + +cancel OPERATION ::= + { + ARGUMENT InvokeId + ERRORS {cancelFailed} + IDEMPOTENT TRUE + CODE local:-4 + } + +cancelFailed ERROR ::= + { + PARAMETER SET + { + problem [0] CancelProblem, + operation [1] InvokeId + } + CODE local:-2 + } + +CancelProblem ::= ENUMERATED +{unknownOperation(0), tooLate(1), operationNotCancellable(2), ...} + +cancelled ERROR ::= {CODE local:-3} + +END -- end of useful definitions. |