?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE SCL Interpreter : Command Display Interfaces' ??
MODULE clm$display_interfaces;

{
{ PURPOSE:
{   This module contains the display interfaces for the SCL command processors.
{

?? NEWTITLE := 'Global Declarations' ??
?? NEWTITLE := 'Display Interface Types', EJECT ??
*copyc clc$page_widths
*copyc clt$display_control
*copyc clt$path_display_chunks
?? OLDTITLE, EJECT ??
?? PUSH (LISTEXT := ON) ??
*IF NOT $true(osv$unix)
*IFEND
*copyc osd$virtual_address
*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 amc$mau_length
*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 clt$data_representation
*copyc clt$file
*copyc clt$path_name
*copyc fsc$max_path_size
*IF NOT $true(osv$unix)
*copyc fst$attachment_options
*copyc fst$file_cycle_attributes
*ELSE
*copyc amc_standard_files
*copyc clv$standard_files
*IFEND
*copyc fst$path
*IF NOT $true(osv$unix)
*copyc oss$job_paged_literal
*IFEND
*copyc ost$status
?? POP ??
*IF NOT $true(osv$unix)
*copyc amp$fetch
*copyc amp$get_file_attributes
*IFEND
*copyc amp$put_next
*copyc amp$put_partial
*copyc clp$get_date_string
*IF $true(osv$unix)
*copyc clp$get_screen_mode
*IFEND
*copyc clp$get_time_string
*copyc clp$right_justify_string
*copyc clp$trimmed_string_size
*IF $true(osv$unix)
*copyc osp_screen_output
*IFEND
*copyc fsp$close_file
*IF NOT $true(osv$unix)
*copyc fsp$get_open_information
*IFEND
*copyc fsp$open_file
*copyc osv$upper_to_lower
*copyc pmp$get_os_version
*IF $true(osv$unix)
*copyc osv$signal
*copyc osv$signal_status
*copyc csp$output_window
*copyc amt$file_contents
*IFEND

?? TITLE := 'clv$nil_display_control', EJECT ??

  VAR
*IF NOT $true(osv$unix)
    clv$nil_display_control: [XDCL, #GATE, READ, oss$job_paged_literal] clt$display_control :=
          [ * , * , * , 0, * , 1, [0, 1], * , * , FALSE, * , FALSE, FALSE, [0, * ], FALSE];
*ELSE
    clv$nil_display_control: [XDCL, #GATE, READ] clt$display_control :=
          [ * , * , * , 0, * , 1, -1, * , * , FALSE, * , FALSE, FALSE, [0, * ], FALSE];
*IFEND

*IF NOT $true(osv$unix)
  VAR
    clv$call_from_colt_command: [XREF] boolean;
*IFEND

?? TITLE := 'clp$close_display', EJECT ??
*copy clh$close_display

  PROCEDURE [XDCL, #GATE] clp$close_display
    (    display_control: clt$display_control;
     VAR status: ost$status);

    VAR
*IF $true(osv$unix)
      in_screen_mode: boolean,
*IFEND
      scratch_display_control: clt$display_control;


    status.normal := TRUE;
    IF display_control.data_in_line THEN
      scratch_display_control := display_control;
      flush_line (scratch_display_control, status);
    IFEND;
*IF $true(osv$unix)

{ Don't close any of the standard files
    CASE display_control.file_id OF
    = amc_stdin_fid, amc_stdout_fid, amc_stderr_fid =
      ;
    ELSE
      IF display_control.file_id <> clv$standard_files [clc$sf_null_file].file_id THEN
*IFEND
    fsp$close_file (display_control.file_id, status);
*IF $true(osv$unix)
      IFEND;
    CASEND;
*IFEND

*IF $true(osv$unix)
    clp$get_screen_mode (in_screen_mode);
{   IF in_screen_mode AND display_control.output_window  THEN
    IF in_screen_mode THEN
      csp_output_window;
    IFEND;
*IFEND
  PROCEND clp$close_display;
?? TITLE := 'clp$discard_accumulated_display', EJECT ??
*copy clh$discard_accumulated_display

  PROCEDURE [XDCL, #GATE] clp$discard_accumulated_display
    (VAR display_control {input, output} : clt$display_control;
     VAR status: ost$status);


    status.normal := TRUE;
    display_control.column_number := 1;
    display_control.data_in_line := FALSE;
    display_control.new_line_started := FALSE;
    display_control.new_page_proc_called := FALSE;
    display_control.line.size := 0;
    display_control.put_partial_line := FALSE;

  PROCEND clp$discard_accumulated_display;
?? TITLE := 'clp$horizontal_tab_display', EJECT ??
*copy clh$horizontal_tab_display

  PROCEDURE [XDCL, #GATE] clp$horizontal_tab_display
    (VAR display_control {input, output} : clt$display_control;
         column_number: amt$page_width;
     VAR status: ost$status);

    VAR
      term_option: amt$term_option,
      count: 0 .. amc$max_page_width,
      spaces: ^string ( * );


    status.normal := TRUE;
    IF NOT display_control.data_in_line THEN
      count := column_number - 1;
      term_option := amc$start;
    ELSEIF column_number > display_control.column_number THEN
      count := column_number - display_control.column_number;
      term_option := amc$continue;
    ELSE
      RETURN;
    IFEND;
    PUSH spaces: [count];
    spaces^ := '';
    clp$put_partial_display (display_control, spaces^, clc$no_trim, term_option, status);

  PROCEND clp$horizontal_tab_display;
?? TITLE := 'flush_line', EJECT ??

  PROCEDURE [INLINE] flush_line
    (VAR display_control {input, output} : clt$display_control;
     VAR status: ost$status);

    VAR
      ignore_byte_address: amt$file_byte_address;


*IF $true(osv$unix)
    IF osv$signal <> $ost$signals [] THEN
      status := osv$signal_status;
      RETURN;
    IFEND;
*IFEND

    IF display_control.put_partial_line THEN
      amp$put_partial (display_control.file_id, ^display_control.line.value, display_control.line.size,
            ignore_byte_address, amc$terminate, status);
    ELSE
      amp$put_next (display_control.file_id, ^display_control.line.value, display_control.line.size,
            ignore_byte_address, status);
    IFEND;

{ Clean out information about the line even if the put fails.

    display_control.put_partial_line := FALSE;
    display_control.line.size := 0;
    display_control.data_in_line := FALSE;

  PROCEND flush_line;
?? TITLE := 'collect_display_line', EJECT ??

  PROCEDURE [INLINE] collect_display_line
    (VAR display_control {input, output} : clt$display_control;
         str: string ( * );
         term_option: amt$term_option;
     VAR status: ost$status);

    VAR
      ignore_byte_address: amt$file_byte_address,
      str_length: integer,
      line_length: integer,
      new_line_length: integer,
      bam_term_option: amt$term_option,
      start_string: integer,
      end_string: integer;


*IF $true(osv$unix)
    IF osv$signal <> $ost$signals [] THEN
      status := osv$signal_status;
      RETURN;
    IFEND;
*IFEND

    str_length := STRLENGTH (str);
    line_length := display_control.line.size;
    new_line_length := line_length + str_length;

{ Check to make sure that new string does not cause line to exceed allowed length.

    IF new_line_length > osc$max_string_size THEN
      IF display_control.put_partial_line THEN
        bam_term_option := amc$continue;
      ELSE
        display_control.put_partial_line := TRUE;
        bam_term_option := amc$start;
      IFEND;
      display_control.line.value (display_control.line.size + 1,
            osc$max_string_size - display_control.line.size) :=
            str (1, osc$max_string_size - display_control.line.size);
      start_string := osc$max_string_size - display_control.line.size;
      amp$put_partial (display_control.file_id, ^display_control.line.value, osc$max_string_size,
            ignore_byte_address, bam_term_option, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      new_line_length := new_line_length - osc$max_string_size;
      WHILE new_line_length > osc$max_string_size DO
*IF NOT $true(osv$unix)
        amp$put_partial (display_control.file_id, ^str (start_string + 1), osc$max_string_size,
*ELSE
        amp$put_partial (display_control.file_id, ^str (start_string + 1, *), osc$max_string_size,
*IFEND
              ignore_byte_address, amc$continue, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
        start_string := start_string + osc$max_string_size;
        new_line_length := new_line_length - osc$max_string_size;
      WHILEND;
      display_control.line.value (1, new_line_length) := str (start_string + 1, new_line_length);
      display_control.line.size := new_line_length;

    ELSE

{ Add text that is passed in to line being stored in display_control.

      display_control.line.value (line_length + 1, str_length) := str;
      line_length := line_length + str_length;
      display_control.line.size := line_length;

    IFEND;

{ If procedure is called with terminate option then put the collected line out.

    IF term_option = amc$terminate THEN
      flush_line (display_control, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
    IFEND;

  PROCEND collect_display_line;
?? TITLE := 'new_display_line', EJECT ??

  PROCEDURE new_display_line
    (VAR display_control {input, output} : clt$display_control;
         skip_count: clt$new_display_line_skip;
     VAR bam_term_option {input, output} : amt$term_option;
     VAR status: ost$status);

    VAR
      ignore_byte_address: amt$file_byte_address,
*IF NOT $true(osv$unix)
      format_effector: char,
*ELSE
      format_effector: string (1),
*IFEND
      count: integer;


*IF $true(osv$unix)
    IF osv$signal <> $ost$signals [] THEN
      status := osv$signal_status;
      RETURN;
    IFEND;
*IFEND

    status.normal := TRUE;
    IF bam_term_option = amc$start THEN
      bam_term_option := amc$continue;
    IFEND;
    IF display_control.new_line_started THEN
      RETURN
    IFEND;
    count := skip_count;
    IF display_control.data_in_line THEN
      flush_line (display_control, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
    IFEND;
    IF (count + display_control.line_number >= display_control.page_length) AND
          ((display_control.page_format = amc$burstable_form) OR
          (display_control.page_format = amc$non_burstable_form)) THEN
      clp$new_display_page (display_control, status);

      IF (NOT status.normal) OR display_control.new_line_started THEN
        RETURN;
      IFEND;
      count := 0;
    IFEND;
    IF display_control.include_format_effectors THEN
      format_effector := '-';
      WHILE count >= 3 DO
        amp$put_next (display_control.file_id, ^format_effector, 1, ignore_byte_address, status);
        IF NOT status.normal THEN
          RETURN
        IFEND;
        count := count - 3;
      WHILEND;
      IF count = 1 THEN
        format_effector := '0';
      ELSEIF count = 0 THEN
        format_effector := ' ';
      ELSEIF count = -1 THEN
        format_effector := '+';
      IFEND;
      count := 1;
      display_control.line.size := 1;
      display_control.line.value (1) := format_effector;
    ELSE
      WHILE count > 0 DO
        amp$put_next (display_control.file_id, ^format_effector, 0, ignore_byte_address, status);
        IF NOT status.normal THEN
          RETURN
        IFEND;
        count := count - 1;
      WHILEND;
      display_control.line.size := 0;
    IFEND;
    display_control.line_number := display_control.line_number + skip_count + 1;
    display_control.column_number := 1;
    display_control.new_line_started := TRUE;
    display_control.data_in_line := TRUE;

  PROCEND new_display_line;
?? TITLE := 'clp$new_display_line', EJECT ??
*copy clh$new_display_line

  PROCEDURE [XDCL, #GATE] clp$new_display_line
    (VAR display_control {input, output} : clt$display_control;
         skip_count: clt$new_display_line_skip;
     VAR status: ost$status);

    VAR
      count: integer,
      dummy_term_option: amt$term_option;


    status.normal := TRUE;
    dummy_term_option := amc$start;
    IF display_control.new_line_started THEN
      count := skip_count - 1;
      IF count < 0 THEN
        RETURN;
      IFEND;
      display_control.new_line_started := FALSE;
    ELSE
      count := skip_count;
    IFEND;
    new_display_line (display_control, count, dummy_term_option, status);

  PROCEND clp$new_display_line;
?? TITLE := 'clp$new_display_page', EJECT ??
*copy clh$new_display_page

  PROCEDURE [XDCL, #GATE] clp$new_display_page
    (VAR display_control {input, output} : clt$display_control;
     VAR status: ost$status);


    status.normal := TRUE;
    IF NOT display_control.new_page_proc_called THEN
      display_control.new_page_proc_called := TRUE;
      display_control.page_number := display_control.page_number + 1;
      IF display_control.new_page_procedure = NIL THEN
        clp$reset_for_next_display_page (display_control, status);
      ELSE
        display_control.new_page_procedure^ (display_control, display_control.page_number, status);
      IFEND;
      display_control.new_page_proc_called := FALSE;
    IFEND;

  PROCEND clp$new_display_page;
?? TITLE := 'clp$open_display', EJECT ??
*copy clh$open_display

  PROCEDURE [XDCL, #GATE] clp$open_display
    (    file: clt$file;
         new_page_procedure: clt$new_display_page_procedure;
     VAR display_control: clt$display_control;
     VAR status: ost$status);

*IF NOT $true(osv$unix)
    VAR
      default_ring_attributes: amt$ring_attributes;


*IF NOT $true(osv$unix)
    default_ring_attributes.r1 := #RING (^default_ring_attributes);
    default_ring_attributes.r2 := #RING (^default_ring_attributes);
    default_ring_attributes.r3 := #RING (^default_ring_attributes);
*ELSE
    default_ring_attributes.r1 := osc$user_ring;
    default_ring_attributes.r2 := osc$user_ring;
    default_ring_attributes.r3 := osc$user_ring;
*IFEND

    clp$open_display_reference (file.local_file_name, new_page_procedure, fsc$list, default_ring_attributes,
          display_control, status);
*ELSE
    clp$open_display_reference (file.local_file_name, new_page_procedure, fsc$list,
          display_control, status);
*IFEND

  PROCEND clp$open_display;
?? TITLE := 'clp$open_display_file', EJECT ??
*copy clh$open_display_file

  PROCEDURE [XDCL, #GATE] clp$open_display_file
    (    file: clt$file;
         new_page_procedure: clt$new_display_page_procedure;
         default_file_contents: amt$file_contents;
*IF NOT $true(osv$unix)
         default_ring_attributes: amt$ring_attributes;
*IFEND
     VAR display_control: clt$display_control;
     VAR status: ost$status);


*IF NOT $true(osv$unix)
    clp$open_display_reference (file.local_file_name, new_page_procedure, default_file_contents,
          default_ring_attributes, display_control, status);
*ELSE
    clp$open_display_reference (file.local_file_name, new_page_procedure, default_file_contents,
          display_control, status);
*IFEND

  PROCEND clp$open_display_file;
?? TITLE := 'clp$open_display_reference', EJECT ??
*copy clh$open_display_reference

  PROCEDURE [XDCL, #GATE] clp$open_display_reference
    (    file: fst$file_reference;
         new_page_procedure: clt$new_display_page_procedure;
         default_file_contents: amt$file_contents;
*IF NOT $true(osv$unix)
         default_ring_attributes: amt$ring_attributes;
*IFEND
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    CONST
      list_unknown = 'LIST_UNKNOWN                   ';

    VAR
*IF NOT $true(osv$unix)
      attachment_option: array [1 .. 4] of fst$attachment_option,
      catalog_information: fst$catalog_information,
      cycle_attribute_values: fst$cycle_attribute_values,
      default_creation_attributes: array [1 .. 3] of fst$file_cycle_attribute,
      fetch_attributes: ^array [1 .. 2] of amt$fetch_item,
      user_defined_attribute_size: fst$user_defined_attribute_size,
      validation_attributes: array [1 .. 9] of fst$file_cycle_attribute;
*ELSE
      attachment_option: array [1 .. 1] of fst$attachment_option,
      in_screen_mode: boolean,
      length: ost_c_integer,
      screen_output: ost_c_fixed_string;
*IFEND


*IF $true(osv$unix)
    IF osv$signal <> $ost$signals [] THEN
      status := osv$signal_status;
      RETURN;
    IFEND;

*IFEND
    status.normal := TRUE;
    display_control := clv$nil_display_control;
    attachment_option [1].selector := fsc$access_and_share_modes;
    attachment_option [1].access_modes.selector := fsc$specific_access_modes;
    attachment_option [1].access_modes.value := $fst$file_access_options [fsc$append, fsc$shorten];
*IF NOT $true(osv$unix)
    attachment_option [1].share_modes.selector := fsc$specific_share_modes;
    attachment_option [1].share_modes.value := $fst$file_access_options [];
    attachment_option [2].selector := fsc$access_and_share_modes;
    attachment_option [2].access_modes.selector := fsc$specific_access_modes;
    attachment_option [2].access_modes.value := $fst$file_access_options [fsc$append];
    attachment_option [2].share_modes.selector := fsc$specific_share_modes;
    attachment_option [2].share_modes.value := $fst$file_access_options [];
    attachment_option [3].selector := fsc$open_share_modes;
    attachment_option [3].open_share_modes := -$fst$file_access_options [];
    IF clv$call_from_colt_command THEN
      attachment_option [4].selector := fsc$delete_data;
      attachment_option [4].delete_data := TRUE;
    ELSE
      attachment_option [4].selector := fsc$null_attachment_option;
    IFEND;

    default_creation_attributes [1].selector := fsc$file_contents_and_processor;
    default_creation_attributes [1].file_contents := default_file_contents;
    default_creation_attributes [1].file_processor := osc$null_name;
    default_creation_attributes [2].selector := fsc$page_format;
    IF default_file_contents = fsc$list THEN
      default_creation_attributes [2].page_format := amc$burstable_form;
    ELSE
      default_creation_attributes [2].page_format := amc$untitled_form;
    IFEND;
    default_creation_attributes [3].selector := fsc$ring_attributes;
    default_creation_attributes [3].ring_attributes := default_ring_attributes;
*IF NOT $true(osv$unix)
    IF #RING (^default_creation_attributes) > default_creation_attributes [3].ring_attributes.r1 THEN
      default_creation_attributes [3].ring_attributes.r1 := #RING (^default_creation_attributes);
    IFEND;
    IF #RING (^default_creation_attributes) > default_creation_attributes [3].ring_attributes.r2 THEN
      default_creation_attributes [3].ring_attributes.r2 := #RING (^default_creation_attributes);
    IFEND;
    IF #RING (^default_creation_attributes) > default_creation_attributes [3].ring_attributes.r3 THEN
      default_creation_attributes [3].ring_attributes.r3 := #RING (^default_creation_attributes);
    IFEND;
*IFEND

    validation_attributes [1].selector := fsc$file_contents_and_processor;
    validation_attributes [1].file_contents := fsc$list;
    validation_attributes [1].file_processor := osc$null_name;
    validation_attributes [2].selector := fsc$file_contents_and_processor;
    validation_attributes [2].file_contents := fsc$legible_data;
    validation_attributes [2].file_processor := osc$null_name;
    validation_attributes [3].selector := fsc$file_contents_and_processor;
    validation_attributes [3].file_contents := fsc$legible_scl_procedure;
    validation_attributes [3].file_processor := osc$null_name;
    validation_attributes [4].selector := fsc$file_contents_and_processor;
    validation_attributes [4].file_contents := fsc$legible_scl_include;
    validation_attributes [4].file_processor := osc$null_name;
    validation_attributes [5].selector := fsc$file_contents_and_processor;
    validation_attributes [5].file_contents := fsc$legible_scl_job;
    validation_attributes [5].file_processor := osc$null_name;
    validation_attributes [6].selector := fsc$file_contents_and_processor;
    validation_attributes [6].file_contents := list_unknown;
    validation_attributes [6].file_processor := osc$null_name;
    validation_attributes [7].selector := fsc$file_contents_and_processor;
    validation_attributes [7].file_contents := amc$legible;
    validation_attributes [7].file_processor := osc$null_name;
    validation_attributes [8].selector := fsc$file_contents_and_processor;
    validation_attributes [8].file_contents := fsc$data;
    validation_attributes [8].file_processor := osc$null_name;
    validation_attributes [9].selector := fsc$file_contents_and_processor;
    validation_attributes [9].file_contents := fsc$unknown_contents;
    validation_attributes [9].file_processor := osc$null_name;
*IFEND

*IF NOT $true(osv$unix)
    fsp$open_file (file, amc$record, ^attachment_option, ^default_creation_attributes, NIL,
          ^validation_attributes, NIL, display_control.file_id, status);
*ELSE
    fsp$open_file (file, amc$record, ^attachment_option, display_control.file_id, status);

{ If in screen mode, write to OSF$SCREEN_OUTPUT instead of STDOUT.  The output
{ will be displayed in the output window.

    clp$get_screen_mode (in_screen_mode);
    IF (display_control.file_id = amc_stdout_fid) AND in_screen_mode THEN

{ ??? find out what to check BEFORE attempting to open the file.

      osp_screen_output (screen_output, length);
      IF length < 1 THEN
        {???
      IFEND;
      fsp$open_file (screen_output(1, length), amc$record, ^attachment_option, display_control.file_id,
            status);
{     display_control.output_window := TRUE;
{   ELSE
{     display_control.output_window := FALSE;
    IFEND;

*IFEND
    IF NOT status.normal THEN
      RETURN;
    IFEND;

*IF NOT $true(osv$unix)
    fsp$get_open_information (display_control.file_id, NIL, ^catalog_information, NIL,
          ^cycle_attribute_values, NIL, NIL, NIL, user_defined_attribute_size, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    display_control.include_format_effectors := (cycle_attribute_values.file_contents = fsc$list);
    display_control.page_format := cycle_attribute_values.page_format;
    display_control.new_page_procedure := new_page_procedure;
    display_control.device_class := catalog_information.cycle_registration.residence.device_class;
    IF catalog_information.cycle_registration.residence.device_class = rmc$connected_file_device THEN
      PUSH fetch_attributes;
      fetch_attributes^ [1].key := amc$page_length;
      fetch_attributes^ [2].key := amc$page_width;
      amp$fetch (display_control.file_id, fetch_attributes^, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      display_control.page_length := fetch_attributes^ [1].page_length;
      display_control.page_width := fetch_attributes^ [2].page_width;
    ELSE
      display_control.page_length := cycle_attribute_values.page_length;
      display_control.page_width := cycle_attribute_values.page_width;
    IFEND;
    display_control.line_number := display_control.page_length + 1;
*ELSE
    display_control.include_format_effectors := FALSE;
{
{ ********  Force fsc$legible_data until SCL file i/o is done **********
{
{   IF default_file_contents = fsc$list THEN
{     display_control.page_format := amc$burstable_form;
{   ELSE
      display_control.page_format := amc$continuous_form;
{   IFEND;
    display_control.new_page_procedure := new_page_procedure;
{   IF NOT display_control.output_window THEN
    display_control.page_length := 24;
    display_control.page_width := 80;
{   ELSE
{     display_control.page_length := ???
{     display_control.page_width := 77;
{   IFEND
    display_control.line_number := display_control.page_length + 1;
*IFEND

  PROCEND clp$open_display_reference;
?? TITLE := 'clp$put_data_representation', EJECT ??
*copy clh$put_data_representation

  PROCEDURE [XDCL, #GATE] clp$put_data_representation
    (VAR display_control {input, output} : clt$display_control;
     VAR data_representation {input, output} : ^clt$data_representation;
     VAR status: ost$status);

    VAR
      i: clt$data_representation_count,
      string_count: ^clt$data_representation_count,
      string_ptr: ^clt$string_value,
      string_size: ^clt$string_size;

    status.normal := TRUE;

    NEXT string_count IN data_representation;
    FOR i := 1 TO string_count^ DO
      NEXT string_size IN data_representation;
      NEXT string_ptr: [string_size^] IN data_representation;
      clp$put_display (display_control, string_ptr^, clc$no_trim, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
    FOREND;

  PROCEND clp$put_data_representation;
?? TITLE := 'clp$put_display', EJECT ??
*copy clh$put_display

  PROCEDURE [XDCL, #GATE] clp$put_display
    (VAR display_control {input, output} : clt$display_control;
         str: string ( * );
         trim_option: clt$trim_display_text_option;
     VAR status: ost$status);

    VAR
      dummy_term_option: amt$term_option;


    status.normal := TRUE;
    dummy_term_option := amc$start;
    new_display_line (display_control, 0, dummy_term_option, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    clp$put_partial_display (display_control, str, trim_option, amc$terminate, status);

  PROCEND clp$put_display;
?? TITLE := 'clp$put_partial_display', EJECT ??
*copy clh$put_partial_display

  PROCEDURE [XDCL, #GATE] clp$put_partial_display
    (VAR display_control {input, output} : clt$display_control;
         str: string ( * );
         trim_option: clt$trim_display_text_option;
         term_option: amt$term_option;
     VAR status: ost$status);

    VAR
      bam_term_option: amt$term_option,
      ignore_byte_address: amt$file_byte_address,
      length: integer;


    status.normal := TRUE;
    bam_term_option := term_option;
    IF (NOT display_control.data_in_line) OR (term_option = amc$start) THEN
      new_display_line (display_control, 0, bam_term_option, status);
      IF NOT status.normal THEN
        RETURN
      IFEND;
    IFEND;
    length := STRLENGTH (str);
    IF trim_option = clc$trim THEN
      WHILE (length > 0) AND (str (length) = ' ') DO
        length := length - 1;
      WHILEND;
    IFEND;
    collect_display_line (display_control, str (1, length), bam_term_option, status);
    IF NOT status.normal THEN
      RETURN
    IFEND;
    display_control.new_line_started := FALSE;
    IF term_option = amc$terminate THEN
      display_control.data_in_line := FALSE;
      display_control.column_number := 1;
    ELSE
      display_control.data_in_line := TRUE;
      display_control.column_number := display_control.column_number + length;
    IFEND;

  PROCEND clp$put_partial_display;
?? TITLE := 'clp$reset_for_next_display_page', EJECT ??
*copy clh$reset_for_next_display_page

  PROCEDURE [XDCL, #GATE] clp$reset_for_next_display_page
    (VAR display_control {input, output} : clt$display_control;
     VAR status: ost$status);

    CONST
      non_burstable_min_lines = 6;

    VAR
*IF NOT $true(osv$unix)
      format_effector: char,
*ELSE
      format_effector: string (1),
*IFEND
      ignore_byte_address: amt$file_byte_address,
      i: 1 .. 3;


*IF $true(osv$unix)
    IF osv$signal <> $ost$signals [] THEN
      status := osv$signal_status;
      RETURN;
    IFEND;
*IFEND

    status.normal := TRUE;
    IF display_control.data_in_line THEN
      flush_line (display_control, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
    IFEND;



    IF display_control.include_format_effectors THEN
      IF (display_control.page_format = amc$burstable_form) OR
            ((display_control.page_format = amc$non_burstable_form) AND
            (display_control.line_number + non_burstable_min_lines >= display_control.page_length)) THEN
        format_effector := '1';
        display_control.line_number := 1;
      ELSE
        format_effector := '-';
        amp$put_next (display_control.file_id, ^format_effector, 1, ignore_byte_address, status);
        IF NOT status.normal THEN
          RETURN
        IFEND;
        display_control.line_number := display_control.line_number + 3;
        format_effector := ' ';
      IFEND;
      display_control.line.size := 1;
      display_control.line.value (1) := format_effector;
    ELSE
      FOR i := 1 TO 3 DO
*IF $true(osv$unix)
        format_effector := ' ';
*IFEND

        amp$put_next (display_control.file_id, ^format_effector, 0, ignore_byte_address, status);
        IF NOT status.normal THEN
          RETURN
        IFEND;
      FOREND;
      display_control.line.size := 0;
      display_control.line_number := 1;
    IFEND;
    display_control.data_in_line := TRUE;
    display_control.new_line_started := TRUE;
    display_control.column_number := 1;

  PROCEND clp$reset_for_next_display_page;
?? TITLE := 'clp$vertical_tab_display', EJECT ??
*copy clh$vertical_tab_display

  PROCEDURE [XDCL, #GATE] clp$vertical_tab_display
    (VAR display_control {input, output} : clt$display_control;
         line_number: amt$page_length;
     VAR status: ost$status);


    status.normal := TRUE;
    IF (line_number = display_control.line_number) AND (display_control.data_in_line) THEN
      RETURN;
    IFEND;
    IF line_number <= display_control.line_number THEN
      clp$new_display_page (display_control, status);
      IF (NOT status.normal) OR (line_number <= display_control.line_number) THEN
        RETURN
      IFEND;
    IFEND;
    clp$new_display_line (display_control, line_number - display_control.line_number, status);

  PROCEND clp$vertical_tab_display;
?? TITLE := 'clp$build_path_subtitle ', EJECT ??
*copy clh$build_path_subtitle

  PROCEDURE [XDCL, #GATE] clp$build_path_subtitle
    (VAR path_name {input,output} : fst$file_reference;
         length: 1 .. fsc$max_path_size;
         width: amt$page_width;
     VAR count: 0 .. fsc$max_path_elements;
     VAR display_array: clt$path_display_chunks);

    VAR
      temp_path: ^string ( * ),
      current_character_position: 0 .. fsc$max_path_size,
      break_position: 0 .. fsc$max_path_size,
      current_length: 0 .. fsc$max_path_size,
      remaining_text: 0 .. fsc$max_path_size,
      starting_position: 1 .. fsc$max_path_size;


    current_character_position := 0;
    remaining_text := length;
    count := 0;
    starting_position := 1;

    PUSH temp_path: [clp$trimmed_string_size (path_name)];
    #TRANSLATE (osv$upper_to_lower, path_name, temp_path^);
    path_name := temp_path^;
    WHILE remaining_text > 0 DO
      count := count + 1;
      IF remaining_text <= width THEN
        display_array [count].position := starting_position;
        display_array [count].length := remaining_text;
        RETURN;
      IFEND;

      break_position := 0;
      REPEAT
        current_character_position := current_character_position + 1;
*IF NOT $true(osv$unix)
        IF path_name (current_character_position) = '.' THEN
*ELSE
        IF path_name (current_character_position) = '/' THEN
*IFEND
          break_position := current_character_position;
        IFEND;
      UNTIL (current_character_position - starting_position) >= (width - 2);

      IF break_position > 0 THEN
        current_character_position := break_position;
      IFEND;

      current_length := current_character_position - starting_position;
      display_array [count].position := starting_position;
      display_array [count].length := current_length;
      starting_position := current_character_position;
      remaining_text := length - starting_position + 1;
    WHILEND;

  PROCEND clp$build_path_subtitle;
?? TITLE := 'clp$build_standard_title ', EJECT ??
*copy clh$build_standard_title

  PROCEDURE [XDCL, #GATE] clp$build_standard_title
    (    wide: boolean;
         command_name: string (osc$max_name_size);
     VAR wide_title: string (clc$wide_page_width);
     VAR narrow_title1: string (clc$narrow_page_width);
     VAR narrow_title2: string (clc$narrow_page_width);
     VAR display_control: clt$display_control;
     VAR status: ost$status);

    CONST
      max_date_length = 18,
      max_time_length = 12,
      max_page_number_length = 6;

    VAR
      date_substring: string (max_date_length),
      date_time_string: ost$string,
      time_substring: string (max_time_length),
      os_version: pmt$os_name;


    pmp$get_os_version (os_version, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    clp$get_date_string (date_time_string, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    date_substring := date_time_string.value (1, date_time_string.size);
    clp$get_time_string (date_time_string, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    time_substring := date_time_string.value (1, date_time_string.size);

    IF display_control.include_format_effectors THEN
      IF wide THEN

        wide_title := '';
        wide_title (1, 46) := command_name;
        wide_title (48, 22) := os_version;
        clp$right_justify_string (date_substring);
        wide_title (91, 18) := date_substring;
        clp$right_justify_string (time_substring);
        wide_title (110, 12) := time_substring;

      ELSE

        narrow_title1 := '';
        narrow_title2 := '';
        narrow_title1 (1, 46) := command_name;
        clp$right_justify_string (date_substring);
        narrow_title1 (48, 18) := date_substring;
        narrow_title2 (1, 22) := os_version;
        clp$right_justify_string (time_substring);
        narrow_title2 (54, 12) := time_substring;

      IFEND;
    ELSE
      IF wide THEN

        wide_title := '';
        wide_title (1, 46) := command_name;
        wide_title (48, 40) := os_version;
        wide_title (91, 18) := date_substring;
        wide_title (110, 12) := time_substring;

      ELSE

        narrow_title1 := '';
        narrow_title2 := '';
        narrow_title1 (1, 46) := command_name;
        narrow_title1 (48, 18) := date_substring;
        narrow_title2 (1, 22) := os_version;
        narrow_title2 (48, 12) := time_substring;

      IFEND;
    IFEND;

  PROCEND clp$build_standard_title;

MODEND clm$display_interfaces;
