ASN.1
Previous: Recursion Up: Additional Features Next: Information Objects and Table Constraints

Macros

NOTE: Macros were depreciated in 1994 and were replaced by Information Objects.

Macros in ASN.1 are similar to macros in application software, they provide the capability of defining types and values that are not included in the standard repertoire. This capability is not commonly implemented in ASN.1, however, because all of the macros' grammatical rules must be known by a compiler before it can compile the module containing the macros. Their definition is found in Annex A of ISO 8824, but discussions are underway to replace macros with built-in data types.

Macros can be reduced to ASN.1 types (another reason why macros are not common), even though macros are not themselves types. One significant use of ASN.1 macros is in OSI application protocol standards, specifically for defining remote operations and object classes. In this section, we include two macros, ERROR and OPERATOR, that appear in the common service elements in a later Chapter.

The template for an ASN.1 macro is

 <macro name> MACRO ::=
 BEGIN
 TYPE NOTATION ::= <user-defined type notation>
 VALUE NOTATION ::= <user-defined value notation>
 <supporting syntax>
 END

where MACRO is the keyword that indicates a definition of the macro named <macro name>; BEGIN and END delimit the body of the macro definition; TYPE NOTATION and VALUE NOTATION, respectively, introduce the production rules for the user-defined types and their values; and <supporting syntax> gives details about the types in the body of the macro.

The following ERROR macro defined in X.219 provides a specific instance of the general template.

 ERROR MACRO ::=
 BEGIN
 TYPE NOTATION ::= Parameter
 VALUE NOTATION ::= value (VALUE CHOICE
 {
 localValue INTEGER,
 globalValue OBJECT IDENTIFIER
 })
 Parameter ::= ``PARAMETER'' NamedType | empty
 NamedType ::= identifier type | type
 END

In this definition, details of Parameter and NamedType are in the supporting syntax. Parameter consists of the keyword ``PARAMETER'' followed by a named type; it may not have an entry. The value notation is a choice of INTEGER or OBJECT IDENTIFIER. The definition allows users to define operation errors. For example, the ERROR macro is used in the Remote Operations Service Element (ROSE) of a following Chapter to define BadQueueName as follows:

 BadQueueName ERROR
 PARAMETER QueueName
 ::= 0

BadQueueName has type ERROR, one parameter ``QueueName'' (identified elsewhere as type IA5String), and value 0. In the remote operation, only the value 0 is transmitted, the other terms in the definition are for the user's benefit.

As a second instance of the macro template, we consider the following OPERATION macro definition, used by application protocol designers to define remote operations.

 OPERATION MACRO ::=
 BEGIN
 TYPE NOTATION ::= Argument Result Errors LinkedOps
 VALUE NOTATION ::= value (VALUE CHOICE
 {
 localValue INTEGER,
 globalValue OBJECT IDENTIFIER
 })
 Argument ::= ``ARGUMENT'' NamedType | empty
 Result ::= ``RESULT'' ResultType | empty
 ResultType ::= NamedType | empty
 Errors ::= ``ERRORS'' ``(ErrorNames)'' | empty
 LinkedOpts ::= ``LINKED'' ``(LinkedOpNames)'' | empty
 ErrorNames ::= ErrorList | empty
 ErrorList ::= Error | ErrorList``,''Error
 Error ::= value(ERROR) | type
 LinkedOptNames ::= OperationalList | empty
 OperationList ::= Operation | OperationList``,''Operation
 Operation ::= value(OPERATION) | type
 NamedType ::= type | identifier type
 END

In this definition, TYPE NOTATION has four production rules, each of which is refined in the supporting syntax. We note that each of them may or may not be present in a specific instance. As in the definition of the ERROR macro, there is a choice for value notation, either INTEGER or OBJECT IDENTIFIER.

In the following example, the OPERATION macro is used to define getcount as type OPERATION with three parameters and value 0.

getcount OPERATION
 ARGUMENT QueueName
 RESULT Count
 ERRORS {BadQueueName, QueueNotAvailable, Other}
 ::= 0

Previous: Recursion Up: Additional Features Next: Information Objects and Table Constraints