?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE Object Code Utilities: Output Display Handlers' ??
MODULE ocm$output_display_handlers;



{ PURPOSE:
{   This module contains the general routines for handling all output displays.

?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc amt$local_file_name
*copyc clc$page_widths
*copyc cle$ecc_miscellaneous
*copyc oct$display_toggles
*copyc oct$open_file_list
?? POP ??
*copyc clp$build_standard_title
*copyc clp$convert_integer_to_string
*copyc clp$close_display
*copyc clp$display_scl_proc_parameters
*copyc clp$new_display_line
*copyc clp$new_display_page
*copyc clp$open_display_reference
*copyc clp$put_display
*copyc clp$reset_for_next_display_page
*copyc clp$right_justify_string
*copyc clp$trimmed_string_size
*copyc ocp$search_open_file_list
*copyc osp$set_status_abnormal
*copyc pmp$exit
*copyc pmp$get_legible_date_time
?? OLDTITLE ??
?? NEWTITLE := 'Global Declarations Declared by This Module', EJECT ??

  VAR
    v$display_control: [STATIC] clt$display_control,

    v$narrow_title1: [STATIC] string (clc$narrow_page_width),
    v$narrow_title2: [STATIC] string (clc$narrow_page_width),
    v$wide: [STATIC] boolean,
    v$wide_title: [STATIC] string (clc$wide_page_width),

    v$output_line: [STATIC] oct$output_line,
    v$error_line: [STATIC] oct$output_line,
    v$warning_line: [STATIC] oct$output_line;

?? OLDTITLE ??
?? NEWTITLE := 'new_page_procedure', EJECT ??

{ PURPOSE:
{   Writes the page header with current page number.

  PROCEDURE new_page_procedure
    (VAR v$display_control: clt$display_control;
         new_page_number: integer;
     VAR status: ost$status);

    CONST
      max_page_chars = 10;

    VAR
      page_number: ost$string,
      ignore: integer,
      ignore_status: ost$status,
      page_and_number: string (max_page_chars);


    clp$reset_for_next_display_page (v$display_control, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$convert_integer_to_string (v$display_control.page_number, 10, FALSE, page_number, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    page_and_number := 'PAGE ';
    page_and_number (6, * ) := page_number.value (1, page_number.size);
    IF v$display_control.include_format_effectors THEN
      clp$right_justify_string (page_and_number);
    IFEND;

    IF v$wide THEN
      v$wide_title (123, 10) := page_and_number;
      clp$put_display (v$display_control, v$wide_title, clc$trim, status);
    ELSE
      v$narrow_title1 (70, 10) := page_and_number;
      clp$put_display (v$display_control, v$narrow_title1, clc$trim, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      clp$put_display (v$display_control, v$narrow_title2, clc$trim, status);
    IFEND;
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$new_display_line (v$display_control, 2, status);

  PROCEND new_page_procedure;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] ocp$open_output_file', EJECT ??

{ PURPOSE:
{   Open the specified file as the output file.

  PROCEDURE [XDCL] ocp$open_output_file
    (    output: fst$file_reference;
         page_header: ^string ( * );
     VAR status: ost$status);


    CONST
      v$command_name = '                               ';

    VAR
      default_ring_attributes: amt$ring_attributes,
      file_has_been_opened: boolean,
      file_descriptor: ^oct$open_file_list,
      i: 1 .. 255,
      size: 1 .. 255;

    default_ring_attributes.r1 := #RING (^default_ring_attributes);
    default_ring_attributes.r2 := #RING (^default_ring_attributes);
    default_ring_attributes.r3 := #RING (^default_ring_attributes);

    clp$open_display_reference (output, ^new_page_procedure, fsc$list, default_ring_attributes,
          v$display_control, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    v$wide := v$display_control.page_width >= clc$wide_page_width;
    clp$build_standard_title (v$wide, v$command_name, v$wide_title, v$narrow_title1, v$narrow_title2,
          v$display_control, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    IF v$wide THEN
      v$wide_title (1, 85) := page_header^;
    ELSE
      size := clp$trimmed_string_size (page_header^);
      IF size > 54 THEN
        i := 54;
        WHILE page_header^ (i) <> ' ' DO
          i := i - 1;
        WHILEND;
        v$narrow_title1 (1, 54) := page_header^ (1, i);
        v$narrow_title2 (1, 54) := page_header^ (i + 1, * );
      ELSE
        v$narrow_title1 (1, 54) := page_header^;
        v$narrow_title2 (1, 54) := ' ';
      IFEND;
    IFEND;

    v$output_line.size := 0;
    v$error_line.size := 0;
    v$warning_line.size := 0;

  PROCEND ocp$open_output_file;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] ocp$output_current_line', EJECT ??

{ PURPOSE:
{   Output the line in progress.

  PROCEDURE [XDCL] ocp$output_current_line
    (    current_line: ^oct$output_line);

    VAR
      local_status: ost$status;


    IF current_line^.size = 0 THEN
      RETURN;
    IFEND;

    WHILE (current_line^.size > 2) AND (current_line^.text (current_line^.size) = ' ') DO
      current_line^.size := current_line^.size - 1;
    WHILEND;

    CASE current_line^.text (1) OF
    = occ$double_space =
      clp$new_display_line (v$display_control, 1, local_status);
    = occ$triple_space =
      clp$new_display_line (v$display_control, 2, local_status);
    = occ$new_page =
      clp$new_display_line (v$display_control, 3, local_status);
    ELSE
      local_status.normal := TRUE;
    CASEND;

    IF NOT local_status.normal THEN
      pmp$exit (local_status);
    IFEND;

    IF current_line^.size > 1 THEN
      clp$put_display (v$display_control, current_line^.text (2, current_line^.size - 1), clc$trim,
            local_status);
      IF NOT local_status.normal THEN
        pmp$exit (local_status);
      IFEND;
    IFEND;

    current_line^.size := 0;

  PROCEND ocp$output_current_line;
?? OLDTITLE ??
?? NEWTITLE := 'add_string_to_line', EJECT ??

{ PURPOSE:
{   Add the specified string to the line in progress.

  PROCEDURE add_string_to_line
    (    strng: ^string ( * );
         string_size: oct$output_line_size;
     VAR line: oct$output_line);


    VAR
      length: oct$output_line_size;


    IF (line.size + string_size) <= #SIZE (line.text) THEN
      length := string_size;
    ELSE
      length := #SIZE (line.text) - line.size;
    IFEND;

    IF length > 0 THEN
      line.text (line.size + 1, length) := strng^ (1, length);
      line.size := line.size + length;
    IFEND;

  PROCEND add_string_to_line;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] ocp$output', EJECT ??

{ PURPOSE:
{   Add the two strings to the line in progress limiting the size of the
{   second string to the given length.  The line is output if the end_of_line
{   parameter is given.

  PROCEDURE [XDCL] ocp$output
    (    string_1: string ( * );
         string_2: string ( * );
         string_2_size: integer;
         end_of_line: boolean);


    VAR
      size: integer;


    add_string_to_line (^string_1, #SIZE (string_1), v$output_line);

    IF string_2_size > #SIZE (string_2) THEN
      size := #SIZE (string_2);
    ELSE
      size := string_2_size;
    IFEND;

    add_string_to_line (^string_2, size, v$output_line);

    IF end_of_line THEN
      ocp$output_current_line (^v$output_line);
    IFEND;


  PROCEND ocp$output;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] ocp$output_scl_parameters', EJECT ??

{ PURPOSE:
{   Displays the specified procedure parameters.

  PROCEDURE [XDCL] ocp$output_scl_parameters
    (    scl_procedure: ^SEQ ( * );
     VAR status: ost$status);


    clp$display_scl_proc_parameters (v$display_control, scl_procedure, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  PROCEND ocp$output_scl_parameters;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] ocp$close_output_file', EJECT ??

{ PURPOSE:
{   Closes the output file.

  PROCEDURE [XDCL] ocp$close_output_file
    (VAR status: ost$status);


    ocp$output ('', ' ', 1, occ$end_of_line);

    clp$close_display (v$display_control, status);

  PROCEND ocp$close_output_file;
?? OLDTITLE ??

MODEND ocm$output_display_handlers;
