?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE SCL Interpreter : Resource Manager Commands' ??
MODULE clm$resource_manager_commands;

{
{ PURPOSE:
{   This module contains the processors for the resource management commands.
{ NOTE:
{   The request_terminal command is in the module clm$interactive_commands.
{
?? NEWTITLE := 'Global Declarations', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc clc$compiling_for_test_harness
*copyc clt$parameter_list
*copyc cle$ecc_file_reference
*copyc cle$ecc_parsing
*copyc fsc$local
*copyc oss$job_paged_literal
*copyc ost$status
*copyc rmc$condition_code_limits
?? POP ??
*copyc clp$count_list_elements
*copyc clp$evaluate_parameters
*copyc clp$evaluate_file_reference
*copyc fsp$create_file
*copyc fsp$path_element
*copyc osp$append_status_file
*copyc osp$append_status_parameter
*copyc osp$set_status_abnormal
*copyc osp$set_status_condition
*copyc rmp$release_resource_command
*copyc rmp$request_null_device
*copyc rmp$reserve_resource_command
*copyc rmp$validate_ansi_string

?? TITLE := 'clp$request_tape_command', EJECT ??

  PROCEDURE [XDCL] clp$request_tape_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{
{ PROCEDURE (osm$reqmt) request_magnetic_tape, reqmt (
{   file, f: file = $required
{   external_vsn, evsn, ev: (BY_NAME) list of any of
{       string 1..6
{       name 1..6
{     anyend = $optional
{   log, l: (BY_NAME, ADVANCED) boolean = false
{   password, pw: (BY_NAME, ADVANCED, SECURE) any of
{       key
{         none
{       keyend
{       name
{     anyend = none
{   recorded_vsn, rvsn, rv: (BY_NAME) list of any of
{       string 1..6
{       name 1..6
{     anyend = $optional
{   removable_media_group, rmg: (BY_NAME, ADVANCED) any of
{       key
{         none
{       keyend
{       name
{     anyend = osd$reqmt_removable_media_group, none
{   ring, r: (BY_NAME) boolean = false
{   density, d, type, t: (BY_NAME) key
{       mt9$800, mt9$1600, mt9$6250, mt18$38000
{     keyend = osd$reqmt_default_density, mt9$1600
{   volume_overflow_allowed, voa: (BY_NAME, ADVANCED) boolean = true
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 23] of clt$pdt_parameter_name,
      parameters: array [1 .. 10] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$list_type_qualifier,
        element_type_spec: record
          header: clt$type_specification_header,
          qualifier: clt$union_type_qualifier,
          type_size_1: clt$type_specification_size,
          element_type_spec_1: record
            header: clt$type_specification_header,
            qualifier: clt$string_type_qualifier,
          recend,
          type_size_2: clt$type_specification_size,
          element_type_spec_2: record
            header: clt$type_specification_header,
            qualifier: clt$name_type_qualifier,
          recend,
        recend,
      recend,
      type3: record
        header: clt$type_specification_header,
        default_value: string (5),
      recend,
      type4: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$name_type_qualifier,
        recend,
        default_value: string (4),
      recend,
      type5: record
        header: clt$type_specification_header,
        qualifier: clt$list_type_qualifier,
        element_type_spec: record
          header: clt$type_specification_header,
          qualifier: clt$union_type_qualifier,
          type_size_1: clt$type_specification_size,
          element_type_spec_1: record
            header: clt$type_specification_header,
            qualifier: clt$string_type_qualifier,
          recend,
          type_size_2: clt$type_specification_size,
          element_type_spec_2: record
            header: clt$type_specification_header,
            qualifier: clt$name_type_qualifier,
          recend,
        recend,
      recend,
      type6: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$name_type_qualifier,
        recend,
        default_name: string (31),
        default_value: string (4),
      recend,
      type7: record
        header: clt$type_specification_header,
        default_value: string (5),
      recend,
      type8: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 4] of clt$keyword_specification,
        default_name: string (25),
        default_value: string (8),
      recend,
      type9: record
        header: clt$type_specification_header,
        default_value: string (4),
      recend,
      type10: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [89, 10, 6, 9, 18, 29, 726],
    clc$command, 23, 10, 1, 4, 0, 0, 10, 'OSM$REQMT'], [
    ['D                              ',clc$alias_entry, 8],
    ['DENSITY                        ',clc$nominal_entry, 8],
    ['EV                             ',clc$abbreviation_entry, 2],
    ['EVSN                           ',clc$alias_entry, 2],
    ['EXTERNAL_VSN                   ',clc$nominal_entry, 2],
    ['F                              ',clc$abbreviation_entry, 1],
    ['FILE                           ',clc$nominal_entry, 1],
    ['L                              ',clc$abbreviation_entry, 3],
    ['LOG                            ',clc$nominal_entry, 3],
    ['PASSWORD                       ',clc$nominal_entry, 4],
    ['PW                             ',clc$abbreviation_entry, 4],
    ['R                              ',clc$abbreviation_entry, 7],
    ['RECORDED_VSN                   ',clc$nominal_entry, 5],
    ['REMOVABLE_MEDIA_GROUP          ',clc$nominal_entry, 6],
    ['RING                           ',clc$nominal_entry, 7],
    ['RMG                            ',clc$abbreviation_entry, 6],
    ['RV                             ',clc$abbreviation_entry, 5],
    ['RVSN                           ',clc$alias_entry, 5],
    ['STATUS                         ',clc$nominal_entry, 10],
    ['T                              ',clc$abbreviation_entry, 8],
    ['TYPE                           ',clc$alias_entry, 8],
    ['VOA                            ',clc$abbreviation_entry, 9],
    ['VOLUME_OVERFLOW_ALLOWED        ',clc$nominal_entry, 9]],
    [
{ PARAMETER 1
    [7, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$required_parameter, 0
  , 0],
{ PARAMETER 2
    [5, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 49, clc$optional_parameter,
  0, 0],
{ PARAMETER 3
    [9, clc$advanced_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_default_parameter, 0, 5],
{ PARAMETER 4
    [10, clc$advanced_usage_entry, clc$secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 69,
  clc$optional_default_parameter, 0, 4],
{ PARAMETER 5
    [13, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 49, clc$optional_parameter,
  0, 0],
{ PARAMETER 6
    [14, clc$advanced_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 69,
  clc$optional_default_parameter, 31, 4],
{ PARAMETER 7
    [15, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_default_parameter, 0, 5],
{ PARAMETER 8
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 155,
  clc$optional_default_parameter, 25, 8],
{ PARAMETER 9
    [23, clc$advanced_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_default_parameter, 0, 4],
{ PARAMETER 10
    [19, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$file_type]],
{ PARAMETER 2
    [[1, 0, clc$list_type], [33, 1, clc$max_list_size, FALSE],
      [[1, 0, clc$union_type], [[clc$name_type, clc$string_type],
      TRUE, 2],
      8, [[1, 0, clc$string_type], [1, 6, FALSE]],
      5, [[1, 0, clc$name_type], [1, 6]]
      ]
    ],
{ PARAMETER 3
    [[1, 0, clc$boolean_type],
    'false'],
{ PARAMETER 4
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$name_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    5, [[1, 0, clc$name_type], [1, osc$max_name_size]]
    ,
    'none'],
{ PARAMETER 5
    [[1, 0, clc$list_type], [33, 1, clc$max_list_size, FALSE],
      [[1, 0, clc$union_type], [[clc$name_type, clc$string_type],
      TRUE, 2],
      8, [[1, 0, clc$string_type], [1, 6, FALSE]],
      5, [[1, 0, clc$name_type], [1, 6]]
      ]
    ],
{ PARAMETER 6
    [[1, 0, clc$union_type], [[clc$keyword_type, clc$name_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['NONE                           ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    5, [[1, 0, clc$name_type], [1, osc$max_name_size]]
    ,
    'OSD$REQMT_REMOVABLE_MEDIA_GROUP',
    'none'],
{ PARAMETER 7
    [[1, 0, clc$boolean_type],
    'false'],
{ PARAMETER 8
    [[1, 0, clc$keyword_type], [4], [
    ['MT18$38000                     ', clc$nominal_entry, clc$normal_usage_entry, 4],
    ['MT9$1600                       ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['MT9$6250                       ', clc$nominal_entry, clc$normal_usage_entry, 3],
    ['MT9$800                        ', clc$nominal_entry, clc$normal_usage_entry, 1]]
    ,
    'OSD$REQMT_DEFAULT_DENSITY',
    'mt9$1600'],
{ PARAMETER 9
    [[1, 0, clc$boolean_type],
    'true'],
{ PARAMETER 10
    [[1, 0, clc$status_type]]];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$file = 1,
      p$external_vsn = 2,
      p$log = 3,
      p$password = 4,
      p$recorded_vsn = 5,
      p$removable_media_group = 6,
      p$ring = 7,
      p$density = 8,
      p$volume_overflow_allowed = 9,
      p$status = 10;

    VAR
      pvt: array [1 .. 10] of clt$parameter_value;

    CONST
      ao_access_and_share_modes = 1,
      da_density = 1,
      da_device_class = 2,
      da_removable_media_group = 3,
      da_volume_list = 4,
      da_volume_overflow_allowed = 5,
      fa_attachment_logging = 1,
      fa_file_password = 2,
      max_attachment_options = 1,
      max_device_attributes = 5,
      max_file_attributes = 2;

    VAR
      attachment_options: ^fst$attachment_options,
      current_evsn: ^clt$data_value,
      current_rvsn: ^clt$data_value,
      device_attributes: ^fst$device_attributes,
      evaluated_file_reference: fst$evaluated_file_reference,
      evsn_count: integer,
      file_attributes: ^fst$file_attributes,
      volume_list_index: integer,
      resolved_path: fst$path,
      rvsn_count: integer,
      volume_list: ^rmt$volume_list,
      vsn_count: integer;

    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$evaluate_file_reference (pvt [p$file].value^.file_value^, $clt$file_ref_parsing_options [],
          FALSE, evaluated_file_reference, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    PUSH attachment_options: [1 .. max_attachment_options];
    attachment_options^ [ao_access_and_share_modes].selector := fsc$access_and_share_modes;
    attachment_options^ [ao_access_and_share_modes].access_modes.selector := fsc$specific_access_modes;
    IF pvt [p$ring].value^.boolean_value.value THEN
      attachment_options^ [ao_access_and_share_modes].access_modes.value := - $fst$file_access_options [];
    ELSE
      attachment_options^ [ao_access_and_share_modes].access_modes.value :=
            $fst$file_access_options [fsc$read, fsc$execute];
    IFEND;
    attachment_options^ [ao_access_and_share_modes].share_modes.selector := fsc$specific_share_modes;
    attachment_options^ [ao_access_and_share_modes].share_modes.value := $fst$file_access_options [];

    PUSH file_attributes: [1 .. max_file_attributes];

    file_attributes^ [fa_attachment_logging].selector := fsc$attachment_logging;
    file_attributes^ [fa_attachment_logging].attachment_logging := pvt [p$log].value^.boolean_value.value;

    file_attributes^ [fa_file_password].selector := fsc$file_password;
    IF pvt [p$password].value^.kind = clc$name THEN
      file_attributes^ [fa_file_password].file_password := pvt [p$password].value^.name_value;
    ELSE { keyword = NONE }
      file_attributes^ [fa_file_password].file_password := osc$null_name;
    IFEND;

    PUSH device_attributes: [1 .. max_device_attributes];

    device_attributes^ [da_device_class].selector := fsc$device_class;
    device_attributes^ [da_device_class].device_class := fsc$magnetic_tape_device;

    device_attributes^ [da_removable_media_group].selector := fsc$removable_media_group;
    IF pvt [p$removable_media_group].value^.kind = clc$name THEN
      device_attributes^ [da_removable_media_group].removable_media_group :=
            pvt [p$removable_media_group].value^.name_value;
    ELSE { keyword = NONE }
      device_attributes^ [da_removable_media_group].removable_media_group := osc$null_name;
    IFEND;

    evsn_count := clp$count_list_elements (pvt [p$external_vsn].value);
    rvsn_count := clp$count_list_elements (pvt [p$recorded_vsn].value);

    IF ((rvsn_count > 0) AND (evsn_count > 0)) AND (rvsn_count <> evsn_count) THEN
      osp$set_status_condition (cle$inconsistent_vsn_lists, status);
      RETURN;
    IFEND;

    IF rvsn_count > evsn_count THEN
      vsn_count := rvsn_count;
    ELSE
      vsn_count := evsn_count;
    IFEND;

    IF vsn_count = 0 THEN
      vsn_count := 1;
    IFEND;

    PUSH volume_list: [1 .. vsn_count];

    device_attributes^ [da_volume_list].selector := fsc$volume_list;
    device_attributes^ [da_volume_list].volume_list := volume_list;

    current_evsn := pvt [p$external_vsn].value;
    current_rvsn := pvt [p$recorded_vsn].value;

    FOR volume_list_index := 1 TO vsn_count DO
      IF current_evsn <> NIL THEN
        IF current_evsn^.element_value^.kind = clc$string THEN
          volume_list^ [volume_list_index].external_vsn := current_evsn^.element_value^.string_value^;
        ELSEIF current_evsn^.element_value^.kind = clc$name THEN
          volume_list^ [volume_list_index].external_vsn := current_evsn^.element_value^.name_value;
        IFEND;
        current_evsn := current_evsn^.link;
      ELSE
        volume_list^ [volume_list_index].external_vsn := rmc$unspecified_vsn;
      IFEND;
      IF current_rvsn <> NIL THEN
        IF current_rvsn^.element_value^.kind = clc$string THEN
          volume_list^ [volume_list_index].recorded_vsn := current_rvsn^.element_value^.string_value^;
        ELSEIF current_rvsn^.element_value^.kind = clc$name THEN
          volume_list^ [volume_list_index].recorded_vsn := current_rvsn^.element_value^.name_value;
        IFEND;
        current_rvsn := current_rvsn^.link;
      ELSE
        volume_list^ [volume_list_index].recorded_vsn := rmc$unspecified_vsn;
      IFEND;
    FOREND;

    FOR volume_list_index := 1 TO UPPERBOUND (volume_list^) DO
      rmp$validate_ansi_string (volume_list^ [volume_list_index].external_vsn,
            volume_list^ [volume_list_index].external_vsn, status);
      IF NOT status.normal THEN
        osp$set_status_abnormal (rmc$resource_management_id, cle$improper_vsn_value,
              volume_list^ [volume_list_index].external_vsn, status);
        osp$append_status_parameter (osc$status_parameter_delimiter, 'EXTERNAL_VSN', status);
        RETURN;
      IFEND;

      rmp$validate_ansi_string (volume_list^ [volume_list_index].recorded_vsn,
            volume_list^ [volume_list_index].recorded_vsn, status);
      IF NOT status.normal THEN
        osp$set_status_abnormal (rmc$resource_management_id, cle$improper_vsn_value,
              volume_list^ [volume_list_index].recorded_vsn, status);
        osp$append_status_parameter (osc$status_parameter_delimiter, 'RECORDED_VSN', status);
        RETURN;
      IFEND;
    FOREND;

    device_attributes^ [da_density].selector := fsc$density;
    IF pvt [p$density].value^.keyword_value = 'MT9$800' THEN
      device_attributes^ [da_density].density := rmc$800;
    ELSEIF pvt [p$density].value^.keyword_value = 'MT9$1600' THEN
      device_attributes^ [da_density].density := rmc$1600;
    ELSEIF pvt [p$density].value^.keyword_value = 'MT9$6250' THEN
      device_attributes^ [da_density].density := rmc$6250;
    ELSEIF pvt [p$density].value^.keyword_value = 'MT18$38000' THEN
      device_attributes^ [da_density].density := rmc$38000;
    IFEND;

    device_attributes^ [da_volume_overflow_allowed].selector := fsc$volume_overflow_allowed;
    device_attributes^ [da_volume_overflow_allowed].volume_overflow_allowed :=
          pvt [p$volume_overflow_allowed].value^.boolean_value.value;

?IF NOT clc$compiling_for_test_harness THEN
    fsp$create_file (pvt [p$file].value^.file_value^, attachment_options, {cycle_attributes} NIL,
          device_attributes, file_attributes, resolved_path, status);
?IFEND

  PROCEND clp$request_tape_command;

?? TITLE := 'clp$reserve_resource_command', EJECT ??

  PROCEDURE [XDCL] clp$reserve_resource_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE (osm$resr) reserve_resource, reserve_resources, resr (
{   mt9$800: integer 0..2147483647 = 0
{   mt9$1600: integer 0..2147483647 = 0
{   mt9$6250: integer 0..2147483647 = 0
{   mt18$38000: integer 0..2147483647 = 0
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 5] of clt$pdt_parameter_name,
      parameters: array [1 .. 5] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
        default_value: string (1),
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
        default_value: string (1),
      recend,
      type3: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
        default_value: string (1),
      recend,
      type4: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
        default_value: string (1),
      recend,
      type5: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [89, 2, 10, 11, 46, 4, 60],
    clc$command, 5, 5, 0, 0, 0, 0, 5, 'OSM$RESR'], [
    ['MT18$38000                     ',clc$nominal_entry, 4],
    ['MT9$1600                       ',clc$nominal_entry, 2],
    ['MT9$6250                       ',clc$nominal_entry, 3],
    ['MT9$800                        ',clc$nominal_entry, 1],
    ['STATUS                         ',clc$nominal_entry, 5]],
    [
{ PARAMETER 1
    [4, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,
  clc$optional_default_parameter, 0, 1],
{ PARAMETER 2
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,
  clc$optional_default_parameter, 0, 1],
{ PARAMETER 3
    [3, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,
  clc$optional_default_parameter, 0, 1],
{ PARAMETER 4
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,
  clc$optional_default_parameter, 0, 1],
{ PARAMETER 5
    [5, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$integer_type], [0, 2147483647, 10],
    '0'],
{ PARAMETER 2
    [[1, 0, clc$integer_type], [0, 2147483647, 10],
    '0'],
{ PARAMETER 3
    [[1, 0, clc$integer_type], [0, 2147483647, 10],
    '0'],
{ PARAMETER 4
    [[1, 0, clc$integer_type], [0, 2147483647, 10],
    '0'],
{ PARAMETER 5
    [[1, 0, clc$status_type]]];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$mt9$800 = 1,
      p$mt9$1600 = 2,
      p$mt9$6250 = 3,
      p$mt18$38000 = 4,
      p$status = 5;

    VAR
      pvt: array [1 .. 5] of clt$parameter_value;

  VAR
    reservation: rmt$tape_reservation;

    status.normal := TRUE;

    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    reservation [rmc$800] := pvt [p$mt9$800].value^.integer_value.value;
    reservation [rmc$1600] := pvt [p$mt9$1600].value^.integer_value.value;
    reservation [rmc$6250] := pvt [p$mt9$6250].value^.integer_value.value;
    reservation [rmc$38000] := pvt [p$mt18$38000].value^.integer_value.value;

    IF (reservation [rmc$800] = 0) AND (reservation [rmc$1600] = 0) AND
          (reservation [rmc$6250] = 0) AND (reservation [rmc$38000] = 0) THEN
      osp$set_status_abnormal ('CL', cle$required_parameter_omitted,
            'MT9$800, MT9$1600, MT9$6250 or MT18$38000', status);
      RETURN;
    IFEND;

    rmp$reserve_resource_command (reservation, status);

  PROCEND clp$reserve_resource_command;
?? TITLE := 'clp$release_resource_command', EJECT ??

  PROCEDURE [XDCL] clp$release_resource_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE (osm$relr) release_resource, release_resources, relr (
{   mt9$800: any of
{       key
{         all, a
{       keyend
{       integer 0..2147483647
{     anyend = 0
{   mt9$1600: any of
{       key
{         all, a
{       keyend
{       integer 0..2147483647
{     anyend = 0
{   mt9$6250: any of
{       key
{         all, a
{       keyend
{       integer 0..2147483647
{     anyend = 0
{   mt18$38000: any of
{       key
{         all, a
{       keyend
{       integer 0..2147483647
{     anyend = 0
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 5] of clt$pdt_parameter_name,
      parameters: array [1 .. 5] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 2] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$integer_type_qualifier,
        recend,
        default_value: string (1),
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 2] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$integer_type_qualifier,
        recend,
        default_value: string (1),
      recend,
      type3: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 2] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$integer_type_qualifier,
        recend,
        default_value: string (1),
      recend,
      type4: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 2] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$integer_type_qualifier,
        recend,
        default_value: string (1),
      recend,
      type5: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [89, 2, 10, 11, 49, 28, 604],
    clc$command, 5, 5, 0, 0, 0, 0, 5, 'OSM$RELR'], [
    ['MT18$38000                     ',clc$nominal_entry, 4],
    ['MT9$1600                       ',clc$nominal_entry, 2],
    ['MT9$6250                       ',clc$nominal_entry, 3],
    ['MT9$800                        ',clc$nominal_entry, 1],
    ['STATUS                         ',clc$nominal_entry, 5]],
    [
{ PARAMETER 1
    [4, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 121,
  clc$optional_default_parameter, 0, 1],
{ PARAMETER 2
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 121,
  clc$optional_default_parameter, 0, 1],
{ PARAMETER 3
    [3, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 121,
  clc$optional_default_parameter, 0, 1],
{ PARAMETER 4
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 121,
  clc$optional_default_parameter, 0, 1],
{ PARAMETER 5
    [5, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$union_type], [[clc$integer_type, clc$keyword_type],
    FALSE, 2],
    81, [[1, 0, clc$keyword_type], [2], [
      ['A                              ', clc$nominal_entry, clc$normal_usage_entry, 2],
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    20, [[1, 0, clc$integer_type], [0, 2147483647, 10]]
    ,
    '0'],
{ PARAMETER 2
    [[1, 0, clc$union_type], [[clc$integer_type, clc$keyword_type],
    FALSE, 2],
    81, [[1, 0, clc$keyword_type], [2], [
      ['A                              ', clc$nominal_entry, clc$normal_usage_entry, 2],
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    20, [[1, 0, clc$integer_type], [0, 2147483647, 10]]
    ,
    '0'],
{ PARAMETER 3
    [[1, 0, clc$union_type], [[clc$integer_type, clc$keyword_type],
    FALSE, 2],
    81, [[1, 0, clc$keyword_type], [2], [
      ['A                              ', clc$nominal_entry, clc$normal_usage_entry, 2],
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    20, [[1, 0, clc$integer_type], [0, 2147483647, 10]]
    ,
    '0'],
{ PARAMETER 4
    [[1, 0, clc$union_type], [[clc$integer_type, clc$keyword_type],
    FALSE, 2],
    81, [[1, 0, clc$keyword_type], [2], [
      ['A                              ', clc$nominal_entry, clc$normal_usage_entry, 2],
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1]]
      ],
    20, [[1, 0, clc$integer_type], [0, 2147483647, 10]]
    ,
    '0'],
{ PARAMETER 5
    [[1, 0, clc$status_type]]];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$mt9$800 = 1,
      p$mt9$1600 = 2,
      p$mt9$6250 = 3,
      p$mt18$38000 = 4,
      p$status = 5;

    VAR
      pvt: array [1 .. 5] of clt$parameter_value;

  VAR
    reservation: rmt$tape_reservation;

    status.normal := TRUE;

    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    IF pvt [p$mt9$800].value^.kind = clc$integer THEN
      reservation [rmc$800] := pvt [p$mt9$800].value^.integer_value.value;
    ELSE  { ALL or A entered
      reservation [rmc$800] := UPPERVALUE (reservation [rmc$800]);
    IFEND;

    IF pvt [p$mt9$1600].value^.kind = clc$integer THEN
      reservation [rmc$1600] := pvt [p$mt9$1600].value^.integer_value.value;
    ELSE  { ALL or A entered
      reservation [rmc$1600] := UPPERVALUE (reservation [rmc$1600]);
    IFEND;

    IF pvt [p$mt9$6250].value^.kind = clc$integer THEN
      reservation [rmc$6250] := pvt [p$mt9$6250].value^.integer_value.value;
    ELSE  { ALL or A entered
      reservation [rmc$6250] := UPPERVALUE (reservation [rmc$6250]);
    IFEND;

    IF pvt [p$mt18$38000].value^.kind = clc$integer THEN
      reservation [rmc$38000] := pvt [p$mt18$38000].value^.integer_value.value;
    ELSE  { ALL or A entered
      reservation [rmc$38000] := UPPERVALUE (reservation [rmc$38000]);
    IFEND;

    IF (reservation [rmc$800] = 0) AND (reservation [rmc$1600] = 0) AND
          (reservation [rmc$6250] = 0) AND (reservation [rmc$38000] = 0) THEN
      osp$set_status_abnormal ('CL', cle$required_parameter_omitted,
            'MT9$800, MT9$1600, MT9$6250 or MT18$38000', status);
      RETURN;
    IFEND;

    rmp$release_resource_command (reservation, status);

  PROCEND clp$release_resource_command;
?? TITLE := 'clp$request_null_command', EJECT ??

  PROCEDURE [XDCL] clp$request_null_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE (osm$reqn) request_null, reqn (
{   file, f: file = $required
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 3] of clt$pdt_parameter_name,
      parameters: array [1 .. 2] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
      type2: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [88, 11, 18, 13, 13, 55, 463],
    clc$command, 3, 2, 1, 0, 0, 0, 2, 'OSM$REQN'], [
    ['F                              ',clc$abbreviation_entry, 1],
    ['FILE                           ',clc$nominal_entry, 1],
    ['STATUS                         ',clc$nominal_entry, 2]],
    [
{ PARAMETER 1
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$required_parameter, 0
  , 0],
{ PARAMETER 2
    [3, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
  clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$file_type]],
{ PARAMETER 2
    [[1, 0, clc$status_type]]];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$file = 1,
      p$status = 2;

    VAR
      pvt: array [1 .. 2] of clt$parameter_value;

  VAR
    evaluated_file_reference: fst$evaluated_file_reference;

    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$evaluate_file_reference (pvt [p$file].value^.file_value^, $clt$file_ref_parsing_options [],
          FALSE, evaluated_file_reference, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    IF (fsp$path_element (^evaluated_file_reference, 1) ^ <> fsc$local) OR
          (evaluated_file_reference.number_of_path_elements = 1) THEN
      osp$set_status_abnormal ('CL', cle$only_permitted_on_loc_file, '', status);
      RETURN;
    IFEND;

    rmp$request_null_device (pvt [p$file].value^.file_value^, status);

  PROCEND clp$request_null_command;

MODEND clm$resource_manager_commands;
