?? NEWTITLE := ' NOS/VE Backup/Restore Utilities:  include_cycles ' ??
MODULE pum$include_cycles;
?? RIGHT := 110 ??

?? NEWTITLE := '   Global Declarations', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc pus$literals
*copyc amc$mau_length
*copyc osd$virtual_address
*copyc pud$hierarchy_list
*copyc pud$selection_criteria
*copyc cle$ecc_parsing
*copyc pue$error_condition_codes
*copyc amt$access_level
*copyc amt$attribute_source
*copyc amt$average_record_length
*copyc amt$block_type
*copyc amt$collate_table
*copyc amt$collation_value
*copyc amt$data_padding
*copyc amt$error_exit_procedure
*copyc amt$error_limit
*copyc amt$estimated_record_count
*copyc amt$file_access_selections
*copyc amt$file_attribute_keys
*copyc amt$file_attributes
*copyc amt$file_byte_address
*copyc amt$file_identifier
*copyc amt$file_length
*copyc amt$file_limit
*copyc amt$file_organization
*copyc amt$file_position
*copyc amt$forced_write
*copyc amt$global_file_position
*copyc amt$index_padding
*copyc amt$internal_code
*copyc amt$key_length
*copyc amt$key_position
*copyc amt$key_type
*copyc amt$label_exit_procedure
*copyc amt$label_options
*copyc amt$label_type
*copyc amt$local_file_name
*copyc amt$max_block_length
*copyc amt$max_record_length
*copyc amt$message_control
*copyc amt$min_block_length
*copyc amt$min_record_length
*copyc amt$padding_character
*copyc amt$record_limit
*copyc amt$record_type
*copyc amt$records_per_block
*copyc amt$return_option
*copyc amt$user_info
*copyc amt$vertical_print_density
*copyc ost$status
*copyc pft$cycle_array_entry_version_2
?? POP ??
*copyc clp$evaluate_parameters
*copyc clp$get_value
*copyc clp$scan_parameter_list
*copyc clp$test_parameter
*copyc osp$append_status_integer
*copyc osp$set_status_abnormal
*copyc pmp$compute_date_time
*copyc pmp$date_time_compare
*copyc pmp$get_compact_date_time
*copyc pup$crack_boolean
*copyc pup$crack_date_time
*copyc pup$display_integer
*copyc pup$display_line
*copyc pup$format_date_time
*copyc puv$exclude_site_backup_options
?? TITLE := '    Global Variables', EJECT ??

  VAR
    puv$maximum_cycle_size: [XDCL, STATIC] amt$file_length := amc$file_byte_limit,
    puv$minimum_cycle_size: [XDCL, STATIC] amt$file_length := 0;

  VAR
    before_default_increment: [pus$literals, READ] pmt$time_increment := [0, 0, 1, 0, 0, 0, 0] {1 day} ,
    selection_criteria_name_table: [STATIC, READ, pus$literals] array [put$selection_criteria_mode] of
          string (9) := ['CREATED', 'ACCESSED', 'MODIFIED', 'EXPIRED'];

  VAR
    puv$backup_criteria: [XDCL] put$selection_criteria := [ * , FALSE, * , FALSE, * , * ];

?? TITLE := '    [XDCL] pup$backup_include_cycles ', EJECT ??

  PROCEDURE [XDCL] pup$backup_include_cycles
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE (osm$bacpf_incc) include_cycles, include_cycle, incc (
{   selection_criteria, sc:
{     key
{       (created, c)
{       (accessed, a)
{       (modified, m)
{       (expired, e)
{       (ignore_date_time, idt)
{     keyend = $required
{   after, a: date_time = 1980-01-01.00:00:00.000
{   before, b: date_time = $optional
{   status)

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 7] of clt$pdt_parameter_name,
      parameters: array [1 .. 4] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 10] of clt$keyword_specification,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$date_time_type_qualifier,
        default_value: string (23),
      recend,
      type3: record
        header: clt$type_specification_header,
        qualifier: clt$date_time_type_qualifier,
      recend,
      type4: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [90, 12, 11, 13, 18, 59, 393],
    clc$command, 7, 4, 1, 0, 0, 0, 4, 'OSM$BACPF_INCC'], [
    ['A                              ',clc$abbreviation_entry, 2],
    ['AFTER                          ',clc$nominal_entry, 2],
    ['B                              ',clc$abbreviation_entry, 3],
    ['BEFORE                         ',clc$nominal_entry, 3],
    ['SC                             ',clc$abbreviation_entry, 1],
    ['SELECTION_CRITERIA             ',clc$nominal_entry, 1],
    ['STATUS                         ',clc$nominal_entry, 4]],
    [
{ PARAMETER 1
    [6, 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, 377,
  clc$required_parameter, 0, 0],
{ 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, 5,
  clc$optional_default_parameter, 0, 23],
{ PARAMETER 3
    [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, 5, clc$optional_parameter, 0
  , 0],
{ PARAMETER 4
    [7, 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$keyword_type], [10], [
    ['A                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['ACCESSED                       ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['C                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['CREATED                        ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['E                              ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
    ['EXPIRED                        ', clc$nominal_entry, clc$normal_usage_entry, 4],
    ['IDT                            ', clc$abbreviation_entry, clc$normal_usage_entry, 5],
    ['IGNORE_DATE_TIME               ', clc$nominal_entry, clc$normal_usage_entry, 5],
    ['M                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['MODIFIED                       ', clc$nominal_entry, clc$normal_usage_entry, 3]]
    ],
{ PARAMETER 2
    [[1, 0, clc$date_time_type], [$clt$date_and_or_time [clc$date, clc$time], $clt$date_time_tenses [clc$past
  , clc$present, clc$future]],
    '1980-01-01.00:00:00.000'],
{ PARAMETER 3
    [[1, 0, clc$date_time_type], [$clt$date_and_or_time [clc$date, clc$time], $clt$date_time_tenses [clc$past
  , clc$present, clc$future]]],
{ PARAMETER 4
    [[1, 0, clc$status_type]]];

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

    CONST
      p$selection_criteria = 1,
      p$after = 2,
      p$before = 3,
      p$status = 4;

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

    VAR
      all_selected: boolean,
      comparison_result: pmt$comparison_result,
      current_date_time: ost$date_time,
      date_time_string: string (25),
      ignore_status: ost$status,
      input_date_time_after: ost$date_time,
      input_date_time_before: ost$date_time,
      input_selection_mode: put$selection_criteria_mode,
      output_line: string (80),
      output_line_index: integer;

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

    input_date_time_after := pvt [p$after].value^.date_time_value.value;
    IF NOT pvt [p$after].value^.date_time_value.date_specified THEN
      osp$set_status_abnormal (puc$pf_utility_id, pue$date_part_omitted, 'AFTER', status);
      RETURN; {----->
    IFEND;

    IF NOT pvt [p$after].value^.date_time_value.time_specified THEN
      input_date_time_after.hour := 0;
      input_date_time_after.minute := 0;
      input_date_time_after.second := 0;
      input_date_time_after.millisecond := 0;
    IFEND;

    IF pvt [p$before].specified THEN
      input_date_time_before := pvt [p$before].value^.date_time_value.value;
      IF NOT pvt [p$before].value^.date_time_value.date_specified THEN
        osp$set_status_abnormal (puc$pf_utility_id, pue$date_part_omitted, 'BEFORE', status);
        RETURN; {----->
      IFEND;
      IF NOT pvt [p$before].value^.date_time_value.time_specified THEN
        input_date_time_before.hour := 0;
        input_date_time_before.minute := 0;
        input_date_time_before.second := 0;
        input_date_time_before.millisecond := 0;
      IFEND;
    ELSE
      pmp$get_compact_date_time (current_date_time, status);
      IF status.normal THEN
        pmp$compute_date_time (current_date_time, before_default_increment, input_date_time_before, status);
      IFEND;
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
    IFEND;

    puv$backup_criteria.after_date_time_selected := FALSE;
    puv$backup_criteria.before_date_time_selected := FALSE;
    IF (pvt [p$selection_criteria].value^.keyword_value = 'IGNORE_DATE_TIME') THEN
      pup$display_line (' INCLUDE CYCLES IGNORE_DATE_TIME', status);
    ELSE
      IF input_date_time_after = input_date_time_before THEN
        osp$set_status_abnormal (puc$pf_utility_id, pue$before_after_time_equal, '', status);
      ELSE

      /find_selection_criteria_name/
        FOR input_selection_mode := puc$created TO puc$expired DO
          IF selection_criteria_name_table [input_selection_mode] = pvt [p$selection_criteria].
                value^.keyword_value THEN
            EXIT /find_selection_criteria_name/; {----->
          IFEND;
        FOREND /find_selection_criteria_name/;
        { CL will detect the case of an illegal selection criteria mode

        puv$backup_criteria.mode := input_selection_mode;
        output_line := ' INCLUDE CYCLES ';
        output_line (17, * ) := selection_criteria_name_table [input_selection_mode];
        pup$display_line (output_line, status);
        puv$backup_criteria.after_date_time_selected := TRUE;
        puv$backup_criteria.after_date_time := input_date_time_after;
        pup$format_date_time (input_date_time_after, date_time_string);
        output_line := '  AFTER  ';
        output_line (10, * ) := date_time_string;
        pup$display_line (output_line, status);
        puv$backup_criteria.before_date_time_selected := TRUE;
        puv$backup_criteria.before_date_time := input_date_time_before;
        pup$format_date_time (input_date_time_before, date_time_string);
        output_line := '  BEFORE ';
        output_line (10, * ) := date_time_string;
        pup$display_line (output_line, status);
        pmp$date_time_compare (puv$backup_criteria.after_date_time, puv$backup_criteria.before_date_time,
              comparison_result, ignore_status);
        puv$backup_criteria.after_time_after_before_time := (comparison_result = pmc$left_is_greater);
      IFEND;
    IFEND;
  PROCEND pup$backup_include_cycles;

?? TITLE := '    [XDCL] pup$check_cycle_access ', EJECT ??

  PROCEDURE [XDCL] pup$check_cycle_access
    (    cycle_array_entry: pft$cycle_array_entry_version_2;
     VAR cycle_included: boolean);

    VAR
      before_time_after_cycle_time: boolean,
      comparison_result: pmt$comparison_result,
      cycle_date_time: ost$date_time,
      cycle_time_after_after_time: boolean,
      ignore_status: ost$status;

    IF (NOT puv$backup_criteria.after_date_time_selected) AND
          (NOT puv$backup_criteria.before_date_time_selected) THEN
      cycle_included := TRUE;
    ELSE
      select_cycle_date_time (cycle_array_entry, puv$backup_criteria.mode, cycle_date_time);
      IF puv$backup_criteria.after_date_time_selected THEN
        pmp$date_time_compare (cycle_date_time, puv$backup_criteria.after_date_time, comparison_result,
              ignore_status);
        cycle_time_after_after_time := (comparison_result = pmc$left_is_greater);
      IFEND;
      IF puv$backup_criteria.before_date_time_selected THEN
        pmp$date_time_compare (puv$backup_criteria.before_date_time, cycle_date_time, comparison_result,
              ignore_status);
        before_time_after_cycle_time := (comparison_result = pmc$left_is_greater);
      IFEND;
      IF puv$backup_criteria.after_date_time_selected AND puv$backup_criteria.before_date_time_selected THEN
        IF puv$backup_criteria.after_time_after_before_time THEN
          cycle_included := cycle_time_after_after_time OR before_time_after_cycle_time;
        ELSE
          cycle_included := cycle_time_after_after_time AND before_time_after_cycle_time;
        IFEND;
      ELSEIF puv$backup_criteria.after_date_time_selected THEN
        cycle_included := cycle_time_after_after_time;
      ELSE
        cycle_included := before_time_after_cycle_time;
      IFEND;
    IFEND;

    IF cycle_array_entry.sparse_allocation OR ((cycle_array_entry.device_class <>
          rmc$magnetic_tape_device) AND (cycle_array_entry.device_class <> rmc$mass_storage_device)) THEN
      cycle_included := FALSE;
    IFEND;

  PROCEND pup$check_cycle_access;

?? TITLE := '    [XDCL] pup$check_if_size_included ', EJECT ??

  PROCEDURE [XDCL] pup$check_if_size_included
    (    cycle_size: amt$file_length;
     VAR cycle_included: boolean);

    cycle_included := (cycle_size >= puv$minimum_cycle_size) AND (cycle_size <= puv$maximum_cycle_size);

  PROCEND pup$check_if_size_included;

?? TITLE := '    [XDCL] pup$check_site_backup_options ', EJECT ??

  PROCEDURE [XDCL] pup$check_site_backup_options
    (    cycle_array_entry: pft$cycle_array_entry_version_2;
     VAR cycle_included: boolean);

    cycle_included := NOT (cycle_array_entry.site_backup_option IN puv$exclude_site_backup_options);

  PROCEND pup$check_site_backup_options;

?? TITLE := '    [XDCL] pup$dis_included_cycles_cm ', EJECT ??

  PROCEDURE [XDCL] pup$dis_included_cycles_cm
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);


{  PDT dis_included_cycles_pdt (status)

?? PUSH (LISTEXT := ON) ??

    VAR
      dis_included_cycles_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table :=
            [^dis_included_cycles_pdt_names, ^dis_included_cycles_pdt_params];

    VAR
      dis_included_cycles_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 1] of
            clt$parameter_name_descriptor := [['STATUS', 1]];

    VAR
      dis_included_cycles_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 1] of
            clt$parameter_descriptor := [

{ STATUS }
      [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed,
            [NIL, clc$variable_reference, clc$array_not_allowed, clc$status_value]]];

?? POP ??

    clp$scan_parameter_list (parameter_list, dis_included_cycles_pdt, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    pup$display_included_cycles;
  PROCEND pup$dis_included_cycles_cm;

?? TITLE := '    [XDCL] pup$display_included_cycles ', EJECT ??

  PROCEDURE [XDCL] pup$display_included_cycles;

    VAR
      date_time_string: string (25),
      status: ost$status;

    IF (NOT puv$backup_criteria.after_date_time_selected) AND
          (NOT puv$backup_criteria.before_date_time_selected) THEN
      pup$display_line (' ALL CYCLES SELECTED', status);
    ELSEIF puv$backup_criteria.after_date_time_selected AND puv$backup_criteria.before_date_time_selected THEN
      IF puv$backup_criteria.after_time_after_before_time THEN
        pup$display_line (' cycles NOT ', status);
        pup$display_line (selection_criteria_name_table [puv$backup_criteria.mode], status);
        pup$display_line (' within the following window will be backed up', status);
      ELSE
        pup$display_line (' cycles ', status);
        pup$display_line (selection_criteria_name_table [puv$backup_criteria.mode], status);
        pup$display_line (' within the following window will be backed up', status);
      IFEND;
      pup$display_line (' before date time', status);
      pup$format_date_time (puv$backup_criteria.before_date_time, date_time_string);
      pup$display_line (date_time_string, status);
      pup$display_line (' after date time', status);
      pup$format_date_time (puv$backup_criteria.after_date_time, date_time_string);
      pup$display_line (date_time_string, status);
    ELSEIF puv$backup_criteria.after_date_time_selected THEN
      pup$display_line (' cycles ', status);
      pup$display_line (selection_criteria_name_table [puv$backup_criteria.mode], status);
      pup$display_line (' after the following date will be backed up', status);
      pup$format_date_time (puv$backup_criteria.after_date_time, date_time_string);
      pup$display_line (date_time_string, status);
    ELSE {puv$backup_criteria.before_date_time_selected}
      pup$display_line (' cycles', status);
      pup$display_line (selection_criteria_name_table [puv$backup_criteria.mode], status);
      pup$display_line (' before the follwing date will be backed up', status);
      pup$format_date_time (puv$backup_criteria.before_date_time, date_time_string);
      pup$display_line (date_time_string, status);
    IFEND;
    pup$display_integer (' Minimum_cycle_size: ', puv$minimum_cycle_size, status);
    pup$display_integer (' Maximum_cycle_size: ', puv$maximum_cycle_size, status);
  PROCEND pup$display_included_cycles;


?? TITLE := '    [XDCL] pup$include_large_cycles_cmd ', EJECT ??

  PROCEDURE [XDCL] pup$include_large_cycles_cmd
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

?? RIGHT := 110 ??
{ PDT include_large_cycles_pdt (minimum_size, ms: integer 0 .. amc$file_byte_limit = $required
{  status)

?? PUSH (LISTEXT := ON) ??

    VAR
      include_large_cycles_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table :=
            [^include_large_cycles_pdt_names, ^include_large_cycles_pdt_params];

    VAR
      include_large_cycles_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 3] of
            clt$parameter_name_descriptor := [['MINIMUM_SIZE', 1], ['MS', 1], ['STATUS', 2]];

    VAR
      include_large_cycles_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 2] of
            clt$parameter_descriptor := [

{ MINIMUM_SIZE MS }
      [[clc$required], 1, 1, 1, 1, clc$value_range_not_allowed,
            [NIL, clc$integer_value, 0, amc$file_byte_limit]],

{ STATUS }
      [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed,
            [NIL, clc$variable_reference, clc$array_not_allowed, clc$status_value]]];

?? POP ??

    VAR
      value: clt$value;

    clp$scan_parameter_list (parameter_list, include_large_cycles_pdt, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    clp$get_value ('MINIMUM_SIZE', 1, 1, clc$low, value, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF puv$maximum_cycle_size < value.int.value THEN
      osp$set_status_abnormal (puc$pf_utility_id, pue$entered_size_above_maximum, '', status);
      osp$append_status_integer (osc$status_parameter_delimiter, value.int.value, value.int.radix,
            value.int.radix_specified, status);
      osp$append_status_integer (osc$status_parameter_delimiter, puv$maximum_cycle_size, value.int.radix,
            value.int.radix_specified, status);
    ELSE
      puv$minimum_cycle_size := value.int.value;
      pup$display_integer (' INCLUDING CYCLES OF LENGTH AT LEAST: ', puv$minimum_cycle_size, status);
    IFEND;

  PROCEND pup$include_large_cycles_cmd;

?? TITLE := '    [XDCL] pup$include_small_cycles_cmd ', EJECT ??

  PROCEDURE [XDCL] pup$include_small_cycles_cmd
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

?? RIGHT := 110 ??

{ pdt include_small_cycles_pdt (
{   maximum_size, ms: integer 0 .. amc$file_byte_limit OR ..
{                       KEY maximum = $required
{   status)

?? PUSH (LISTEXT := ON) ??

    VAR
      include_small_cycles_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table :=
            [^include_small_cycles_pdt_names, ^include_small_cycles_pdt_params];

    VAR
      include_small_cycles_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 3] of
            clt$parameter_name_descriptor := [['MAXIMUM_SIZE', 1], ['MS', 1], ['STATUS', 2]];

    VAR
      include_small_cycles_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 2] of
            clt$parameter_descriptor := [

{ MAXIMUM_SIZE MS }
      [[clc$required], 1, 1, 1, 1, clc$value_range_not_allowed,
            [^include_small_cycles_pdt_kv1, clc$integer_value, 0, amc$file_byte_limit]],

{ STATUS }
      [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed,
            [NIL, clc$variable_reference, clc$array_not_allowed, clc$status_value]]];

    VAR
      include_small_cycles_pdt_kv1: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 1] of
            ost$name := ['MAXIMUM'];

?? POP ??

    VAR
      value: clt$value;

    clp$scan_parameter_list (parameter_list, include_small_cycles_pdt, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    clp$get_value ('MAXIMUM_SIZE', 1, 1, clc$low, value, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    IF puv$minimum_cycle_size > value.int.value THEN
      osp$set_status_abnormal (puc$pf_utility_id, pue$entered_size_below_minimum, '', status);
      osp$append_status_integer (osc$status_parameter_delimiter, value.int.value, value.int.radix,
            value.int.radix_specified, status);
      osp$append_status_integer (osc$status_parameter_delimiter, puv$minimum_cycle_size, value.int.radix,
            value.int.radix_specified, status);
    ELSE
      puv$maximum_cycle_size := value.int.value;
      pup$display_integer (' INCLUDING CYCLES OF LENGTH AT MOST: ', puv$maximum_cycle_size, status);
    IFEND;

  PROCEND pup$include_small_cycles_cmd;

?? TITLE := '    [XDCL] pup$restore_include_cycles ', EJECT ??

  PROCEDURE [XDCL] pup$restore_include_cycles
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE (osm$respf_incc) include_cycles, include_cycle, incc (
{   selection_criteria, sc:
{     key
{       (created, c)
{       (accessed, a)
{       (modified, m)
{       (expired, e)
{       (ignore_date_time, idt)
{     keyend = $required
{   after, a: date_time = 1980-01-01.00:00:00.000
{   before, b: date_time = $optional
{   status)

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 7] of clt$pdt_parameter_name,
      parameters: array [1 .. 4] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 10] of clt$keyword_specification,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$date_time_type_qualifier,
        default_value: string (23),
      recend,
      type3: record
        header: clt$type_specification_header,
        qualifier: clt$date_time_type_qualifier,
      recend,
      type4: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [90, 12, 11, 13, 19, 9, 773],
    clc$command, 7, 4, 1, 0, 0, 0, 4, 'OSM$RESPF_INCC'], [
    ['A                              ',clc$abbreviation_entry, 2],
    ['AFTER                          ',clc$nominal_entry, 2],
    ['B                              ',clc$abbreviation_entry, 3],
    ['BEFORE                         ',clc$nominal_entry, 3],
    ['SC                             ',clc$abbreviation_entry, 1],
    ['SELECTION_CRITERIA             ',clc$nominal_entry, 1],
    ['STATUS                         ',clc$nominal_entry, 4]],
    [
{ PARAMETER 1
    [6, 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, 377,
  clc$required_parameter, 0, 0],
{ 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, 5,
  clc$optional_default_parameter, 0, 23],
{ PARAMETER 3
    [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, 5, clc$optional_parameter, 0
  , 0],
{ PARAMETER 4
    [7, 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$keyword_type], [10], [
    ['A                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
    ['ACCESSED                       ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['C                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
    ['CREATED                        ', clc$nominal_entry, clc$normal_usage_entry, 1],
    ['E                              ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
    ['EXPIRED                        ', clc$nominal_entry, clc$normal_usage_entry, 4],
    ['IDT                            ', clc$abbreviation_entry, clc$normal_usage_entry, 5],
    ['IGNORE_DATE_TIME               ', clc$nominal_entry, clc$normal_usage_entry, 5],
    ['M                              ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
    ['MODIFIED                       ', clc$nominal_entry, clc$normal_usage_entry, 3]]
    ],
{ PARAMETER 2
    [[1, 0, clc$date_time_type], [$clt$date_and_or_time [clc$date, clc$time], $clt$date_time_tenses [clc$past
  , clc$present, clc$future]],
    '1980-01-01.00:00:00.000'],
{ PARAMETER 3
    [[1, 0, clc$date_time_type], [$clt$date_and_or_time [clc$date, clc$time], $clt$date_time_tenses [clc$past
  , clc$present, clc$future]]],
{ PARAMETER 4
    [[1, 0, clc$status_type]]];

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

    CONST
      p$selection_criteria = 1,
      p$after = 2,
      p$before = 3,
      p$status = 4;

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

    VAR
      all_selected: boolean,
      comparison_result: pmt$comparison_result,
      current_date_time: ost$date_time,
      date_time_string: string (25),
      ignore_status: ost$status,
      input_date_time_after: ost$date_time,
      input_date_time_before: ost$date_time,
      input_selection_mode: put$selection_criteria_mode,
      output_line: string (80),
      output_line_index: integer;

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

    input_date_time_after := pvt [p$after].value^.date_time_value.value;
    IF NOT pvt [p$after].value^.date_time_value.date_specified THEN
      osp$set_status_abnormal (puc$pf_utility_id, pue$date_part_omitted, 'AFTER', status);
      RETURN; {----->
    IFEND;
    IF NOT pvt [p$after].value^.date_time_value.time_specified THEN
      input_date_time_after.hour := 0;
      input_date_time_after.minute := 0;
      input_date_time_after.second := 0;
      input_date_time_after.millisecond := 0;
    IFEND;

    IF pvt [p$before].specified THEN
      input_date_time_before := pvt [p$before].value^.date_time_value.value;
      IF NOT pvt [p$before].value^.date_time_value.date_specified THEN
        osp$set_status_abnormal (puc$pf_utility_id, pue$date_part_omitted, 'BEFORE', status);
        RETURN; {----->
      IFEND;
      IF NOT pvt [p$before].value^.date_time_value.time_specified THEN
        input_date_time_before.hour := 0;
        input_date_time_before.minute := 0;
        input_date_time_before.second := 0;
        input_date_time_before.millisecond := 0;
      IFEND;
    ELSE
      pmp$get_compact_date_time (current_date_time, status);
      IF status.normal THEN
        pmp$compute_date_time (current_date_time, before_default_increment, input_date_time_before, status);
      IFEND;
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
    IFEND;

    puv$backup_criteria.after_date_time_selected := FALSE;
    puv$backup_criteria.before_date_time_selected := FALSE;
    IF (pvt [p$selection_criteria].value^.keyword_value = 'IGNORE_DATE_TIME') THEN
      pup$display_line (' INCLUDE CYCLES IGNORE_DATE_TIME', status);
    ELSE
      IF input_date_time_after = input_date_time_before THEN
        osp$set_status_abnormal (puc$pf_utility_id, pue$before_after_time_equal, '', status);
      ELSE

      /find_selection_criteria_name/
        FOR input_selection_mode := puc$created TO puc$expired DO
          IF selection_criteria_name_table [input_selection_mode] = pvt [p$selection_criteria].
                value^.keyword_value THEN
            EXIT /find_selection_criteria_name/; {----->
          IFEND;
        FOREND /find_selection_criteria_name/;
        { CL will detect the case of an illegal selection criteria mode

        puv$backup_criteria.mode := input_selection_mode;
        output_line := ' INCLUDE CYCLES ';
        output_line (17, * ) := selection_criteria_name_table [input_selection_mode];
        pup$display_line (output_line, status);
        puv$backup_criteria.after_date_time_selected := TRUE;
        puv$backup_criteria.after_date_time := input_date_time_after;
        pup$format_date_time (input_date_time_after, date_time_string);
        output_line := '  AFTER  ';
        output_line (10, * ) := date_time_string;
        pup$display_line (output_line, status);
        puv$backup_criteria.before_date_time_selected := TRUE;
        puv$backup_criteria.before_date_time := input_date_time_before;
        pup$format_date_time (input_date_time_before, date_time_string);
        output_line := '  BEFORE ';
        output_line (10, * ) := date_time_string;
        pup$display_line (output_line, status);
        pmp$date_time_compare (puv$backup_criteria.after_date_time, puv$backup_criteria.before_date_time,
              comparison_result, ignore_status);
        puv$backup_criteria.after_time_after_before_time := (comparison_result = pmc$left_is_greater);
      IFEND;
    IFEND;
  PROCEND pup$restore_include_cycles;

?? TITLE := '    select_cycle_date_time ', EJECT ??

  PROCEDURE select_cycle_date_time
    (    cycle_array_entry: pft$cycle_array_entry_version_2;
         selection_criteria_mode: put$selection_criteria_mode;
     VAR cycle_date_time: ost$date_time);

    CASE selection_criteria_mode OF
    = puc$created =
      cycle_date_time := cycle_array_entry.cycle_statistics.creation_date_time;
    = puc$accessed =
      cycle_date_time := cycle_array_entry.cycle_statistics.access_date_time;
    = puc$modified =
      cycle_date_time := cycle_array_entry.cycle_statistics.modification_date_time;
    = puc$expired =
      cycle_date_time := cycle_array_entry.expiration_date_time;
    CASEND;
  PROCEND select_cycle_date_time;

MODEND pum$include_cycles;
