# Compaq ACMS for OpenVMS
ADU Reference Manual

Previous | Contents | Index

ACMS starts an Rdb transaction that can read data in the EMPLOYEES relation, and that can store, modify, and erase data in the SALARY_HISTORY and JOBS relations. EXCLUSIVE specifies that no other users can access a relation while you are working with it; SHARED specifies that other users can work with a relation while you are working with it; READ specifies that you can only read data in a relation; and WRITE specifies that you can store, modify, or erase data in a relation. You do not use a semicolon (;) after the DML string because RDB RECOVERY is a phrase rather than a clause.

#3
    GET_EMPLOYEE_ID_TASK
      DEFAULT SERVER IS EMPLOYEE_SERVER;
      BLOCK WORK WITH FORM I/O
                      RDB RECOVERY
        "START_TRANSACTION READ_WRITE RESERVING EMPLOYEES FOR
                                      PROTECTED WRITE"
        EXCHANGE
          RECEIVE FORM RECORD GET_EMPLOYEE_ID_RECORD
            RECEIVING EMPLOYEE_ID_WKSP;

        PROCESSING
          CALL GET_EMPLOYEE_INFO
            USING EMPLOYEE_ID_WKSP;
          CONTROL FIELD ACMS$T_STATUS_TYPE
            "G"     : RETAIN SERVER CONTEXT;
                      RETAIN RECOVERY UNIT;
                      GOTO NEXT STEP;
            "B"     : ROLLBACK;
                      CANCEL TASK;
          END CONTROL FIELD;

        EXCHANGE
          SEND FORM RECORD GET_EMPLOYEE_ID_RECORD
            SENDING EMPLOYEE_ID_WKSP
            WITH RECEIVE CONTROL QUIT_WORKSPACE;
          CONTROL FIELD IS QUIT_WORKSPACE.QUIT_KEY
            " FEXT"   :    ROLLBACK;
                           EXIT TASK;
          END CONTROL FIELD;

        PROCESSING
          CALL WRITE_EMPLOYEE_INFO
            USING EMPLOYEE_ID_WKSP;
          CONTROL FIELD ACMS$T_STATUS_TYPE
            "G"     : COMMIT;
            "B"     : ROLLBACK;
                      CANCEL TASK;
          END CONTROL FIELD;
      END BLOCK;
    END DEFINITION;

> In this example definition, the user retrieves and modifies information about an employee. The Rdb transaction is specified on the block step. If the operation fails (either in retrieving or updating the information), the transaction is rolled back; otherwise, the updates are committed. Note that server context and the recovery unit are retained after the first processing step.

## Processing Phrase Examples

#1
    PROCESSING WITH
      RDB RECOVERY "START_TRANSACTION READ_WRITE RESERVING " &
        "DEPART FOR SHARED READ, ADMIN FOR PROTECTED WRITE"

> This DML string starts a read-write database transaction, allowing read- only access to the DEPART relation and protected write access to the ADMIN relation. No other relations are available for access.

#2
    PROCESSING WITH RDB RECOVERY
      "START_TRANSACTION READ_WRITE RESERVING EMPLOYEES
                         FOR SHARED WRITE"

> ACMS starts a recovery unit for a transaction that can store, modify, and erase data in the EMPLOYEES relation. SHARED specifies that other users can work with the EMPLOYEES relation while you are working with it, and WRITE specifies that you can store, modify, or erase data in the relation. You do not use a semicolon (;) after the database string because RDB RECOVERY is a phrase rather than a clause.

#3
    GET_EMPLOYEE_ID_TASK
      DEFAULT SERVER IS EMPLOYEE_SERVER;
      BLOCK WORK WITH FORM I/O
        EXCHANGE
           RECEIVE FORM RECORD GET_EMPLOYEE_ID_RECORD
             RECEIVING EMPLOYEE_ID_WKSP
             WITH RECEIVE CONTROL QUIT_WORKSPACE;
           CONTROL FIELD IS QUIT_WORKSPACE.QUIT_KEY
             " FEXT"  :  EXIT TASK;
           END CONTROL FIELD;

        PROCESSING WITH RDB RECOVERY
          "START_TRANSACTION READ_WRITE RESERVING EMPLOYEES
                             FOR SHARED WRITE"
           CALL GET_EMPLOYEE_INFO
             USING EMPLOYEE_ID_WKSP;
           CONTROL FIELD ACMS$T_STATUS_TYPE
            "G"     :  RETAIN SERVER CONTEXT;
                       RETAIN RECOVERY UNIT;
                       GOTO NEXT STEP;
            "B"     :  ROLLBACK;
                       GOTO PREVIOUS TASK;
           END CONTROL FIELD;

        EXCHANGE
          SEND FORM RECORD GET_EMPLOYEE_ID_RECORD
            SENDING EMPLOYEE_ID_WKSP
            WITH RECEIVE CONTROL QUIT_WORKSPACE;
          CONTROL FIELD IS QUIT_WORKSPACE.QUIT_KEY
            " FEXT"   :    ROLLBACK;
                           CANCEL TASK;
          END CONTROL FIELD;

        PROCESSING
           CALL WRITE_EMPLOYEE_INFO
             USING EMPLOYEE_ID_WKSP;
           CONTROL FIELD ACMS$T_STATUS_TYPE
            "G"     :  COMMIT;
            "B"     :  ROLLBACK;
                       CANCEL TASK;
           END CONTROL FIELD;
      END BLOCK;
    END DEFINITION;

> In this example, the user retrieves and modifies information about an employee. The Rdb transaction is specified on the first processing step. If the information about the employee cannot be retrieved, the transaction is rolled back and the initial exchange is repeated. If the update fails, the transaction is rolled back and the task is canceled. Note that server context and the recovery unit are retained after the first processing step.

# REPEAT TASK Clause (Action)

> Ends the current task instance and restarts the task without requiring the terminal user to select the task from a menu.

## Format

> REPEAT TASK [ PASSING workspace-name [,...] ] ;

## Parameter

> ### workspace-name

> The name of the workspace you want to pass from the current task instance to the new task instance.

## Clause Default

> If you do not use the REPEAT TASK clause, ACMS does not repeat the task. The default sequencing action for a step within a root block is GOTO NEXT STEP. The default sequencing action for a root block or a processing step in a single-step task is EXIT TASK.

## Notes

> You cannot specify the REPEAT TASK clause in the action part of a step within a distributed transaction. If you specify REPEAT TASK on a root block, that task cannot be called by a parent task to participate in a distributed transaction.

> When you use the REPEAT TASK clause in a step that does not start a distributed transaction, the default recovery action is COMMIT IF ACTIVE RECOVERY UNIT and the default context action is RELEASE SERVER CONTEXT IF ACTIVE SERVER CONTEXT.

> If you use the REPEAT TASK clause, you cannot declare the following clauses in the same action specification:

> - RETAIN RECOVERY UNIT
> - RETAIN RECOVERY UNIT IF ACTIVE RECOVERY UNIT
> - RETAIN SERVER CONTEXT
> - RETAIN SERVER CONTEXT IF ACTIVE SERVER CONTEXT

> When you chain from one task to another, ACMS reinitializes any task workspaces not passed.

## Example

    WORKSPACES ARE ADD_EMPLOYEE_WKSP, QUIT_WORKSPACE;
    BLOCK WITH FORM I/O
      EXCHANGE
        RECEIVE FORM RECORD ADD_EMPLOYEE_RECORD
          RECEIVING ADD_EMPLOYEE_WKSP
          WITH RECEIVE CONTROL QUIT_WORKSPACE;
        CONTROL FIELD IS QUIT_WORKSPACE.QUIT_KEY
          " FCAN"   :  CANCEL TASK;
        END CONTROL FIELD;
      PROCESSING
        CALL PERSADD IN PERSONNEL USING ADD_EMPLOYEE_WKSP;
        CONTROL FIELD ACMS$T_STATUS_TYPE
          "B"        : GET ERROR MESSAGE;
                       GOTO PREVIOUS EXCHANGE;
        END CONTROL FIELD;
      END BLOCK WORK;
      REPEAT TASK;
    END DEFINITION;

> This data entry task adds a new employee record to a file. Because this is a task a user would like to repeat without having to reselect the task from a menu, you include the REPEAT TASK clause in the action part of the block step definition.

# RETAIN RECOVERY UNIT Clause (Action)

> Maintains the recovery unit within the current server.

## Format

> RETAIN RECOVERY UNIT [ IF ACTIVE RECOVERY UNIT ] ;

## Keyword

> ### IF ACTIVE RECOVERY UNIT

> Retains the recovery unit only if there is an active recovery unit. If you use the IF ACTIVE RECOVERY UNIT keywords, and there is no active recovery unit, ACMS does not attempt to retain a recovery unit. If you do not use the IF ACTIVE RECOVERY UNIT keywords, and there is no active recovery unit when you use the RETAIN RECOVERY UNIT clause, ACMS cancels the task.

## Clause Default

> The RETAIN RECOVERY UNIT clause is optional.

> Table 7-3 shows the default recovery actions for a task.

## Notes

> You can use the RETAIN RECOVERY UNIT clause only in the action specifications of steps within a block.

## Example

    BLOCK
      WORK WITH FORM I/O
      GET_DEPT_NUMBER:
        EXCHANGE
          RECEIVE FORM RECORD REVIEW_SCHEDULE
            RECEIVING REVIEW_SCHEDULE_WKSP
            WITH RECEIVE CONTROL QUIT_WORKSPACE;
          CONTROL FIELD IS QUIT_WORKSPACE.QUIT_KEY
            " FCAN"   : CANCEL TASK;
          END CONTROL FIELD;

      GET_FIVE_EMPLOYEES:
        PROCESSING WITH
          DBMS RECOVERY "READY ADMIN DEPART CONCURRENT RETRIEVAL"
          CALL REVIEW_SCHEDULE_GET IN DEPARTMENT_SERVER
            USING REVIEW_SCHEDULE_WKSP;
          CONTROL FIELD ACMS$T_STATUS_TYPE
            "B"        : GET ERROR MESSAGE;
                         GOTO PREVIOUS EXCHANGE;
            "G"        : RETAIN RECOVERY UNIT;
                         RETAIN SERVER CONTEXT;
                         GOTO NEXT STEP;
          END CONTROL FIELD;

> If the REVIEW_SCHEDULE_GET procedure is successful in retrieving review schedule information for a department, ACMS returns the value "G" to the ACMS$T_STATUS_TYPE field of the ACMS$PROCESSING_STATUS system workspace. In this task, the user can choose to look at the next five records in the file. Therefore, you want to retain currency indicators to maintain the user's file location. Use the RETAIN RECOVERY UNIT clause to maintain that recovery unit.

# RMS RECOVERY Phrase (Block, Processing)

> Starts an RMS recovery unit for a block or processing step.

## Format

> RMS RECOVERY

## Phrase Default

> The RMS RECOVERY phrase is optional. If you do not include it, ACMS does not start an RMS recovery unit.

## Notes

> You can use the RMS RECOVERY phrase only when defining a processing step or block step. When you use the RMS RECOVERY phrase at the start of a processing step or block step, ACMS sets the default recovery action for that step to COMMIT IF ACTIVE RECOVERY.

> You cannot use the RMS RECOVERY phrase in a processing step that runs in a DCL server.

> If you use the RMS RECOVERY phrase and the NO PROCESSING clause in the same processing step, ACMS cancels the task.

> You must use separate servers for DBMS, Rdb, RMS, and SQL procedures if you are using recovery units with more than one of these products in the same application. Only one type of recovery unit can be used for each server or step.

> You cannot specify the RMS RECOVERY phrase on a nested block.

> You cannot specify more than one recovery statement (RDB, DBMS, RMS, or SQL) for the same block or processing step.

> Table 7-3 shows the default recovery actions for different situations in a task definition.

> Table 7-3 Default Recovery Actions
> | Default Recovery Action
> --- | ---
> Action Clause | If you started the recovery unit in the current step | If you did not start the recovery unit in the current step
> CANCEL TASK RAISE EXCEPTION | ROLLBACK IF ACTIVE RECOVERY UNIT | ROLLBACK IF ACTIVE RECOVERY UNIT
> EXIT TASK, GOTO TASK, REPEAT TASK, RELEASE CONTEXT, RELEASE CONTEXT IF ACTIVE RECOVERY UNIT | COMMIT IF ACTIVE RECOVERY UNIT | COMMIT IF ACTIVE RECOVERY UNIT
> OTHER | COMMIT IF ACTIVE RECOVERY UNIT | NO RECOVERY UNIT ACTION

## Block Phrase Examples

#1
    BLOCK WITH RMS RECOVERY

> ACMS starts an RMS recovery unit for the transaction. You do not use a semicolon (;) because RMS RECOVERY is a phrase, not a clause.

#2
    GET_EMPLOYEE_ID_TASK
      DEFAULT SERVER IS EMPLOYEE_SERVER;

      BLOCK WORK WITH FORM I/O
                      RMS RECOVERY

        EXCHANGE
          RECEIVE FORM RECORD GET_EMPLOYEE_ID_RECORD
            RECEIVING EMPLOYEE_ID_WKSP;

        PROCESSING
          CALL GET_EMPLOYEE_INFO
            USING EMPLOYEE_ID_WKSP;
          CONTROL FIELD ACMS$T_STATUS_TYPE
            "G"     : RETAIN SERVER CONTEXT;
                      RETAIN RECOVERY UNIT;
                      GOTO NEXT STEP;
            "B"     : ROLLBACK;
                      CANCEL TASK;
          END CONTROL FIELD;

        EXCHANGE
          SEND FORM RECORD GET_EMPLOYEE_ID_RECORD
            SENDING EMPLOYEE_ID_WKSP
            WITH RECEIVE CONTROL QUIT_WORKSPACE;
          CONTROL FIELD IS QUIT_WORKSPACE.QUIT_KEY
            " FEXT"   :    ROLLBACK;
                           EXIT TASK;
          END CONTROL FIELD;

        PROCESSING
          CALL WRITE_EMPLOYEE_INFO
            USING EMPLOYEE_ID_WKSP;
          CONTROL FIELD ACMS$T_STATUS_TYPE
            "G"     : COMMIT;
            "B"     : ROLLBACK;
                      CANCEL TASK;
          END CONTROL FIELD;
      END BLOCK;
    END DEFINITION;

> In this example definition, the user retrieves and modifies information about an employee. The RMS transaction is specified in the block step. If the operation fails (either in retrieving or updating the information), the transaction is rolled back; otherwise, the updates are committed.

> Note that server context and the recovery unit are retained after the first processing step.

## Processing Phrase Examples

#1
    PROCESSING WITH RMS RECOVERY

> ACMS starts a recovery unit for the transaction. You do not use a semicolon (;) because RMS RECOVERY is a phrase rather than a clause.

#2
    GET_EMPLOYEE_ID_TASK
      DEFAULT SERVER IS EMPLOYEE_SERVER;
      BLOCK WORK WITH FORM I/O
        EXCHANGE
           RECEIVE FORM RECORD GET_EMPLOYEE_ID_RECORD
             RECEIVING EMPLOYEE_ID_WKSP
             WITH RECEIVE CONTROL QUIT_WORKSPACE;
           CONTROL FIELD IS QUIT_WORKSPACE.QUIT_KEY
             " FEXT"  :  EXIT TASK;
           END CONTROL FIELD;

        PROCESSING WITH RMS RECOVERY
           CALL GET_EMPLOYEE_INFO
             USING EMPLOYEE_ID_WKSP;
           CONTROL FIELD ACMS$T_STATUS_TYPE
            "G"     :  RETAIN SERVER CONTEXT;
                       RETAIN RECOVERY UNIT;
                       GOTO NEXT STEP;
            "B"     :  ROLLBACK;
                       GOTO PREVIOUS TASK;
           END CONTROL FIELD;

        EXCHANGE
          SEND FORM RECORD GET_EMPLOYEE_ID_RECORD
            SENDING EMPLOYEE_ID_WKSP
            WITH RECEIVE CONTROL QUIT_WORKSPACE;
          CONTROL FIELD IS QUIT_WORKSPACE.QUIT_KEY
            " FEXT"   :    ROLLBACK;
                           CANCEL TASK;
          END CONTROL FIELD;

        PROCESSING
           CALL WRITE_EMPLOYEE_INFO
             USING EMPLOYEE_ID_WKSP;
           CONTROL FIELD ACMS$T_STATUS_TYPE
            "G"     :  COMMIT;
            "B"     :  ROLLBACK;
                       CANCEL TASK;
           END CONTROL FIELD;
      END BLOCK;
    END DEFINITION;

> In this example definition, the user retrieves and modifies information about an employee. The RMS transaction is specified in the first processing step. If the information about the employee cannot be retrieved, the transaction is rolled back and the initial exchange is repeated. If the update fails, the transaction is rolled back and the task is canceled.

> Note that server context and the recovery unit are retained after the first processing step.

# ROLLBACK Clause (Action)

> Signals the end of a recovery unit, returning (rolling back) all recoverable objects to the state they were in at the beginning of the current recovery unit.

## Format

> ROLLBACK [ IF ACTIVE RECOVERY UNIT ] ;

## Keywords

> ### IF ACTIVE RECOVERY UNIT

> Performs a ROLLBACK only if there is an active recovery unit. If you use the IF ACTIVE RECOVERY UNIT keywords, and there is no active recovery unit, ACMS does not attempt to roll back a database transaction. If you do not use the IF ACTIVE RECOVERY UNIT keywords, and there is no active recovery unit when you use the ROLLBACK clause, ACMS cancels the task.

## Clause Default

> The ROLLBACK clause is optional.

> Table 7-3 shows the default recovery actions for a task.

## Example

    BLOCK WITH FORM I/O
      GET_DEPT_NUMBER:
        EXCHANGE
          RECEIVE FORM RECORD REVIEW_SCHEDULE
            RECEIVING REVIEW_SCHEDULE_WKSP
            WITH RECEIVE CONTROL QUIT_WORKSPACE;
          CONTROL FIELD IS QUIT_WORKSPACE.QUIT_KEY
            " FCAN"   : CANCEL TASK;
          END CONTROL FIELD;

      GET_FIVE_EMPLOYEES:
        PROCESSING WITH
          DBMS RECOVERY "READY CONCURRENT UPDATE"
          CALL REVIEW_SCHEDULE_GET IN DEPARTMENT_SERVER
            USING REVIEW_SCHEDULE_WKSP;
          CONTROL FIELD ACMS$T_STATUS_TYPE
            "B"        : GET ERROR MESSAGE;
                         ROLLBACK;
                         RELEASE SERVER CONTEXT;
                         GOTO PREVIOUS EXCHANGE;
            "G"        : RETAIN RECOVERY UNIT;
                         NO CONTEXT ACTION;
                         GOTO NEXT STEP;
          END CONTROL FIELD;

> If the REVIEW_SCHEDULE_GET procedure is successful in retrieving review schedule information for a department, ACMS returns the value "G" to the ACMS$T_STATUS_TYPE field of the ACMS$PROCESSING_STATUS system workspace. In this task, the user can choose to look at the next five records in the file. Therefore, you want to retain currency indicators to maintain the user's file location. However, you do not want to retain these currency indicators if the procedure is unsuccessful. Use the ROLLBACK clause to return the database to the state it was in at the start of the recovery unit.

# SQL RECOVERY Phrase (Block, Processing)

> Starts an SQL transaction with an Rdb database or a VIDA database at the beginning of a block or processing step. If you use the SQL RECOVERY phrase to start your transaction, you must end your transaction with a COMMIT or ROLLBACK clause.

## Format

> SQL RECOVERY dml-string [,...]

## Parameter

> ### dml-string

> The Data Manipulation Language (DML) string is a DML statement with which you start an SQL transaction at the block or processing step level. The DML string can contain any legal SET TRANSACTION syntax, including the characteristics you want to apply to the transaction. Use the DML RESERVING clause to apply different characteristics to different relations.

> ADU supports DML strings up to a length of 255 characters.

> When you enter strings longer than 255 characters into ADU, ACMS issues a warning, and the string is truncated. To overcome this restriction, put SQL RECOVERY statements in procedure servers rather than in task definitions.

> For more information on DML strings, refer to the SQL documentation.

## Phrase Default

> The SQL RECOVERY phrase is optional. If you do not include it or the RDB RECOVERY phrase, ACMS does not start an RDB database transaction.

## Notes

> ACMS calls SQL$INTERPRET to execute the DML statement that you supply to start the database transaction. Starting an update transaction creates a recovery unit. To use the SQL RECOVERY phrase, you must bind the database in the server initialization procedure.

> Use the SQL RECOVERY phrase only when defining a processing step or block step. When you use the SQL RECOVERY phrase at the start of a processing step or block step, ACMS sets the default recovery action for that step to COMMIT IF ACTIVE RECOVERY.

> You cannot use the SQL RECOVERY phrase in a processing step that runs in a DCL server.

> If you use the SQL RECOVERY phrase and the NO PROCESSING clause in the same processing step, ACMS cancels the task.

> You must use separate servers for DBMS, Rdb, RMS, and SQL procedures if you are using recovery units with more than one of these products in the same application. Only one type of recovery unit can be used for each server or step. You cannot specify more than one recovery statement (SQL, RDB, DBMS, or RMS) for the same block or processing step. Table 7-4 shows the default recovery actions for different situations in a task definition.

> Table 7-4 Default Recovery Actions
> | Default Recovery Action
> --- | ---
> Action Clause | If you started the recovery unit in the current step | If you did not start the recovery unit in the current step
> CANCEL TASK RAISE EXCEPTION | ROLLBACK IF ACTIVE RECOVERY UNIT | ROLLBACK IF ACTIVE RECOVERY UNIT
> EXIT TASK, GOTO TASK, REPEAT TASK, RELEASE CONTEXT, RELEASE CONTEXT IF ACTIVE RECOVERY UNIT | COMMIT IF ACTIVE RECOVERY UNIT | COMMIT IF ACTIVE RECOVERY UNIT
> OTHER | COMMIT IF ACTIVE RECOVERY UNIT | NO RECOVERY UNIT ACTION

## Block Phrase Examples

#1
    BLOCK WITH SQL RECOVERY
      "SET TRANSACTION READ WRITE RESERVING EMPLOYEES FOR SHARED WRITE"

> ACMS starts an SQL transaction that can store, modify, and erase data in the EMPLOYEES table. SHARED specifies that other users can work with the EMPLOYEES relation while you are working with it, and WRITE specifies that you can store, modify, or erase data in the table. Do not use a semicolon (;) after the database string because SQL RECOVERY is a phrase rather than a clause.

#2
    BLOCK WITH SQL RECOVERY
      "SET TRANSACTION READ WRITE RESERVING "       &
                  "EMPLOYEES FOR SHARED READ, "       &
                  "SALARY_HISTORY FOR SHARED WRITE, " &
                  "JOBS FOR EXCLUSIVE WRITE"

> ACMS starts an SQL transaction that can read data in the EMPLOYEES table, and store, modify, and erase data in the SALARY_HISTORY and JOBS tables. EXCLUSIVE specifies that no other users can access a table while you are working with it; SHARED specifies that other users can work with a table while you are working with it; READ specifies that you can only read data in a table; and WRITE specifies that you can store, modify, or erase data in a table. You do not use a semicolon (;) after the DML string because SQL RECOVERY is a phrase rather than a clause.

#3
    GET_EMPLOYEE_ID_TASK
      DEFAULT SERVER IS EMPLOYEE_SERVER;
      BLOCK WORK WITH
                 FORM I/O
                 SQL RECOVERY
        "SET TRANSACTION READ WRITE
             RESERVING EMPLOYEES FOR PROTECTED WRITE"
        EXCHANGE
          RECEIVE FORM RECORD GET_EMPLOYEE_ID_RECORD
            RECEIVING EMPLOYEE_ID_WKSP;

        PROCESSING
          CALL GET_EMPLOYEE_INFO
            USING EMPLOYEE_ID_WKSP;
          CONTROL FIELD ACMS$T_STATUS_TYPE
            "G"     : RETAIN SERVER CONTEXT;
                      RETAIN RECOVERY UNIT;
                      GOTO NEXT STEP;
            "B"     : ROLLBACK;
                      CANCEL TASK;
          END CONTROL FIELD;

        EXCHANGE
          SEND FORM RECORD GET_EMPLOYEE_ID_RECORD
            SENDING EMPLOYEE_ID_WKSP
            WITH RECEIVE CONTROL QUIT_WORKSPACE;
          CONTROL FIELD IS QUIT_WORKSPACE.QUIT_KEY
            " FEXT"   :    ROLLBACK;
                           EXIT TASK;
          END CONTROL FIELD;

        PROCESSING
          CALL WRITE_EMPLOYEE_INFO
            USING EMPLOYEE_ID_WKSP;
          CONTROL FIELD ACMS$T_STATUS_TYPE
            "G"     : COMMIT;
            "B"     : ROLLBACK;
                      CANCEL TASK;
          END CONTROL FIELD;
      END BLOCK;
    END DEFINITION;

> Previous | Next | Contents | Index