?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE Object Code Utilities: Display Object Text' ??
MODULE ocm$list_object_file;

{
{ PURPOSE:
{   This module contains the processor for the DISPLAY_OBJECT_TEXT command
{   (once called LIST_OBJECT_FILE).
{

?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc clt$scl_procedure
*copyc cyd$debug_symbol_table
*copyc llt$deferred_common_blocks
*copyc llt$deferred_entry_points
*copyc llt$function_dictionary
*copyc llt$help_module_dictionary
*copyc llt$load_module
*copyc llt$message_module_dictionary
*copyc llt$object_library
*copyc llt$object_module
*copyc llt$panel_dictionary
*copyc oce$library_generator_errors
*copyc oct$display_toggles
?? POP ??
*copyc amp$get_segment_pointer
*copyc clp$convert_integer_to_string
*copyc clp$evaluate_parameters
*copyc clp$get_message_module_info
*copyc fsp$get_open_information
*copyc fsp$open_file
*copyc i#build_adaptable_array_ptr
*copyc i#current_sequence_position
*copyc ocp$close_output_file
*copyc ocp$convert_information_element
*copyc ocp$initialize_oc_environment
*copyc ocp$open_output_file
*copyc ocp$output
*copyc ocp$output_boolean
*copyc ocp$output_date
*copyc ocp$output_module_generator
*copyc ocp$output_module_kind
*copyc ocp$output_section_kind
*copyc ocp$output_time
*copyc osp$set_status_abnormal
*copyc pmp$get_last_path_name
*copyc pmp$position_object_library
?? OLDTITLE ??
?? NEWTITLE := 'Global Declarations Declared by This Module', EJECT ??

  CONST
    c$allotted = TRUE,
    premature_end_of_file = 'PREMATURE END-OF-FILE ENCOUNTERED';

?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] ocp$list_object_file', EJECT ??

  PROCEDURE [XDCL, #GATE] ocp$list_object_file
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

?? NEWTITLE := 'process_cybil_symbol_table', EJECT ??

    PROCEDURE process_cybil_symbol_table
      (    sequence_length: ost$segment_length;
       VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        debug_table_fragment: ^llt$debug_table_fragment,
        text: ^SEQ ( * ),
        number_of_items: integer,
        debug_symbol_table: ^cyt$debug_symbol_table,
        item: ^array [0 .. * ] of cyt$debug_symbol_table_item,
        i: integer;


      NEXT debug_table_fragment: [[REP sequence_length OF cell]] IN file;
      IF debug_table_fragment = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      hexrep (strng, length, debug_table_fragment^.offset);
      ocp$output ('      ', 'offset:', 7, occ$continue);
      ocp$output (' ', strng, length, occ$end_of_line);

      IF module_info.version >= 'V1.3' THEN
        number_of_items := sequence_length DIV #SIZE (cyt$debug_symbol_table_item);

        text := ^debug_table_fragment^.text;
        RESET text;

        IF (sequence_length MOD #SIZE (cyt$debug_symbol_table_item)) <> 0 THEN
          NEXT debug_symbol_table: [0 .. number_of_items - 1] IN text;
          IF debug_symbol_table = NIL THEN
            error (' ', 'INTERNAL PROBLEM 7', 18, occ$end_of_line);
            fatal_error := TRUE;
            RETURN;
          IFEND;

          ocp$output ('      ', 'original name:', 14, occ$continue);
          ocp$output (' ', debug_symbol_table^.original_name, #SIZE (debug_symbol_table^.original_name),
                occ$end_of_line);

          ocp$output ('      ', 'language:', 9, occ$continue);
          output_language (^debug_symbol_table^.language, occ$continue);

          STRINGREP (strng, length, debug_symbol_table^.optimization_level);
          ocp$output ('  ', 'optimization level:', 19, occ$continue);
          ocp$output (' ', strng, length, occ$end_of_line);

          ocp$output ('      ', 'version:', 8, occ$continue);
          ocp$output (' ', debug_symbol_table^.version, #SIZE (debug_symbol_table^.version), occ$continue);

          STRINGREP (strng, length, debug_symbol_table^.module_symbol_list);
          ocp$output ('  module symbol list:', strng, length, occ$continue);

          STRINGREP (strng, length, debug_symbol_table^.number_of_symbols);
          ocp$output ('  number of symbols:', strng, length, occ$end_of_line);

          item := ^debug_symbol_table^.item;

        ELSE
          NEXT item: [0 .. number_of_items - 1] IN text;
          IF item = NIL THEN
            error (' ', 'INTERNAL PROBLEM 8', 18, occ$end_of_line);
            fatal_error := TRUE;
            RETURN;
          IFEND;
        IFEND;

        FOR i := 0 TO (number_of_items - 1) DO
          ocp$output ('0     ', 'symbol name:', 12, occ$continue);
          ocp$output (' ', item^ [i].symbol_name, #SIZE (item^ [i].symbol_name), occ$continue);

          STRINGREP (strng, length, item^ [i].symtab_no);
          ocp$output ('  symtab no:', strng, length, occ$end_of_line);

          ocp$output ('      ', 'end of chain:', 13, occ$continue);
          ocp$output_boolean (item^ [i].end_of_chain, occ$continue);

          ocp$output ('  ', 'symbol type:', 12, occ$continue);

          CASE item^ [i].symbol_type OF
          = int_kind =
            ocp$output (' ', 'INT KIND', 8, occ$end_of_line);

          = bool_kind =
            ocp$output (' ', 'BOOL KIND', 9, occ$end_of_line);

          = char_kind =
            ocp$output (' ', 'CHAR KIND', 9, occ$end_of_line);

          = real_kind =
            ocp$output (' ', 'REAL KIND', 9, occ$end_of_line);

          = longreal_kind =
            ocp$output (' ', 'LONGREAL KIND', 13, occ$end_of_line);

          = cell_kind =
            ocp$output (' ', 'CELL KIND', 9, occ$end_of_line);

          = var_kind =
            ocp$output (' ', 'VAR KIND', 8, occ$end_of_line);

            STRINGREP (strng, length, item^ [i].var_type);
            ocp$output ('      var type:', strng, length, occ$continue);

            hexrep (strng, length, item^ [i].var_length);
            ocp$output ('  var length: ', strng, length, occ$continue);

            ocp$output ('  ', 'base: ', 6, occ$continue);
            CASE item^ [i].base OF
            = null_base =
              ocp$output (' ', 'NULL BASE', 9, occ$end_of_line);
            = static_base =
              ocp$output (' ', 'STATIC BASE', 11, occ$end_of_line);
            = constant_base =
              ocp$output (' ', 'CONSTANT BASE', 13, occ$end_of_line);
            = stack_frame_base =
              ocp$output (' ', 'STACK FRAME BASE', 16, occ$end_of_line);
            = parm_list_base =
              ocp$output (' ', 'PARM LIST BASE', 14, occ$end_of_line);
            = xref_base =
              ocp$output (' ', 'XREF BASE', 9, occ$end_of_line);
            = register_base =
              ocp$output (' ', 'REGISTER BASE', 13, occ$end_of_line);
            ELSE
              ocp$output (' ', '*************', 13, occ$end_of_line);
              error (' ', 'INVALID BASE', 12, occ$end_of_line);
            CASEND;

            hexrep (strng, length, item^ [i].var_section_ordinal);
            ocp$output ('      var section ordinal: ', strng, length, occ$continue);

            hexrep (strng, length, item^ [i].var_offset);
            ocp$output ('  var section offset: ', strng, length, occ$end_of_line);

            ocp$output ('      ', 'indirectly referenced:', 22, occ$continue);
            ocp$output_boolean (item^ [i].indirectly_referenced, occ$continue);

            ocp$output ('  ', 'var is parameter:', 17, occ$continue);
            ocp$output_boolean (item^ [i].var_is_parameter, occ$end_of_line);

          = cons_kind =
            ocp$output (' ', 'CONS KIND', 9, occ$end_of_line);

            STRINGREP (strng, length, item^ [i].cons_type);
            ocp$output ('      cons type:', strng, length, occ$continue);

            ocp$output ('  ', 'cons length type:', 17, occ$continue);
            CASE item^ [i].cons_length_type OF
            = short_constant_type =
              ocp$output (' ', 'SHORT CONSTANT TYPE', 19, occ$continue);
            = long_constant_type =
              ocp$output (' ', 'LONG CONSTANT TYPE', 18, occ$continue);
            ELSE
              ocp$output (' ', '******************', 18, occ$end_of_line);
              error (' ', 'INVALID CONSTANT TYPE', 21, occ$end_of_line);
            CASEND;

            STRINGREP (strng, length, item^ [i].cons_value);
            ocp$output ('  cons value:', strng, length, occ$end_of_line);

          = label_kind =
            ocp$output (' ', 'LABEL KIND', 10, occ$end_of_line);

            STRINGREP (strng, length, item^ [i].line_no);
            ocp$output ('      line no:', strng, length, occ$end_of_line);


          = ordinal_kind =
            ocp$output (' ', 'ORDINAL KIND', 12, occ$end_of_line);

            STRINGREP (strng, length, item^ [i].last_const);
            ocp$output ('      last const:', strng, length, occ$continue);

            STRINGREP (strng, length, item^ [i].upper_bound);
            ocp$output ('  upper bound:', strng, length, occ$end_of_line);

          = subrange_kind =
            ocp$output (' ', 'SUBRANGE KIND', 13, occ$end_of_line);

            STRINGREP (strng, length, item^ [i].subtype);
            ocp$output ('      subtype:', strng, length, occ$continue);

            ocp$output ('  ', 'low value type:', 15, occ$continue);
            CASE item^ [i].low_value_type OF
            = short_len =
              ocp$output (' ', 'SHORT LEN', 9, occ$continue);
            = long_len =
              ocp$output (' ', 'LONG LEN', 8, occ$continue);
            = not_fixed_spare_len =
              ocp$output (' ', 'NOT FIXED SPARE LEN', 19, occ$continue);
            = adapt_len =
              ocp$output (' ', 'ADAPT LEN', 9, occ$continue);
            ELSE
              ocp$output (' ', '*********', 9, occ$end_of_line);
              error (' ', 'INVALID LEN KIND', 16, occ$end_of_line);
            CASEND;

            ocp$output ('  ', 'high value type:', 16, occ$continue);
            CASE item^ [i].high_value_type OF
            = short_len =
              ocp$output (' ', 'SHORT LEN', 9, occ$end_of_line);
            = long_len =
              ocp$output (' ', 'LONG LEN', 8, occ$end_of_line);
            = not_fixed_spare_len =
              ocp$output (' ', 'NOT FIXED SPARE LEN', 19, occ$end_of_line);
            = adapt_len =
              ocp$output (' ', 'ADAPT LEN', 9, occ$end_of_line);
            ELSE
              ocp$output (' ', '*********', 9, occ$end_of_line);
              error (' ', 'INVALID LEN KIND', 16, occ$end_of_line);
            CASEND;

            STRINGREP (strng, length, item^ [i].low_value);
            ocp$output ('      low value:', strng, length, occ$continue);

            STRINGREP (strng, length, item^ [i].high_value);
            ocp$output ('  high value:', strng, length, occ$end_of_line);

          = proc_kind =
            ocp$output (' ', 'PROC KIND', 9, occ$end_of_line);

            STRINGREP (strng, length, item^ [i].lexical_level);
            ocp$output ('      lexical level:', strng, length, occ$continue);

            STRINGREP (strng, length, item^ [i].symbol_list);
            ocp$output ('  symbol list: ', strng, length, occ$end_of_line);

            hexrep (strng, length, item^ [i].proc_section_ordinal);
            ocp$output ('      proc section ordinal: ', strng, length, occ$continue);

            hexrep (strng, length, item^ [i].proc_offset);
            ocp$output ('  proc offset: ', strng, length, occ$continue);

            hexrep (strng, length, item^ [i].proc_length);
            ocp$output ('  proc length: ', strng, length, occ$end_of_line);

            STRINGREP (strng, length, item^ [i].parent_proc);
            ocp$output ('      parent proc:', strng, length, occ$continue);

            STRINGREP (strng, length, item^ [i].return_type);
            ocp$output ('  return type: ', strng, length, occ$end_of_line);

          = pointer_kind =
            ocp$output (' ', 'POINTER KIND', 12, occ$end_of_line);

            STRINGREP (strng, length, item^ [i].ptr_type);
            ocp$output ('      ptr type', strng, length, occ$continue);

            hexrep (strng, length, item^ [i].ptr_object_length);
            ocp$output ('  ptr object length: ', strng, length, occ$end_of_line);

          = set_kind =
            ocp$output (' ', 'SET KIND', 8, occ$end_of_line);

            STRINGREP (strng, length, item^ [i].set_element_type);
            ocp$output ('      set element type:', strng, length, occ$continue);

            STRINGREP (strng, length, item^ [i].set_len);
            ocp$output ('  set len:', strng, length, occ$end_of_line);

          = string_kind =
            ocp$output (' ', 'STRING KIND', 11, occ$end_of_line);

            ocp$output ('      ', 'len type:', 9, occ$continue);
            CASE item^ [i].len_type OF
            = short_len =
              ocp$output (' ', 'SHORT LEN', 9, occ$continue);
            = long_len =
              ocp$output (' ', 'LONG LEN', 8, occ$continue);
            = not_fixed_spare_len =
              ocp$output (' ', 'NOT FIXED SPARE LEN', 19, occ$continue);
            = adapt_len =
              ocp$output (' ', 'ADAPT LEN', 9, occ$continue);
            ELSE
              ocp$output (' ', '*********', 9, occ$end_of_line);
              error (' ', 'INVALID LEN TYPE', 16, occ$end_of_line);
            CASEND;

            STRINGREP (strng, length, item^ [i].string_len);
            ocp$output ('  string len:', strng, length, occ$end_of_line);

          = array_kind =
            ocp$output (' ', 'ARRAY KIND', 10, occ$end_of_line);

            ocp$output ('      ', 'array binding: [', 16, occ$continue);
            IF fixed_bind IN item^ [i].array_binding THEN
              ocp$output (' ', 'FIXED BIND', 10, occ$continue);
            IFEND;
            IF variable_spare_bind IN item^ [i].array_binding THEN
              ocp$output (' ', 'VARIABLE SPARE BIND', 19, occ$continue);
            IFEND;
            IF adaptable_bind IN item^ [i].array_binding THEN
              ocp$output (' ', 'ADAPTABLE BIND', 14, occ$continue);
            IFEND;
            IF variant_bind IN item^ [i].array_binding THEN
              ocp$output (' ', 'VARIANT BIND', 12, occ$continue);
            IFEND;
            ocp$output (' ', ']', 1, occ$end_of_line);

            ocp$output ('      ', 'array packing:', 14, occ$continue);
            CASE item^ [i].array_packing OF
            = packd =
              ocp$output (' ', 'PACKD', 5, occ$continue);
            = unpackd =
              ocp$output (' ', 'UNPACKD', 7, occ$continue);
            = not_packd =
              ocp$output (' ', 'NOT PACKD', 9, occ$continue);
            ELSE
              ocp$output (' ', '*********', 9, occ$end_of_line);
              error (' ', 'INVALID ARRAY PACKING', 21, occ$end_of_line);
            CASEND;

            ocp$output ('  ', 'length is bits:', 15, occ$continue);
            ocp$output_boolean (item^ [i].length_is_bits, occ$end_of_line);

            STRINGREP (strng, length, item^ [i].index_type);
            ocp$output ('      index type:', strng, length, occ$continue);

            STRINGREP (strng, length, item^ [i].array_element_type);
            ocp$output ('  array element type:', strng, length, occ$continue);

            STRINGREP (strng, length, item^ [i].element_length);
            ocp$output ('  element length:', strng, length, occ$end_of_line);

          = record_kind =
            ocp$output (' ', 'RECORD KIND', 11, occ$end_of_line);

            ocp$output ('      ', 'record binding: [', 17, occ$continue);
            IF fixed_bind IN item^ [i].record_binding THEN
              ocp$output (' ', 'FIXED BIND', 10, occ$continue);
            IFEND;
            IF variable_spare_bind IN item^ [i].record_binding THEN
              ocp$output (' ', 'VARIABLE SPARE BIND', 19, occ$continue);
            IFEND;
            IF adaptable_bind IN item^ [i].record_binding THEN
              ocp$output (' ', 'ADAPTABLE BIND', 14, occ$continue);
            IFEND;
            IF variant_bind IN item^ [i].record_binding THEN
              ocp$output (' ', 'VARIANT BIND', 12, occ$continue);
            IFEND;
            ocp$output (' ', ']', 1, occ$end_of_line);

            ocp$output ('      ', 'record packing:', 14, occ$continue);
            CASE item^ [i].record_packing OF
            = packd =
              ocp$output (' ', 'PACKD', 5, occ$continue);
            = unpackd =
              ocp$output (' ', 'UNPACKD', 7, occ$continue);
            = not_packd =
              ocp$output (' ', 'NOT PACKD', 9, occ$continue);
            ELSE
              ocp$output (' ', '*********', 9, occ$end_of_line);
              error (' ', 'INVALID ARRAY PACKING', 21, occ$end_of_line);
            CASEND;

            ocp$output ('  ', 'variation flag:', 15, occ$continue);
            ocp$output_boolean (item^ [i].variation_flag, occ$end_of_line);

            STRINGREP (strng, length, item^ [i].first_field);
            ocp$output ('      first field:', strng, length, occ$continue);

            STRINGREP (strng, length, item^ [i].record_length);
            ocp$output ('  record length:', strng, length, occ$continue);

            STRINGREP (strng, length, item^ [i].selector);
            ocp$output ('  selector:', strng, length, occ$end_of_line);

          = field_kind =
            ocp$output (' ', 'FIELD KIND', 10, occ$end_of_line);

            STRINGREP (strng, length, item^ [i].field_offset);
            ocp$output ('      field offset:', strng, length, occ$continue);

            STRINGREP (strng, length, item^ [i].field_length);
            ocp$output ('  field length:', strng, length, occ$continue);

            ocp$output ('  ', 'unit addressed:', 15, occ$continue);
            IF item^ [i].unit_addressed THEN
              ocp$output (' ', 'BYTES', 5, occ$end_of_line);
            ELSE
              ocp$output (' ', 'BITS', 4, occ$end_of_line);
            IFEND;

            STRINGREP (strng, length, item^ [i].field_type);
            ocp$output ('      field type:', strng, length, occ$continue);

            STRINGREP (strng, length, item^ [i].next_field);
            ocp$output ('  next field:', strng, length, occ$end_of_line);

          = selector_kind =
            ocp$output (' ', 'SELECTOR KIND', 13, occ$end_of_line);

            STRINGREP (strng, length, item^ [i].variation);
            ocp$output ('      variation:', strng, length, occ$continue);

            STRINGREP (strng, length, item^ [i].next_selector);
            ocp$output ('  next selector:', strng, length, occ$end_of_line);

            STRINGREP (strng, length, item^ [i].low_selector);
            ocp$output ('      low selector:', strng, length, occ$continue);

            STRINGREP (strng, length, item^ [i].high_selector);
            ocp$output ('  high selector:', strng, length, occ$end_of_line);

          = heap_kind =
            ocp$output (' ', 'HEAP KIND', 9, occ$end_of_line);

          = seq_kind =
            ocp$output (' ', 'SEQ KIND', 8, occ$end_of_line);

          = bound_vrec_kind =
            ocp$output (' ', 'BOUND VREC KIND', 15, occ$end_of_line);

            STRINGREP (strng, length, item^ [i].bound_type);
            ocp$output ('      bound type:', strng, length, occ$end_of_line);

          = rel_ptr_kind =
            ocp$output (' ', 'REL PTR KIND', 12, occ$end_of_line);

            STRINGREP (strng, length, item^ [i].parent_type);
            ocp$output ('      parent_type:', strng, length, occ$continue);

            STRINGREP (strng, length, item^ [i].object_type);
            ocp$output ('  object type:', strng, length, occ$continue);

            STRINGREP (strng, length, item^ [i].rel_ptr_object_length);
            ocp$output ('  rel ptr object length:', strng, length, occ$end_of_line);

          = error_kind =
            ocp$output (' ', 'ERROR KIND', 10, occ$end_of_line);

          = vstring_spare_kind =
            ocp$output (' ', 'VSTRING SPARE KIND', 18, occ$end_of_line);

          = union_spare_kind =
            ocp$output (' ', 'UNION SPARE KIND', 16, occ$end_of_line);

          = lbl_typ_spare_kind =
            ocp$output (' ', 'LBL TYP SPARE KIND', 18, occ$end_of_line);

          = nil_kind =
            ocp$output (' ', 'NIL KIND', 8, occ$end_of_line);

          = parameter_kind =
            ocp$output (' ', 'PARAMETER KIND', 14, occ$end_of_line);

          = proc_decl_kind =
            ocp$output (' ', 'PROC DECL KIND', 14, occ$end_of_line);

          = file_kind =
            ocp$output (' ', 'FILE KIND', 9, occ$end_of_line);

          = union_spare_element_kind =
            ocp$output (' ', 'UNION SPARE ELEMENT KIND', 24, occ$end_of_line);

          = span_elem_kind =
            ocp$output (' ', 'SPAN ELEM KIND', 14, occ$end_of_line);

          = module_kind =
            ocp$output (' ', 'MODULE KIND', 11, occ$end_of_line);

          = prong_kind =
            ocp$output (' ', 'PRONG KIND', 10, occ$end_of_line);

          = synonym_kind =
            ocp$output (' ', 'SYNONYM KIND', 12, occ$end_of_line);

          = last_one =
            ocp$output (' ', 'LAST ONE', 8, occ$end_of_line);

          = section_kind =
            ocp$output (' ', 'SECTION KIND', 12, occ$end_of_line);

          ELSE
            ocp$output (' ', '************', 12, occ$end_of_line);
            error (' ', 'INVALID SYMBOL TYPE', 19, occ$end_of_line);

          CASEND;
        FOREND;
      IFEND;


    PROCEND process_cybil_symbol_table;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_OBSOLETE_LINE_TABLE', EJECT ??

    PROCEDURE process_obsolete_line_table
      (    number_of_line_items: llt$line_address_table_size;
       VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        obsolete_line_address_table: ^llt$obsolete_line_address_table,
        i: llt$line_address_table_size;


      NEXT obsolete_line_address_table: [1 .. number_of_line_items] IN file;
      IF obsolete_line_address_table = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      ocp$output ('      ', 'original name:', 14, occ$continue);
      ocp$output (' ', obsolete_line_address_table^.original_name,
            STRLENGTH (obsolete_line_address_table^.original_name), occ$continue);

      ocp$output ('  ', 'optimized code:', 15, occ$continue);
      ocp$output_boolean (obsolete_line_address_table^.optimized_code, occ$end_of_line);

      ocp$output ('      ', 'language:', 9, occ$continue);
      output_language (^obsolete_line_address_table^.language, occ$continue);

      STRINGREP (strng, length, obsolete_line_address_table^.number_of_items);
      ocp$output ('  number of items:', strng, length, occ$end_of_line);

      FOR i := 1 TO number_of_line_items DO
        ocp$output ('0     ', 'line number:', 12, occ$continue);
        ocp$output (' ', obsolete_line_address_table^.item [i].
              line_number, STRLENGTH (obsolete_line_address_table^.item [i].line_number), occ$end_of_line);

        hexrep (strng, length, obsolete_line_address_table^.item [i].section_ordinal);
        ocp$output ('      ', 'section ordinal:', 16, occ$continue);
        ocp$output (' ', strng, length, occ$continue);

        hexrep (strng, length, obsolete_line_address_table^.item [i].offset);
        ocp$output ('  ', 'offset:', 7, occ$continue);
        ocp$output (' ', strng, length, occ$continue);

        hexrep (strng, length, obsolete_line_address_table^.item [i].extent);
        ocp$output ('  ', 'extent:', 7, occ$continue);
        ocp$output (' ', strng, length, occ$end_of_line);

        verify_address (obsolete_line_address_table^.item [i].section_ordinal,
              obsolete_line_address_table^.item [i].offset);

        ocp$output ('      ', 'statement labeled:', 18, occ$continue);
        ocp$output_boolean (obsolete_line_address_table^.item [i].statement_labeled, occ$continue);

        ocp$output ('  ', 'breakpoint permitted:', 21, occ$continue);
        ocp$output_boolean (obsolete_line_address_table^.item [i].breakpoint_permitted, occ$end_of_line);

        CASE obsolete_line_address_table^.language OF
        = llc$cybil, llc$obsolete_cybil =
          ocp$output ('      ', 'cybil line kind:', 16, occ$continue);
          CASE obsolete_line_address_table^.item [i].cybil_line_kind OF
          = cyc$cybil_procedure =
            ocp$output (' ', 'cybil procedure', 15, occ$end_of_line);
          = cyc$cybil_assignment =
            ocp$output (' ', 'cybil assignment', 16, occ$end_of_line);
          = cyc$cybil_begin =
            ocp$output (' ', 'cybil begin', 11, occ$end_of_line);
          = cyc$cybil_end =
            ocp$output (' ', 'cybil end', 9, occ$end_of_line);
          = cyc$cybil_while =
            ocp$output (' ', 'cybil while', 11, occ$end_of_line);
          = cyc$cybil_whilend =
            ocp$output (' ', 'cybil whilend', 13, occ$end_of_line);
          = cyc$cybil_repeat =
            ocp$output (' ', 'cybil repeat', 12, occ$end_of_line);
          = cyc$cybil_until =
            ocp$output (' ', 'cybil until', 11, occ$end_of_line);
          = cyc$cybil_for =
            ocp$output (' ', 'cybil for', 9, occ$end_of_line);
          = cyc$cybil_forend =
            ocp$output (' ', 'cybil forend', 12, occ$end_of_line);
          = cyc$cybil_procedure_call =
            ocp$output (' ', 'cybil procedure call', 20, occ$end_of_line);
          = cyc$cybil_if =
            ocp$output (' ', 'cybil if', 8, occ$end_of_line);
          = cyc$cybil_elseif =
            ocp$output (' ', 'cybil elseif', 12, occ$end_of_line);
          = cyc$cybil_else =
            ocp$output (' ', 'cybil else', 10, occ$end_of_line);
          = cyc$cybil_ifend =
            ocp$output (' ', 'cybil ifend', 11, occ$end_of_line);
          = cyc$cybil_case =
            ocp$output (' ', 'cybil case', 10, occ$end_of_line);
          = cyc$cybil_case_selector =
            ocp$output (' ', 'cybil case selector', 19, occ$end_of_line);
          = cyc$cybil_casend =
            ocp$output (' ', 'cybil casend', 12, occ$end_of_line);
          = cyc$cybil_cycle =
            ocp$output (' ', 'cybil cycle', 11, occ$end_of_line);
          = cyc$cybil_exit =
            ocp$output (' ', 'cybil exit', 10, occ$end_of_line);
          = cyc$cybil_return =
            ocp$output (' ', 'cybil return', 12, occ$end_of_line);
          = cyc$cybil_push =
            ocp$output (' ', 'cybil push', 10, occ$end_of_line);
          = cyc$cybil_next =
            ocp$output (' ', 'cybil next', 10, occ$end_of_line);
          = cyc$cybil_reset =
            ocp$output (' ', 'cybil reset', 11, occ$end_of_line);
          = cyc$cybil_allocate =
            ocp$output (' ', 'cybil allocate', 14, occ$end_of_line);
          = cyc$cybil_free =
            ocp$output (' ', 'cybil free', 10, occ$end_of_line);
          ELSE
            ocp$output (' ', '**********', 10, occ$end_of_line);
            error (' ', 'INVALID CYBIL LINE KIND', 23, occ$end_of_line);
          CASEND;
        ELSE
          ocp$output (' ', '**********', 10, occ$end_of_line);
          error (' ', 'INVALID LINE ADDRESS TABLE LANGUAGE KIND', 40, occ$end_of_line);
        CASEND;
      FOREND;


    PROCEND process_obsolete_line_table;
?? OLDTITLE ??
?? NEWTITLE := '  OUTPUT_OPTIMIZATION_LEVEL', EJECT ??

    PROCEDURE output_optimization_level
      (    optimization_level: llt$optimization_level;
           end_of_line: boolean);

      CASE optimization_level OF
      = llc$debug_optimization_level =
        ocp$output (' ', 'debug', 5, end_of_line);
      = llc$low_optimization_level =
        ocp$output (' ', 'low', 3, end_of_line);
      = llc$high_optimization_level =
        ocp$output (' ', 'high', 4, end_of_line);
      ELSE
        ocp$output (' ', 'INVALID OPTIMIZATION LEVEL', 26, end_of_line);
      CASEND;
    PROCEND output_optimization_level;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_LINE_TABLE' ??
?? EJECT ??

    PROCEDURE process_line_table
      (    number_of_line_items: llt$line_address_table_size;
       VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        line_address_table: ^llt$line_address_table,
        i: llt$line_address_table_size;


      NEXT line_address_table: [1 .. number_of_line_items] IN file;
      IF line_address_table = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      ocp$output ('      ', 'original name:', 14, occ$continue);
      ocp$output (' ', line_address_table^.original_module_name,
            STRLENGTH (line_address_table^.original_module_name), occ$continue);

      ocp$output (' ', 'version:', 8, occ$continue);
      ocp$output (' ', line_address_table^.version, STRLENGTH (line_address_table^.version), occ$end_of_line);

      ocp$output ('      ', 'language:', 9, occ$continue);
      output_language (^line_address_table^.language, occ$continue);

      ocp$output ('  ', 'optimization level:', 19, occ$continue);
      output_optimization_level (line_address_table^.optimization_level, occ$continue);

      STRINGREP (strng, length, line_address_table^.number_of_items);
      ocp$output ('  number of items:', strng, length, occ$end_of_line);

      FOR i := 1 TO number_of_line_items DO
        ocp$output (' ', ' ', 1, occ$end_of_line);

        STRINGREP (strng, length, line_address_table^.item [i].line_number);
        ocp$output ('      line number', strng, length, occ$continue);

        hexrep (strng, length, line_address_table^.item [i].section_ordinal);
        ocp$output ('      ', 'section ordinal:', 16, occ$continue);
        ocp$output (' ', strng, length, occ$continue);

        hexrep (strng, length, line_address_table^.item [i].offset);
        ocp$output ('  ', 'offset:', 7, occ$continue);
        ocp$output (' ', strng, length, occ$continue);

        hexrep (strng, length, line_address_table^.item [i].extent);
        ocp$output ('  ', 'extent:', 7, occ$continue);
        ocp$output (' ', strng, length, occ$end_of_line);

        verify_address (line_address_table^.item [i].section_ordinal, line_address_table^.item [i].offset);

        ocp$output ('      ', 'line attributes: [', 18, occ$continue);
        IF llc$line_number_unique IN line_address_table^.item [i].line_attributes THEN
          ocp$output (' ', 'LINE_NUMBER_UNIQUE', 18, occ$continue);
        IFEND;

        IF llc$breakpoint_permitted IN line_address_table^.item [i].line_attributes THEN
          ocp$output (' ', 'BREAKPOINT_PERMITTED', 20, occ$continue);
        IFEND;

        IF llc$labelled_line IN line_address_table^.item [i].line_attributes THEN
          ocp$output (' ', 'LABELLED_LINE', 13, occ$continue);
        IFEND;

        IF llc$prolog_code IN line_address_table^.item [i].line_attributes THEN
          ocp$output (' ', 'PROLOG_CODE', 11, occ$continue);
        IFEND;

        IF llc$no_object_code_for_line IN line_address_table^.item [i].line_attributes THEN
          ocp$output (' ', 'NO_OBJECT_CODE_FOR_LINE', 23, occ$continue);
        IFEND;

        IF llc$line_attribute_spare6 IN line_address_table^.item [i].line_attributes THEN
          ocp$output (' ', 'SPARE6', 6, occ$continue);
        IFEND;

        IF llc$line_attribute_spare7 IN line_address_table^.item [i].line_attributes THEN
          ocp$output (' ', 'SPARE7', 6, occ$continue);
        IFEND;

        IF llc$line_attribute_spare8 IN line_address_table^.item [i].line_attributes THEN
          ocp$output (' ', 'SPARE8', 6, occ$continue);
        IFEND;

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

        CASE line_address_table^.language OF
        = llc$cobol =
          ocp$output ('      ', 'cobol statement kind:', 21, occ$continue);
          CASE line_address_table^.item [i].cobol_statement_kind OF
          = llc$cobol_unknown_stmt_kind =
            ocp$output (' ', 'unknown cobol statement', 23, occ$end_of_line);
          = llc$cobol_program =
            ocp$output (' ', 'cobol program', 13, occ$end_of_line);
          = llc$cobol_section =
            ocp$output (' ', 'cobol section', 13, occ$end_of_line);
          = llc$cobol_paragraph =
            ocp$output (' ', 'cobol paragraph', 15, occ$end_of_line);
          = llc$cobol_accept =
            ocp$output (' ', 'cobol accept', 12, occ$end_of_line);
          = llc$cobol_add =
            ocp$output (' ', 'cobol add', 9, occ$end_of_line);
          = llc$cobol_alter =
            ocp$output (' ', 'cobol alter', 11, occ$end_of_line);
          = llc$cobol_call =
            ocp$output (' ', 'cobol call', 10, occ$end_of_line);
          = llc$cobol_cancel =
            ocp$output (' ', 'cobol cancel', 12, occ$end_of_line);
          = llc$cobol_close =
            ocp$output (' ', 'cobol close', 11, occ$end_of_line);
          = llc$cobol_compute =
            ocp$output (' ', 'cobol compute', 13, occ$end_of_line);
          = llc$cobol_continue =
            ocp$output (' ', 'cobol continue', 14, occ$end_of_line);
          = llc$cobol_delete =
            ocp$output (' ', 'cobol delete', 12, occ$end_of_line);
          = llc$cobol_display =
            ocp$output (' ', 'cobol display', 13, occ$end_of_line);
          = llc$cobol_divide =
            ocp$output (' ', 'cobol divide', 12, occ$end_of_line);
          = llc$cobol_else =
            ocp$output (' ', 'cobol else', 10, occ$end_of_line);
          = llc$cobol_end_if =
            ocp$output (' ', 'cobol endif', 11, occ$end_of_line);
          = llc$cobol_end_perform =
            ocp$output (' ', 'cobol end perform', 17, occ$end_of_line);
          = llc$cobol_enter =
            ocp$output (' ', 'cobol enter', 11, occ$end_of_line);
          = llc$cobol_exit =
            ocp$output (' ', 'cobol exit', 10, occ$end_of_line);
          = llc$cobol_generate =
            ocp$output (' ', 'cobol generate', 14, occ$end_of_line);
          = llc$cobol_goto =
            ocp$output (' ', 'cobol goto', 10, occ$end_of_line);
          = llc$cobol_if =
            ocp$output (' ', 'cobol if', 8, occ$end_of_line);
          = llc$cobol_initialize =
            ocp$output (' ', 'cobol initialize', 16, occ$end_of_line);
          = llc$cobol_initiate =
            ocp$output (' ', 'cobol initiate', 14, occ$end_of_line);
          = llc$cobol_inspect =
            ocp$output (' ', 'cobol inspect', 13, occ$end_of_line);
          = llc$cobol_merge =
            ocp$output (' ', 'cobol merge', 11, occ$end_of_line);
          = llc$cobol_move =
            ocp$output (' ', 'cobol move', 10, occ$end_of_line);
          = llc$cobol_multiply =
            ocp$output (' ', 'cobol multiply', 14, occ$end_of_line);
          = llc$cobol_open =
            ocp$output (' ', 'cobol open', 10, occ$end_of_line);
          = llc$cobol_perform =
            ocp$output (' ', 'cobol perform', 13, occ$end_of_line);
          = llc$cobol_purge =
            ocp$output (' ', 'cobol purge', 11, occ$end_of_line);
          = llc$cobol_read =
            ocp$output (' ', 'cobol read', 10, occ$end_of_line);
          = llc$cobol_receive =
            ocp$output (' ', 'cobol receive', 13, occ$end_of_line);
          = llc$cobol_release =
            ocp$output (' ', 'cobol release', 13, occ$end_of_line);
          = llc$cobol_return =
            ocp$output (' ', 'cobol return', 12, occ$end_of_line);
          = llc$cobol_rewrite =
            ocp$output (' ', 'cobol rewrite', 13, occ$end_of_line);
          = llc$cobol_search =
            ocp$output (' ', 'cobol search', 12, occ$end_of_line);
          = llc$cobol_send =
            ocp$output (' ', 'cobol send', 10, occ$end_of_line);
          = llc$cobol_set =
            ocp$output (' ', 'cobol set', 9, occ$end_of_line);
          = llc$cobol_sort =
            ocp$output (' ', 'cobol sort', 10, occ$end_of_line);
          = llc$cobol_start =
            ocp$output (' ', 'cobol start', 11, occ$end_of_line);
          = llc$cobol_stop =
            ocp$output (' ', 'cobol stop', 10, occ$end_of_line);
          = llc$cobol_string =
            ocp$output (' ', 'cobol string', 12, occ$end_of_line);
          = llc$cobol_subtract =
            ocp$output (' ', 'cobol subtract', 14, occ$end_of_line);
          = llc$cobol_suppress =
            ocp$output (' ', 'cobol suppress', 14, occ$end_of_line);
          = llc$cobol_terminate =
            ocp$output (' ', 'cobol terminate', 15, occ$end_of_line);
          = llc$cobol_unstring =
            ocp$output (' ', 'cobol unstring', 14, occ$end_of_line);
          = llc$cobol_write =
            ocp$output (' ', 'cobol write', 11, occ$end_of_line);
          ELSE
            ocp$output (' ', '**********', 10, occ$end_of_line);
            error (' ', 'INVALID COBOL LINE KIND', 23, occ$end_of_line);

          CASEND;

        = llc$fortran =
          ocp$output ('      ', 'fortran statement kind:', 23, occ$continue);
          CASE line_address_table^.item [i].fortran_statement_kind OF
          = llc$fortran_unknown_stmt_kind =
            ocp$output (' ', 'unknown fortran statement', 25, occ$end_of_line);
          = llc$fortran_program =
            ocp$output (' ', 'fortran program', 15, occ$end_of_line);
          = llc$fortran_subroutine =
            ocp$output (' ', 'fortran subroutine', 18, occ$end_of_line);
          = llc$fortran_function =
            ocp$output (' ', 'fortran function', 16, occ$end_of_line);
          = llc$fortran_arithmetic_if =
            ocp$output (' ', 'fortran arithmatic if', 21, occ$end_of_line);
          = llc$fortran_assign =
            ocp$output (' ', 'fortran assign', 14, occ$end_of_line);
          = llc$fortran_assigned_goto =
            ocp$output (' ', 'fortran assigned goto', 21, occ$end_of_line);
          = llc$fortran_assignment =
            ocp$output (' ', 'fortran assignment', 18, occ$end_of_line);
          = llc$fortran_backspace =
            ocp$output (' ', 'fortran backspace', 17, occ$end_of_line);
          = llc$fortran_block_if =
            ocp$output (' ', 'fortran block if', 16, occ$end_of_line);
          = llc$fortran_buffer_in =
            ocp$output (' ', 'fortran buffer in', 17, occ$end_of_line);
          = llc$fortran_buffer_out =
            ocp$output (' ', 'fortran buffer out', 18, occ$end_of_line);
          = llc$fortran_call =
            ocp$output (' ', 'fortran call', 12, occ$end_of_line);
          = llc$fortran_close =
            ocp$output (' ', 'fortran close', 13, occ$end_of_line);
          = llc$fortran_computed_goto =
            ocp$output (' ', 'fortran computed goto', 21, occ$end_of_line);
          = llc$fortran_continue =
            ocp$output (' ', 'fortran continue', 16, occ$end_of_line);
          = llc$fortran_decode =
            ocp$output (' ', 'fortran decode', 14, occ$end_of_line);
          = llc$fortran_do =
            ocp$output (' ', 'fortran do', 10, occ$end_of_line);
          = llc$fortran_else =
            ocp$output (' ', 'fortran else', 12, occ$end_of_line);
          = llc$fortran_elseif =
            ocp$output (' ', 'fortran elseif', 14, occ$end_of_line);
          = llc$fortran_encode =
            ocp$output (' ', 'fortran encode', 14, occ$end_of_line);
          = llc$fortran_end =
            ocp$output (' ', 'fortran end', 11, occ$end_of_line);
          = llc$fortran_endfile =
            ocp$output (' ', 'fortran endfile', 15, occ$end_of_line);
          = llc$fortran_endif =
            ocp$output (' ', 'fortran endif', 13, occ$end_of_line);
          = llc$fortran_entry =
            ocp$output (' ', 'fortran entry', 13, occ$end_of_line);
          = llc$fortran_inquire =
            ocp$output (' ', 'fortran inquire', 15, occ$end_of_line);
          = llc$fortran_logical_if =
            ocp$output (' ', 'fortran logical if', 18, occ$end_of_line);
          = llc$fortran_open =
            ocp$output (' ', 'fortran open', 12, occ$end_of_line);
          = llc$fortran_pause =
            ocp$output (' ', 'fortran pause', 13, occ$end_of_line);
          = llc$fortran_print =
            ocp$output (' ', 'fortran print', 13, occ$end_of_line);
          = llc$fortran_punch =
            ocp$output (' ', 'fortran punch', 13, occ$end_of_line);
          = llc$fortran_read =
            ocp$output (' ', 'fortran read', 12, occ$end_of_line);
          = llc$fortran_return =
            ocp$output (' ', 'fortran return', 14, occ$end_of_line);
          = llc$fortran_rewind =
            ocp$output (' ', 'fortran rewind', 14, occ$end_of_line);
          = llc$fortran_stop =
            ocp$output (' ', 'fortran stop', 12, occ$end_of_line);
          = llc$fortran_write =
            ocp$output (' ', 'fortran write', 13, occ$end_of_line);
          = llc$fortran_unconditional_goto =
            ocp$output (' ', 'fortran unconditional goto', 26, occ$end_of_line);
          ELSE
            ocp$output (' ', '**********', 10, occ$end_of_line);
            error (' ', 'INVALID FORTRAN LINE KIND', 25, occ$end_of_line);
          CASEND;

        = llc$cybil, llc$obsolete_cybil =
          ocp$output ('      ', 'cybil statement kind:', 21, occ$continue);
          CASE line_address_table^.item [i].cybil_statement_kind OF
          = llc$cybil_unknown_stmt_kind =
            ocp$output (' ', 'unknown cybil statement', 23, occ$end_of_line);
          = llc$cybil_procedure =
            ocp$output (' ', 'cybil procedure', 15, occ$end_of_line);
          = llc$cybil_assignment =
            ocp$output (' ', 'cybil assignment', 16, occ$end_of_line);
          = llc$cybil_begin =
            ocp$output (' ', 'cybil begin', 11, occ$end_of_line);
          = llc$cybil_end =
            ocp$output (' ', 'cybil end', 9, occ$end_of_line);
          = llc$cybil_while =
            ocp$output (' ', 'cybil while', 11, occ$end_of_line);
          = llc$cybil_whilend =
            ocp$output (' ', 'cybil whilend', 13, occ$end_of_line);
          = llc$cybil_repeat =
            ocp$output (' ', 'cybil repeat', 12, occ$end_of_line);
          = llc$cybil_until =
            ocp$output (' ', 'cybil until', 11, occ$end_of_line);
          = llc$cybil_for =
            ocp$output (' ', 'cybil for', 9, occ$end_of_line);
          = llc$cybil_forend =
            ocp$output (' ', 'cybil forend', 12, occ$end_of_line);
          = llc$cybil_procedure_call =
            ocp$output (' ', 'cybil procedure call', 20, occ$end_of_line);
          = llc$cybil_if =
            ocp$output (' ', 'cybil if', 8, occ$end_of_line);
          = llc$cybil_elseif =
            ocp$output (' ', 'cybil elseif', 12, occ$end_of_line);
          = llc$cybil_else =
            ocp$output (' ', 'cybil else', 10, occ$end_of_line);
          = llc$cybil_ifend =
            ocp$output (' ', 'cybil ifend', 11, occ$end_of_line);
          = llc$cybil_case =
            ocp$output (' ', 'cybil case', 10, occ$end_of_line);
          = llc$cybil_case_selector =
            ocp$output (' ', 'cybil case selector', 19, occ$end_of_line);
          = llc$cybil_casend =
            ocp$output (' ', 'cybil casend', 12, occ$end_of_line);
          = llc$cybil_cycle =
            ocp$output (' ', 'cybil cycle', 11, occ$end_of_line);
          = llc$cybil_exit =
            ocp$output (' ', 'cybil exit', 10, occ$end_of_line);
          = llc$cybil_return =
            ocp$output (' ', 'cybil return', 12, occ$end_of_line);
          = llc$cybil_push =
            ocp$output (' ', 'cybil push', 10, occ$end_of_line);
          = llc$cybil_next =
            ocp$output (' ', 'cybil next', 10, occ$end_of_line);
          = llc$cybil_reset =
            ocp$output (' ', 'cybil reset', 11, occ$end_of_line);
          = llc$cybil_allocate =
            ocp$output (' ', 'cybil allocate', 14, occ$end_of_line);
          = llc$cybil_free =
            ocp$output (' ', 'cybil free', 10, occ$end_of_line);
          = llc$cybil_procend =
            ocp$output (' ', 'cybil procend', 13, occ$end_of_line);
          = llc$cybil_pocket_code =
            ocp$output (' ', 'cybil pocket code', 17, occ$end_of_line);
          ELSE
            ocp$output (' ', '**********', 10, occ$end_of_line);
            error (' ', 'INVALID CYBIL LINE KIND', 23, occ$end_of_line);
          CASEND;
        = llc$the_c_language =
          ocp$output ('      ', 'c statement kind:', 17, occ$continue);
          CASE line_address_table^.item [i].c_statement_kind OF
          = llc$c_unknown_statement_kind =
            ocp$output (' ', 'unknown c statement', 19, occ$end_of_line);
          = llc$c_function =
            ocp$output (' ', 'c function', 10, occ$end_of_line);
          = llc$c_assignment =
            ocp$output (' ', 'c assignment', 12, occ$end_of_line);
          = llc$c_begin =
            ocp$output (' ', 'c begin', 7, occ$end_of_line);
          = llc$c_end =
            ocp$output (' ', 'c end', 5, occ$end_of_line);
          = llc$c_while =
            ocp$output (' ', 'c while', 7, occ$end_of_line);
          = llc$c_whilend =
            ocp$output (' ', 'c whilend', 9, occ$end_of_line);
          = llc$c_do =
            ocp$output (' ', 'c do', 4, occ$end_of_line);
          = llc$c_until =
            ocp$output (' ', 'c until', 7, occ$end_of_line);
          = llc$c_for =
            ocp$output (' ', 'c for', 5, occ$end_of_line);
          = llc$c_forend =
            ocp$output (' ', 'c forend', 8, occ$end_of_line);
          = llc$c_function_call =
            ocp$output (' ', 'c function call', 15, occ$end_of_line);
          = llc$c_if =
            ocp$output (' ', 'c if', 4, occ$end_of_line);
          = llc$c_elseif =
            ocp$output (' ', 'c elseif', 8, occ$end_of_line);
          = llc$c_else =
            ocp$output (' ', 'c else', 6, occ$end_of_line);
          = llc$c_ifend =
            ocp$output (' ', 'c ifend', 7, occ$end_of_line);
          = llc$c_switch =
            ocp$output (' ', 'c switch', 8, occ$end_of_line);
          = llc$c_switch_selector =
            ocp$output (' ', 'c switch selector', 17, occ$end_of_line);
          = llc$c_switchend =
            ocp$output (' ', 'c switchend', 11, occ$end_of_line);
          = llc$c_continue =
            ocp$output (' ', 'c continue', 10, occ$end_of_line);
          = llc$c_break =
            ocp$output (' ', 'c break', 7, occ$end_of_line);
          = llc$c_return =
            ocp$output (' ', 'c return', 8, occ$end_of_line);
          = llc$c_push =
            ocp$output (' ', 'c push', 6, occ$end_of_line);
          = llc$c_next =
            ocp$output (' ', 'c next', 6, occ$end_of_line);
          = llc$c_reset =
            ocp$output (' ', 'c reset', 7, occ$end_of_line);
          = llc$c_allocate =
            ocp$output (' ', 'c allocate', 10, occ$end_of_line);
          = llc$c_free =
            ocp$output (' ', 'c free', 6, occ$end_of_line);
          = llc$c_function_end =
            ocp$output (' ', 'c function end', 14, occ$end_of_line);
          = llc$c_goto =
            ocp$output (' ', 'c goto', 6, occ$end_of_line);
          = llc$c_null =
            ocp$output (' ', 'c null', 6, occ$end_of_line);
          ELSE
            ocp$output (' ', '**********', 10, occ$end_of_line);
            error (' ', 'INVALID C LINE KIND', 19, occ$end_of_line);
          CASEND;
        ELSE
          ocp$output (' ', '**********', 10, occ$end_of_line);
          error (' ', 'INVALID LINE ADDRESS TABLE LANGUAGE KIND', 40, occ$end_of_line);
        CASEND;
      FOREND;


    PROCEND process_line_table;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS SYMBOL TABLE' ??
?? NEWTITLE := '    OUTPUT_LENGTH_KINDS', EJECT ??

    PROCEDURE process_symbol_table
      (    sequence_length: ost$segment_length;
       VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);





      PROCEDURE output_length_kinds
        (    s: string ( * );
             value_type: llt$length_kind;
             end_of_line: boolean);

        CASE value_type OF
        = llc$short_length =
          ocp$output (s, 'SHORT LENGTH', 12, end_of_line);

        = llc$long_length =
          ocp$output (s, 'LONG LENGTH', 11, end_of_line);

        = llc$variable_length =
          ocp$output (s, 'VARIABLE LENGTH', 15, end_of_line);

        = llc$adaptable_length =
          ocp$output (s, 'ADAPTABLE LENGTH', 16, end_of_line);

        = llc$dynamic_length =
          ocp$output (s, 'DYNAMIC LENGTH', 14, end_of_line);

        = llc$indefinite_length =
          ocp$output (s, 'INDEFINITE LENGTH', 17, end_of_line);

        = llc$null_terminator_length =
          ocp$output (s, 'NULL TERMINATOR LENGTH', 21, end_of_line);
        ELSE
          ocp$output (' ', '************', 12, occ$end_of_line);
          error (' ', 'UNKNOWN LENGTH??', 16, end_of_line);
        CASEND;

      PROCEND output_length_kinds;
?? OLDTITLE ??
?? EJECT ??


      VAR
        symbol_table: ^llt$symbol_table,
        text: ^SEQ ( * ),
        debug_symbol_table: ^llt$debug_symbol_table,
        item: ^array [1 .. * ] of llt$symbol_table_item,
        i: integer;


      NEXT symbol_table: [[REP sequence_length OF cell]] IN file;
      IF symbol_table = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      ocp$output ('      ', 'language:', 9, occ$continue);
      output_language (^symbol_table^.language, occ$end_of_line);

      text := ^symbol_table^.text;
      RESET text;

      NEXT debug_symbol_table: [1 .. 1] IN text;
      IF debug_symbol_table = NIL THEN
        error (' ', 'First NEXT in SYMBOL_TABLE failed', 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      RESET text;
      NEXT debug_symbol_table: [1 .. debug_symbol_table^.number_of_items] IN text;
      IF debug_symbol_table = NIL THEN
        error (' ', 'Second NEXT in SYMBOL_TABLE failed', 34, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      ocp$output ('      ', 'original module name:', 21, occ$continue);
      ocp$output (' ', debug_symbol_table^.original_module_name,
            #SIZE (debug_symbol_table^.original_module_name), occ$end_of_line);

      ocp$output ('      ', 'language:', 9, occ$continue);
      output_language (^debug_symbol_table^.language, occ$continue);

      ocp$output ('  ', 'optimization level:', 19, occ$continue);
      output_optimization_level (debug_symbol_table^.optimization_level, occ$end_of_line);

      ocp$output ('      ', 'version:', 8, occ$continue);
      ocp$output (' ', debug_symbol_table^.version, #SIZE (debug_symbol_table^.version), occ$continue);

      STRINGREP (strng, length, debug_symbol_table^.first_symbol_for_module);
      ocp$output ('  first symbol for module:', strng, length, occ$continue);

      STRINGREP (strng, length, debug_symbol_table^.number_of_items);
      ocp$output ('  number of items:', strng, length, occ$end_of_line);

      ocp$output ('      ', 'symbol table attributes: [', 26, occ$continue);
      IF (llc$symbol_number_is_index IN debug_symbol_table^.attributes) THEN
        ocp$output (' ', 'INDEX', 5, occ$continue);
      IFEND;

      IF (llc$language_is_case_sensitive IN debug_symbol_table^.attributes) THEN
        ocp$output (' ', 'LANGUAGE IS CASE SENSITIVE', 26, occ$continue);
      IFEND;

      IF (llc$sym_table_attribute_spare3 IN debug_symbol_table^.attributes) THEN
        ocp$output (' ', 'SPARE3', 6, occ$continue);
      IFEND;

      IF (llc$sym_table_attribute_spare4 IN debug_symbol_table^.attributes) THEN
        ocp$output (' ', 'SPARE4', 6, occ$continue);
      IFEND;

      IF (llc$sym_table_attribute_spare5 IN debug_symbol_table^.attributes) THEN
        ocp$output (' ', 'SPARE5', 6, occ$continue);
      IFEND;

      IF (llc$sym_table_attribute_spare6 IN debug_symbol_table^.attributes) THEN
        ocp$output (' ', 'SPARE6', 6, occ$continue);
      IFEND;

      IF (llc$sym_table_attribute_spare7 IN debug_symbol_table^.attributes) THEN
        ocp$output (' ', 'SPARE7', 6, occ$continue);
      IFEND;

      IF (llc$sym_table_attribute_spare8 IN debug_symbol_table^.attributes) THEN
        ocp$output (' ', 'SPARE8', 6, occ$continue);
      IFEND;
      ocp$output (' ', ']', 1, occ$end_of_line);

      item := ^debug_symbol_table^.item;

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

      FOR i := 1 TO (debug_symbol_table^.number_of_items) DO
        ocp$output ('      ', 'symbol name:', 12, occ$continue);
        ocp$output (' ', item^ [i].symbol_name, #SIZE (item^ [i].symbol_name), occ$continue);

        STRINGREP (strng, length, item^ [i].symbol_number);
        ocp$output ('  symbol number:', strng, length, occ$end_of_line);

        ocp$output ('      ', 'end of chain:', 13, occ$continue);
        ocp$output_boolean (item^ [i].end_of_chain, occ$continue);

        ocp$output ('  ', 'symbol kind:', 12, occ$continue);

        CASE item^ [i].symbol_kind OF
        = llc$integer_kind =
          ocp$output (' ', 'INTEGER KIND', 12, occ$end_of_line);

        = llc$boolean_kind =
          ocp$output (' ', 'BOOLEAN KIND', 12, occ$end_of_line);

        = llc$char_kind =
          ocp$output (' ', 'CHAR KIND', 9, occ$end_of_line);

        = llc$real_kind =
          ocp$output (' ', 'REAL KIND', 9, occ$end_of_line);

        = llc$longreal_kind =
          ocp$output (' ', 'LONGREAL KIND', 13, occ$end_of_line);

        = llc$cell_kind =
          ocp$output (' ', 'CELL KIND', 9, occ$end_of_line);

        = llc$complex_kind =
          ocp$output (' ', 'COMPLEX KIND', 12, occ$end_of_line);

        = llc$ftn_logical_kind =
          ocp$output (' ', 'FORTRAN LOGICAL KIND', 20, occ$end_of_line);

        = llc$ftn_boolean_kind =
          ocp$output (' ', 'FORTRAN BOOLEAN KIND', 20, occ$end_of_line);

        = llc$bit_kind =
          ocp$output (' ', 'BIT KIND', 8, occ$end_of_line);

        = llc$shortreal_kind =
          ocp$output (' ', 'SHORTREAL KIND', 14, occ$end_of_line);

        = llc$ftn_subprogram_name =
          ocp$output (' ', 'FORTRAN SUBPROGRAM NAME', 23, occ$end_of_line);

        = llc$ftn_character_kind =
          ocp$output (' ', 'FORTRAN CHARACTER KIND', 22, occ$end_of_line);

        = llc$typeless_kind =
          ocp$output (' ', 'TYPELESS KIND', 13, occ$end_of_line);

        = llc$filename_kind =
          ocp$output (' ', 'FILENAME KIND', 13, occ$end_of_line);

        = llc$bdp_pdu =
          ocp$output (' ', 'BDP PDU', 7, occ$end_of_line);

        = llc$bdp_pdulsd =
          ocp$output (' ', 'BDP PDULSD', 10, occ$end_of_line);

        = llc$bdp_pds =
          ocp$output (' ', 'BDP PDS', 7, occ$end_of_line);

        = llc$bdp_pdslsd =
          ocp$output (' ', 'BDP PDSLSD', 10, occ$end_of_line);

        = llc$bdp_udu =
          ocp$output (' ', 'BDP UDU', 7, occ$end_of_line);

        = llc$bdp_udtsch =
          ocp$output (' ', 'BDP UDTSCH', 10, occ$end_of_line);

        = llc$bdp_udtss =
          ocp$output (' ', 'BDP UDTSS', 9, occ$end_of_line);

        = llc$bdp_bu =
          ocp$output (' ', 'BDP BU', 6, occ$end_of_line);

        = llc$bdp_tpds =
          ocp$output (' ', 'BDP TPDS', 8, occ$end_of_line);

        = llc$bdp_tpdslsd =
          ocp$output (' ', 'BDP TPDSLSD', 11, occ$end_of_line);

        = llc$bdp_tbu =
          ocp$output (' ', 'BDP TBU', 7, occ$end_of_line);

        = llc$bdp_tbs =
          ocp$output (' ', 'BDP TBS', 7, occ$end_of_line);

        = llc$bdp_a =
          ocp$output (' ', 'BDP A', 5, occ$end_of_line);

        = llc$cobol_justified =
          ocp$output (' ', 'COBOL JUSTIFIED', 15, occ$end_of_line);

        = llc$cobol_index_data_item =
          ocp$output (' ', 'COBOL INDEX DATA ITEM', 21, occ$end_of_line);

        = llc$cobol_index_name =
          ocp$output (' ', 'COBOL INDEX NAME', 16, occ$end_of_line);

        = llc$bdp_udlsch =
          ocp$output (' ', 'BDP UDLSCH', 10, occ$end_of_line);

        = llc$bdp_udlss =
          ocp$output (' ', 'BDP UDLSS', 9, occ$end_of_line);

        = llc$cobol_numeric_edited =
          ocp$output (' ', 'COBOL NUMERIC EDITED', 20, occ$end_of_line);

        = llc$cobol_a_edited =
          ocp$output (' ', 'COBOL A EDITED', 14, occ$end_of_line);

        = llc$var_kind =
          ocp$output (' ', 'VAR KIND', 8, occ$end_of_line);

          STRINGREP (strng, length, item^ [i].var_type);
          ocp$output ('      var type: ', strng, length, occ$continue);

          hexrep (strng, length, item^ [i].var_length);
          ocp$output ('  var length: ', strng, length, occ$continue);

          ocp$output ('  ', 'var base:', 9, occ$continue);
          CASE item^ [i].var_base OF
          = llc$null_base =
            ocp$output (' ', 'NULL BASE', 9, occ$end_of_line);

          = llc$static_base =
            ocp$output (' ', 'STATIC BASE', 11, occ$end_of_line);

          = llc$constant_base =
            ocp$output (' ', 'CONSTANT BASE', 13, occ$end_of_line);

          = llc$stack_frame_base =
            ocp$output (' ', 'STACK FRAME BASE', 16, occ$end_of_line);

          = llc$parm_list_base =
            ocp$output (' ', 'PARM LIST BASE', 14, occ$end_of_line);

          = llc$xref_base =
            ocp$output (' ', 'XREF BASE', 9, occ$end_of_line);

          = llc$register_base =
            ocp$output (' ', 'REGISTER BASE', 13, occ$end_of_line);

          ELSE
            ocp$output (' ', '*************', 13, occ$end_of_line);
            error (' ', 'INVALID BASE', 12, occ$end_of_line);
          CASEND;

          hexrep (strng, length, item^ [i].var_section_ordinal);
          ocp$output ('      var section ordinal: ', strng, length, occ$continue);

          hexrep (strng, length, item^ [i].var_offset);
          ocp$output ('  var section offset: ', strng, length, occ$end_of_line);

          IF item^ [i].var_base = llc$static_base THEN
            verify_address (item^ [i].var_section_ordinal, item^ [i].var_offset);
          IFEND;

          ocp$output ('      ', 'var attributes: [', 17, occ$continue);
          IF (llc$var_qualifier_needed IN item^ [i].var_attributes) THEN
            ocp$output (' ', 'VAR_QUALIFIER_NEEDED', 20, occ$continue);
          IFEND;

          IF (llc$var_indirectly_referenced IN item^ [i].var_attributes) THEN
            ocp$output (' ', 'VAR_INDIRECTLY_REFERENCED', 25, occ$continue);
          IFEND;

          IF (llc$var_is_dummy_argument IN item^ [i].var_attributes) THEN
            ocp$output (' ', 'VAR_IS_DUMMY_ARGUMENT', 21, occ$continue);
          IFEND;

          IF (llc$non_source_variable IN item^ [i].var_attributes) THEN
            ocp$output (' ', 'NON_SOURCE_VARIABLE', 19, occ$continue);
          IFEND;

          IF (llc$var_attribute_spare5 IN item^ [i].var_attributes) THEN
            ocp$output (' ', 'SPARE5', 6, occ$continue);
          IFEND;

          IF (llc$var_attribute_spare6 IN item^ [i].var_attributes) THEN
            ocp$output (' ', 'SPARE6', 6, occ$continue);
          IFEND;

          IF (llc$var_attribute_spare7 IN item^ [i].var_attributes) THEN
            ocp$output (' ', 'SPARE7', 6, occ$continue);
          IFEND;

          IF (llc$var_attribute_spare8 IN item^ [i].var_attributes) THEN
            ocp$output (' ', 'SPARE8', 6, occ$continue);
          IFEND;

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

          STRINGREP (strng, length, item^ [i].var_containing_symbol);
          ocp$output ('      var containing symbol:', strng, length, occ$continue);

          STRINGREP (strng, length, item^ [i].var_point_location.value);
          ocp$output ('      var point location:', strng, length, occ$end_of_line);

        = llc$cobol_array_kind =
          ocp$output (' ', 'COBOL ARRAY KIND', 16, occ$end_of_line);

          ocp$output ('      ', 'cobol array element type:', 25, occ$continue);

          CASE item^ [i].cobol_array_element_type OF
          = llc$integer_kind =
            ocp$output (' ', 'INTEGER KIND', 12, occ$end_of_line);

          = llc$boolean_kind =
            ocp$output (' ', 'BOOLEAN KIND', 12, occ$end_of_line);

          = llc$char_kind =
            ocp$output (' ', 'CHAR KIND', 9, occ$end_of_line);

          = llc$real_kind =
            ocp$output (' ', 'REAL KIND', 9, occ$end_of_line);

          = llc$longreal_kind =
            ocp$output (' ', 'LONGREAL KIND', 13, occ$end_of_line);

          = llc$cell_kind =
            ocp$output (' ', 'CELL KIND', 9, occ$end_of_line);

          = llc$complex_kind =
            ocp$output (' ', 'COMPLEX KIND', 12, occ$end_of_line);

          = llc$ftn_logical_kind =
            ocp$output (' ', 'FORTRAN LOGICAL KIND', 20, occ$end_of_line);

          = llc$ftn_boolean_kind =
            ocp$output (' ', 'FORTRAN BOOLEAN KIND', 20, occ$end_of_line);

          = llc$bit_kind =
            ocp$output (' ', 'BIT KIND', 8, occ$end_of_line);

          = llc$shortreal_kind =
            ocp$output (' ', 'SHORTREAL KIND', 14, occ$end_of_line);

          = llc$ftn_subprogram_name =
            ocp$output (' ', 'FORTRAN SUBPROGRAM NAME', 23, occ$end_of_line);

          = llc$ftn_character_kind =
            ocp$output (' ', 'FORTRAN CHARACTER KIND', 22, occ$end_of_line);

          = llc$typeless_kind =
            ocp$output (' ', 'TYPELESS KIND', 13, occ$end_of_line);

          = llc$filename_kind =
            ocp$output (' ', 'FILENAME KIND', 13, occ$end_of_line);

          = llc$bdp_pdu =
            ocp$output (' ', 'BDP PDU', 7, occ$end_of_line);

          = llc$bdp_pdulsd =
            ocp$output (' ', 'BDP PDULSD', 10, occ$end_of_line);

          = llc$bdp_pds =
            ocp$output (' ', 'BDP PDS', 7, occ$end_of_line);

          = llc$bdp_pdslsd =
            ocp$output (' ', 'BDP PDSLSD', 10, occ$end_of_line);

          = llc$bdp_udu =
            ocp$output (' ', 'BDP UDU', 7, occ$end_of_line);

          = llc$bdp_udtsch =
            ocp$output (' ', 'BDP UDTSCH', 10, occ$end_of_line);

          = llc$bdp_udtss =
            ocp$output (' ', 'BDP UDTSS', 9, occ$end_of_line);

          = llc$bdp_bu =
            ocp$output (' ', 'BDP BU', 6, occ$end_of_line);

          = llc$bdp_tpds =
            ocp$output (' ', 'BDP TPDS', 8, occ$end_of_line);

          = llc$bdp_tpdslsd =
            ocp$output (' ', 'BDP TPDSLSD', 11, occ$end_of_line);

          = llc$bdp_tbu =
            ocp$output (' ', 'BDP TBU', 7, occ$end_of_line);

          = llc$bdp_tbs =
            ocp$output (' ', 'BDP TBS', 7, occ$end_of_line);

          = llc$bdp_a =
            ocp$output (' ', 'BDP A', 5, occ$end_of_line);

          = llc$cobol_justified =
            ocp$output (' ', 'COBOL JUSTIFIED', 15, occ$end_of_line);

          = llc$cobol_index_data_item =
            ocp$output (' ', 'COBOL INDEX DATA ITEM', 20, occ$end_of_line);

          = llc$cobol_index_name =
            ocp$output (' ', 'COBOL INDEX NAME', 16, occ$end_of_line);

          = llc$bdp_udlsch =
            ocp$output (' ', 'BDP UDLSCH', 10, occ$end_of_line);

          = llc$bdp_udlss =
            ocp$output (' ', 'BDP UDLSS', 9, occ$end_of_line);

          = llc$cobol_numeric_edited =
            ocp$output (' ', 'COBOL NUMERIC EDITED', 20, occ$end_of_line);

          = llc$cobol_a_edited =
            ocp$output (' ', 'COBOL A EDITED', 14, occ$end_of_line);

          = llc$var_kind =
            ocp$output (' ', 'VAR KIND', 8, occ$end_of_line);

          = llc$cobol_array_kind =
            ocp$output (' ', 'COBOL ARRAY KIND', 15, occ$end_of_line);

          = llc$constant_kind =
            ocp$output (' ', 'CONSTANT KIND', 13, occ$end_of_line);

          = llc$label_kind =
            ocp$output (' ', 'LABEL KIND', 10, occ$end_of_line);

          = llc$ordinal_kind =
            ocp$output (' ', 'ORDINAL KIND', 12, occ$end_of_line);

          = llc$subrange_kind =
            ocp$output (' ', 'SUBRANGE KIND', 13, occ$end_of_line);

          = llc$proc_kind =
            ocp$output (' ', 'PROC KIND', 9, occ$end_of_line);

          = llc$pointer_kind =
            ocp$output (' ', 'POINTER KIND', 12, occ$end_of_line);

          = llc$set_kind =
            ocp$output (' ', 'SET KIND', 8, occ$end_of_line);

          = llc$string_kind =
            ocp$output (' ', 'STRING KIND', 11, occ$end_of_line);

          = llc$cybil_array_kind =
            ocp$output (' ', 'CYBIL ARRAY KIND', 16, occ$end_of_line);

          = llc$record_kind =
            ocp$output (' ', 'RECORD KIND', 11, occ$end_of_line);

          = llc$field_kind =
            ocp$output (' ', 'FIELD KIND', 10, occ$end_of_line);

          = llc$selector_kind =
            ocp$output (' ', 'SELECTOR KIND', 13, occ$end_of_line);

          = llc$heap_kind =
            ocp$output (' ', 'HEAP KIND', 9, occ$end_of_line);

          = llc$seq_kind =
            ocp$output (' ', 'SEQ KIND', 8, occ$end_of_line);

          = llc$bound_vrec_kind =
            ocp$output (' ', 'BOUND VREC KIND', 15, occ$end_of_line);

          = llc$rel_ptr_kind =
            ocp$output (' ', 'REL PTR KIND', 12, occ$end_of_line);

          = llc$ftn_array_kind =
            ocp$output (' ', 'FORTRAN ARRAY KIND', 18, occ$end_of_line);

          = llc$namelist_group_kind =
            ocp$output (' ', 'NAMELIST GROUP KIND', 19, occ$end_of_line);

          = llc$equated_label =
            ocp$output (' ', 'EQUATED LABEL', 13, occ$end_of_line);

          = llc$external_equate =
            ocp$output (' ', 'EXTERNAL EQUATE', 15, occ$end_of_line);

          = llc$basic_array_kind =
            ocp$output (' ', 'BASIC ARRAY KIND', 16, occ$end_of_line);

          = llc$pascal_conf_array_kind =
            ocp$output (' ', 'PASCAL CONF ARRAY KIND', 22, occ$end_of_line);

          = llc$pascal_file_kind =
            ocp$output (' ', 'PASCAL FILE KIND', 16, occ$end_of_line);

          = llc$pascal_with_kind =
            ocp$output (' ', 'PASCAL WITH KIND', 16, occ$end_of_line);

          = llc$unsigned_integer_kind =
            ocp$output (' ', 'UNSIGNED INTEGER KIND', 21, occ$end_of_line);

          ELSE
            ocp$output (' ', '************', 12, occ$end_of_line);
            error (' ', 'INVALID SYMBOL TYPE', 19, occ$end_of_line);
          CASEND;

          STRINGREP (strng, length, item^ [i].cobol_subscript_count);
          ocp$output ('      cobol subscript count: ', strng, length, occ$end_of_line);

          STRINGREP (strng, length, item^ [i].max_cobol_subscript_value);
          ocp$output ('      max cobol subscript value: ', strng, length, occ$continue);

          STRINGREP (strng, length, item^ [i].occurrence_length);
          ocp$output ('  occurrence length: ', strng, length, occ$end_of_line);

        = llc$constant_kind =
          ocp$output (' ', 'CONSTANT KIND', 13, occ$end_of_line);

          STRINGREP (strng, length, item^ [i].constant_type);
          ocp$output ('      constant type: ', strng, length, occ$continue);

          STRINGREP (strng, length, item^ [i].constant_length);
          ocp$output ('  constant length: ', strng, length, occ$end_of_line);

          ocp$output ('      ', 'constant kind:', 14, occ$continue);
          CASE item^ [i].constant_kind OF
          = llc$short_constant =
            ocp$output (' ', 'SHORT CONSTANT', 14, occ$end_of_line);

            ocp$output ('      ', 'kind:', 5, occ$continue);
            CASE item^ [i].short_constant_value.kind OF
            = llc$boolean_kind =
              ocp$output (' BOOLEAN KIND', '  value:', 8, occ$continue);
              ocp$output_boolean (item^ [i].short_constant_value.boolean_value, occ$end_of_line);

            = llc$ftn_logical_kind =
              ocp$output (' FTN LOGICAL KIND', '  value:', 8, occ$continue);
              ocp$output_boolean (item^ [i].short_constant_value.boolean_value, occ$end_of_line);

            = llc$char_kind =
              ocp$output (' CHAR KIND', '  value:', 8, occ$continue);
              strng (1) := item^ [i].short_constant_value.char_value;
              ocp$output (' ', strng, 1, occ$end_of_line);

            = llc$bit_kind =
              ocp$output (' BIT KIND', '  value:', 8, occ$continue);
              STRINGREP (strng, length, item^ [i].short_constant_value.bit_value);
              ocp$output (' ', strng, length, occ$end_of_line);

            = llc$integer_kind =
              ocp$output (' INTEGER KIND', '  value:', 8, occ$continue);
              STRINGREP (strng, length, item^ [i].short_constant_value.integer_value);
              ocp$output (' ', strng, length, occ$end_of_line);

            ELSE
              ocp$output (' ', '**********', 10, occ$end_of_line);
              error (' ', 'INVALID SHORT CONSTANT KIND', 28, occ$end_of_line);
            CASEND;

          = llc$medium_constant =
            ocp$output (' ', 'MEDIUM CONSTANT', 15, occ$end_of_line);

            ocp$output ('      ', 'kind:', 5, occ$continue);
            CASE item^ [i].medium_constant_value.kind OF
            = llc$integer_kind =
              ocp$output (' INTEGER KIND', '  value:', 8, occ$continue);
              STRINGREP (strng, length, item^ [i].medium_constant_value.integer_value);
              ocp$output (' ', strng, length, occ$end_of_line);

            = llc$ftn_boolean_kind =
              ocp$output (' FTN BOOLEAN KIND', '  value:', 8, occ$continue);
              STRINGREP (strng, length, item^ [i].medium_constant_value.integer_value);
              ocp$output (' ', strng, length, occ$end_of_line);

            = llc$real_kind =
              ocp$output (' REAL KIND', '  value:', 8, occ$continue);
              STRINGREP (strng, length, item^ [i].medium_constant_value.real_value);
              ocp$output (' ', strng, length, occ$end_of_line);

            = llc$shortreal_kind =
              ocp$output ('SHORTREAL KIND', '  value:', 8, occ$continue);
              STRINGREP (strng, length, item^ [i].medium_constant_value.shortreal_value);
              ocp$output (' ', strng, length, occ$end_of_line);

            ELSE
              ocp$output (' ', '**********', 10, occ$end_of_line);
              error (' ', 'INVALID MEDIMUM CONSTANT VALUE', 32, occ$end_of_line);
            CASEND;

          = llc$long_constant =
            ocp$output (' ', 'LONG CONSTANT', 13, occ$end_of_line);

            hexrep (strng, length, item^ [i].constant_section_ordinal);
            ocp$output ('      constant section ordinal: ', strng, length, occ$continue);

            hexrep (strng, length, item^ [i].constant_offset);
            ocp$output ('  constant offset: ', strng, length, occ$end_of_line);

            verify_address (item^ [i].constant_section_ordinal, item^ [i].constant_offset);

          ELSE
            ocp$output (' ', '******************', 18, occ$end_of_line);
            error (' ', 'INVALID CONSTANT TYPE', 21, occ$end_of_line);
          CASEND;


        = llc$label_kind =
          ocp$output (' ', 'LABEL KIND', 10, occ$end_of_line);


          ocp$output ('      ', 'label attributes: [', 19, occ$continue);
          IF llc$label_qualifier_needed IN item^ [i].label_attributes THEN
            ocp$output (' ', 'LABEL_QUALIFIER_NEEDED', 22, occ$continue);
          IFEND;

          IF llc$cobol_section_name IN item^ [i].label_attributes THEN
            ocp$output (' ', 'COBOL_SECTION_NAME', 18, occ$continue);
          IFEND;

          IF llc$cobol_paragraph_name IN item^ [i].label_attributes THEN
            ocp$output (' ', 'COBOL_PARAGRAPH_NAME', 19, occ$continue);
          IFEND;

          IF llc$no_object_code_for_label IN item^ [i].label_attributes THEN
            ocp$output (' ', 'NO_OBJECT_CODE_FOR_LABEL', 24, occ$continue);
          IFEND;

          IF llc$non_source_label IN item^ [i].label_attributes THEN
            ocp$output (' ', 'NON_SOURCE_LABEL', 16, occ$continue);
          IFEND;

          IF llc$label_attribute_spare6 IN item^ [i].label_attributes THEN
            ocp$output (' ', 'SPARE6', 6, occ$continue);
          IFEND;

          IF llc$label_attribute_spare7 IN item^ [i].label_attributes THEN
            ocp$output (' ', 'SPARE7', 6, occ$continue);
          IFEND;

          IF llc$label_attribute_spare8 IN item^ [i].label_attributes THEN
            ocp$output (' ', 'SPARE8', 6, occ$continue);
          IFEND;

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

          hexrep (strng, length, item^ [i].label_section_ordinal);
          ocp$output ('      label section ordinal: ', strng, length, occ$continue);

          hexrep (strng, length, item^ [i].label_offset);
          ocp$output ('  label offset: ', strng, length, occ$end_of_line);

          verify_address (item^ [i].label_section_ordinal, item^ [i].label_offset);

          hexrep (strng, length, item^ [i].label_scope);
          ocp$output ('      label scope: ', strng, length, occ$continue);

          STRINGREP (strng, length, item^ [i].label_containing_symbol);
          ocp$output ('  label containing symbol: ', strng, length, occ$end_of_line);

        = llc$ordinal_kind =
          ocp$output (' ', 'ORDINAL KIND', 12, occ$end_of_line);

          STRINGREP (strng, length, item^ [i].last_constant);
          ocp$output ('      last constant: ', strng, length, occ$continue);

          STRINGREP (strng, length, item^ [i].ordinal_upper_bound);
          ocp$output ('  ordinal upper bound: ', strng, length, occ$end_of_line);

        = llc$subrange_kind =
          ocp$output (' ', 'SUBRANGE KIND', 13, occ$end_of_line);

          STRINGREP (strng, length, item^ [i].subtype);
          ocp$output ('      subtype: ', strng, length, occ$continue);

          output_length_kinds ('  low value type: ', item^ [i].low_value_type, occ$continue);
          output_length_kinds ('  high value type: ', item^ [i].high_value_type, occ$end_of_line);

          STRINGREP (strng, length, item^ [i].low_value);
          ocp$output ('      low value: ', strng, length, occ$continue);

          STRINGREP (strng, length, item^ [i].high_value);
          ocp$output ('  high value: ', strng, length, occ$end_of_line);

        = llc$proc_kind =
          ocp$output (' ', 'PROC KIND', 9, occ$end_of_line);

          STRINGREP (strng, length, item^ [i].proc_lexical_level);
          ocp$output ('      lexical level: ', strng, length, occ$continue);

          STRINGREP (strng, length, item^ [i].first_symbol_for_proc);
          ocp$output ('  first symbol for proc: ', strng, length, occ$end_of_line);

          hexrep (strng, length, item^ [i].proc_section_ordinal);
          ocp$output ('      proc section ordinal: ', strng, length, occ$continue);

          hexrep (strng, length, item^ [i].proc_offset);
          ocp$output ('  proc offset: ', strng, length, occ$continue);

          verify_address (item^ [i].proc_section_ordinal, item^ [i].proc_offset);

          hexrep (strng, length, item^ [i].proc_length);
          ocp$output ('  proc length: ', strng, length, occ$end_of_line);

          STRINGREP (strng, length, item^ [i].proc_parent);
          ocp$output ('      proc parent: ', strng, length, occ$end_of_line);

          ocp$output ('      ', 'proc attributes: [', 18, occ$continue);
          IF llc$multiple_entry_points IN item^ [i].proc_attributes THEN
            ocp$output (' ', 'MULTIPLE_ENTRY_POINTS', 21, occ$continue);
          IFEND;

          IF llc$proc_uses_outer_level_stack IN item^ [i].proc_attributes THEN
            ocp$output (' ', 'PROC_USES_OUTER_LEVEL_STACK', 27, occ$continue);
          IFEND;

          IF llc$proc_attribute_spare3 IN item^ [i].proc_attributes THEN
            ocp$output (' ', 'SPARE3', 6, occ$continue);
          IFEND;

          IF llc$proc_attribute_spare4 IN item^ [i].proc_attributes THEN
            ocp$output (' ', 'SPARE4', 6, occ$continue);
          IFEND;

          IF llc$proc_attribute_spare5 IN item^ [i].proc_attributes THEN
            ocp$output (' ', 'SPARE5', 6, occ$continue);
          IFEND;

          IF llc$proc_attribute_spare6 IN item^ [i].proc_attributes THEN
            ocp$output (' ', 'SPARE6', 6, occ$continue);
          IFEND;

          IF llc$proc_attribute_spare7 IN item^ [i].proc_attributes THEN
            ocp$output (' ', 'SPARE7', 6, occ$continue);
          IFEND;

          IF llc$proc_attribute_spare8 IN item^ [i].proc_attributes THEN
            ocp$output (' ', 'SPARE8', 6, occ$continue);
          IFEND;

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

          STRINGREP (strng, length, item^ [i].proc_return_type);
          ocp$output ('      proc return type: ', strng, length, occ$continue);

          STRINGREP (strng, length, item^ [i].proc_return_length);
          ocp$output ('  proc return length: ', strng, length, occ$end_of_line);

        = llc$pointer_kind =
          ocp$output (' ', 'POINTER KIND', 12, occ$end_of_line);

          STRINGREP (strng, length, item^ [i].ptr_type);
          ocp$output ('      ptr type: ', strng, length, occ$continue);

          hexrep (strng, length, item^ [i].ptr_object_length);
          ocp$output ('  ptr object length: ', strng, length, occ$end_of_line);

        = llc$set_kind =
          ocp$output (' ', 'SET KIND', 8, occ$end_of_line);

          STRINGREP (strng, length, item^ [i].set_element_type);
          ocp$output ('      set element type: ', strng, length, occ$continue);

          STRINGREP (strng, length, item^ [i].set_length);
          ocp$output ('  set length: ', strng, length, occ$end_of_line);

        = llc$string_kind =
          ocp$output (' ', 'STRING KIND', 11, occ$end_of_line);

          output_length_kinds ('      string length type: ', item^ [i].string_length_type, occ$continue);

          STRINGREP (strng, length, item^ [i].string_length);
          ocp$output ('  string length: ', strng, length, occ$end_of_line);

        = llc$cybil_array_kind =
          ocp$output (' ', 'CYBIL ARRAY KIND', 16, occ$end_of_line);

          ocp$output ('      ', 'cybil array binding:', 20, occ$continue);
          CASE item^ [i].cybil_array_binding OF
          = llc$fixed_binding =
            ocp$output (' ', 'FIXED BINDING', 13, occ$continue);

          = llc$variable_spare_binding =
            ocp$output (' ', 'VARIABLE SPARE BINDING', 22, occ$continue);

          = llc$adaptable_binding =
            ocp$output (' ', 'ADAPTABLE BINDING', 17, occ$continue);

          = llc$variant_binding =
            ocp$output (' ', 'VARIANT BINDING', 15, occ$continue);

          ELSE
            ocp$output (' ', 'INVALID BINDING KIND', 20, occ$continue);
          CASEND;

          ocp$output ('  ', 'cybil array packing:', 20, occ$continue);
          CASE item^ [i].cybil_array_packing OF
          = llc$packed =
            ocp$output (' ', 'PACKED', 6, occ$end_of_line);

          = llc$unpacked =
            ocp$output (' ', 'UNPACKED', 8, occ$end_of_line);

          = llc$not_packed =
            ocp$output (' ', 'NOT PACKED', 10, occ$end_of_line);

          ELSE
            ocp$output (' ', '*********', 9, occ$end_of_line);
            error (' ', 'INVALID ARRAY PACKING', 21, occ$end_of_line);
          CASEND;


          ocp$output ('      ', 'cybil array attributes: [', 25, occ$continue);
          IF llc$cybil_array_is_bits IN item^ [i].cybil_array_attributes THEN
            ocp$output (' ', 'CYBIL_ARRAY_IS_BITS', 19, occ$continue);
          IFEND;

          IF llc$cyb_array_attribute_spare2 IN item^ [i].cybil_array_attributes THEN
            ocp$output (' ', 'SPARE2', 6, occ$continue);
          IFEND;

          IF llc$cyb_array_attribute_spare3 IN item^ [i].cybil_array_attributes THEN
            ocp$output (' ', 'SPARE3', 6, occ$continue);
          IFEND;

          IF llc$cyb_array_attribute_spare4 IN item^ [i].cybil_array_attributes THEN
            ocp$output (' ', 'SPARE4', 6, occ$continue);
          IFEND;

          IF llc$cyb_array_attribute_spare5 IN item^ [i].cybil_array_attributes THEN
            ocp$output (' ', 'SPARE5', 6, occ$continue);
          IFEND;

          IF llc$cyb_array_attribute_spare6 IN item^ [i].cybil_array_attributes THEN
            ocp$output (' ', 'SPARE6', 6, occ$continue);
          IFEND;

          IF llc$cyb_array_attribute_spare7 IN item^ [i].cybil_array_attributes THEN
            ocp$output (' ', 'SPARE7', 6, occ$continue);
          IFEND;

          IF llc$cyb_array_attribute_spare8 IN item^ [i].cybil_array_attributes THEN
            ocp$output (' ', 'SPARE8', 6, occ$continue);
          IFEND;

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

          STRINGREP (strng, length, item^ [i].cybil_index_type);
          ocp$output ('      cybil index type: ', strng, length, occ$continue);

          STRINGREP (strng, length, item^ [i].cybil_array_element_type);
          ocp$output ('  cybil array element type: ', strng, length, occ$continue);

          STRINGREP (strng, length, item^ [i].cybil_array_element_length);
          ocp$output ('  cybil array element length: ', strng, length, occ$end_of_line);

        = llc$record_kind =
          ocp$output (' ', 'RECORD KIND', 11, occ$end_of_line);

          ocp$output ('      ', 'record binding:', 15, occ$continue);
          CASE item^ [i].record_binding OF
          = llc$fixed_binding =
            ocp$output (' ', 'FIXED BINDING', 13, occ$continue);

          = llc$variable_spare_binding =
            ocp$output (' ', 'VARIABLE SPARE BINDING', 22, occ$continue);

          = llc$adaptable_binding =
            ocp$output (' ', 'ADAPTABLE BINDING', 17, occ$continue);

          = llc$variant_binding =
            ocp$output (' ', 'VARIANT BINDING', 15, occ$continue);

          ELSE
            ocp$output (' ', '********************', 20, occ$end_of_line);
            error (' ', 'INVALID BINDING KIND', 20, occ$end_of_line);
          CASEND;

          ocp$output ('  ', 'record packing:', 15, occ$continue);
          CASE item^ [i].record_packing OF
          = llc$packed =
            ocp$output (' ', 'PACKED', 6, occ$end_of_line);

          = llc$unpacked =
            ocp$output (' ', 'UNPACKED', 8, occ$end_of_line);

          = llc$not_packed =
            ocp$output (' ', 'NOT PACKED', 10, occ$end_of_line);

          ELSE
            ocp$output (' ', '*********', 9, occ$end_of_line);
            error (' ', 'INVALID RECORD PACKING', 22, occ$end_of_line);
          CASEND;

          ocp$output ('      ', 'record attributes: [', 20, occ$continue);
          IF llc$record_variation IN item^ [i].record_attributes THEN
            ocp$output (' ', 'RECORD_VARIATION', 16, occ$continue);
          IFEND;

          IF llc$record_attribute_spare2 IN item^ [i].record_attributes THEN
            ocp$output (' ', 'SPARE2', 6, occ$continue);
          IFEND;

          IF llc$record_attribute_spare3 IN item^ [i].record_attributes THEN
            ocp$output (' ', 'SPARE3', 6, occ$continue);
          IFEND;

          IF llc$record_attribute_spare4 IN item^ [i].record_attributes THEN
            ocp$output (' ', 'SPARE4', 6, occ$continue);
          IFEND;

          IF llc$record_attribute_spare5 IN item^ [i].record_attributes THEN
            ocp$output (' ', 'SPARE5', 6, occ$continue);
          IFEND;

          IF llc$record_attribute_spare6 IN item^ [i].record_attributes THEN
            ocp$output (' ', 'SPARE6', 6, occ$continue);
          IFEND;

          IF llc$record_attribute_spare7 IN item^ [i].record_attributes THEN
            ocp$output (' ', 'SPARE7', 6, occ$continue);
          IFEND;

          IF llc$record_attribute_spare8 IN item^ [i].record_attributes THEN
            ocp$output (' ', 'SPARE8', 6, occ$continue);
          IFEND;

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

          STRINGREP (strng, length, item^ [i].record_first_field);
          ocp$output ('      record first field: ', strng, length, occ$continue);

          STRINGREP (strng, length, item^ [i].record_length);
          ocp$output ('  record length: ', strng, length, occ$continue);

          STRINGREP (strng, length, item^ [i].record_selector);
          ocp$output ('  record selector: ', strng, length, occ$end_of_line);

        = llc$field_kind =
          ocp$output (' ', 'FIELD KIND', 10, occ$end_of_line);

          STRINGREP (strng, length, item^ [i].field_offset);
          ocp$output ('      field offset: ', strng, length, occ$continue);

          STRINGREP (strng, length, item^ [i].field_length);
          ocp$output ('  field length: ', strng, length, occ$continue);

          ocp$output ('      ', 'field attributes: [', 19, occ$continue);
          IF llc$field_is_byte_addressable IN item^ [i].field_attributes THEN
            ocp$output (' ', 'FIELD_IS_BYTE_ADDRESSABLE', 25, occ$continue);
          IFEND;

          IF llc$field_attribute_spare2 IN item^ [i].field_attributes THEN
            ocp$output (' ', 'SPARE2', 6, occ$continue);
          IFEND;

          IF llc$field_attribute_spare3 IN item^ [i].field_attributes THEN
            ocp$output (' ', 'SPARE3', 6, occ$continue);
          IFEND;

          IF llc$field_attribute_spare4 IN item^ [i].field_attributes THEN
            ocp$output (' ', 'SPARE4', 6, occ$continue);
          IFEND;

          IF llc$field_attribute_spare5 IN item^ [i].field_attributes THEN
            ocp$output (' ', 'SPARE5', 6, occ$continue);
          IFEND;

          IF llc$field_attribute_spare6 IN item^ [i].field_attributes THEN
            ocp$output (' ', 'SPARE6', 6, occ$continue);
          IFEND;

          IF llc$field_attribute_spare7 IN item^ [i].field_attributes THEN
            ocp$output (' ', 'SPARE7', 6, occ$continue);
          IFEND;

          IF llc$field_attribute_spare8 IN item^ [i].field_attributes THEN
            ocp$output (' ', 'SPARE8', 6, occ$continue);
          IFEND;

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

          STRINGREP (strng, length, item^ [i].field_type);
          ocp$output ('      field type: ', strng, length, occ$continue);

          STRINGREP (strng, length, item^ [i].next_field);
          ocp$output ('  next field: ', strng, length, occ$end_of_line);

        = llc$selector_kind =
          ocp$output (' ', 'SELECTOR KIND', 13, occ$end_of_line);

          STRINGREP (strng, length, item^ [i].variation);
          ocp$output ('      variation: ', strng, length, occ$continue);

          STRINGREP (strng, length, item^ [i].next_selector);
          ocp$output ('  next selector: ', strng, length, occ$end_of_line);

          STRINGREP (strng, length, item^ [i].low_selector);
          ocp$output ('      low selector: ', strng, length, occ$continue);

          STRINGREP (strng, length, item^ [i].high_selector);
          ocp$output ('  high selector: ', strng, length, occ$end_of_line);

        = llc$heap_kind =
          ocp$output (' ', 'HEAP KIND', 9, occ$end_of_line);

        = llc$seq_kind =
          ocp$output (' ', 'SEQ KIND', 8, occ$end_of_line);

        = llc$bound_vrec_kind =
          ocp$output (' ', 'BOUND VREC KIND', 15, occ$end_of_line);

          STRINGREP (strng, length, item^ [i].bound_type);
          ocp$output ('      bound type: ', strng, length, occ$end_of_line);

        = llc$rel_ptr_kind =
          ocp$output (' ', 'REL PTR KIND', 12, occ$end_of_line);

          STRINGREP (strng, length, item^ [i].parent_type);
          ocp$output ('      parent_type: ', strng, length, occ$continue);

          STRINGREP (strng, length, item^ [i].object_type);
          ocp$output ('  object type: ', strng, length, occ$continue);

          STRINGREP (strng, length, item^ [i].rel_ptr_object_length);
          ocp$output ('  rel ptr object length: ', strng, length, occ$end_of_line);

        = llc$ftn_array_kind =
          ocp$output (' ', 'FORTRAN ARRAY KIND', 18, occ$end_of_line);

          STRINGREP (strng, length, item^ [i].ftn_array_element_type);
          ocp$output ('      fortran array element type: ', strng, length, occ$continue);

          STRINGREP (strng, length, item^ [i].ftn_array_element_length);
          ocp$output ('  fortran array element length: ', strng, length, occ$end_of_line);

          ocp$output ('      ', 'fortran array base:', 19, occ$continue);
          CASE item^ [i].ftn_array_base OF
          = llc$null_base =
            ocp$output (' ', 'NULL BASE', 9, occ$end_of_line);

          = llc$static_base =
            ocp$output (' ', 'STATIC BASE', 11, occ$end_of_line);

          = llc$constant_base =
            ocp$output (' ', 'CONSTANT BASE', 13, occ$end_of_line);

          = llc$stack_frame_base =
            ocp$output (' ', 'STACK FRAME BASE', 16, occ$end_of_line);

          = llc$parm_list_base =
            ocp$output (' ', 'PARM LIST BASE', 14, occ$end_of_line);

          = llc$xref_base =
            ocp$output (' ', 'XREF BASE', 9, occ$end_of_line);

          = llc$register_base =
            ocp$output (' ', 'REGISTER BASE', 13, occ$end_of_line);

          ELSE
            ocp$output (' ', '*************', 13, occ$end_of_line);
            error (' ', 'INVALID BASE', 12, occ$end_of_line);
          CASEND;

          hexrep (strng, length, item^ [i].ftn_array_section_ordinal);
          ocp$output ('      fortran array section ordinal: ', strng, length, occ$continue);

          hexrep (strng, length, item^ [i].ftn_array_offset);
          ocp$output ('  fortran array offset: ', strng, length, occ$end_of_line);

          IF item^ [i].ftn_array_base = llc$static_base THEN
            verify_address (item^ [i].ftn_array_section_ordinal, item^ [i].ftn_array_offset);
          IFEND;

          ocp$output ('      ', 'fortran array attributes: [', 27, occ$continue);
          IF llc$ftn_array_is_parameter IN item^ [i].ftn_array_attributes THEN
            ocp$output (' ', 'ARRAY_IS_PARAMETER', 18, occ$continue);
          IFEND;

          IF llc$ftn_storage_is_columnwise IN item^ [i].ftn_array_attributes THEN
            ocp$output (' ', 'STORAGE_IS_COLUMNWISE', 21, occ$continue);
          IFEND;

          IF llc$ftn_array_adjustable IN item^ [i].ftn_array_attributes THEN
            ocp$output (' ', 'ADUSTABLE', 9, occ$continue);
          IFEND;

          IF llc$ftn_array_assumed_size IN item^ [i].ftn_array_attributes THEN
            ocp$output (' ', 'ASSUMED_SIZE', 12, occ$continue);
          IFEND;

          IF llc$ftn_array_assumed_shape IN item^ [i].ftn_array_attributes THEN
            ocp$output (' ', 'ASSUMED_SHAPE', 13, occ$continue);
          IFEND;

          IF llc$ftn_array_indirect_accessed IN item^ [i].ftn_array_attributes THEN
            ocp$output (' ', 'INDIRECT_ACCESSED', 17, occ$continue);
          IFEND;

          IF llc$cdc_ftn_dimension_desc IN item^ [i].ftn_array_attributes THEN
            ocp$output (' ', 'DIMENSION_DESC', 14, occ$continue);
          IFEND;

          IF llc$ftn_array_attribute_spare8 IN item^ [i].ftn_array_attributes THEN
            ocp$output (' ', 'SPARE8', 6, occ$continue);
          IFEND;

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

          hexrep (strng, length, item^ [i].dimension_info_section_ordinal);
          ocp$output ('      dimension info section ordinal: ', strng, length, occ$continue);

          hexrep (strng, length, item^ [i].dimension_info_offset);
          ocp$output ('  dimension info offset: ', strng, length, occ$end_of_line);

          verify_address (item^ [i].dimension_info_section_ordinal, item^ [i].dimension_info_offset);

        = llc$namelist_group_kind =
          ocp$output (' ', 'NAMELIST GROUP KIND', 19, occ$end_of_line);

          hexrep (strng, length, item^ [i].namelist_info_section_ordinal);
          ocp$output ('      namelist info section ordinal: ', strng, length, occ$continue);

          hexrep (strng, length, item^ [i].namelist_info_offset);
          ocp$output ('  namelist info offset: ', strng, length, occ$end_of_line);

          verify_address (item^ [i].namelist_info_section_ordinal, item^ [i].namelist_info_offset);

        = llc$equated_label =
          ocp$output (' ', 'EQUATED LABEL', 13, occ$end_of_line);

          STRINGREP (strng, length, item^ [i].first_equated_symbol);
          ocp$output ('      first equated symbol: ', strng, length, occ$end_of_line);

        = llc$external_equate =
          ocp$output (' ', 'EXTERNAL EQUATE', 15, occ$end_of_line);

          ocp$output ('      ', 'operation:', 10, occ$continue);
          CASE item^ [i].operation OF
          = llc$external_no_operation =
            ocp$output (' ', 'EXTERNAL NO OPERATION', 21, occ$continue);

          = llc$external_addition =
            ocp$output (' ', 'EXTERNAL ADDITION', 17, occ$continue);

          = llc$external_subtraction =
            ocp$output (' ', 'EXTERNAL SUBTRACTION', 20, occ$continue);

          = llc$external_multiplication =
            ocp$output (' ', 'EXTERNAL MULTIPLICATION', 23, occ$continue);

          = llc$external_division =
            ocp$output (' ', 'EXTERNAL DIVISION', 17, occ$continue);

          ELSE
            ocp$output (' ', 'INVALID EXTERNAL', 16, occ$continue);
          CASEND;

          STRINGREP (strng, length, item^ [i].operand);
          ocp$output ('  operand: ', strng, length, occ$end_of_line);

        = llc$basic_array_kind =
          ocp$output (' ', 'BASIC ARRAY KIND', 16, occ$end_of_line);

          STRINGREP (strng, length, item^ [i].basic_array_element_type);
          ocp$output ('   basic array element type: ', strng, length, occ$end_of_line);

        = llc$pascal_conf_array_kind =
          ocp$output (' ', 'PASCAL CONF ARRAY KIND', 22, occ$end_of_line);

          ocp$output ('  ', 'conf array packing:', 20, occ$continue);
          CASE item^ [i].conf_array_packing OF
          = llc$packed =
            ocp$output (' ', 'PACKED', 6, occ$end_of_line);

          = llc$unpacked =
            ocp$output (' ', 'UNPACKED', 8, occ$end_of_line);

          = llc$not_packed =
            ocp$output (' ', 'NOT PACKED', 10, occ$end_of_line);

          ELSE
            ocp$output (' ', '*********', 9, occ$end_of_line);
            error (' ', 'INVALID ARRAY PACKING', 21, occ$end_of_line);
          CASEND;

          ocp$output ('      ', 'conf array attributes: [', 25, occ$continue);
          IF llc$cybil_array_is_bits IN item^ [i].conf_array_attributes THEN
            ocp$output (' ', 'CYBIL_ARRAY_IS_BITS', 19, occ$continue);
          IFEND;

          IF llc$cyb_array_attribute_spare2 IN item^ [i].conf_array_attributes THEN
            ocp$output (' ', 'SPARE2', 6, occ$continue);
          IFEND;

          IF llc$cyb_array_attribute_spare3 IN item^ [i].conf_array_attributes THEN
            ocp$output (' ', 'SPARE3', 6, occ$continue);
          IFEND;

          IF llc$cyb_array_attribute_spare4 IN item^ [i].conf_array_attributes THEN
            ocp$output (' ', 'SPARE4', 6, occ$continue);
          IFEND;

          IF llc$cyb_array_attribute_spare5 IN item^ [i].conf_array_attributes THEN
            ocp$output (' ', 'SPARE5', 6, occ$continue);
          IFEND;

          IF llc$cyb_array_attribute_spare6 IN item^ [i].conf_array_attributes THEN
            ocp$output (' ', 'SPARE6', 6, occ$continue);
          IFEND;

          IF llc$cyb_array_attribute_spare7 IN item^ [i].conf_array_attributes THEN
            ocp$output (' ', 'SPARE7', 6, occ$continue);
          IFEND;

          IF llc$cyb_array_attribute_spare8 IN item^ [i].conf_array_attributes THEN
            ocp$output (' ', 'SPARE8', 6, occ$continue);
          IFEND;

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

          STRINGREP (strng, length, item^ [i].conf_array_lower_bound);
          ocp$output ('      conf array lower bound: ', strng, length, occ$continue);

          STRINGREP (strng, length, item^ [i].conf_array_upper_bound);
          ocp$output ('  conf array upper bound: ', strng, length, occ$continue);

          STRINGREP (strng, length, item^ [i].conf_array_element_kind);
          ocp$output ('  conf array element kind: ', strng, length, occ$continue);

          STRINGREP (strng, length, item^ [i].conf_array_element_length);
          ocp$output ('  conf array element length: ', strng, length, occ$end_of_line);

        = llc$pascal_file_kind =
          ocp$output (' ', ' PASCAL FILE KIND', 16, occ$end_of_line);

          STRINGREP (strng, length, item^ [i].buffer_type);
          ocp$output ('       buffer type: ', strng, length, occ$end_of_line);

        = llc$pascal_with_kind =
          ocp$output (' ', 'PASCAL WITH KIND', 16, occ$end_of_line);

          STRINGREP (strng, length, item^ [i].with_first_symbol);
          ocp$output ('   with first symbol: ', strng, length, occ$continue);

          hexrep (strng, length, item^ [i].with_section_ordinal);
          ocp$output ('   with section ordinal: ', strng, length, occ$continue);

          hexrep (strng, length, item^ [i].with_offset);
          ocp$output ('       with offset: ', strng, length, occ$continue);

          hexrep (strng, length, item^ [i].with_length);
          ocp$output ('       with length: ', strng, length, occ$end_of_line);

          STRINGREP (strng, length, item^ [i].with_parent);
          ocp$output ('       with parent: ', strng, length, occ$end_of_line);

        = llc$unsigned_integer_kind =
          ocp$output (' ', 'UNSIGNED INTEGER KIND', 21, occ$end_of_line);

        ELSE
          ocp$output (' ', '************', 12, occ$end_of_line);
          error (' ', 'INVALID SYMBOL TYPE', 19, occ$end_of_line);
        CASEND;

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

      FOREND;


    PROCEND process_symbol_table;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_SUPPLEMENTAL_DTABLES' ??
?? EJECT ??

    PROCEDURE process_supplemental_dtables
      (    sequence_length: ost$segment_length;
       VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);

      VAR
        supplemental_debug_tables: ^llt$supplemental_debug_tables;

      NEXT supplemental_debug_tables: [[REP sequence_length OF cell]] IN file;
      IF supplemental_debug_tables = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
      IFEND;

    PROCEND process_supplemental_dtables;

?? OLDTITLE ??
?? NEWTITLE := '  HEXREP' ??
?? EJECT ??

    PROCEDURE hexrep
      (VAR strng: string ( * );
       VAR length: integer;
           intger: integer);


      VAR
        str: ost$string,
        status: ost$status;


      clp$convert_integer_to_string (intger, 16, FALSE, str, status);

      length := str.size;
      strng (1, length) := str.value;


    PROCEND hexrep;
?? OLDTITLE ??
?? NEWTITLE := '  HEXREP_FULL' ??
?? EJECT ??

    PROCEDURE hexrep_full
      (VAR strng: string ( * );
       VAR length: integer;
           location: ^cell;
           offset: integer;
           size: 1 .. 32);


      VAR
        array_pointer: ^array [1 .. * ] of 0 .. 0ff(16),
        i: 1 .. 32,
        str: ost$string,
        status: ost$status;


      length := 0;
      i#build_adaptable_array_ptr (#RING (location), #SEGMENT (location), (#OFFSET (location) + offset), size,
            1, 1, #LOC (array_pointer));

      FOR i := 1 TO size DO
        clp$convert_integer_to_string (array_pointer^ [i], 16, FALSE, str, status);

        CASE str.size OF
        = 1 =
          strng (1 + length) := '0';
          strng (1 + length + 1) := str.value (1);
        = 2 =
          strng (1 + length, 2) := str.value (1, 2);
        = 3 =
          strng (1 + length, 2) := str.value (2, 2);
        ELSE
          error (' ', 'INTERNAL PROBLEM 1', 18, occ$end_of_line);
        CASEND;

        length := length + 2;
      FOREND;


    PROCEND hexrep_full;
?? OLDTITLE ??
?? NEWTITLE := '  HEX_DUMP' ??
?? EJECT ??

    PROCEDURE hex_dump
      (    location: ^cell;
           size: integer);


      VAR
        i: integer;


      IF NOT display_hex_records THEN
        ocp$output ('0', '     {**** HEX RECORD NOT DISPLAYED ****}', 41, occ$end_of_line);
        RETURN;
      IFEND;

      ocp$output (' ', '     ', 5, occ$continue);

      i := 0;
      REPEAT
        IF (size - i) < 4 THEN
          hexrep_full (strng, length, location, i, (size - i));
        ELSE
          hexrep_full (strng, length, location, i, 4);
        IFEND;

        IF (i MOD 24) = 0 THEN
          ocp$output ('', '', 0, occ$end_of_line);
          ocp$output ('      ', strng, length, occ$continue);
        ELSE
          ocp$output ('  ', strng, length, occ$continue);
        IFEND;

        i := i + 4;
      UNTIL i >= size;

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


    PROCEND hex_dump;
?? OLDTITLE ??
?? NEWTITLE := '  OUTPUT_LANGUAGE', EJECT ??

    PROCEDURE output_language
      (    language: ^llt$module_generator;
           end_of_line: boolean);


      VAR
        valid_language: boolean;


      ocp$output_module_generator (language, end_of_line, valid_language);

      IF NOT valid_language THEN
        ocp$output (' ', ' ', 1, occ$end_of_line);
        error (' ', 'INVALID MODULE GENERATOR', 24, occ$end_of_line);
      IFEND;


    PROCEND output_language;
?? OLDTITLE ??
?? NEWTITLE := '  VERIFY_ADDRESS' ??
?? EJECT ??

    PROCEDURE verify_address
      (    section_ordinal: integer;
           offset: integer);


      IF section_ordinal > module_info.greatest_section_ordinal THEN
        hexrep (strng, length, section_ordinal);
        error (' ', 'SECTION ORDINAL > GREATEST SECTION ORDINAL:', 43, occ$continue);
        error (' ', strng, length, occ$end_of_line);

      ELSEIF module_info.section_definition^ [section_ordinal] = NIL THEN
        hexrep (strng, length, section_ordinal);
        error (' ', 'SECTION DEFINITION FOR THIS SECTION NOT YET ENCOUNTERED:', 56, occ$continue);
        error (' ', strng, length, occ$end_of_line);

      ELSEIF (offset + 1) > module_info.section_definition^ [section_ordinal]^.length THEN
        hexrep (strng, length, (offset + 1));
        warning (' ', 'OFFSET REFERENCE (', 18, occ$continue);
        warning (' ', strng, length, occ$continue);
        hexrep (strng, length, module_info.section_definition^ [section_ordinal]^.length);
        warning (' ', ') > SECTION LENGTH (', 20, occ$continue);
        warning (' ', strng, length, occ$continue);
        warning (' ', ')', 1, occ$end_of_line);

      ELSEIF offset < 0 THEN
        hexrep (strng, length, offset);
        warning (' ', 'INVALID OFFSET:', 15, occ$continue);
        warning (' ', strng, length, occ$end_of_line);

      IFEND;


    PROCEND verify_address;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_OBJECT_TEXT_DESCRIPTOR' ??
?? EJECT ??

    PROCEDURE process_object_text_descriptor
      (VAR file: ^SEQ ( * );
       VAR fatal_error: boolean;
       VAR end_of_file: boolean;
       VAR kind: llt$object_record_kind;
       VAR size: integer);


      VAR
        object_text_descriptor: ^llt$object_text_descriptor,

        file_position: ost$segment_offset;


      end_of_file := FALSE;

      NEXT object_text_descriptor IN file;
      IF object_text_descriptor = NIL THEN
        file_position := i#current_sequence_position (file);
        IF file_position >= #SIZE (file^) THEN
          end_of_file := TRUE;
        ELSE
          error (' ', premature_end_of_file, 33, occ$end_of_line);
          fatal_error := TRUE;
        IFEND;
        RETURN;
      IFEND;


      CASE object_text_descriptor^.kind OF
      = llc$identification =
        kind := llc$identification;
        ocp$output ('0', 'IDR', 3, occ$continue);

      = llc$libraries =
        kind := llc$libraries;
        ocp$output ('0', 'LIB', 3, occ$continue);

      = llc$section_definition =
        kind := llc$section_definition;
        ocp$output ('0', 'SDC', 3, occ$continue);

      = llc$allotted_section_definition =
        kind := llc$allotted_section_definition;
        ocp$output ('0', 'ASD', 3, occ$continue);

      = llc$segment_definition =
        kind := llc$segment_definition;
        ocp$output ('0', 'SGD', 3, occ$continue);

      = llc$allotted_segment_definition =
        kind := llc$allotted_segment_definition;
        ocp$output ('0', 'ASG', 3, occ$continue);

      = llc$obsolete_segment_definition =
        kind := llc$obsolete_segment_definition;
        ocp$output ('0', 'OSD', 3, occ$continue);

      = llc$obsolete_allotted_seg_def =
        kind := llc$obsolete_allotted_seg_def;
        ocp$output ('0', 'OAS', 3, occ$continue);

      = llc$unallocated_common_block =
        kind := llc$unallocated_common_block;
        ocp$output ('0', 'UCB', 3, occ$continue);

      = llc$text =
        kind := llc$text;
        ocp$output ('0', 'TEX', 3, occ$continue);

      = llc$replication =
        kind := llc$replication;
        ocp$output ('0', 'RPL', 3, occ$continue);

      = llc$bit_string_insertion =
        kind := llc$bit_string_insertion;
        ocp$output ('0', 'BSI', 3, occ$continue);

      = llc$entry_definition =
        kind := llc$entry_definition;
        ocp$output ('0', 'EPT', 3, occ$continue);

      = llc$deferred_entry_points =
        kind := llc$deferred_entry_points;
        ocp$output ('0', 'DEP', 3, occ$continue);

      = llc$deferred_common_blocks =
        kind := llc$deferred_common_blocks;
        ocp$output ('0', 'DCB', 3, occ$continue);

      = llc$relocation =
        kind := llc$relocation;
        ocp$output ('0', 'RIF', 3, occ$continue);

      = llc$address_formulation =
        kind := llc$address_formulation;
        ocp$output ('0', 'ADR', 3, occ$continue);

      = llc$external_linkage =
        kind := llc$external_linkage;
        ocp$output ('0', 'EXT', 3, occ$continue);

      = llc$obsolete_formal_parameters =
        kind := llc$obsolete_formal_parameters;
        ocp$output ('0', 'OFP', 3, occ$continue);

      = llc$formal_parameters =
        kind := llc$formal_parameters;
        ocp$output ('0', 'FPR', 3, occ$continue);

      = llc$actual_parameters =
        kind := llc$actual_parameters;
        ocp$output ('0', 'APR', 3, occ$continue);

      = llc$binding_template =
        kind := llc$binding_template;
        ocp$output ('0', 'BTI', 3, occ$continue);

      = llc$ppu_absolute =
        kind := llc$ppu_absolute;
        ocp$output ('0', 'PPU', 3, occ$continue);

      = llc$obsolete_line_table =
        kind := llc$obsolete_line_table;
        ocp$output ('0', 'OLT', 3, occ$continue);

      = llc$cybil_symbol_table_fragment =
        kind := llc$cybil_symbol_table_fragment;
        ocp$output ('0', 'CST', 3, occ$continue);

      = llc$line_table =
        kind := llc$line_table;
        ocp$output ('0', 'LAT', 3, occ$continue);

      = llc$symbol_table =
        kind := llc$symbol_table;
        ocp$output ('0', 'DST', 3, occ$continue);

      = llc$supplemental_debug_tables =
        kind := llc$supplemental_debug_tables;
        ocp$output ('0', 'SDT', 3, occ$continue);

      = llc$form_definition =
        kind := llc$form_definition;
        ocp$output ('0', 'FRM', 3, occ$continue);

      = llc$application_identifier =
        kind := llc$application_identifier;
        ocp$output ('0', 'AIR', 3, occ$continue);

      = llc$68000_absolute =
        kind := llc$68000_absolute;
        ocp$output ('0', '68A', 3, occ$continue);

      = llc$transfer_symbol =
        kind := llc$transfer_symbol;
        ocp$output ('0', 'TRA', 3, occ$continue);

      ELSE
        ocp$output ('0', '***', 3, occ$continue);
      CASEND;

      STRINGREP (strng, length, record_number);
      ocp$output ('  ', 'rn:', 3, occ$continue);
      ocp$output (' ', strng, length, occ$continue);
      record_number := record_number + 1;

      hexrep (strng, length, #OFFSET (object_text_descriptor));
      ocp$output ('  ', 'bn:', 3, occ$continue);
      ocp$output (' ', strng, length, occ$continue);
      CASE object_text_descriptor^.kind OF
      = llc$identification, llc$section_definition, llc$bit_string_insertion, llc$entry_definition,
            llc$binding_template, llc$transfer_symbol, llc$segment_definition, llc$unallocated_common_block,
            llc$application_identifier, llc$obsolete_segment_definition =
        ocp$output ('', '', 0, occ$end_of_line);

      = llc$libraries =
        size := object_text_descriptor^.number_of_libraries;
        hexrep (strng, length, object_text_descriptor^.number_of_libraries);
        ocp$output ('  ', 'number of libraries:', 20, occ$continue);
        ocp$output (' ', strng, length, occ$end_of_line);

        IF object_text_descriptor^.number_of_libraries = 0 THEN
          error (' ', 'NUMBER OF LIBRARIES CAN NOT BE 0', 32, occ$end_of_line);
          fatal_error := TRUE;
        IFEND;

      = llc$allotted_section_definition =
        size := object_text_descriptor^.allotted_section;
        hexrep (strng, length, object_text_descriptor^.allotted_section);
        ocp$output ('  ', 'allotted section:', 17, occ$continue);
        ocp$output (' ', strng, length, occ$end_of_line);

      = llc$allotted_segment_definition, llc$obsolete_allotted_seg_def =
        size := object_text_descriptor^.allotted_segment;
        hexrep (strng, length, object_text_descriptor^.allotted_segment);
        ocp$output ('  ', 'allotted segment:', 17, occ$continue);
        ocp$output (' ', strng, length, occ$continue);
        size := (size * 100000000(16)) + object_text_descriptor^.allotted_segment_length; {kludge}
        hexrep (strng, length, object_text_descriptor^.allotted_segment_length);
        ocp$output ('  ', 'allotted segment length:', 24, occ$continue);
        ocp$output (' ', strng, length, occ$end_of_line);

      = llc$text, llc$replication =
        size := object_text_descriptor^.number_of_bytes;
        hexrep (strng, length, object_text_descriptor^.number_of_bytes);
        ocp$output ('  ', 'number of bytes:', 16, occ$continue);
        ocp$output (' ', strng, length, occ$end_of_line);

        IF object_text_descriptor^.number_of_bytes = 0 THEN
          error (' ', 'NUMBER OF BYTES CAN NOT BE 0', 33, occ$end_of_line);
          fatal_error := TRUE;
        IFEND;

      = llc$relocation =
        size := object_text_descriptor^.number_of_rel_items;
        hexrep (strng, length, object_text_descriptor^.number_of_rel_items);
        ocp$output ('  ', 'number of relocation items:', 27, occ$continue);
        ocp$output (' ', strng, length, occ$end_of_line);

        IF object_text_descriptor^.number_of_rel_items = 0 THEN
          error (' ', 'NUMBER OF ITEMS CAN NOT BE 0', 33, occ$end_of_line);
          fatal_error := TRUE;
        IFEND;

      = llc$address_formulation =
        size := object_text_descriptor^.number_of_adr_items;
        hexrep (strng, length, object_text_descriptor^.number_of_adr_items);
        ocp$output ('  ', 'number of address formulation items:', 36, occ$continue);
        ocp$output (' ', strng, length, occ$end_of_line);

        IF object_text_descriptor^.number_of_adr_items = 0 THEN
          error (' ', 'NUMBER OF ITEMS CAN NOT BE 0', 33, occ$end_of_line);
          fatal_error := TRUE;
        IFEND;

      = llc$deferred_entry_points =
        size := object_text_descriptor^.number_of_entry_points;
        hexrep (strng, length, object_text_descriptor^.number_of_entry_points);
        ocp$output ('  ', 'number of entry points:', 23, occ$continue);
        ocp$output (' ', strng, length, occ$end_of_line);

      = llc$deferred_common_blocks =
        size := object_text_descriptor^.number_of_common_blocks;
        hexrep (strng, length, object_text_descriptor^.number_of_common_blocks);
        ocp$output ('  ', 'number of common blocks:', 24, occ$continue);
        ocp$output (' ', strng, length, occ$end_of_line);

      = llc$external_linkage =
        size := object_text_descriptor^.number_of_ext_items;
        hexrep (strng, length, object_text_descriptor^.number_of_ext_items);
        ocp$output ('  ', 'number of external items:', 25, occ$continue);
        ocp$output (' ', strng, length, occ$end_of_line);

        IF object_text_descriptor^.number_of_ext_items = 0 THEN
          error (' ', 'NUMBER OF ITEMS CAN NOT BE 0', 33, occ$end_of_line);
          fatal_error := TRUE;
        IFEND;

      = llc$obsolete_line_table, llc$line_table =
        size := object_text_descriptor^.number_of_line_items;
        hexrep (strng, length, object_text_descriptor^.number_of_line_items);
        ocp$output ('  ', 'number of line table items:', 27, occ$continue);
        ocp$output (' ', strng, length, occ$end_of_line);

        IF object_text_descriptor^.number_of_line_items = 0 THEN
          error (' ', 'NUMBER OF LINE TABLE ITEMS CAN NOT BE 0', 39, occ$end_of_line);
          fatal_error := TRUE;
        IFEND;

      = llc$obsolete_formal_parameters, llc$formal_parameters, llc$actual_parameters,
            llc$cybil_symbol_table_fragment, llc$68000_absolute, llc$symbol_table, llc$form_definition,
            llc$supplemental_debug_tables =
        size := object_text_descriptor^.sequence_length;
        hexrep (strng, length, object_text_descriptor^.sequence_length);
        ocp$output ('  ', 'sequence length:', 16, occ$continue);
        ocp$output (' ', strng, length, occ$end_of_line);

        IF object_text_descriptor^.sequence_length = 0 THEN
          error (' ', 'SEQUENCE LENGTH CAN NOT BE 0', 28, occ$end_of_line);
          fatal_error := TRUE;
        IFEND;

      = llc$ppu_absolute =
        size := object_text_descriptor^.number_of_words;
        hexrep (strng, length, object_text_descriptor^.number_of_words);
        ocp$output ('  ', 'number of words:', 17, occ$continue);
        ocp$output (' ', strng, length, occ$end_of_line);

        IF object_text_descriptor^.number_of_words > llc$max_ppu_size THEN
          error (' ', 'INVALID NUMBER OF WORDS', 23, occ$end_of_line);
          fatal_error := TRUE;
        IFEND;

      ELSE
        ocp$output ('', '', 0, occ$end_of_line);

        error (' ', 'INVALID OBJECT RECORD KIND', 26, occ$end_of_line);
        fatal_error := TRUE;
      CASEND;


    PROCEND process_object_text_descriptor;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_IDENTIFICATION_RECORD' ??
?? EJECT ??

    PROCEDURE process_identification_record
      (VAR file: ^SEQ ( * );
       VAR fatal_error: boolean;
       VAR module_kind: llt$module_kind);


      VAR
        valid: boolean,
        identification: ^llt$identification;


      NEXT identification IN file;
      IF identification = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      ocp$output ('      ', 'name:', 5, occ$continue);
      ocp$output (' ', identification^.name, STRLENGTH (identification^.name), occ$end_of_line);

      ocp$output ('      ', 'kind:', 5, occ$continue);
      ocp$output_module_kind (^identification^.kind, occ$continue, valid);
      IF valid THEN
        module_kind := identification^.kind;
      ELSE
        ocp$output (' ', '*', 1, occ$end_of_line);
        error (' ', 'INVALID MODULE KIND', 19, occ$end_of_line);
        fatal_error := TRUE;
      IFEND;

      ocp$output ('   ', 'created:', 8, occ$continue);
      ocp$output_time (^identification^.time_created, occ$continue, valid);
      IF NOT valid THEN
        ocp$output (' ', ' ', 1, occ$end_of_line);
        error (' ', 'INVALID TIME FORMAT', 19, occ$end_of_line);
        ocp$output (' ', '     ', 5, occ$continue);
      IFEND;

      ocp$output ('', ' ', 1, occ$continue);
      ocp$output_date (^identification^.date_created, occ$end_of_line, valid);
      IF NOT valid THEN
        error (' ', 'INVALID DATE FORMAT', 19, occ$end_of_line);
      IFEND;

      ocp$output ('      ', 'attr = [', 8, occ$continue);
      IF NOT (llc$nonbindable IN identification^.attributes) THEN
        ocp$output (' ', 'BIND', 4, occ$continue);
      IFEND;
      IF NOT (llc$nonexecutable IN identification^.attributes) THEN
        ocp$output (' ', 'EXECUTE', 7, occ$continue);
      IFEND;
      IF (identification^.generator_id = llc$cybil) OR (identification^.generator_id =
            llc$object_library_generator) OR (identification^.generator_id = llc$virtual_environment_linker)
            THEN
        IF (llc$object_cybil_checking IN identification^.attributes) THEN
          ocp$output (' ', 'OBJECT_CYBIL_CHECKING', 21, occ$continue);
        ELSE
          ocp$output (' ', 'SOURCE_CYBIL_CHECKING', 21, occ$continue);
        IFEND;
      IFEND;
      IF (llc$ma_unused_1 IN identification^.attributes) THEN
        ocp$output (' ', 'SPARE1', 6, occ$continue);
      IFEND;
      IF (llc$ma_unused_2 IN identification^.attributes) THEN
        ocp$output (' ', 'SPARE2', 6, occ$continue);
      IFEND;
      IF (llc$ma_unused_3 IN identification^.attributes) THEN
        ocp$output (' ', 'SPARE3', 6, occ$continue);
      IFEND;
      IF (llc$ma_unused_4 IN identification^.attributes) THEN
        ocp$output (' ', 'SPARE4', 6, occ$continue);
      IFEND;
      IF (llc$ma_unused_5 IN identification^.attributes) THEN
        ocp$output (' ', 'SPARE5', 6, occ$continue);
      IFEND;
      ocp$output (' ', ']', 1, occ$continue);

      IF identification^.kind <> llc$iou THEN
        module_info.greatest_section_ordinal := identification^.greatest_section_ordinal;
        hexrep (strng, length, module_info.greatest_section_ordinal);
        ocp$output ('   ', 'greatest section ordinal:', 25, occ$continue);
        ocp$output (' ', strng, length, occ$end_of_line);
      ELSE
        module_info.greatest_section_ordinal := 0;
        ocp$output ('', '', 0, occ$end_of_line);
      IFEND;

      ocp$output ('      ', 'generator:', 10, occ$continue);
      output_language (^identification^.generator_id, occ$continue);

      module_info.version := identification^.object_text_version;
      ocp$output ('   ', 'object text version:', 20, occ$continue);
      ocp$output (' ', module_info.version, STRLENGTH (module_info.version), occ$end_of_line);
      IF (module_info.version <> 'V1.2') AND (module_info.version <> 'V1.3') AND (module_info.version <>
            'V1.4') THEN
        error (' ', 'INVALID OBJECT TEXT VERSION', 27, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      IF (module_info.version < 'V1.4') AND ((identification^.generator_id = llc$cybil) OR
            (identification^.generator_id = llc$obsolete_cybil)) THEN
        error (' ', 'CYBIL must be > V1.3', 20, occ$end_of_line);
      IFEND;

      ocp$output ('      ', 'generator name version:', 23, occ$continue);
      ocp$output (' ', identification^.generator_name_vers, STRLENGTH (identification^.generator_name_vers),
            occ$end_of_line);

      ocp$output ('      ', 'commentary:', 11, occ$continue);
      ocp$output (' ', identification^.commentary, STRLENGTH (identification^.commentary), occ$end_of_line);


    PROCEND process_identification_record;
?? OLDTITLE ??
?? NEWTITLE := '  DISPLAY_SECTION_DEFINITION' ??
?? EJECT ??

    PROCEDURE display_section_definition
      (    section_definition: ^llt$section_definition;
           allotted: boolean;
           allotted_section: ost$relative_pointer;
       VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        valid: boolean,
        valid_position: boolean,
        file_ptr: ost$segment_offset,
        reset_value: ^SEQ ( * ),
        section_element: ^array [1 .. * ] of 0 .. 0ff(16);


      hexrep (strng, length, section_definition^.section_ordinal);
      ocp$output (' ', '     section:', 13, occ$continue);
      ocp$output (' ', strng, length, occ$continue);

      ocp$output ('  ', 'kind:', 5, occ$continue);
      ocp$output_section_kind (^section_definition^.kind, occ$continue, valid);
      IF NOT valid THEN
        ocp$output (' ', ' ', 1, occ$end_of_line);
        ocp$output (' ', '     ', 5, occ$continue);
        error (' ', 'INVALID SECTION KIND', 20, occ$end_of_line);
      IFEND;

      ocp$output ('  ', 'attr = [', 8, occ$continue);
      IF llc$read IN section_definition^.access_attributes THEN
        ocp$output (' ', 'R', 1, occ$continue);
      IFEND;
      IF llc$write IN section_definition^.access_attributes THEN
        ocp$output (' ', 'W', 1, occ$continue);
      IFEND;
      IF llc$execute IN section_definition^.access_attributes THEN
        ocp$output (' ', 'X', 1, occ$continue);
      IFEND;
      IF llc$binding IN section_definition^.access_attributes THEN
        ocp$output (' ', 'B', 1, occ$continue);
      IFEND;
      ocp$output (' ', ']', 1, occ$end_of_line);

      hexrep (strng, length, section_definition^.length);
      ocp$output ('      ', 'length:', 7, occ$continue);
      ocp$output (' ', strng, length, occ$continue);

      hexrep (strng, length, section_definition^.allocation_offset);
      ocp$output ('  ', 'offset:', 7, occ$continue);
      ocp$output (' ', strng, length, occ$continue);

      hexrep (strng, length, section_definition^.allocation_alignment);
      ocp$output ('  ', 'alignment:', 10, occ$continue);
      ocp$output (' ', strng, length, occ$end_of_line);

      IF section_definition^.allocation_alignment = 0 THEN
        error (' ', 'ALLOCATION ALIGNMENT EQUALS 0', 29, occ$end_of_line);
      IFEND;
      IF section_definition^.name <> osc$null_name THEN
        ocp$output ('      ', 'name:', 5, occ$continue);
        ocp$output (' ', section_definition^.name, STRLENGTH (section_definition^.name), occ$end_of_line);
      IFEND;

      IF section_definition^.section_ordinal > module_info.greatest_section_ordinal THEN
        error (' ', 'SECTION ORDINAL > GREATEST SECTION ORDINAL', 43, occ$end_of_line);
        RETURN;
      IFEND;

      IF module_info.section_definition^ [section_definition^.section_ordinal] <> NIL THEN
        error (' ', 'SECTION DEFINTION ALREADY ENCOUNTERED FOR THIS SECTION', 54, occ$end_of_line);
        RETURN;
      IFEND;

      module_info.section_definition^ [section_definition^.section_ordinal] := section_definition;

      IF allotted THEN
        IF section_definition^.length = 0 THEN
          error (' ', 'ZERO LENGTH SECTION', 19, occ$end_of_line);
        ELSE
          reset_value := file;
          pmp$position_object_library (file, allotted_section, valid_position);
          IF NOT valid_position THEN
            error (' ', 'PREMATURE END_OF_FILE ENCOUNTERED', 33, occ$end_of_line);
          ELSE
            NEXT section_element: [1 .. section_definition^.length] IN file;
            IF section_element = NIL THEN
              error (' ', premature_end_of_file, 33, occ$end_of_line);
            ELSE
              ocp$output (' ', ' ', 1, occ$end_of_line);
              hex_dump (#LOC (section_element^), section_definition^.length);
            IFEND;
          IFEND;

          file := reset_value;
        IFEND;
      IFEND;


    PROCEND display_section_definition;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_SECTION_DEFINITION' ??
?? EJECT ??

    PROCEDURE process_section_definition
      (VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        section_definition: ^llt$section_definition;


      NEXT section_definition IN file;
      IF section_definition = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      display_section_definition (section_definition, (NOT c$allotted), 0, file, fatal_error);


    PROCEND process_section_definition;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_ALLOTTED_SECTION_DEF' ??
?? EJECT ??

    PROCEDURE process_allotted_section_def
      (    allotted_section: ost$relative_pointer;
       VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        section_definition: ^llt$section_definition;


      NEXT section_definition IN file;
      IF section_definition = NIL THEN
        error (' ', 'PREMATURE END-OF-FILE encountered', 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      display_section_definition (section_definition, c$allotted, allotted_section, file, fatal_error);


    PROCEND process_allotted_section_def;
?? OLDTITLE ??
?? NEWTITLE := '  DISPLAY_SEGMENT_DEFINITION', EJECT ??

    PROCEDURE display_segment_definition
      (    segment_definition: ^llt$segment_definition;
           allotted: boolean;
           allotted_segment: ost$segment_length;
           allotted_segment_length: ost$segment_length;
       VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        bytes_to_display: integer,
        valid_position: boolean,
        file_ptr: ost$segment_offset,
        reset_value: ^SEQ ( * ),
        segment_element: ^array [1 .. * ] of 0 .. 0ff(16);


      hexrep (strng, length, segment_definition^.segment_number);
      ocp$output (' ', '     segment:', 13, occ$continue);
      ocp$output (' ', strng, length, occ$continue);

      hexrep (strng, length, segment_definition^.r1);
      ocp$output ('  r1: ', strng, length, occ$continue);

      hexrep (strng, length, segment_definition^.r2);
      ocp$output ('  r2: ', strng, length, occ$end_of_line);

      display_section_definition (^segment_definition^.section_definition, (NOT c$allotted), 0, file,
            fatal_error);
      IF (fatal_error) THEN
        RETURN;
      IFEND;

      hexrep (strng, length, segment_definition^.binding_section_ordinal);
      ocp$output ('      binding section ordinal: ', strng, length, occ$continue);
      hexrep (strng, length, segment_definition^.binding_section_offset);
      ocp$output ('  binding section offset: ', strng, length, occ$continue);
      hexrep (strng, length, segment_definition^.future_use);
      ocp$output ('  future use: ', strng, length, occ$end_of_line);

      IF allotted THEN
        IF llc$write IN segment_definition^.section_definition.access_attributes THEN
          bytes_to_display := allotted_segment_length;
        ELSE
          bytes_to_display := segment_definition^.section_definition.length;
        IFEND;

        IF bytes_to_display = 0 THEN
          error (' ', 'ZERO LENGTH SEGMENT', 19, occ$end_of_line);
        ELSE
          reset_value := file;
          pmp$position_object_library (file, allotted_segment, valid_position);
          IF NOT valid_position THEN
            error (' ', 'PREMATURE END_OF_FILE ENCOUNTERED', 33, occ$end_of_line);
          ELSE
            NEXT segment_element: [1 .. bytes_to_display] IN file;
            IF segment_element = NIL THEN
              error (' ', premature_end_of_file, 33, occ$end_of_line);
            ELSE
              ocp$output (' ', ' ', 1, occ$end_of_line);
              hex_dump (#LOC (segment_element^), segment_definition^.section_definition.length);
            IFEND;
          IFEND;

          file := reset_value;
        IFEND;
      IFEND;


    PROCEND display_segment_definition;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_SEGMENT_DEFINITION' ??
?? EJECT ??

    PROCEDURE process_segment_definition
      (VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        segment_definition: ^llt$segment_definition;


      NEXT segment_definition IN file;
      IF segment_definition = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      display_segment_definition (segment_definition, (NOT c$allotted), 0, 0, file, fatal_error);


    PROCEND process_segment_definition;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_ALLOTTED_SEGMENT_DEF' ??
?? EJECT ??

    PROCEDURE process_allotted_segment_def
      (    allotted_segment: ost$segment_length;
           allotted_segment_length: ost$segment_length;
       VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        segment_definition: ^llt$segment_definition;


      NEXT segment_definition IN file;
      IF segment_definition = NIL THEN
        error (' ', 'PREMATURE END-OF-FILE encountered', 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      display_segment_definition (segment_definition, c$allotted, allotted_segment, allotted_segment_length,
            file, fatal_error);


    PROCEND process_allotted_segment_def;
?? OLDTITLE ??
?? NEWTITLE := '  DISPLAY_OBSOLETE_SEG_DEF', EJECT ??

    PROCEDURE display_obsolete_seg_def
      (    segment_definition: ^llt$obsolete_segment_definition;
           allotted: boolean;
           allotted_segment: ost$segment_length;
           allotted_segment_length: ost$segment_length;
       VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        bytes_to_display: integer,
        valid_position: boolean,
        file_ptr: ost$segment_offset,
        reset_value: ^SEQ ( * ),
        segment_element: ^array [1 .. * ] of 0 .. 0ff(16);


      hexrep (strng, length, segment_definition^.segment_number);
      ocp$output (' ', '     segment:', 13, occ$continue);
      ocp$output (' ', strng, length, occ$continue);

      hexrep (strng, length, segment_definition^.r1);
      ocp$output ('  r1: ', strng, length, occ$continue);

      hexrep (strng, length, segment_definition^.r2);
      ocp$output ('  r2: ', strng, length, occ$end_of_line);

      display_section_definition (^segment_definition^.section_definition, (NOT c$allotted), 0, file,
            fatal_error);
      IF (fatal_error) THEN
        RETURN;
      IFEND;

      IF allotted THEN
        IF llc$write IN segment_definition^.section_definition.access_attributes THEN
          bytes_to_display := allotted_segment_length;
        ELSE
          bytes_to_display := segment_definition^.section_definition.length;
        IFEND;

        IF bytes_to_display = 0 THEN
          error (' ', 'ZERO LENGTH SEGMENT', 19, occ$end_of_line);
        ELSE
          reset_value := file;
          pmp$position_object_library (file, allotted_segment, valid_position);
          IF NOT valid_position THEN
            error (' ', 'PREMATURE END_OF_FILE ENCOUNTERED', 33, occ$end_of_line);
          ELSE
            NEXT segment_element: [1 .. bytes_to_display] IN file;
            IF segment_element = NIL THEN
              error (' ', premature_end_of_file, 33, occ$end_of_line);
            ELSE
              ocp$output (' ', ' ', 1, occ$end_of_line);
              hex_dump (#LOC (segment_element^), segment_definition^.section_definition.length);
            IFEND;
          IFEND;

          file := reset_value;
        IFEND;
      IFEND;


    PROCEND display_obsolete_seg_def;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_OBSOLETE_SEG_DEF' ??
?? EJECT ??

    PROCEDURE process_obsolete_seg_def
      (VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        obsolete_segment_definition: ^llt$obsolete_segment_definition;


      NEXT obsolete_segment_definition IN file;
      IF obsolete_segment_definition = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      display_obsolete_seg_def (obsolete_segment_definition, (NOT c$allotted), 0, 0, file, fatal_error);


    PROCEND process_obsolete_seg_def;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_OBS_ALLOTTED_SEG_DEF' ??
?? EJECT ??

    PROCEDURE process_obs_allotted_seg_def
      (    allotted_segment: ost$segment_length;
           allotted_segment_length: ost$segment_length;
       VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        obsolete_segment_definition: ^llt$obsolete_segment_definition;


      NEXT obsolete_segment_definition IN file;
      IF obsolete_segment_definition = NIL THEN
        error (' ', 'PREMATURE END-OF-FILE encountered', 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      display_obsolete_seg_def (obsolete_segment_definition, c$allotted, allotted_segment,
            allotted_segment_length, file, fatal_error);


    PROCEND process_obs_allotted_seg_def;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_LIBRARIES_RECORD' ??
?? EJECT ??

    PROCEDURE process_libraries_record
      (    number_of_libraries: 1 .. llc$max_libraries;
       VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        libraries: ^llt$libraries,
        l: 1 .. llc$max_libraries;


      NEXT libraries: [1 .. number_of_libraries] IN file;
      IF libraries = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      l := 1;
      REPEAT
        ocp$output ('      ', libraries^ [l], STRLENGTH (libraries^ [l]), occ$continue);
        l := l + 1;
        IF l > number_of_libraries THEN
          ocp$output ('', '', 0, occ$end_of_line);
        ELSE
          ocp$output ('  ', libraries^ [l], STRLENGTH (libraries^ [l]), occ$end_of_line);
          l := l + 1;
        IFEND;
      UNTIL l > number_of_libraries;


    PROCEND process_libraries_record;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_TEXT_RECORD' ??
?? EJECT ??

    PROCEDURE process_text_record
      (    number_of_bytes: 1 .. osc$max_segment_length;
       VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        text: ^llt$text;


      NEXT text: [1 .. number_of_bytes] IN file;
      IF text = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      hexrep (strng, length, text^.section_ordinal);
      ocp$output ('      ', 'section:', 8, occ$continue);
      ocp$output (' ', strng, length, occ$continue);

      hexrep (strng, length, text^.offset);
      ocp$output ('  ', 'offset:', 7, occ$continue);
      ocp$output (' ', strng, length, occ$end_of_line);

      verify_address (text^.section_ordinal, (text^.offset + number_of_bytes - 1));

      hex_dump (#LOC (text^.byte), number_of_bytes);


    PROCEND process_text_record;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_REPLICATION_RECORD' ??
?? EJECT ??

    PROCEDURE process_replication_record
      (    number_of_bytes: 1 .. osc$max_segment_length;
       VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        replication: ^llt$replication;


      NEXT replication: [1 .. number_of_bytes] IN file;
      IF replication = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      hexrep (strng, length, replication^.section_ordinal);
      ocp$output ('      ', 'section:', 8, occ$continue);
      ocp$output (' ', strng, length, occ$continue);

      hexrep (strng, length, replication^.offset);
      ocp$output ('  ', 'offset:', 7, occ$continue);
      ocp$output (' ', strng, length, occ$end_of_line);

      hexrep (strng, length, replication^.increment);
      ocp$output ('      ', 'increment:', 10, occ$continue);
      IF replication^.increment = 0 THEN
        ocp$output (' ', '********', 8, occ$end_of_line);
        ocp$output (' ', '     ', 5, occ$continue);
        error (' ', 'INVALID INCREMENT:', 18, occ$continue);
        error (' ', strng, length, occ$end_of_line);
      ELSE
        ocp$output (' ', strng, length, occ$continue);
      IFEND;

      hexrep (strng, length, replication^.count);
      ocp$output ('  ', 'count:', 6, occ$continue);
      IF replication^.increment = 0 THEN
        ocp$output (' ', '********', 8, occ$end_of_line);
        error (' ', 'INVALID COUNT:', 14, occ$continue);
        error (' ', strng, length, occ$end_of_line);
      ELSE
        ocp$output (' ', strng, length, occ$end_of_line);
      IFEND;

      verify_address (replication^.section_ordinal, (replication^.offset +
            ((replication^.count - 1) * replication^.increment) + number_of_bytes - 1));

      hex_dump (#LOC (replication^.byte), number_of_bytes);


    PROCEND process_replication_record;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_BIT_INSERTION_RECORD' ??
?? EJECT ??

    PROCEDURE process_bit_insertion_record
      (VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        bit_insertion: ^llt$bit_string_insertion;


      NEXT bit_insertion IN file;
      IF bit_insertion = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      hexrep (strng, length, bit_insertion^.section_ordinal);
      ocp$output ('      ', 'section:', 8, occ$continue);
      ocp$output (' ', strng, length, occ$continue);

      hexrep (strng, length, bit_insertion^.offset);
      ocp$output ('  ', 'offset:', 7, occ$continue);
      ocp$output (' ', strng, length, occ$end_of_line);

      hexrep (strng, length, bit_insertion^.bit_offset);
      ocp$output ('      ', 'bit offset:', 11, occ$continue);
      IF bit_insertion^.bit_offset > UPPERVALUE (bit_insertion^.bit_offset) THEN
        ocp$output (' ', '*', 1, occ$end_of_line);
        ocp$output (' ', '     ', 5, occ$continue);
        error (' ', 'INVALID BIT OFFSET:', 19, occ$continue);
        error (' ', strng, length, occ$end_of_line);
      ELSE
        ocp$output (' ', strng, length, occ$continue);
      IFEND;

      hexrep (strng, length, bit_insertion^.bit_length);
      ocp$output ('  ', 'bit length:', 11, occ$continue);
      IF (bit_insertion^.bit_length < LOWERVALUE (bit_insertion^.bit_length)) OR
            (bit_insertion^.bit_length > UPPERVALUE (bit_insertion^.bit_length)) THEN
        ocp$output (' ', '**', 2, occ$end_of_line);
        error (' ', 'INVALID BIT LENGTH:', 19, occ$continue);
        error (' ', strng, length, occ$end_of_line);
      ELSE
        ocp$output (' ', strng, length, occ$end_of_line);
      IFEND;

      hexrep_full (strng, length, #LOC (bit_insertion^.bit_string), 0, #SIZE (bit_insertion^.bit_string));
      ocp$output ('      ', 'bit string:', 11, occ$continue);
      ocp$output (' ', strng, length, occ$end_of_line);

      verify_address (bit_insertion^.section_ordinal, (bit_insertion^.offset - 1 +
            ((bit_insertion^.bit_offset + bit_insertion^.bit_length + 7) DIV 8)));


    PROCEND process_bit_insertion_record;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_ENTRY_DEFINITION_RECORD' ??
?? EJECT ??

    PROCEDURE process_entry_definition_record
      (VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        entry_definition: ^llt$entry_definition;


      NEXT entry_definition IN file;
      IF entry_definition = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      ocp$output ('      ', 'name:', 5, occ$continue);
      ocp$output (' ', entry_definition^.name, STRLENGTH (entry_definition^.name), occ$continue);

      ocp$output (' ', 'language:', 9, occ$continue);
      output_language (^entry_definition^.language, occ$end_of_line);

      hexrep (strng, length, entry_definition^.section_ordinal);
      ocp$output ('      ', 'section:', 8, occ$continue);
      ocp$output (' ', strng, length, occ$continue);

      hexrep (strng, length, entry_definition^.offset);
      ocp$output ('  ', 'offset:', 7, occ$continue);
      ocp$output (' ', strng, length, occ$continue);

      ocp$output ('  ', 'attr = [', 8, occ$continue);
      IF llc$retain_entry_point IN entry_definition^.attributes THEN
        ocp$output (' ', 'RETAIN', 6, occ$continue);
      IFEND;
      IF llc$gated_entry_point IN entry_definition^.attributes THEN
        ocp$output (' ', 'GATED', 5, occ$continue);
      IFEND;
      IF llc$epa_unused_1 IN entry_definition^.attributes THEN
        ocp$output (' ', 'SPARE1', 6, occ$continue);
      IFEND;
      IF llc$epa_unused_2 IN entry_definition^.attributes THEN
        ocp$output (' ', 'SPARE2', 6, occ$continue);
      IFEND;
      IF llc$epa_unused_3 IN entry_definition^.attributes THEN
        ocp$output (' ', 'SPARE3', 6, occ$continue);
      IFEND;
      IF llc$epa_unused_4 IN entry_definition^.attributes THEN
        ocp$output (' ', 'SPARE4', 6, occ$continue);
      IFEND;
      IF llc$epa_unused_5 IN entry_definition^.attributes THEN
        ocp$output (' ', 'SPARE5', 6, occ$continue);
      IFEND;
      IF llc$epa_unused_6 IN entry_definition^.attributes THEN
        ocp$output (' ', 'SPARE6', 6, occ$continue);
      IFEND;
      ocp$output (' ', ']', 1, occ$end_of_line);

      ocp$output ('      ', 'declaration matching required:', 30, occ$continue);
      ocp$output_boolean (entry_definition^.declaration_matching_required, occ$continue);
      IF entry_definition^.declaration_matching_required THEN
        IF entry_definition^.language = llc$cybil THEN
          ocp$output ('  ', 'object:', 7, occ$continue);
          hexrep_full (strng, length, #LOC (entry_definition^.declaration_matching.object_encryption), 0,
                #SIZE (entry_definition^.declaration_matching.object_encryption));
          ocp$output (' ', strng, length, occ$continue);
          ocp$output ('  ', 'source:', 7, occ$continue);
          hexrep_full (strng, length, #LOC (entry_definition^.declaration_matching.source_encryption), 0,
                #SIZE (entry_definition^.declaration_matching.source_encryption));
          ocp$output (' ', strng, length, occ$continue);
          ocp$output ('', ' ', 1, occ$end_of_line);
        ELSE
          hexrep_full (strng, length, #LOC (entry_definition^.declaration_matching.language_dependent_value),
                0, #SIZE (entry_definition^.declaration_matching.language_dependent_value));
          ocp$output ('  ', 'value:', 6, occ$continue);
          ocp$output (' ', strng, length, occ$end_of_line);
        IFEND;
      ELSE
        ocp$output ('', ' ', 1, occ$end_of_line);
      IFEND;

      verify_address (entry_definition^.section_ordinal, entry_definition^.offset);


    PROCEND process_entry_definition_record;
?? OLDTITLE ??
?? NEWTITLE := 'process_deferred_entry_points', EJECT ??

{ PURPOSE:
{   The purpose of this request is to display the deferred entry point object text record.

    PROCEDURE process_deferred_entry_points
      (    number_of_entry_points: 1 .. llc$max_deferred_entry_points;
       VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        deferred_entry_points: ^llt$deferred_entry_points,
        entry_point_index: 1 .. llc$max_deferred_entry_points;


      NEXT deferred_entry_points: [1 .. number_of_entry_points] IN file;
      IF deferred_entry_points = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      FOR entry_point_index := 1 TO number_of_entry_points DO
        hexrep (strng, length, deferred_entry_points^ [entry_point_index].address.ring);
        ocp$output ('      ring: ', strng, length, occ$continue);

        hexrep (strng, length, deferred_entry_points^ [entry_point_index].address.segment);
        ocp$output ('  segment: ', strng, length, occ$continue);

        hexrep (strng, length, deferred_entry_points^ [entry_point_index].address.offset);
        ocp$output ('  offset: ', strng, length, occ$end_of_line);

        hexrep (strng, length, deferred_entry_points^ [entry_point_index].section_ordinal);
        ocp$output ('      section ordinal: ', strng, length, occ$continue);

        ocp$output ('  ', 'attr = [', 8, occ$continue);
        IF llc$retain_entry_point IN deferred_entry_points^ [entry_point_index].attributes THEN
          ocp$output (' ', 'RETAIN', 6, occ$continue);
        IFEND;
        IF llc$gated_entry_point IN deferred_entry_points^ [entry_point_index].attributes THEN
          ocp$output (' ', 'GATED', 5, occ$continue);
        IFEND;
        IF llc$epa_unused_1 IN deferred_entry_points^ [entry_point_index].attributes THEN
          ocp$output (' ', 'SPARE1', 6, occ$continue);
        IFEND;
        IF llc$epa_unused_2 IN deferred_entry_points^ [entry_point_index].attributes THEN
          ocp$output (' ', 'SPARE2', 6, occ$continue);
        IFEND;
        IF llc$epa_unused_3 IN deferred_entry_points^ [entry_point_index].attributes THEN
          ocp$output (' ', 'SPARE3', 6, occ$continue);
        IFEND;
        IF llc$epa_unused_4 IN deferred_entry_points^ [entry_point_index].attributes THEN
          ocp$output (' ', 'SPARE4', 6, occ$continue);
        IFEND;
        IF llc$epa_unused_5 IN deferred_entry_points^ [entry_point_index].attributes THEN
          ocp$output (' ', 'SPARE5', 6, occ$continue);
        IFEND;
        IF llc$epa_unused_6 IN deferred_entry_points^ [entry_point_index].attributes THEN
          ocp$output (' ', 'SPARE6', 6, occ$continue);
        IFEND;
        ocp$output (' ', ']', 1, occ$end_of_line);

        ocp$output ('      ', 'name:', 5, occ$continue);
        ocp$output (' ', deferred_entry_points^ [entry_point_index].
              name, STRLENGTH (deferred_entry_points^ [entry_point_index].name), occ$continue);

        ocp$output (' ', 'language:', 9, occ$continue);
        output_language (^deferred_entry_points^ [entry_point_index].language, occ$end_of_line);

        ocp$output ('      ', 'declaration matching required:', 30, occ$continue);
        ocp$output_boolean (deferred_entry_points^ [entry_point_index].declaration_matching_required,
              occ$continue);
        IF deferred_entry_points^ [entry_point_index].declaration_matching_required THEN
          IF deferred_entry_points^ [entry_point_index].language = llc$cybil THEN
            ocp$output ('  ', 'object:', 7, occ$continue);
            hexrep_full (strng, length, #LOC (deferred_entry_points^ [entry_point_index].
                  declaration_matching_value.object_encryption),
                  0, #SIZE (deferred_entry_points^ [entry_point_index].declaration_matching_value.
                  object_encryption));
            ocp$output (' ', strng, length, occ$continue);
            ocp$output ('  ', 'source:', 7, occ$continue);
            hexrep_full (strng, length, #LOC (deferred_entry_points^ [entry_point_index].
                  declaration_matching_value.source_encryption),
                  0, #SIZE (deferred_entry_points^ [entry_point_index].declaration_matching_value.
                  source_encryption));
            ocp$output (' ', strng, length, occ$continue);
            ocp$output (' ', 'source declaration matching:', 28, occ$continue);
            ocp$output_boolean (deferred_entry_points^ [entry_point_index].source_type_checking,
                  occ$end_of_line);
          ELSE
            hexrep_full (strng, length, #LOC (deferred_entry_points^ [entry_point_index].
                  declaration_matching_value.language_dependent_value),
                  0, #SIZE (deferred_entry_points^ [entry_point_index].declaration_matching_value.
                  language_dependent_value));
            ocp$output ('  ', 'value:', 6, occ$continue);
            ocp$output (' ', strng, length, occ$end_of_line);
          IFEND;
        ELSE
          ocp$output ('', ' ', 1, occ$end_of_line);
        IFEND;

        hexrep (strng, length, deferred_entry_points^ [entry_point_index].binding_section_address.ring);
        ocp$output ('      binding section address - ring: ', strng, length, occ$continue);

        hexrep (strng, length, deferred_entry_points^ [entry_point_index].binding_section_address.segment);
        ocp$output ('  segment: ', strng, length, occ$continue);

        hexrep (strng, length, deferred_entry_points^ [entry_point_index].binding_section_address.offset);
        ocp$output ('  offset: ', strng, length, occ$end_of_line);

      FOREND;

    PROCEND process_deferred_entry_points;
?? OLDTITLE ??
?? NEWTITLE := 'process_deferred_common_blocks', EJECT ??

{ PURPOSE:
{   The purpose of this request is to display the deferred common block object text record.

    PROCEDURE process_deferred_common_blocks
      (    number_of_common_blocks: 1 .. llc$max_deferred_common_blocks;
       VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        common_block_index: 1 .. llc$max_deferred_common_blocks,
        deferred_common_blocks: ^llt$deferred_common_blocks;


      NEXT deferred_common_blocks: [1 .. number_of_common_blocks] IN file;
      IF deferred_common_blocks = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      FOR common_block_index := 1 TO number_of_common_blocks DO
        ocp$output ('      name: ', deferred_common_blocks^ [common_block_index].
              name, STRLENGTH (deferred_common_blocks^ [common_block_index].name), occ$continue);

        hexrep (strng, length, deferred_common_blocks^ [common_block_index].global_lock);
        ocp$output ('  global lock: ', strng, length, occ$continue);

        hexrep (strng, length, deferred_common_blocks^ [common_block_index].loaded_ring);
        ocp$output ('  loaded ring: ', strng, length, occ$end_of_line);

        hexrep (strng, length, deferred_common_blocks^ [common_block_index].address.ring);
        ocp$output ('      ring: ', strng, length, occ$continue);

        hexrep (strng, length, deferred_common_blocks^ [common_block_index].address.segment);
        ocp$output ('  segment: ', strng, length, occ$continue);

        hexrep (strng, length, deferred_common_blocks^ [common_block_index].address.offset);
        ocp$output ('  offset: ', strng, length, occ$continue);

        hexrep (strng, length, deferred_common_blocks^ [common_block_index].allocation_length);
        ocp$output ('  allocation length: ', strng, length, occ$end_of_line);

        hexrep (strng, length, deferred_common_blocks^ [common_block_index].allocation_alignment);
        ocp$output ('      allocation alignment: ', strng, length, occ$continue);

        hexrep (strng, length, deferred_common_blocks^ [common_block_index].allocation_offset);
        ocp$output ('  allocation offset: ', strng, length, occ$continue);

        ocp$output ('  ', 'attr = [', 8, occ$continue);
        IF llc$read IN deferred_common_blocks^ [common_block_index].access_attributes THEN
          ocp$output (' ', 'R', 1, occ$continue);
        IFEND;
        IF llc$write IN deferred_common_blocks^ [common_block_index].access_attributes THEN
          ocp$output (' ', 'W', 1, occ$continue);
        IFEND;
        IF llc$execute IN deferred_common_blocks^ [common_block_index].access_attributes THEN
          ocp$output (' ', 'X', 1, occ$continue);
        IFEND;
        IF llc$binding IN deferred_common_blocks^ [common_block_index].access_attributes THEN
          ocp$output (' ', 'B', 1, occ$continue);
        IFEND;
        ocp$output (' ', ']', 1, occ$end_of_line);

        ocp$output ('      ', 'cache bypass: ', 14, occ$continue);
        ocp$output_boolean (deferred_common_blocks^ [common_block_index].segment_access_control.cache_bypass,
              occ$continue);

        ocp$output ('  ', 'privileges = [', 14, occ$continue);
        CASE deferred_common_blocks^ [common_block_index].segment_access_control.execute_privilege OF
        = osc$non_executable =
          ocp$output (' ', 'NON EXECUTABLE, ', 16, occ$continue);
        = osc$non_privileged =
          ocp$output (' ', 'NON PRIVILEGED, ', 16, occ$continue);
        = osc$local_privilege =
          ocp$output (' ', 'LOCAL PRIVILEGE, ', 17, occ$continue);
        = osc$global_privilege =
          ocp$output (' ', 'GLOBAL PRIVILEGE, ', 18, occ$continue);
        ELSE
          error (' ', 'INVALID EXECUTE PRIVILEGE', 25, occ$continue);
        CASEND;
        CASE deferred_common_blocks^ [common_block_index].segment_access_control.read_privilege OF
        = osc$non_readable =
          ocp$output (' ', 'NON READABLE, ', 14, occ$continue);
        = osc$read_key_lock_controlled =
          ocp$output (' ', 'READ KEY LOCK CONTROLLED, ', 26, occ$continue);
        = osc$read_uncontrolled =
          ocp$output (' ', 'READ UNCONTROLLED, ', 19, occ$continue);
        = osc$binding_segment =
          ocp$output (' ', 'BINDING SEGMENT, ', 17, occ$continue);
        ELSE
          error (' ', 'INVALID READ PRIVILEGE', 22, occ$continue);
        CASEND;
        CASE deferred_common_blocks^ [common_block_index].segment_access_control.write_privilege OF
        = osc$non_writable =
          ocp$output (' ', 'NON WRITABLE', 12, occ$continue);
        = osc$write_key_lock_controlled =
          ocp$output (' ', 'WRITE KEY LOCK CONTROLLED', 25, occ$continue);
        = osc$write_uncontrolled =
          ocp$output (' ', 'WRITE UNCONTROLLED', 18, occ$continue);
        = osc$wp_reserved =
          ocp$output (' ', 'RESERVED', 8, occ$continue);
        ELSE
          error (' ', 'INVALID WRITE PRIVILEGE', 23, occ$continue);
        CASEND;
        ocp$output (' ', ']', 1, occ$end_of_line);

        ocp$output ('      ', 'extensible: ', 12, occ$continue);
        ocp$output_boolean (deferred_common_blocks^ [common_block_index].extensible, occ$continue);

        ocp$output (' ', 'unallocated common: ', 20, occ$continue);
        ocp$output_boolean (deferred_common_blocks^ [common_block_index].unallocated_common, occ$end_of_line);

        IF deferred_common_blocks^ [common_block_index].unallocated_common THEN
          ocp$output ('      ', 'unallocated common open: ', 25, occ$continue);
          ocp$output_boolean (deferred_common_blocks^ [common_block_index].unallocated_common_open,
                occ$continue);

          hexrep (strng, length, deferred_common_blocks^ [common_block_index].unallocated_common_segment);
          ocp$output ('  unallocated common segment: ', strng, length, occ$end_of_line);

          IF deferred_common_blocks^ [common_block_index].unallocated_common_open THEN
            hexrep (strng, length, deferred_common_blocks^ [common_block_index].unallocated_common_file_id.
                  ordinal);
            ocp$output ('      unallocated common file id: ', strng, length, occ$continue);

            hexrep (strng, length, deferred_common_blocks^ [common_block_index].unallocated_common_file_id.
                  sequence);
            ocp$output (' ', strng, length, occ$end_of_line);
          IFEND;
        IFEND;
      FOREND;

    PROCEND process_deferred_common_blocks;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_RELOCATION_RECORD' ??
?? EJECT ??

    PROCEDURE process_relocation_record
      (    number_of_rel_items: llt$number_of_info_elements;
       VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        relocation: ^llt$relocation,
        i: llt$number_of_info_elements;


      NEXT relocation: [1 .. number_of_rel_items] IN file;
      IF relocation = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      FOR i := 1 TO number_of_rel_items DO
        hexrep (strng, length, relocation^ [i].section_ordinal);
        ocp$output ('0     ', 'section:', 8, occ$continue);
        ocp$output (' ', strng, length, occ$continue);

        hexrep (strng, length, relocation^ [i].offset);
        ocp$output ('  ', 'offset:', 7, occ$continue);
        ocp$output (' ', strng, length, occ$end_of_line);

        verify_address (relocation^ [i].section_ordinal, relocation^ [i].offset);

        hexrep (strng, length, relocation^ [i].relocating_section);
        ocp$output ('      ', 'relocating section:', 19, occ$continue);
        ocp$output (' ', strng, length, occ$continue);

        ocp$output ('  ', 'container:', 10, occ$continue);
        CASE relocation^ [i].container OF
        = llc$two_bytes =
          ocp$output (' ', 'TWO BYTES', 9, occ$end_of_line);
        = llc$three_bytes =
          ocp$output (' ', 'THREE BYTES', 11, occ$end_of_line);
        = llc$four_bytes =
          ocp$output (' ', 'FOUR BYTES', 10, occ$end_of_line);
        = llc$eight_bytes =
          ocp$output (' ', 'EIGHT BYTES', 11, occ$end_of_line);
        = llc$180_d_field =
          ocp$output (' ', '180 D-FIELD', 11, occ$end_of_line);
        = llc$180_q_field =
          ocp$output (' ', '180 Q-FIELD', 11, occ$end_of_line);
        = llc$180_long_d_field =
          ocp$output (' ', '180 LONG D-FIELD', 16, occ$end_of_line);
        ELSE
          ocp$output (' ', '************', 12, occ$end_of_line);
          error (' ', 'INVALID CONTAINER', 17, occ$end_of_line);
        CASEND;

        ocp$output ('      ', 'address:', 8, occ$continue);
        CASE relocation^ [i].address OF
        = llc$byte_positive =
          ocp$output (' ', 'BYTE POSITIVE', 13, occ$end_of_line);
        = llc$two_byte_positive =
          ocp$output (' ', 'TWO BYTE POSITIVE', 17, occ$end_of_line);
        = llc$four_byte_positive =
          ocp$output (' ', 'FOUR BYTE POSITIVE', 18, occ$end_of_line);
        = llc$eight_byte_positive =
          ocp$output (' ', 'EIGHT BYTE POSITIVE', 20, occ$end_of_line);
        = llc$byte_signed =
          ocp$output (' ', 'BYTE SIGNED', 11, occ$end_of_line);
        = llc$two_byte_signed =
          ocp$output (' ', 'TWO BYTE SIGNED', 15, occ$end_of_line);
        = llc$four_byte_signed =
          ocp$output (' ', 'FOUR BYTE SIGNED', 16, occ$end_of_line);
        = llc$eight_byte_signed =
          ocp$output (' ', 'EIGHT BYTE SIGNED', 17, occ$end_of_line);
        ELSE
          ocp$output (' ', '*****************', 17, occ$end_of_line);
          error (' ', 'INVALID ADDRESS', 15, occ$end_of_line);
        CASEND;
      FOREND;


    PROCEND process_relocation_record;
?? OLDTITLE ??
?? NEWTITLE := '  PROC_OBSOLETE_FORMAL_PARA_REC' ??
?? EJECT ??

    PROCEDURE proc_obsolete_formal_param_rec
      (    sequence_length: ost$segment_length;
       VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);

      VAR
        obsolete_formal_parameters: ^llt$obsolete_formal_parameters;

      NEXT obsolete_formal_parameters: [[REP sequence_length OF cell]] IN file;
      IF obsolete_formal_parameters = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      ocp$output ('      ', 'procedure name:', 15, occ$continue);
      ocp$output (' ', obsolete_formal_parameters^.procedure_name,
            STRLENGTH (obsolete_formal_parameters^.procedure_name), occ$end_of_line);

      hex_dump (#LOC (obsolete_formal_parameters^.specification), sequence_length);

    PROCEND proc_obsolete_formal_param_rec;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_FORMAL_PARAMETER_RECORD' ??
?? EJECT ??

    PROCEDURE process_formal_parameter_record
      (    sequence_length: ost$segment_length;
       VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        formal_parameters: ^llt$formal_parameters;


      NEXT formal_parameters: [[REP sequence_length OF cell]] IN file;
      IF formal_parameters = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;
      ocp$output ('      ', 'language: ', 10, occ$continue);
      output_language (^formal_parameters^.language, occ$end_of_line);

      ocp$output ('      ', 'procedure name:', 15, occ$continue);
      ocp$output (' ', formal_parameters^.procedure_name, STRLENGTH (formal_parameters^.procedure_name),
            occ$end_of_line);

      hex_dump (#LOC (formal_parameters^.specification), sequence_length);


    PROCEND process_formal_parameter_record;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_ACTUAL_PARAMETERS' ??
?? EJECT ??

    PROCEDURE process_actual_parameter_record
      (    sequence_length: ost$segment_length;
       VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        actual_parameters: ^llt$actual_parameters;


      NEXT actual_parameters: [[REP sequence_length OF cell]] IN file;
      IF actual_parameters = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      ocp$output ('      ', 'callee name:', 12, occ$continue);
      ocp$output (' ', actual_parameters^.callee_name, STRLENGTH (actual_parameters^.callee_name),
            occ$continue);

      ocp$output ('     ', 'language: ', 10, occ$continue);
      output_language (^actual_parameters^.language, occ$end_of_line);

      ocp$output ('      ', 'line number of call:', 20, occ$continue);
      STRINGREP (strng, length, actual_parameters^.line_number_of_call);
      ocp$output ('', strng, length, occ$end_of_line);

      hex_dump (#LOC (actual_parameters^.specification), sequence_length);


    PROCEND process_actual_parameter_record;
?? OLDTITLE ??
?? NEWTITLE := ' PROCESS_FORM_DEFINITION' ??
?? EJECT ??

    PROCEDURE process_form_definition
      (VAR fatal_error: boolean);

      error (' ', 'FORM DEFINITION FOUND IN OBJECT MODULE', 39, occ$end_of_line);
      fatal_error := TRUE;
      RETURN;

    PROCEND process_form_definition;
?? OLDTITLE ??
?? NEWTITLE := ' PROCESS_APPLICATION_IDENTIFIER' ??
?? EJECT ??

    PROCEDURE process_applic_identifier
      (VAR fatal_error: boolean);


      VAR
        application_identifier: ^llt$application_identifier;


      NEXT application_identifier IN file;
      IF application_identifier = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      IF application_identifier^.name <> osc$null_name THEN
        ocp$output ('      ', 'application identifier:', 24, occ$continue);
        ocp$output (' ', application_identifier^.name, STRLENGTH (application_identifier^.name),
              occ$end_of_line);
      IFEND;


    PROCEND process_applic_identifier;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_ADDRESS_FORMULATION' ??
?? EJECT ??

    PROCEDURE process_address_formulation
      (    number_of_adr_items: 1 .. llc$max_adr_items;
       VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);

      VAR
        address_formulation: ^llt$address_formulation,
        i: 1 .. llc$max_adr_items;

      NEXT address_formulation: [1 .. number_of_adr_items] IN file;
      IF address_formulation = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      hexrep (strng, length, address_formulation^.value_section);
      ocp$output ('      ', 'value section:', 14, occ$continue);
      ocp$output (' ', strng, length, occ$continue);

      hexrep (strng, length, address_formulation^.dest_section);
      ocp$output ('  ', 'dest. section:', 14, occ$continue);
      ocp$output (' ', strng, length, occ$end_of_line);

      FOR i := 1 TO number_of_adr_items DO
        ocp$output ('      ', 'kind:', 5, occ$continue);
        CASE address_formulation^.item [i].kind OF
        = llc$address =
          ocp$output (' ', 'ADDRESS', 7, occ$end_of_line);
        = llc$internal_proc =
          ocp$output (' ', 'INTERNAL PROC', 13, occ$end_of_line);
        = llc$short_address =
          ocp$output (' ', 'SHORT ADDRESS', 13, occ$end_of_line);
        = llc$external_proc =
          ocp$output (' ', 'EXTERNAL PROC', 13, occ$end_of_line);
        ELSE
          ocp$output (' ', '**********************', 22, occ$end_of_line);
          error (' ', 'INVALID ADDRESS KIND', 20, occ$end_of_line);
        CASEND;

        hexrep (strng, length, address_formulation^.item [i].value_offset);
        ocp$output ('      ', 'value offset:', 13, occ$continue);
        ocp$output (' ', strng, length, occ$continue);

        hexrep (strng, length, address_formulation^.item [i].dest_offset);
        ocp$output ('  ', 'dest. offset:', 13, occ$continue);
        ocp$output (' ', strng, length, occ$end_of_line);

        verify_address (address_formulation^.value_section, 0);
        verify_address (address_formulation^.dest_section, address_formulation^.item [i].dest_offset);
      FOREND;

    PROCEND process_address_formulation;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_EXTERNAL_LINKAGE' ??
?? EJECT ??

    PROCEDURE process_external_linkage
      (    number_of_ext_items: 1 .. llc$max_ext_items;
       VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        external: ^llt$external_linkage,
        i: 1 .. llc$max_ext_items;


      NEXT external: [1 .. number_of_ext_items] IN file;
      IF external = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      ocp$output ('      ', 'name:', 5, occ$continue);
      ocp$output (' ', external^.name, STRLENGTH (external^.name), occ$continue);

      ocp$output ('  ', 'language:', 9, occ$continue);
      output_language (^external^.language, occ$end_of_line);

      ocp$output ('      ', 'declaration matching required:', 30, occ$continue);
      ocp$output_boolean (external^.declaration_matching_required, occ$continue);
      IF external^.declaration_matching_required THEN
        IF external^.language = llc$cybil THEN
          ocp$output (' ', 'object:', 7, occ$continue);
          hexrep_full (strng, length, #LOC (external^.declaration_matching.object_encryption),
                0, #SIZE (external^.declaration_matching.object_encryption));
          ocp$output (' ', strng, length, occ$continue);
          ocp$output (' ', 'source:', 7, occ$continue);
          hexrep_full (strng, length, #LOC (external^.declaration_matching.source_encryption),
                0, #SIZE (external^.declaration_matching.source_encryption));
          ocp$output (' ', strng, length, occ$continue);
          ocp$output ('', ' ', 1, occ$end_of_line);
        ELSE
          hexrep_full (strng, length, #LOC (external^.declaration_matching.language_dependent_value), 0,
                #SIZE (external^.declaration_matching.language_dependent_value));
          ocp$output (' ', 'value = ', 8, occ$continue);
          ocp$output (' ', strng, length, occ$end_of_line);
        IFEND;
      ELSE
        ocp$output ('', ' ', 1, occ$end_of_line);
      IFEND;

      FOR i := 1 TO number_of_ext_items DO
        hexrep (strng, length, external^.item [i].section_ordinal);
        ocp$output ('      ', 'section:', 8, occ$continue);
        ocp$output (' ', strng, length, occ$continue);

        hexrep (strng, length, external^.item [i].offset);
        ocp$output ('  ', 'offset:', 7, occ$continue);
        ocp$output (' ', strng, length, occ$end_of_line);

        verify_address (external^.item [i].section_ordinal, external^.item [i].offset);

        ocp$output ('      ', 'kind:', 5, occ$continue);
        CASE external^.item [i].kind OF
        = llc$address =
          ocp$output (' ', 'ADDRESS', 7, occ$end_of_line);
        = llc$internal_proc =
          ocp$output (' ', 'INTERNAL PROC', 13, occ$end_of_line);
        = llc$short_address =
          ocp$output (' ', 'SHORT ADDRESS', 13, occ$end_of_line);
        = llc$external_proc =
          ocp$output (' ', 'EXTERNAL PROC', 13, occ$end_of_line);
        = llc$address_addition =
          ocp$output (' ', 'ADDRESS ADDITION', 17, occ$continue);
          hexrep (strng, length, external^.item [i].offset_operand);
          ocp$output ('  ', '  offset operand:', 17, occ$continue);
          ocp$output (' ', strng, length, occ$end_of_line);
        = llc$address_subtraction =
          ocp$output (' ', 'ADDRESS SUBTRACTION', 20, occ$continue);
          hexrep (strng, length, external^.item [i].offset_operand);
          ocp$output ('  ', '  offset operand:', 17, occ$continue);
          ocp$output (' ', strng, length, occ$end_of_line);
        ELSE
          ocp$output (' ', '**********************', 22, occ$end_of_line);
          error (' ', 'INVALID ADDRESS KIND', 20, occ$end_of_line);
        CASEND;

      FOREND;


    PROCEND process_external_linkage;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_BINDING_TEMPLATE_RECORD' ??
?? EJECT ??

    PROCEDURE process_binding_template_record
      (VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        binding_template: ^llt$binding_template;


      NEXT binding_template IN file;
      IF binding_template = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      hexrep (strng, length, binding_template^.binding_offset);
      ocp$output ('      ', 'binding offset:', 15, occ$continue);
      ocp$output (' ', strng, length, occ$continue);

      ocp$output ('  ', 'kind:', 5, occ$continue);
      CASE binding_template^.kind OF
      = llc$current_module =
        ocp$output (' ', 'CURRENT MODULE', 14, occ$end_of_line);

        hexrep (strng, length, binding_template^.section_ordinal);
        ocp$output ('      ', 'section:', 8, occ$continue);
        ocp$output (' ', strng, length, occ$continue);

        hexrep (strng, length, binding_template^.offset);
        ocp$output ('  ', 'offset:', 7, occ$continue);
        ocp$output (' ', strng, length, occ$continue);

        ocp$output ('  ', 'address:', 8, occ$continue);
        CASE binding_template^.internal_address OF
        = llc$address =
          ocp$output (' ', 'ADDRESS', 7, occ$end_of_line);
        = llc$internal_proc =
          ocp$output (' ', 'INTERNAL PROC', 13, occ$end_of_line);
        = llc$short_address =
          ocp$output (' ', 'SHORT ADDRESS', 13, occ$end_of_line);
        = llc$external_proc =
          ocp$output (' ', 'EXTERNAL PROC', 13, occ$end_of_line);
        ELSE
          ocp$output (' ', '**********************', 22, occ$end_of_line);
          error (' ', 'INVALID ADDRESS KIND', 20, occ$end_of_line);
        CASEND;

        verify_address (binding_template^.section_ordinal, binding_template^.offset);

      = llc$external_reference =
        ocp$output (' ', 'EXTERNAL REFERENCE', 18, occ$end_of_line);

        ocp$output ('      ', 'name:', 5, occ$continue);
        ocp$output (' ', binding_template^.name, STRLENGTH (binding_template^.name), occ$continue);

        ocp$output ('  ', 'address:', 8, occ$continue);
        CASE binding_template^.address OF
        = llc$address =
          ocp$output ('  ', 'ADDRESS', 7, occ$end_of_line);
        = llc$internal_proc =
          ocp$output ('  ', 'INTERNAL PROC', 13, occ$end_of_line);
        = llc$short_address =
          ocp$output ('  ', 'SHORT ADDRESS', 13, occ$end_of_line);
        = llc$external_proc =
          ocp$output ('  ', 'EXTERNAL PROC', 13, occ$end_of_line);
        = llc$address_addition =
          ocp$output ('  ', 'ADDRESS ADDITION', 17, occ$end_of_line);
        = llc$address_subtraction =
          ocp$output ('  ', 'ADDRESS SUBTRACTION', 20, occ$end_of_line);
        ELSE
          ocp$output (' ', '**********************', 22, occ$end_of_line);
          error (' ', 'INVALID ADDRESS KIND', 20, occ$end_of_line);
        CASEND;

      ELSE
        ocp$output (' ', '******************', 18, occ$end_of_line);
        error (' ', 'INVALID TEMPLATE KIND', 19, occ$end_of_line);
      CASEND;


    PROCEND process_binding_template_record;
?? OLDTITLE ??
?? NEWTITLE := 'PROCESS_68000_ABSOLUTE', EJECT ??

    PROCEDURE process_68000_absolute
      (    number_of_68000_bytes: 1 .. llc$maximum_68000_address;
       VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        m68000_absolute: ^llt$68000_absolute;


      NEXT m68000_absolute: [[REP number_of_68000_bytes OF cell]] IN file;
      IF m68000_absolute = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      hexrep (strng, length, m68000_absolute^.load_address);
      ocp$output ('      load_address: ', strng, length, occ$continue);

      hexrep (strng, length, m68000_absolute^.transfer_address);
      ocp$output ('  transfer_address: ', strng, length, occ$end_of_line);

      hex_dump (#LOC (m68000_absolute^.text), number_of_68000_bytes);


    PROCEND process_68000_absolute;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_TRANSFER_SYMBOL_RECORD' ??
?? EJECT ??

    PROCEDURE process_transfer_symbol_record
      (VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        transfer_symbol: ^llt$transfer_symbol;


      NEXT transfer_symbol IN file;
      IF transfer_symbol = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      IFEND;

      IF transfer_symbol^.name <> osc$null_name THEN
        ocp$output ('      ', 'starting procedure:', 19, occ$continue);
        ocp$output (' ', transfer_symbol^.name, STRLENGTH (transfer_symbol^.name), occ$end_of_line);
      IFEND;


    PROCEND process_transfer_symbol_record;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_CPU_MODULE' ??
?? EJECT ??

    PROCEDURE process_cpu_module
      (VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);


      VAR
        end_of_file: boolean,
        record_kind: llt$object_record_kind,
        size: integer,
        s: llt$section_ordinal;


      ALLOCATE module_info.section_definition: [0 .. module_info.greatest_section_ordinal];
      IF module_info.section_definition = NIL THEN
        error (' ', 'INTERNAL PROBLEM 6 - no space in heap', 37, occ$end_of_line);
        fatal_error := TRUE;
        RETURN;
      ELSE
        FOR s := 0 TO module_info.greatest_section_ordinal DO
          module_info.section_definition^ [s] := NIL;

        FOREND;
      IFEND;

      REPEAT
        process_object_text_descriptor (file, fatal_error, end_of_file, record_kind, size);
        IF NOT fatal_error THEN
          IF end_of_file THEN
            error (' ', premature_end_of_file, 33, occ$end_of_line);
            fatal_error := TRUE;
          ELSE
            CASE record_kind OF
            = llc$identification =
              error (' ', 'DUPLICATE IDENTIFICATION RECORD ENCOUNTERED', 43, occ$end_of_line);
              fatal_error := TRUE;
            = llc$libraries =
              process_libraries_record (size, file, fatal_error);
            = llc$section_definition, llc$unallocated_common_block =
              process_section_definition (file, fatal_error);
            = llc$allotted_section_definition =
              process_allotted_section_def (size, file, fatal_error);
            = llc$segment_definition =
              process_segment_definition (file, fatal_error);
            = llc$allotted_segment_definition =

{ DIV and MOD is to extract allotted_segment_length and allotted_segment

              process_allotted_segment_def ((size DIV 100000000(16)), size MOD 100000000(16), file,
                    fatal_error);
            = llc$obsolete_segment_definition =
              process_obsolete_seg_def (file, fatal_error);
            = llc$obsolete_allotted_seg_def =

{ DIV and MOD is to extract allotted_segment_length and allotted_segment

              process_obs_allotted_seg_def ((size DIV 100000000(16)), size MOD 100000000(16), file,
                    fatal_error);
            = llc$text =
              process_text_record (size, file, fatal_error);
            = llc$replication =
              process_replication_record (size, file, fatal_error);
            = llc$bit_string_insertion =
              process_bit_insertion_record (file, fatal_error);
            = llc$entry_definition =
              process_entry_definition_record (file, fatal_error);
            = llc$deferred_entry_points =
              process_deferred_entry_points (size, file, fatal_error);
            = llc$deferred_common_blocks =
              process_deferred_common_blocks (size, file, fatal_error);
            = llc$relocation =
              process_relocation_record (size, file, fatal_error);
            = llc$obsolete_formal_parameters =
              proc_obsolete_formal_param_rec (size, file, fatal_error);
            = llc$formal_parameters =
              process_formal_parameter_record (size, file, fatal_error);
            = llc$actual_parameters =
              process_actual_parameter_record (size, file, fatal_error);
            = llc$obsolete_line_table =
              process_obsolete_line_table (size, file, fatal_error);
            = llc$cybil_symbol_table_fragment =
              process_cybil_symbol_table (size, file, fatal_error);
            = llc$line_table =
              process_line_table (size, file, fatal_error);
            = llc$symbol_table =
              process_symbol_table (size, file, fatal_error);
            = llc$supplemental_debug_tables =
              process_supplemental_dtables (size, file, fatal_error);
            = llc$form_definition =
              process_form_definition (fatal_error);
            = llc$application_identifier =
              process_applic_identifier (fatal_error);
            = llc$address_formulation =
              process_address_formulation (size, file, fatal_error);
            = llc$external_linkage =
              process_external_linkage (size, file, fatal_error);
            = llc$binding_template =
              process_binding_template_record (file, fatal_error);
            = llc$68000_absolute =
              process_68000_absolute (size, file, fatal_error);
            = llc$transfer_symbol =
              process_transfer_symbol_record (file, fatal_error);
            ELSE
              error (' ', 'INVALID CPU RECORD KIND', 23, occ$end_of_line);
              fatal_error := TRUE;
            CASEND;
          IFEND;
        IFEND;
      UNTIL fatal_error OR (record_kind = llc$transfer_symbol);


    PROCEND process_cpu_module;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_IOU_MODULE' ??
?? EJECT ??

    PROCEDURE process_iou_module
      (VAR file: ^SEQ ( * );
       VAR fatal_error: boolean);

?? NEWTITLE := '    PROCESS_PPU_ABSOLUTE_RECORD' ??
?? EJECT ??

      PROCEDURE process_ppu_absolute_record
        (    number_of_words: llt$ppu_address;
         VAR file: ^SEQ ( * );
         VAR fatal_error: boolean);


        VAR
          ppu_absolute: ^llt$ppu_absolute;


        NEXT ppu_absolute: [0 .. number_of_words - 1] IN file;
        IF ppu_absolute = NIL THEN
          error (' ', premature_end_of_file, 33, occ$end_of_line);
          fatal_error := TRUE;
          RETURN;
        IFEND;

        ocp$output ('      ', 'executes on any ppu:', 20, occ$continue);
        ocp$output_boolean (ppu_absolute^.executes_on_any_ppu, occ$continue);

        hexrep (strng, length, ppu_absolute^.ppu_number);
        ocp$output ('  ', 'ppu number:', 11, occ$continue);
        IF ppu_absolute^.ppu_number <= llc$max_ppu_number THEN
          ocp$output (' ', strng, length, occ$end_of_line);
        ELSE
          ocp$output (' ', '***', 3, occ$end_of_line);
          error (' ', 'INVALID PPU NUMBER:', 19, occ$continue);
          error (' ', strng, length, occ$end_of_line);
        IFEND;

        hexrep (strng, length, ppu_absolute^.load_address);
        ocp$output ('      ', 'load address:', 13, occ$continue);
        ocp$output (' ', strng, length, occ$continue);

        hexrep (strng, length, ppu_absolute^.entry_address);
        ocp$output ('  ', 'entry address:', 14, occ$continue);
        ocp$output (' ', strng, length, occ$end_of_line);

        IF ppu_absolute^.load_address > llc$max_ppu_size THEN
          error (' ', 'INVALID LOAD ADDRESS', 20, occ$end_of_line);
        IFEND;
        IF ppu_absolute^.entry_address > llc$max_ppu_size THEN
          error (' ', 'INVALID ENTRY ADDRESS', 21, occ$end_of_line);
        IFEND;

        hex_dump (#LOC (ppu_absolute^.text), (number_of_words * 2));


      PROCEND process_ppu_absolute_record;
?? OLDTITLE ??
?? EJECT ??


      VAR
        end_of_file: boolean,
        record_kind: llt$object_record_kind,
        size: integer;


      process_object_text_descriptor (file, fatal_error, end_of_file, record_kind, size);

      IF NOT fatal_error THEN
        IF end_of_file THEN
          error (' ', premature_end_of_file, 33, occ$end_of_line);
          fatal_error := TRUE;
        ELSE
          IF record_kind = llc$ppu_absolute THEN
            process_ppu_absolute_record (size, file, fatal_error);
          ELSE
            error (' ', 'INVALID IOU RECORD KIND', 23, occ$end_of_line);
            fatal_error := TRUE;
          IFEND;
        IFEND;
      IFEND;


    PROCEND process_iou_module;
?? OLDTITLE ??
?? NEWTITLE := 'process_object_file' ??
?? EJECT ??

    PROCEDURE process_object_file
      (VAR file: ^SEQ ( * ));


      VAR
        fatal_error: [STATIC] boolean := FALSE,
        end_of_file: boolean,

        record_kind: llt$object_record_kind,
        size: integer,
        module_kind: llt$module_kind;


      REPEAT
        module_info.section_definition := NIL;
        record_number := 1;
        ocp$output ('1', '  ', 2, occ$end_of_line);

        process_object_text_descriptor (file, fatal_error, end_of_file, record_kind, size);

        IF NOT (end_of_file OR fatal_error) THEN
          IF record_kind <> llc$identification THEN
            error (' ', 'IDENTIFICATION RECORD MUST BE FIRST RECORD OF MODULE', 52, occ$end_of_line);
            fatal_error := TRUE;
          ELSE
            process_identification_record (file, fatal_error, module_kind);
          IFEND;

          IF NOT fatal_error THEN
            CASE module_kind OF
            = llc$mi_virtual_state, llc$vector_virtual_state, llc$motorola_68000, llc$motorola_68000_absolute,
                  llc$vector_extended_state =
              process_cpu_module (file, fatal_error);
            = llc$iou =
              process_iou_module (file, fatal_error);
            ELSE
              error (' ', 'INTERNAL PROBLEM 2', 18, occ$end_of_line);
              fatal_error := TRUE;
            CASEND;
          IFEND;
        IFEND;

        IF module_info.section_definition <> NIL THEN
          FREE module_info.section_definition;
        IFEND;
      UNTIL end_of_file OR fatal_error;


    PROCEND process_object_file;
?? OLDTITLE ??
?? NEWTITLE := '  PROCESS_OBJECT_LIBRARY' ??
?? EJECT ??

    PROCEDURE process_object_library
      (VAR file: ^SEQ ( * ));

?? NEWTITLE := '    PROCESS_MODULE_DICTIONARY' ??
?? EJECT ??

      PROCEDURE process_module_dictionary
        (    number_of_modules: 0 .. llc$max_modules_in_library;
             module_dictionary: ^llt$module_dictionary);


        VAR
          i: 0 .. llc$max_modules_in_library;


        ocp$output ('-', 'module dictionary', 17, occ$end_of_line);
        ocp$output (' ', '~~~~~~~~~~~~~~~~~', 17, occ$end_of_line);

        IF number_of_modules = 0 THEN
          ocp$output ('0', '*** NO MODULES ON LIBRARY ***', 29, occ$end_of_line);
        ELSE
          FOR i := 1 TO number_of_modules DO
            ocp$output ('0', 'name:', 5, occ$continue);
            ocp$output (' ', module_dictionary^ [i].name, STRLENGTH (module_dictionary^ [i].name),
                  occ$end_of_line);

            ocp$output (' ', 'kind:', 5, occ$continue);
            CASE module_dictionary^ [i].kind OF
            = llc$load_module =
              ocp$output (' ', 'LOAD MODULE', 11, occ$end_of_line);
            = llc$ppu_object_module =
              ocp$output (' ', 'PPU OBJECT MODULE', 17, occ$end_of_line);
            = llc$program_description =
              ocp$output (' ', 'PROGRAM DESCRIPTION', 19, occ$end_of_line);
            = llc$applic_program_description =
              ocp$output (' ', 'APPLICATION PROGRAM DESCRIPTION', 31, occ$end_of_line);
            = llc$command_procedure =
              ocp$output (' ', 'COMMAND PROCEDURE', 17, occ$end_of_line);
            = llc$applic_command_procedure =
              ocp$output (' ', 'APPLICATION COMMAND PROCEDURE', 29, occ$end_of_line);
            = llc$command_description =
              ocp$output (' ', 'COMMAND DESCRIPTION', 19, occ$end_of_line);
            = llc$applic_command_description =
              ocp$output (' ', 'APPLICATION COMMAND DESCRIPTION', 31, occ$end_of_line);
            = llc$function_procedure =
              ocp$output (' ', 'FUNCTION PROCEDURE', 18, occ$end_of_line);
            = llc$function_description =
              ocp$output (' ', 'FUNCTION DESCRIPTION', 20, occ$end_of_line);
            = llc$message_module =
              ocp$output (' ', 'MESSAGE MODULE', 14, occ$end_of_line);
            = llc$panel_module =
              ocp$output (' ', 'FORM MODULE', 11, occ$end_of_line);

            ELSE
              ocp$output (' ', '*******************', 19, occ$end_of_line);
              ocp$output ('', ' ', 1, occ$continue);

              error (' ', 'INVALID KIND', 12, occ$end_of_line);
            CASEND;

          FOREND;
        IFEND;


      PROCEND process_module_dictionary;
?? OLDTITLE ??
?? NEWTITLE := '    PROCESS_ENTRY_POINT_DICTIONARY' ??
?? EJECT ??

      PROCEDURE process_entry_point_dictionary
        (    number_of_entry_points: 0 .. llc$max_entry_points_in_library;
             entry_point_dictionary: ^llt$entry_point_dictionary);


        VAR
          i: 0 .. llc$max_entry_points_in_library;


        ocp$output ('1', 'entry point dictionary', 22, occ$end_of_line);
        ocp$output (' ', '~~~~~~~~~~~~~~~~~~~~~~', 22, occ$end_of_line);

        IF number_of_entry_points = 0 THEN
          ocp$output ('0', ' * NO ENTRY POINTS *', 20, occ$end_of_line);
        ELSE
          FOR i := 1 TO number_of_entry_points DO
            ocp$output ('0', 'name:', 5, occ$continue);
            ocp$output (' ', entry_point_dictionary^ [i].name, STRLENGTH (entry_point_dictionary^ [i].name),
                  occ$end_of_line);

            ocp$output (' ', 'scope:', 6, occ$continue);
            CASE entry_point_dictionary^ [i].kind OF
            = llc$entry_point =
              ocp$output (' ', 'XDCL', 4, occ$continue);
            = llc$gate =
              ocp$output (' ', 'GATE', 4, occ$continue);
            ELSE
              ocp$output (' ', '***********', 11, occ$end_of_line);
              error (' ', 'INVALID KIND', 12, occ$end_of_line);
            CASEND;

            ocp$output ('  ', 'module kind:', 12, occ$continue);
            CASE entry_point_dictionary^ [i].module_kind OF
            = llc$load_module =
              ocp$output (' ', 'LOAD MODULE', 11, occ$end_of_line);
            = llc$program_description =
              ocp$output (' ', 'PROGRAM DESCRIPTION', 19, occ$end_of_line);
            = llc$command_procedure =
              ocp$output (' ', 'COMMAND PROCEDURE', 17, occ$end_of_line);

            ELSE
              ocp$output (' ', '*******************', 19, occ$end_of_line);

              error (' ', 'INVALID MODULE KIND', 19, occ$end_of_line);
            CASEND;
          FOREND;
        IFEND;

      PROCEND process_entry_point_dictionary;
?? OLDTITLE ??
?? NEWTITLE := '    PROCESS_COMMAND_DICTIONARY' ??
?? EJECT ??

      PROCEDURE process_command_dictionary
        (    number_of_commands: 0 .. llc$max_commands_in_library;
             command_dictionary: ^llt$command_dictionary);


        VAR
          i: 0 .. llc$max_commands_in_library;


        ocp$output ('-', 'command dictionary', 18, occ$end_of_line);
        ocp$output (' ', '~~~~~~~~~~~~~~~~~~', 18, occ$end_of_line);

        IF number_of_commands = 0 THEN
          ocp$output ('0', '*** NO COMMANDS ON LIBRARY ***', 30, occ$end_of_line);
        ELSE
          FOR i := 1 TO number_of_commands DO
            ocp$output ('0', 'name:', 5, occ$continue);
            ocp$output (' ', command_dictionary^ [i].name, STRLENGTH (command_dictionary^ [i].name),
                  occ$end_of_line);

            ocp$output (' ', 'class:', 6, occ$continue);
            CASE command_dictionary^ [i].class OF
            = clc$nominal_entry =
              ocp$output (' ', 'NOMINAL', 7, occ$end_of_line);
            = clc$alias_entry =
              ocp$output (' ', 'ALIAS', 5, occ$end_of_line);
            = clc$abbreviation_entry =
              ocp$output (' ', 'ABBREVIATION', 12, occ$end_of_line);

            ELSE
              ocp$output (' ', '*******************', 19, occ$end_of_line);
              ocp$output ('', ' ', 1, occ$continue);

              error (' ', 'INVALID CLASS', 13, occ$end_of_line);
            CASEND;


            ocp$output (' ', 'availability:', 13, occ$continue);
            CASE command_dictionary^ [i].availability OF
            = clc$normal_usage_entry =
              ocp$output (' ', 'NORMAL_USAGE', 12, occ$end_of_line);
            = clc$advanced_usage_entry =
              ocp$output (' ', 'ADVANCED_USAGE', 14, occ$end_of_line);
            = clc$hidden_entry =
              ocp$output (' ', 'HIDDEN', 6, occ$end_of_line);

            ELSE
              ocp$output (' ', '*******************', 19, occ$end_of_line);
              ocp$output ('', ' ', 1, occ$continue);

              error (' ', 'INVALID AVAILABILITY', 20, occ$end_of_line);
            CASEND;

            STRINGREP (strng, length, command_dictionary^ [i].ordinal);
            ocp$output (' ', 'ordinal:', 8, occ$continue);
            ocp$output (' ', strng, length, occ$end_of_line);

            ocp$output (' ', 'scope:', 6, occ$continue);
            CASE command_dictionary^ [i].kind OF
            = llc$entry_point =
              ocp$output (' ', 'XDCL', 4, occ$end_of_line);
            = llc$gate =
              ocp$output (' ', 'GATE', 4, occ$end_of_line);
            = llc$local_to_library =
              ocp$output (' ', 'LOCAL', 5, occ$end_of_line);

            ELSE
              ocp$output (' ', '*******************', 19, occ$end_of_line);
              ocp$output ('', ' ', 1, occ$continue);

              error (' ', 'INVALID SCOPE', 13, occ$end_of_line);
            CASEND;

            ocp$output (' ', 'log option:', 11, occ$continue);
            CASE command_dictionary^ [i].log_option OF
            = clc$automatically_log =
              ocp$output (' ', 'AUTOMATIC', 9, occ$end_of_line);
            = clc$manually_log =
              ocp$output (' ', 'MANUAL', 6, occ$end_of_line);

            ELSE
              ocp$output (' ', '*******************', 19, occ$end_of_line);
              ocp$output ('', ' ', 1, occ$continue);

              error (' ', 'INVALID LOG OPTION', 18, occ$end_of_line);
            CASEND;

            ocp$output (' ', 'module kind:', 12, occ$continue);
            CASE command_dictionary^ [i].module_kind OF
            = llc$command_procedure =
              ocp$output (' ', 'COMMAND PROCEDURE', 17, occ$end_of_line);
            = llc$applic_command_procedure =
              ocp$output (' ', 'APPLICATION COMMAND PROCEDURE', 29, occ$end_of_line);
            = llc$command_description =
              ocp$output (' ', 'COMMAND DESCRIPTION', 19, occ$end_of_line);
            = llc$applic_command_description =
              ocp$output (' ', 'APPLICATION COMMAND DESCRIPTION', 31, occ$end_of_line);
            = llc$program_description =
              ocp$output (' ', 'PROGRAM DESCRIPTION', 19, occ$end_of_line);
            = llc$applic_program_description =
              ocp$output (' ', 'APPLICATION PROGRAM DESCRIPTION', 31, occ$end_of_line);
            = llc$load_module =
              ocp$output (' ', 'LOAD MODULE', 11, occ$end_of_line);

            ELSE
              ocp$output (' ', '*******************', 19, occ$end_of_line);
              ocp$output ('', ' ', 1, occ$continue);

              error (' ', 'INVALID MODULE KIND', 19, occ$end_of_line);
            CASEND;

          FOREND;
        IFEND;


      PROCEND process_command_dictionary;
?? OLDTITLE ??
?? NEWTITLE := '    PROCESS_FUNCTION_DICTIONARY' ??
?? EJECT ??

      PROCEDURE process_function_dictionary
        (    number_of_functions: 0 .. llc$max_functions_in_library;
             function_dictionary: ^llt$function_dictionary);


        VAR
          i: 0 .. llc$max_functions_in_library;


        ocp$output ('-', 'function dictionary', 19, occ$end_of_line);
        ocp$output (' ', '~~~~~~~~~~~~~~~~~~~', 19, occ$end_of_line);

        IF number_of_functions = 0 THEN
          ocp$output ('0', '*** NO FUNCTIONS ON LIBRARY ***', 31, occ$end_of_line);
        ELSE
          FOR i := 1 TO number_of_functions DO
            ocp$output ('0', 'name:', 5, occ$continue);
            ocp$output (' ', function_dictionary^ [i].name, STRLENGTH (function_dictionary^ [i].name),
                  occ$end_of_line);

            ocp$output (' ', 'class:', 6, occ$continue);
            CASE function_dictionary^ [i].class OF
            = clc$nominal_entry =
              ocp$output (' ', 'NOMINAL', 7, occ$end_of_line);
            = clc$alias_entry =
              ocp$output (' ', 'ALIAS', 5, occ$end_of_line);
            = clc$abbreviation_entry =
              ocp$output (' ', 'ABBREVIATION', 12, occ$end_of_line);

            ELSE
              ocp$output (' ', '*******************', 19, occ$end_of_line);
              ocp$output ('', ' ', 1, occ$continue);

              error (' ', 'INVALID CLASS', 13, occ$end_of_line);
            CASEND;

            ocp$output (' ', 'availability:', 13, occ$continue);
            CASE function_dictionary^ [i].availability OF
            = clc$normal_usage_entry =
              ocp$output (' ', 'NORMAL_USAGE', 12, occ$end_of_line);
            = clc$advanced_usage_entry =
              ocp$output (' ', 'ADVANCED_USAGE', 14, occ$end_of_line);
            = clc$hidden_entry =
              ocp$output (' ', 'HIDDEN', 6, occ$end_of_line);

            ELSE
              ocp$output (' ', '*******************', 19, occ$end_of_line);
              ocp$output ('', ' ', 1, occ$continue);

              error (' ', 'INVALID AVAILABILITY', 20, occ$end_of_line);
            CASEND;

            STRINGREP (strng, length, function_dictionary^ [i].ordinal);
            ocp$output (' ', 'ordinal:', 8, occ$continue);
            ocp$output (' ', strng, length, occ$end_of_line);

            ocp$output (' ', 'scope:', 6, occ$continue);
            CASE function_dictionary^ [i].kind OF
            = llc$entry_point =
              ocp$output (' ', 'XDCL', 4, occ$end_of_line);
            = llc$gate =
              ocp$output (' ', 'GATE', 4, occ$end_of_line);
            = llc$local_to_library =
              ocp$output (' ', 'LOCAL', 5, occ$end_of_line);

            ELSE
              ocp$output (' ', '*******************', 19, occ$end_of_line);
              ocp$output ('', ' ', 1, occ$continue);

              error (' ', 'INVALID SCOPE', 13, occ$end_of_line);
            CASEND;

            ocp$output (' ', 'module kind:', 12, occ$continue);
            CASE function_dictionary^ [i].module_kind OF
            = llc$function_procedure =
              ocp$output (' ', 'FUNCTION PROCEDURE', 18, occ$end_of_line);
            = llc$function_description =
              ocp$output (' ', 'FUNCTION DESCRIPTION', 20, occ$end_of_line);

            ELSE
              ocp$output (' ', '*******************', 19, occ$end_of_line);
              ocp$output ('', ' ', 1, occ$continue);

              error (' ', 'INVALID MODULE KIND', 19, occ$end_of_line);
            CASEND;

          FOREND;
        IFEND;


      PROCEND process_function_dictionary;
?? OLDTITLE ??
?? NEWTITLE := '    PROCESS_HELP_MODULE_DICTIONARY' ??
?? EJECT ??

      PROCEDURE process_help_module_dictionary
        (    number_of_help_modules: 0 .. llc$max_help_modules_in_library;
             help_module_dictionary: ^llt$help_module_dictionary);


        VAR
          i: 0 .. llc$max_help_modules_in_library;


        ocp$output ('-', 'help module dictionary', 22, occ$end_of_line);
        ocp$output (' ', '~~~~~~~~~~~~~~~~~~~~~~', 22, occ$end_of_line);

        IF number_of_help_modules = 0 THEN
          ocp$output ('0', '*** NO HELP MODULES ON LIBRARY ***', 34, occ$end_of_line);
        ELSE
          FOR i := 1 TO number_of_help_modules DO
            ocp$output ('0', 'name:', 5, occ$continue);
            ocp$output (' ', help_module_dictionary^ [i].name, STRLENGTH (help_module_dictionary^ [i].name),
                  occ$end_of_line);
            ocp$output (' ', 'language:', 9, occ$continue);
            ocp$output (' ', help_module_dictionary^ [i].language,
                  STRLENGTH (help_module_dictionary^ [i].name), occ$end_of_line);
          FOREND;
        IFEND;


      PROCEND process_help_module_dictionary;
?? OLDTITLE ??
?? NEWTITLE := '    PROCESS_MESSAGE_MODULE_DICTIONARY' ??
?? EJECT ??

      PROCEDURE process_msg_module_dictionary
        (    number_of_message_modules: 0 .. llc$max_message_modules_in_lib;
             message_module_dictionary: ^llt$message_module_dictionary);


        VAR
          i: 0 .. llc$max_message_modules_in_lib;


        ocp$output ('-', 'message module dictionary', 25, occ$end_of_line);
        ocp$output (' ', '~~~~~~~~~~~~~~~~~~~~~~~~~', 25, occ$end_of_line);

        IF number_of_message_modules = 0 THEN
          ocp$output ('0', '*** NO MESSAGE MODULES ON LIBRARY ***', 37, occ$end_of_line);
        ELSE
          FOR i := 1 TO number_of_message_modules DO
            ocp$output ('0', 'name:', 5, occ$continue);
            ocp$output (' ', message_module_dictionary^ [i].name,
                  STRLENGTH (message_module_dictionary^ [i].name), occ$end_of_line);
            ocp$output (' ', 'language:', 9, occ$continue);
            ocp$output (' ', message_module_dictionary^ [i].language,
                  STRLENGTH (message_module_dictionary^ [i].language), occ$end_of_line);

            STRINGREP (strng, length, message_module_dictionary^ [i].lowest_condition_code);
            ocp$output (' ', 'lowest condition code:', 22, occ$continue);
            ocp$output (' ', strng, length, occ$end_of_line);

            STRINGREP (strng, length, message_module_dictionary^ [i].highest_condition_code);
            ocp$output (' ', 'highest condition code:', 22, occ$continue);
            ocp$output (' ', strng, length, occ$end_of_line);
          FOREND;
        IFEND;


      PROCEND process_msg_module_dictionary;
?? OLDTITLE ??
?? NEWTITLE := '    PROCESS_PANEL_DICTIONARY' ??
?? EJECT ??

      PROCEDURE process_panel_dictionary
        (    number_of_panels: 0 .. llc$max_panels_in_library;
             panel_dictionary: ^llt$panel_dictionary);


        VAR
          i: 0 .. llc$max_panels_in_library;


        ocp$output ('-', 'form dictionary', 15, occ$end_of_line);
        ocp$output (' ', '~~~~~~~~~~~~~~~', 15, occ$end_of_line);

        IF number_of_panels = 0 THEN
          ocp$output ('0', '*** NO FORMS ON LIBRARY ***', 27, occ$end_of_line);
        ELSE
          FOR i := 1 TO number_of_panels DO
            ocp$output ('0', 'name:', 5, occ$continue);
            ocp$output (' ', panel_dictionary^ [i].name, STRLENGTH (panel_dictionary^ [i].name),
                  occ$end_of_line);
          FOREND;
        IFEND;


      PROCEND process_panel_dictionary;
?? OLDTITLE ??
?? NEWTITLE := '    PROCESS_LIBRARY_MODULES' ??
?? EJECT ??

      PROCEDURE process_library_modules
        (    number_of_modules: 0 .. llc$max_modules_in_library;
             module_dictionary: ^llt$module_dictionary;
         VAR file: ^SEQ ( * ));


?? NEWTITLE := '      PROCESS_LIBRARY_MEMBER_HEADER' ??
?? EJECT ??

        PROCEDURE process_library_member_header
          (    library_member_header: ^llt$library_member_header;
           VAR file: ^SEQ ( * );
           VAR fatal_error: boolean);


          VAR
            aliases: ^pmt$module_list,
            availability_kinds: [STATIC, READ] llt$library_member_kinds :=
                  [llc$command_procedure, llc$program_description, llc$function_procedure,
                  llc$applic_command_procedure, llc$applic_program_description,
                  llc$applic_command_description, llc$command_description, llc$function_description],
            scope_kinds: [STATIC, READ] llt$library_member_kinds :=
                  [llc$command_procedure, llc$program_description, llc$function_procedure,
                  llc$applic_command_procedure, llc$applic_program_description,
                  llc$applic_command_description, llc$command_description, llc$function_description],
            log_option_kinds: [STATIC, READ] llt$library_member_kinds :=
                  [llc$command_procedure, llc$program_description, llc$applic_command_procedure,
                  llc$applic_program_description, llc$applic_command_description, llc$command_description],
            i: llt$number_of_aliases,
            valid: boolean;


          ocp$output ('0', 'library member header', 21, occ$end_of_line);
          ocp$output (' ', '~~~~~~~~~~~~~~~~~~~~~', 21, occ$end_of_line);

          ocp$output ('0', 'module name:', 12, occ$continue);
          ocp$output (' ', library_member_header^.name, STRLENGTH (library_member_header^.name),
                occ$continue);

          STRINGREP (strng, length, library_member_header^.module_index);
          ocp$output ('  ', 'module index:', 13, occ$continue);
          ocp$output (' ', strng, length, occ$end_of_line);

          ocp$output (' ', 'kind:', 5, occ$continue);
          CASE library_member_header^.kind OF
          = llc$program_description =
            ocp$output (' ', 'PROGRAM DESCRIPTION', 19, occ$continue);
          = llc$applic_program_description =
            ocp$output (' ', 'APPLICATION PROGRAM DESCRIPTION', 31, occ$continue);
          = llc$command_procedure =
            ocp$output (' ', 'COMMAND PROCEDURE', 17, occ$continue);
          = llc$applic_command_procedure =
            ocp$output (' ', 'APPLICATION COMMAND PROCEDURE', 29, occ$continue);
          = llc$command_description =
            ocp$output (' ', 'COMMAND DESCRIPTION', 19, occ$continue);
          = llc$applic_command_description =
            ocp$output (' ', 'APPLICATION COMMAND DESCRIPTION', 31, occ$continue);
          = llc$function_procedure =
            ocp$output (' ', 'FUNCTION PROCEDURE', 18, occ$continue);
          = llc$function_description =
            ocp$output (' ', 'FUNCTION DESCRIPTION', 20, occ$continue);
          = llc$message_module =
            ocp$output (' ', 'MESSAGE MODULE', 14, occ$continue);
          = llc$panel_module =
            ocp$output (' ', 'FORM MODULE', 11, occ$continue);
          ELSE
            ocp$output (' ', '*******************', 19, occ$end_of_line);
            error (' ', 'INVALID MEMBER KIND', 19, occ$end_of_line);
          CASEND;

          ocp$output ('  ', 'created:', 8, occ$continue);

          ocp$output_time (^library_member_header^.time_created, occ$continue, valid);
          IF NOT valid THEN
            ocp$output ('', ' ', 1, occ$end_of_line);
            error (' ', 'INVALID TIME FORMAT', 19, occ$end_of_line);
            ocp$output (occ$single_space, '', 0, occ$continue);
          IFEND;

          ocp$output ('', ' ', 1, occ$continue);
          ocp$output_date (^library_member_header^.date_created, occ$end_of_line, valid);
          IF NOT valid THEN
            error (' ', 'INVALID DATE FORMAT', 19, occ$end_of_line);
          IFEND;

          ocp$output (' ', 'generator:', 10, occ$continue);
          output_language (^library_member_header^.generator_id, occ$end_of_line);

          ocp$output (' ', 'generator name version:', 23, occ$continue);
          ocp$output (' ', library_member_header^.generator_name_vers,
                STRLENGTH (library_member_header^.generator_name_vers), occ$end_of_line);

          IF library_member_header^.commentary <> osc$null_name THEN
            ocp$output (' ', 'commentary:', 11, occ$continue);
            ocp$output (' ', library_member_header^.commentary, STRLENGTH (library_member_header^.commentary),
                  occ$end_of_line);
          IFEND;

          STRINGREP (strng, length, library_member_header^.member_size);
          ocp$output (' ', 'member size:', 12, occ$continue);
          ocp$output (' ', strng, length, occ$end_of_line);

          STRINGREP (strng, length, library_member_header^.number_of_aliases);
          ocp$output (' ', 'number of aliases:', 18, occ$continue);
          ocp$output (' ', strng, length, occ$end_of_line);


          IF library_member_header^.number_of_aliases <> 0 THEN
            ocp$output ('0', 'aliases', 7, occ$end_of_line);
            ocp$output (' ', '~~~~~~~', 7, occ$end_of_line);

            aliases := #PTR (library_member_header^.aliases, file^);
            IF aliases = NIL THEN
              error ('', premature_end_of_file, 33, occ$end_of_line);
              fatal_error := TRUE;
              RETURN;
            IFEND;

            FOR i := 1 TO library_member_header^.number_of_aliases DO
              ocp$output ('   ', aliases^ [i], STRLENGTH (aliases^ [i]), occ$end_of_line);
            FOREND;
          IFEND;

          IF library_member_header^.kind IN availability_kinds THEN
            ocp$output ('0', 'availability:', 12, occ$continue);
            CASE library_member_header^.command_function_availability OF
            = clc$normal_usage_entry =
              ocp$output (' ', 'NORMAL_USAGE', 12, occ$end_of_line);
            = clc$advanced_usage_entry =
              ocp$output (' ', 'ADVANCED_USAGE', 14, occ$end_of_line);
            = clc$hidden_entry =
              ocp$output (' ', 'HIDDEN', 6, occ$end_of_line);
            ELSE
              ocp$output (' ', '********************', 20, occ$end_of_line);
              ocp$output (' ', 'INVALID AVAILABILITY', 20, occ$end_of_line);
            CASEND;
          IFEND;

          IF library_member_header^.kind IN scope_kinds THEN
            ocp$output ('0', 'scope:', 6, occ$continue);
            CASE library_member_header^.command_function_kind OF
            = llc$entry_point =
              ocp$output (' ', 'XDCL', 4, occ$end_of_line);
            = llc$gate =
              ocp$output (' ', 'GATE', 4, occ$end_of_line);
            = llc$local_to_library =
              ocp$output (' ', 'LOCAL', 5, occ$end_of_line);
            ELSE
              ocp$output (' ', '*************', 13, occ$end_of_line);
              ocp$output (' ', 'INVALID SCOPE', 13, occ$end_of_line);
            CASEND;
          IFEND;

          IF library_member_header^.kind IN log_option_kinds THEN
            ocp$output ('0', 'log option:', 11, occ$continue);
            CASE library_member_header^.command_log_option OF
            = clc$automatically_log =
              ocp$output (' ', 'AUTOMATIC', 9, occ$end_of_line);
            = clc$manually_log =
              ocp$output (' ', 'MANUAL', 6, occ$end_of_line);
            ELSE
              ocp$output (' ', '******************', 18, occ$end_of_line);
              ocp$output (' ', 'INVALID LOG OPTION', 18, occ$end_of_line);
            CASEND;
          IFEND;

        PROCEND process_library_member_header;
?? OLDTITLE ??
?? NEWTITLE := '      PROCESS_LOAD_MODULE' ??
?? EJECT ??

        PROCEDURE process_load_module
          (    load_module_header: ^llt$load_module_header;
           VAR file: ^SEQ ( * ));

?? NEWTITLE := '        PROCESS_LOAD_MODULE_HEADER' ??
?? EJECT ??

          PROCEDURE process_load_module_header
            (    load_module_header: ^llt$load_module_header);


            ocp$output ('0', 'load module header', 18, occ$end_of_line);
            ocp$output (' ', '~~~~~~~~~~~~~~~~~~', 18, occ$end_of_line);

            STRINGREP (strng, length, load_module_header^.module_index);
            ocp$output ('0', 'index:', 6, occ$continue);
            ocp$output (' ', strng, length, occ$continue);

            ocp$output ('  ', 'elements defined = [', 20, occ$continue);
            IF llc$information_element IN load_module_header^.elements_defined THEN
              ocp$output (' ', 'INFORMATION', 11, occ$continue);
            IFEND;
            IF llc$interpretive_element IN load_module_header^.elements_defined THEN
              ocp$output (' ', 'INTERPRETIVE', 12, occ$continue);
            IFEND;
            ocp$output (' ', ']', 1, occ$end_of_line);

            IF llc$interpretive_element IN load_module_header^.elements_defined THEN
              ocp$output (' ', 'interpretive elements defined = [', 33, occ$continue);
              IF llc$library_element IN load_module_header^.interpretive_header.elements_defined THEN
                ocp$output (' ', 'LIB', 3, occ$continue);
              IFEND;
              IF llc$section_element IN load_module_header^.interpretive_header.elements_defined THEN
                ocp$output (' ', 'SDC', 3, occ$continue);
              IFEND;
              IF llc$entry_point_element IN load_module_header^.interpretive_header.elements_defined THEN
                ocp$output (' ', 'EPT', 3, occ$continue);
              IFEND;
              IF llc$external_element IN load_module_header^.interpretive_header.elements_defined THEN
                ocp$output (' ', 'EXT', 3, occ$continue);
              IFEND;
              IF llc$transfer_symbol_element IN load_module_header^.interpretive_header.elements_defined THEN
                ocp$output (' ', 'TRA', 3, occ$continue);
              IFEND;
              ocp$output (' ', ']', 1, occ$end_of_line);
            IFEND;

          PROCEND process_load_module_header;
?? OLDTITLE ??
?? NEWTITLE := 'process_interpretive_element' ??
?? EJECT ??

          PROCEDURE process_interpretive_element
            (    load_module_header: ^llt$load_module_header;
             VAR file: ^SEQ ( * ));


            VAR
              interpretive_element: ^llt$object_text_descriptor,

              fatal_error: boolean,
              end_of_file: boolean,
              record_kind: llt$object_record_kind,
              size: integer,
              module_kind: llt$module_kind;


            fatal_error := FALSE;

            ocp$output ('-', 'interpretive element', 20, occ$end_of_line);
            ocp$output (' ', '~~~~~~~~~~~~~~~~~~~~', 20, occ$end_of_line);

            interpretive_element := #PTR (load_module_header^.interpretive_element, file^);
            IF interpretive_element = NIL THEN
              error (' ', premature_end_of_file, 33, occ$end_of_line);
              RETURN;
            IFEND;
            RESET file TO interpretive_element;

            process_object_text_descriptor (file, fatal_error, end_of_file, record_kind, size);
            IF NOT fatal_error THEN
              IF end_of_file THEN
                error (' ', premature_end_of_file, 33, occ$end_of_line);
              ELSE
                IF record_kind <> llc$identification THEN
                  error (' ', 'IDENTIFICATION RECORD MUST BE FIRST RECORD OF MODULE', 52, occ$end_of_line);
                ELSE
                  process_identification_record (file, fatal_error, module_kind);
                  IF NOT fatal_error THEN
                    CASE module_kind OF
                    = llc$mi_virtual_state, llc$vector_virtual_state, llc$motorola_68000,
                          llc$motorola_68000_absolute, llc$vector_extended_state =
                      process_cpu_module (file, fatal_error);
                    = llc$iou =
                      error (' ', 'INVALID LOAD MODULE KIND', 24, occ$end_of_line);
                    ELSE
                      error (' ', 'INTERNAL PROBLEM 3', 18, occ$end_of_line);
                    CASEND;
                  IFEND;
                IFEND;
              IFEND;
            IFEND;


          PROCEND process_interpretive_element;
?? OLDTITLE ??
?? NEWTITLE := '        PROCESS_INFORMATION_ELEMENT' ??
?? EJECT ??

          PROCEDURE process_information_element
            (    load_module_header: ^llt$load_module_header;
             VAR file: ^SEQ ( * ));

?? NEWTITLE := '          PROCESS_RELOCATION_ITEMS' ??
?? EJECT ??

            PROCEDURE process_relocation_items
              (    number_of_rel_items: llt$number_of_info_elements;
               VAR file: ^SEQ ( * );
               VAR fatal_error: boolean);


              ocp$output ('0', 'RIF', 3, occ$continue);

              STRINGREP (strng, length, record_number);
              ocp$output ('  ', 'rn:', 3, occ$continue);
              ocp$output (' ', strng, length, occ$continue);
              record_number := record_number + 1;

              hexrep (strng, length, number_of_rel_items);
              ocp$output ('  ', 'number of relocation items:', 27, occ$continue);
              ocp$output (' ', strng, length, occ$end_of_line);

              process_relocation_record (number_of_rel_items, file, fatal_error);
              IF fatal_error THEN
                fatal_error := FALSE;
              IFEND;


            PROCEND process_relocation_items;
?? OLDTITLE ??
?? NEWTITLE := '          PROCESS_BINDING_TEMPLATE_ITEMS' ??
?? EJECT ??

            PROCEDURE process_binding_template_items
              (    number_of_template_items: llt$number_of_info_elements;
               VAR file: ^SEQ ( * );
               VAR fatal_error: boolean);


              VAR
                i: integer;


              FOR i := 1 TO number_of_template_items DO
                ocp$output ('0', 'BTI', 3, occ$continue);

                STRINGREP (strng, length, record_number);
                ocp$output ('  ', 'rn:', 3, occ$continue);
                ocp$output (' ', strng, length, occ$end_of_line);
                record_number := record_number + 1;

                process_binding_template_record (file, fatal_error);
                IF fatal_error THEN
                  fatal_error := FALSE;
                  RETURN;
                IFEND;
              FOREND;


            PROCEND process_binding_template_items;
?? OLDTITLE ??
?? NEWTITLE := '          PROCESS_COMPONENT_INFO' ??
?? EJECT ??

            PROCEDURE process_component_info
              (    number_of_components: llt$number_of_info_elements;
                   component_information: ^llt$component_information);


              VAR
                i: integer;


              ocp$output ('-', 'component information', 21, occ$end_of_line);
              ocp$output (' ', '~~~~~~~~~~~~~~~~~~~~~', 21, occ$end_of_line);

              FOR i := 1 TO number_of_components DO
                ocp$output ('0', 'component name:', 15, occ$continue);
                ocp$output (' ', component_information^ [i].name, STRLENGTH (component_information^ [i].name),
                      occ$continue);
                STRINGREP (strng, length, i);
                ocp$output ('  number:', strng, length, occ$end_of_line);

                ocp$output (' ', 'created:', 8, occ$continue);
                CASE component_information^ [i].time_created.time_format OF
                = osc$ampm_time =
                  ocp$output (' ', component_information^ [i].time_created.ampm,
                        STRLENGTH (component_information^ [i].time_created.ampm), occ$continue);
                = osc$hms_time =
                  ocp$output (' ', component_information^ [i].time_created.hms,
                        STRLENGTH (component_information^ [i].time_created.hms), occ$continue);
                = osc$millisecond_time =
                  ocp$output (' ', component_information^ [i].time_created.millisecond,
                        STRLENGTH (component_information^ [i].time_created.millisecond), occ$continue);
                ELSE
                  ocp$output (' ', '**:**:**.***', 12, occ$end_of_line);
                  error (' ', 'INVALID TIME FORMAT', 19, occ$end_of_line);
                CASEND;

                CASE component_information^ [i].date_created.date_format OF
                = osc$month_date =
                  ocp$output ('  ', component_information^ [i].date_created.month,
                        STRLENGTH (component_information^ [i].date_created.month), occ$end_of_line);
                = osc$mdy_date =
                  ocp$output ('  ', component_information^ [i].date_created.mdy,
                        STRLENGTH (component_information^ [i].date_created.mdy), occ$end_of_line);
                = osc$iso_date =
                  ocp$output ('  ', component_information^ [i].date_created.iso,
                        STRLENGTH (component_information^ [i].date_created.iso), occ$end_of_line);
                = osc$ordinal_date =
                  ocp$output ('  ', component_information^ [i].date_created.ordinal,
                        STRLENGTH (component_information^ [i].date_created.ordinal), occ$end_of_line);
                ELSE
                  ocp$output ('  ', '**/**/**', 8, occ$end_of_line);
                  error (' ', 'INVALID DATE FORMAT', 19, occ$end_of_line);
                CASEND;

                ocp$output (' ', 'generator:', 10, occ$continue);
                output_language (^component_information^ [i].generator_id, occ$end_of_line);

                ocp$output (' ', 'generator name version:', 23, occ$continue);
                ocp$output (' ', component_information^ [i].generator_name_vers,
                      STRLENGTH (component_information^ [i].generator_name_vers), occ$end_of_line);

                ocp$output (' ', 'commentary:', 11, occ$continue);
                ocp$output (' ', component_information^ [i].commentary,
                      STRLENGTH (component_information^ [i].commentary), occ$end_of_line);
              FOREND;


            PROCEND process_component_info;
?? OLDTITLE ??
?? NEWTITLE := '          PROCESS_SECTION_MAPS', EJECT ??

            PROCEDURE process_section_maps
              (    section_maps: ^llt$section_maps;
               VAR file: ^SEQ ( * );
               VAR fatal_error: boolean);


              VAR
                i: integer,
                j: integer,
                map: ^llt$section_map_items;


              ocp$output ('-', 'section maps', 12, occ$end_of_line);
              ocp$output (' ', '~~~~~~~~~~~~', 12, occ$end_of_line);

              FOR i := 0 TO UPPERBOUND (section_maps^) DO
                hexrep (strng, length, i);
                ocp$output ('0section ordinal: ', strng, length, occ$continue);

                STRINGREP (strng, length, section_maps^ [i].number_of_items);
                ocp$output ('  number of items:', strng, length, occ$end_of_line);

                IF section_maps^ [i].number_of_items <> 0 THEN
                  map := #PTR (section_maps^ [i].map, file^);

                  FOR j := 1 TO UPPERBOUND (map^) DO
                    hexrep (strng, length, map^ [j].original_section_ordinal);
                    ocp$output ('   original section ordinal: ', strng, length, occ$continue);
                    hexrep (strng, length, map^ [j].offset);
                    ocp$output ('  offset: ', strng, length, occ$continue);
                    hexrep (strng, length, map^ [j].length);
                    ocp$output ('  length: ', strng, length, occ$end_of_line);

                    ocp$output ('   name: ', map^ [j].name, STRLENGTH (map^ [j].name), occ$continue);
                    STRINGREP (strng, length, map^ [j].component);
                    ocp$output ('  component:', strng, length, occ$end_of_line);
                  FOREND;
                IFEND;
              FOREND;

            PROCEND process_section_maps;
?? OLDTITLE ??
?? NEWTITLE := '          PROCESS_INFO_ELEMENT_HEADER' ??
?? EJECT ??

            PROCEDURE process_info_element_header
              (    info_element_header: ^llt$info_element_header;
                   version: llt$version;
               VAR file: ^SEQ ( * ));


              VAR
                component_information: ^llt$component_information,
                relocation: ^llt$relocation,
                binding_template: ^llt$binding_section_template,
                section_maps: ^llt$section_maps,
                fatal_error: boolean;


              ocp$output ('0version: ', version, STRLENGTH (version), occ$end_of_line);

              hexrep (strng, length, info_element_header^.number_of_rel_items);
              ocp$output ('0', 'number of relocation items:', 27, occ$continue);
              ocp$output (' ', strng, length, occ$end_of_line);

              hexrep (strng, length, info_element_header^.number_of_template_items);
              ocp$output (' ', 'number of template items:', 25, occ$continue);
              ocp$output (' ', strng, length, occ$end_of_line);

              hexrep (strng, length, info_element_header^.number_of_components);
              ocp$output (' ', 'number of components:', 21, occ$continue);
              ocp$output (' ', strng, length, occ$end_of_line);

              hexrep (strng, length, info_element_header^.number_of_section_maps);
              ocp$output (' ', 'number of section maps:', 23, occ$continue);
              ocp$output (' ', strng, length, occ$end_of_line);

              IF info_element_header^.number_of_rel_items <> 0 THEN
                relocation := #PTR (info_element_header^.relocation_ptr, file^);
                IF relocation = NIL THEN
                  error (' ', premature_end_of_file, 33, occ$end_of_line);
                ELSE
                  RESET file TO relocation;
                  process_relocation_items (info_element_header^.number_of_rel_items, file, fatal_error);
                IFEND;
              IFEND;

              IF info_element_header^.number_of_template_items <> 0 THEN
                binding_template := #PTR (info_element_header^.binding_template_ptr, file^);
                IF binding_template = NIL THEN
                  error (' ', premature_end_of_file, 33, occ$end_of_line);
                ELSE
                  RESET file TO binding_template;
                  process_binding_template_items (info_element_header^.number_of_template_items, file,
                        fatal_error);
                IFEND;
              IFEND;

              IF info_element_header^.number_of_components <> 0 THEN
                component_information := #PTR (info_element_header^.component_ptr, file^);
                IF component_information = NIL THEN
                  error (' ', premature_end_of_file, 33, occ$end_of_line);
                ELSE
                  process_component_info (info_element_header^.number_of_components, component_information);
                IFEND;
              IFEND;

              IF info_element_header^.number_of_section_maps <> 0 THEN
                section_maps := #PTR (info_element_header^.section_maps, file^);
                IF section_maps = NIL THEN
                  error (' ', premature_end_of_file, 33, occ$end_of_line);
                ELSE
                  process_section_maps (section_maps, file, fatal_error);
                IFEND;
              IFEND;


            PROCEND process_info_element_header;
?? OLDTITLE ??
?? EJECT ??

            VAR
              info_element_header: ^llt$info_element_header,
              new_header: llt$info_element_header,
              version: llt$version;

            ocp$output ('-', 'information element', 19, occ$end_of_line);
            ocp$output (' ', '~~~~~~~~~~~~~~~~~~~', 19, occ$end_of_line);

            info_element_header := #PTR (load_module_header^.information_element, file^);
            IF info_element_header = NIL THEN
              error (' ', premature_end_of_file, 33, occ$end_of_line);
              RETURN;
            IFEND;

            version := info_element_header^.version;

            IF (version <> llc$info_element_version) THEN
              IF (version <> llc$info_element_version_1_0) THEN
                version := '????';
              IFEND;

              ocp$convert_information_element (info_element_header, new_header);

              info_element_header := ^new_header;
            IFEND;

            process_info_element_header (info_element_header, version, file);


          PROCEND process_information_element;
?? OLDTITLE ??
?? EJECT ??

          module_info.section_definition := NIL;
          record_number := 1;

          process_load_module_header (load_module_header);

          IF NOT (llc$interpretive_element IN load_module_header^.elements_defined) THEN
            error (' ', 'INTERPRETIVE ELEMENT NOT PRESENT', 32, occ$end_of_line);
            RETURN;
          IFEND;

          process_interpretive_element (load_module_header, file);

          IF llc$information_element IN load_module_header^.elements_defined THEN
            process_information_element (load_module_header, file);
          IFEND;

          IF module_info.section_definition <> NIL THEN
            FREE module_info.section_definition;
          IFEND;


        PROCEND process_load_module;
?? OLDTITLE ??
?? NEWTITLE := 'process_ppu_object_module' ??
?? EJECT ??

        PROCEDURE process_ppu_object_module
          (VAR file: ^SEQ ( * ));


          VAR
            fatal_error: boolean,
            end_of_file: boolean,
            record_kind: llt$object_record_kind,
            size: integer,
            module_kind: llt$module_kind;


          fatal_error := FALSE;

          process_object_text_descriptor (file, fatal_error, end_of_file, record_kind, size);
          IF NOT fatal_error THEN
            IF end_of_file THEN
              error (' ', premature_end_of_file, 33, occ$end_of_line);
            ELSE
              IF record_kind <> llc$identification THEN
                error (' ', 'IDENTIFICATION RECORD MUST BE FIRST RECORD OF MODULE', 52, occ$end_of_line);
              ELSE
                process_identification_record (file, fatal_error, module_kind);
                IF NOT fatal_error THEN
                  CASE module_kind OF
                  = llc$mi_virtual_state, llc$vector_virtual_state, llc$motorola_68000,
                        llc$motorola_68000_absolute, llc$vector_extended_state =
                    error (' ', 'INVALID PPU OBJECT MODULE KIND', 30, occ$end_of_line);
                  = llc$iou =
                    process_iou_module (file, fatal_error);
                  ELSE
                    error (' ', 'INTERNAL PROBLEM 4', 18, occ$end_of_line);
                  CASEND;
                IFEND;
              IFEND;
            IFEND;
          IFEND;


        PROCEND process_ppu_object_module;
?? OLDTITLE ??
?? NEWTITLE := '      PROCESS_PROGRAM_DESCRIPTION' ??
?? EJECT ??

        PROCEDURE process_program_description
          (    library_member_header: ^llt$library_member_header;
           VAR file: ^SEQ ( * ));


          VAR
            fatal_error: boolean,
            member: ^llt$program_description,
            program_attributes: ^llt$program_attributes,
            conditions: ^pmt$enable_inhibit_conditions,
            object_file_list: ^llt$object_file_list,
            library_list: ^llt$object_library_list,
            module_list: ^pmt$module_list,
            i: integer;


          fatal_error := FALSE;

          process_library_member_header (library_member_header, file, fatal_error);
          IF fatal_error THEN
            RETURN;
          IFEND;

          member := #PTR (library_member_header^.member, file^);
          IF member = NIL THEN
            error (' ', premature_end_of_file, 33, occ$end_of_line);
            RETURN;
          IFEND;
          RESET member;

          NEXT program_attributes IN member;
          IF program_attributes = NIL THEN
            error (' ', premature_end_of_file, 33, occ$end_of_line);
            RETURN;
          IFEND;

          IF (pmc$object_file_list_specified IN program_attributes^.contents) AND
                (program_attributes^.number_of_object_files <> 0) THEN
            NEXT object_file_list: [1 .. program_attributes^.number_of_object_files] IN member;
            IF object_file_list = NIL THEN
              error (' ', premature_end_of_file, 33, occ$end_of_line);
              RETURN;
            IFEND;

            ocp$output ('0', 'object file list', 16, occ$end_of_line);
            ocp$output (' ', '~~~~~~~~~~~~~~~~', 16, occ$end_of_line);

            FOR i := 1 TO program_attributes^.number_of_object_files DO
              ocp$output ('   ', object_file_list^ [i], STRLENGTH (object_file_list^ [i]), occ$end_of_line);
            FOREND;
          IFEND;

          IF (pmc$module_list_specified IN program_attributes^.contents) AND
                (program_attributes^.number_of_modules <> 0) THEN
            NEXT module_list: [1 .. program_attributes^.number_of_modules] IN member;
            IF module_list = NIL THEN
              error (' ', premature_end_of_file, 33, occ$end_of_line);
              RETURN;
            IFEND;

            ocp$output ('0', 'module list', 11, occ$end_of_line);
            ocp$output (' ', '~~~~~~~~~~~', 11, occ$end_of_line);

            i := 1;
            FOR i := 1 TO program_attributes^.number_of_modules DO
              ocp$output ('   ', module_list^ [i], STRLENGTH (module_list^ [i]), occ$end_of_line);
            FOREND;
          IFEND;

          IF (pmc$library_list_specified IN program_attributes^.contents) AND
                (program_attributes^.number_of_libraries <> 0) THEN
            NEXT library_list: [1 .. program_attributes^.number_of_libraries] IN member;
            IF library_list = NIL THEN
              error (' ', premature_end_of_file, 33, occ$end_of_line);
              RETURN;
            IFEND;

            ocp$output ('0', 'library list', 12, occ$end_of_line);
            ocp$output (' ', '~~~~~~~~~~~~', 12, occ$end_of_line);

            FOR i := 1 TO program_attributes^.number_of_libraries DO
              ocp$output ('   ', library_list^ [i], STRLENGTH (library_list^ [i]), occ$end_of_line);
            FOREND;
          IFEND;

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

          IF (pmc$condition_specified IN program_attributes^.contents) THEN
            NEXT conditions IN member;
            IF conditions = NIL THEN
              error (' ', premature_end_of_file, 33, occ$end_of_line);
              RETURN;
            IFEND;

            ocp$output ('0', 'conditions', 10, occ$end_of_line);
            ocp$output (' ', '~~~~~~~~~~', 10, occ$end_of_line);

            IF pmc$arithmetic_overflow IN conditions^.enable_system_conditions THEN
              ocp$output ('   ', 'arithmetic overflow             :  ON', 37, occ$end_of_line);
            ELSEIF pmc$arithmetic_overflow IN conditions^.inhibit_system_conditions THEN
              ocp$output ('   ', 'arithmetic overflow             : OFF', 37, occ$end_of_line);
            IFEND;

            IF pmc$arithmetic_significance IN conditions^.enable_system_conditions THEN
              ocp$output ('   ', 'arithmetic loss of significance :  ON', 37, occ$end_of_line);
            ELSEIF pmc$arithmetic_significance IN conditions^.inhibit_system_conditions THEN
              ocp$output ('   ', 'arithmetic loss of significance : OFF', 37, occ$end_of_line);
            IFEND;

            IF pmc$divide_fault IN conditions^.enable_system_conditions THEN
              ocp$output ('   ', 'divide_fault                    :  ON', 37, occ$end_of_line);
            ELSEIF pmc$divide_fault IN conditions^.inhibit_system_conditions THEN
              ocp$output ('   ', 'divide_fault                    : OFF', 37, occ$end_of_line);
            IFEND;

            IF pmc$exponent_overflow IN conditions^.enable_system_conditions THEN
              ocp$output ('   ', 'exponent overflow               :  ON', 37, occ$end_of_line);
            ELSEIF pmc$exponent_overflow IN conditions^.inhibit_system_conditions THEN
              ocp$output ('   ', 'exponent overflow               : OFF', 37, occ$end_of_line);
            IFEND;

            IF pmc$exponent_underflow IN conditions^.enable_system_conditions THEN
              ocp$output ('   ', 'exponent underflow              :  ON', 37, occ$end_of_line);
            ELSEIF pmc$exponent_underflow IN conditions^.inhibit_system_conditions THEN
              ocp$output ('   ', 'exponent underflow              : OFF', 37, occ$end_of_line);
            IFEND;

            IF pmc$fp_indefinite IN conditions^.enable_system_conditions THEN
              ocp$output ('   ', 'fp indefinite                   :  ON', 37, occ$end_of_line);
            ELSEIF pmc$fp_indefinite IN conditions^.inhibit_system_conditions THEN
              ocp$output ('   ', 'fp indefinite                   : OFF', 37, occ$end_of_line);
            IFEND;

            IF pmc$fp_significance_loss IN conditions^.enable_system_conditions THEN
              ocp$output ('   ', 'fp loss of significance         :  ON', 37, occ$end_of_line);
            ELSEIF pmc$fp_significance_loss IN conditions^.inhibit_system_conditions THEN
              ocp$output ('   ', 'fp loss of significance         : OFF', 37, occ$end_of_line);
            IFEND;

            IF pmc$invalid_bdp_data IN conditions^.enable_system_conditions THEN
              ocp$output ('   ', 'invalid BDP data                :  ON', 37, occ$end_of_line);
            ELSEIF pmc$invalid_bdp_data IN conditions^.inhibit_system_conditions THEN
              ocp$output ('   ', 'invalid BDP data                : OFF', 37, occ$end_of_line);
            IFEND;
          IFEND;

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

          IF pmc$starting_proc_specified IN program_attributes^.contents THEN
            ocp$output (' ', 'starting procedure:', 19, occ$continue);
            ocp$output (' ', program_attributes^.starting_procedure,
                  STRLENGTH (program_attributes^.starting_procedure), occ$end_of_line);
          IFEND;

          IF pmc$load_map_file_specified IN program_attributes^.contents THEN
            ocp$output (' ', 'load map file:', 14, occ$continue);
            ocp$output (' ', program_attributes^.load_map_file, STRLENGTH (program_attributes^.load_map_file),
                  occ$end_of_line);
          IFEND;

          IF pmc$load_map_options_specified IN program_attributes^.contents THEN
            ocp$output (' ', 'load map options: [', 19, occ$continue);

            IF pmc$no_load_map IN program_attributes^.load_map_options THEN
              ocp$output (' ', 'NONE', 4, occ$continue);
            IFEND;
            IF pmc$segment_map IN program_attributes^.load_map_options THEN
              ocp$output (' ', 'SEGMENT', 7, occ$continue);
            IFEND;
            IF pmc$block_map IN program_attributes^.load_map_options THEN
              ocp$output (' ', 'BLOCK', 5, occ$continue);
            IFEND;
            IF pmc$entry_point_map IN program_attributes^.load_map_options THEN
              ocp$output (' ', 'ENTRY_POINT', 11, occ$continue);
            IFEND;
            IF pmc$entry_point_xref IN program_attributes^.load_map_options THEN
              ocp$output (' ', 'XREF', 4, occ$continue);
            IFEND;

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

          IF pmc$term_error_level_specified IN program_attributes^.contents THEN
            ocp$output (' ', 'termination error level:', 24, occ$continue);

            CASE program_attributes^.termination_error_level OF
            = pmc$warning_load_errors =
              ocp$output (' ', 'WARNING', 7, occ$end_of_line);
            = pmc$error_load_errors =
              ocp$output (' ', 'ERROR', 5, occ$end_of_line);
            = pmc$fatal_load_errors =
              ocp$output (' ', 'FATAL', 5, occ$end_of_line);
            ELSE
              ocp$output (' ', '*******', 7, occ$end_of_line);
            CASEND;
          IFEND;

          IF pmc$preset_specified IN program_attributes^.contents THEN
            ocp$output (' ', 'preset value:', 13, occ$continue);

            CASE program_attributes^.preset OF
            = pmc$initialize_to_zero =
              ocp$output (' ', 'ZERO', 4, occ$end_of_line);
            = pmc$initialize_to_alt_ones =
              ocp$output (' ', 'ALTERNATE ONES', 14, occ$end_of_line);
            = pmc$initialize_to_indefinite =
              ocp$output (' ', 'FLOATING POINT INDEFINITE', 25, occ$end_of_line);
            = pmc$initialize_to_infinity =
              ocp$output (' ', 'INFINITY', 8, occ$end_of_line);
            ELSE
              ocp$output (' ', '******', 6, occ$end_of_line);
            CASEND;
          IFEND;

          IF pmc$max_stack_size_specified IN program_attributes^.contents THEN
            hexrep (strng, length, program_attributes^.maximum_stack_size);

            ocp$output (' ', 'stack size:', 11, occ$continue);
            ocp$output ('', strng, length, occ$end_of_line);
          IFEND;

          IF pmc$abort_file_specified IN program_attributes^.contents THEN
            ocp$output (' ', 'abort file:', 11, occ$continue);
            ocp$output (' ', program_attributes^.abort_file, STRLENGTH (program_attributes^.abort_file),
                  occ$end_of_line);
          IFEND;

          IF pmc$debug_mode_specified IN program_attributes^.contents THEN
            IF program_attributes^.debug_mode THEN
              ocp$output (' ', 'debug mode: ON', 14, occ$end_of_line);
            ELSE
              ocp$output (' ', 'debug mode: OFF', 15, occ$end_of_line);
            IFEND;
          IFEND;

          IF pmc$debug_input_specified IN program_attributes^.contents THEN
            ocp$output (' debug_input: ', program_attributes^.debug_input,
                  STRLENGTH (program_attributes^.debug_input), occ$end_of_line);
          IFEND;

          IF pmc$debug_output_specified IN program_attributes^.contents THEN
            ocp$output ('      debug_output: ', program_attributes^.debug_output,
                  STRLENGTH (program_attributes^.debug_output), occ$end_of_line);
          IFEND;


        PROCEND process_program_description;
?? OLDTITLE ??
?? NEWTITLE := '      PROCESS_COMMAND_DESCRIPTION' ??
?? EJECT ??

        PROCEDURE process_command_description
          (    library_member_header: ^llt$library_member_header;
           VAR file: ^SEQ ( * ));


          VAR
            fatal_error: boolean,
            member: ^llt$command_description,
            command_attributes: ^llt$command_desc_contents,
            library_path: ^fst$file_reference,
            i: integer;


          fatal_error := FALSE;

          process_library_member_header (library_member_header, file, fatal_error);
          IF fatal_error THEN
            RETURN;
          IFEND;

          member := #PTR (library_member_header^.member, file^);
          IF member = NIL THEN
            error (' ', premature_end_of_file, 33, occ$end_of_line);
            RETURN;
          IFEND;
          RESET member;

          NEXT command_attributes IN member;
          IF command_attributes = NIL THEN
            error (' ', premature_end_of_file, 33, occ$end_of_line);
            RETURN;
          IFEND;

          IF command_attributes^.system_command THEN
            ocp$output ('0', 'system command name:', 20, occ$continue);
            ocp$output (' ', command_attributes^.system_command_name,
                  STRLENGTH (command_attributes^.system_command_name), occ$end_of_line);

          ELSE
            ocp$output ('0', 'starting procedure:', 19, occ$continue);
            ocp$output (' ', command_attributes^.starting_procedure,
                  STRLENGTH (command_attributes^.starting_procedure), occ$end_of_line);

            IF command_attributes^.library_path_size > 0 THEN
              NEXT library_path: [command_attributes^.library_path_size] IN member;
              IF library_path = NIL THEN
                error (' ', premature_end_of_file, 33, occ$end_of_line);
                RETURN;
              IFEND;

              ocp$output ('0', 'library', 7, occ$end_of_line);
              ocp$output (' ', '~~~~~~~', 7, occ$end_of_line);

              ocp$output ('   ', library_path^, STRLENGTH (library_path^), occ$end_of_line);
            IFEND;
          IFEND;

        PROCEND process_command_description;
?? OLDTITLE ??
?? NEWTITLE := '      PROCESS_COMMAND_PROCEDURE' ??
?? EJECT ??

        PROCEDURE process_command_procedure
          (    library_member_header: ^llt$library_member_header;
           VAR file: ^SEQ ( * ));


          VAR
            fatal_error: boolean,
            command_procedure: ^clt$scl_procedure;


          fatal_error := FALSE;

          process_library_member_header (library_member_header, file, fatal_error);
          IF fatal_error THEN
            RETURN;
          IFEND;

          command_procedure := #PTR (library_member_header^.member, file^);
          IF command_procedure = NIL THEN
            error (' ', premature_end_of_file, 33, occ$end_of_line);
            RETURN;
          IFEND;

          ocp$output ('0', 'command procedure', 17, occ$end_of_line);
          ocp$output (' ', '~~~~~~~~~~~~~~~~~', 17, occ$end_of_line);
          hex_dump (#LOC (command_procedure^), library_member_header^.member_size);


        PROCEND process_command_procedure;
?? OLDTITLE ??
?? NEWTITLE := '      PROCESS_APPLIC_PROGRAM_DESCRIP' ??
?? EJECT ??

        PROCEDURE process_applic_program_descrip
          (    application_member_header: ^llt$application_member_header;
           VAR file: ^SEQ ( * ));

          VAR
            library_member_header: ^llt$library_member_header;

          library_member_header := ^application_member_header^.library_member_header;

          process_program_description (library_member_header, file);

          ocp$output (' ', 'application identifier:', 23, occ$continue);
          ocp$output (' ', application_member_header^.application_identifier.name,
                STRLENGTH (application_member_header^.application_identifier.name), occ$end_of_line);
        PROCEND process_applic_program_descrip;
?? OLDTITLE ??
?? NEWTITLE := '      PROCESS_APPLIC_COMMAND_DESCRIP' ??
?? EJECT ??

        PROCEDURE process_applic_command_descrip
          (    application_member_header: ^llt$application_member_header;
           VAR file: ^SEQ ( * ));

          VAR
            library_member_header: ^llt$library_member_header;

          library_member_header := ^application_member_header^.library_member_header;

          process_command_description (library_member_header, file);

          ocp$output (' ', 'application identifier:', 23, occ$continue);
          ocp$output (' ', application_member_header^.application_identifier.name,
                STRLENGTH (application_member_header^.application_identifier.name), occ$end_of_line);
        PROCEND process_applic_command_descrip;
?? OLDTITLE ??
?? NEWTITLE := '      PROCESS_APPLIC_COMMAND_PROC' ??
?? EJECT ??

        PROCEDURE process_applic_command_proc
          (    application_member_header: ^llt$application_member_header;
           VAR file: ^SEQ ( * ));

          VAR
            library_member_header: ^llt$library_member_header;

          library_member_header := ^application_member_header^.library_member_header;

          process_command_procedure (library_member_header, file);

          ocp$output (' ', 'application identifier:', 23, occ$continue);
          ocp$output (' ', application_member_header^.application_identifier.name,
                STRLENGTH (application_member_header^.application_identifier.name), occ$end_of_line);
        PROCEND process_applic_command_proc;
?? OLDTITLE ??
?? NEWTITLE := '      PROCESS_FUNCTION_PROCEDURE' ??
?? EJECT ??

        PROCEDURE process_function_procedure
          (    library_member_header: ^llt$library_member_header;
           VAR file: ^SEQ ( * ));


          VAR
            fatal_error: boolean,
            function_procedure: ^clt$scl_procedure;


          fatal_error := FALSE;

          process_library_member_header (library_member_header, file, fatal_error);
          IF fatal_error THEN
            RETURN;
          IFEND;

          function_procedure := #PTR (library_member_header^.member, file^);
          IF function_procedure = NIL THEN
            error (' ', premature_end_of_file, 33, occ$end_of_line);
            RETURN;
          IFEND;

          ocp$output ('0', 'function procedure', 18, occ$end_of_line);
          ocp$output (' ', '~~~~~~~~~~~~~~~~~~', 18, occ$end_of_line);
          hex_dump (#LOC (function_procedure^), library_member_header^.member_size);


        PROCEND process_function_procedure;
?? OLDTITLE ??
?? NEWTITLE := '      PROCESS_FUNCTION_DESCRIPTION' ??
?? EJECT ??

        PROCEDURE process_function_description
          (    library_member_header: ^llt$library_member_header;
           VAR file: ^SEQ ( * ));


          VAR
            fatal_error: boolean,
            member: ^llt$function_description,
            function_attributes: ^llt$function_desc_contents,
            library_path: ^fst$file_reference,
            i: integer;


          fatal_error := FALSE;

          process_library_member_header (library_member_header, file, fatal_error);
          IF fatal_error THEN
            RETURN;
          IFEND;

          member := #PTR (library_member_header^.member, file^);
          IF member = NIL THEN
            error (' ', premature_end_of_file, 33, occ$end_of_line);
            RETURN;
          IFEND;
          RESET member;

          NEXT function_attributes IN member;
          IF function_attributes = NIL THEN
            error (' ', premature_end_of_file, 33, occ$end_of_line);
            RETURN;
          IFEND;

          ocp$output ('0', 'starting procedure:', 19, occ$continue);
          ocp$output (' ', function_attributes^.starting_procedure,
                STRLENGTH (function_attributes^.starting_procedure), occ$end_of_line);

          IF function_attributes^.library_path_size > 0 THEN
            NEXT library_path: [function_attributes^.library_path_size] IN member;
            IF library_path = NIL THEN
              error (' ', premature_end_of_file, 33, occ$end_of_line);
              RETURN;
            IFEND;

            ocp$output ('0', 'library', 7, occ$end_of_line);
            ocp$output (' ', '~~~~~~~', 7, occ$end_of_line);

            ocp$output ('   ', library_path^, STRLENGTH (library_path^), occ$end_of_line);
          IFEND;

        PROCEND process_function_description;
?? OLDTITLE ??
?? NEWTITLE := '      PROCESS_MESSAGE_MODULE_PROCEDURE' ??
?? EJECT ??

        PROCEDURE process_msg_module_procedure
          (    library_member_header: ^llt$library_member_header;
           VAR file: ^SEQ ( * ));


          VAR
            fatal_error: boolean,
            message_template_module: ^ost$message_template_module,
            natural_language: ost$natural_language,
            online_manual: ost$online_manual_name,
            help_module: boolean,
            message_module: boolean,
            lowest_condition_code: ost$status_condition_code,
            highest_condition_code: ost$status_condition_code,
            local_status: ost$status;

          fatal_error := FALSE;

          process_library_member_header (library_member_header, file, fatal_error);
          IF fatal_error THEN
            RETURN;
          IFEND;

          message_template_module := #PTR (library_member_header^.member, file^);
          IF message_template_module = NIL THEN
            error (' ', premature_end_of_file, 33, occ$end_of_line);
            RETURN;
          IFEND;

          clp$get_message_module_info (message_template_module, natural_language, online_manual, help_module,
                message_module, lowest_condition_code, highest_condition_code, local_status);

          IF NOT local_status.normal THEN
            RETURN;
          IFEND;

          ocp$output ('0', 'module type:', 12, occ$continue);
          IF message_module AND help_module THEN
            ocp$output (' ', 'MESSAGE AND HELP MODULE', 23, occ$end_of_line);
          ELSEIF message_module THEN
            ocp$output (' ', 'MESSAGE MODULE', 14, occ$end_of_line);
          ELSEIF help_module THEN
            ocp$output (' ', 'HELP MODULE', 11, occ$end_of_line);
          IFEND;

          ocp$output ('0', 'natural language:', 17, occ$continue);
          ocp$output (' ', natural_language, STRLENGTH (natural_language), occ$end_of_line);

          ocp$output ('0', 'online manual:', 14, occ$continue);
          ocp$output (' ', online_manual, STRLENGTH (online_manual), occ$end_of_line);

          IF message_module THEN
            STRINGREP (strng, length, lowest_condition_code);
            ocp$output ('0', 'lowest condition code:', 22, occ$continue);
            ocp$output (' ', strng, length, occ$end_of_line);
            STRINGREP (strng, length, highest_condition_code);
            ocp$output (' ', 'highest condition code:', 22, occ$continue);
            ocp$output (' ', strng, length, occ$end_of_line);
          IFEND;

          hex_dump (#LOC (message_template_module^), library_member_header^.member_size);


        PROCEND process_msg_module_procedure;
?? OLDTITLE ??
?? NEWTITLE := '      PROCESS_PANEL_MODEL_PROCEDURE' ??
?? EJECT ??

        PROCEDURE process_panel_module_procedure
          (    library_member_header: ^llt$library_member_header;
           VAR file: ^SEQ ( * ));


          VAR
            fatal_error: boolean,
            panel_module_procedure: ^SEQ ( * );


          fatal_error := FALSE;

          process_library_member_header (library_member_header, file, fatal_error);
          IF fatal_error THEN
            RETURN;
          IFEND;

          panel_module_procedure := #PTR (library_member_header^.member, file^);
          IF panel_module_procedure = NIL THEN
            error (' ', premature_end_of_file, 33, occ$end_of_line);
            RETURN;
          IFEND;

          ocp$output ('0', 'form module procedure', 21, occ$end_of_line);
          ocp$output (' ', '~~~~~~~~~~~~~~~~~~~~~', 21, occ$end_of_line);

          hex_dump (#LOC (panel_module_procedure^), library_member_header^.member_size);


        PROCEND process_panel_module_procedure;
?? OLDTITLE ??
?? EJECT ??

        VAR
          application_member_header: ^llt$application_member_header,
          valid_position: boolean,
          i: 1 .. llc$max_modules_in_library,
          load_module_header: ^llt$load_module_header,
          object_text_descriptor: ^llt$object_text_descriptor,
          library_member_header: ^llt$library_member_header;


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

        FOR i := 1 TO number_of_modules DO
          ocp$output (' ', 'module:', 7, occ$continue);
          ocp$output (' ', module_dictionary^ [i].name, STRLENGTH (module_dictionary^ [i].name),
                occ$end_of_line);

          CASE module_dictionary^ [i].kind OF

          = llc$load_module =
            load_module_header := #PTR (module_dictionary^ [i].module_header, file^);
            IF load_module_header = NIL THEN
              error (' ', premature_end_of_file, 33, occ$end_of_line);
            IFEND;
            process_load_module (load_module_header, file);

          = llc$ppu_object_module =
            object_text_descriptor := #PTR (module_dictionary^ [i].ppu_header, file^);
            IF object_text_descriptor = NIL THEN
              error (' ', premature_end_of_file, 33, occ$end_of_line);
            IFEND;
            RESET file TO object_text_descriptor;
            process_ppu_object_module (file);

          = llc$program_description =
            library_member_header := #PTR (module_dictionary^ [i].program_header, file^);
            IF library_member_header = NIL THEN
              error (' ', premature_end_of_file, 33, occ$end_of_line);
            IFEND;
            process_program_description (library_member_header, file);

          = llc$command_procedure =
            library_member_header := #PTR (module_dictionary^ [i].command_header, file^);
            IF library_member_header = NIL THEN
              error (' ', premature_end_of_file, 33, occ$end_of_line);
            IFEND;
            process_command_procedure (library_member_header, file);

          = llc$command_description =
            library_member_header := #PTR (module_dictionary^ [i].command_description_header, file^);
            IF library_member_header = NIL THEN
              error (' ', premature_end_of_file, 33, occ$end_of_line);
            IFEND;
            process_command_description (library_member_header, file);

          = llc$function_procedure =
            library_member_header := #PTR (module_dictionary^ [i].function_header, file^);
            IF library_member_header = NIL THEN
              error (' ', premature_end_of_file, 33, occ$end_of_line);
            IFEND;
            process_function_procedure (library_member_header, file);

          = llc$function_description =
            library_member_header := #PTR (module_dictionary^ [i].function_description_header, file^);
            IF library_member_header = NIL THEN
              error (' ', premature_end_of_file, 33, occ$end_of_line);
            IFEND;
            process_function_description (library_member_header, file);

          = llc$message_module =
            library_member_header := #PTR (module_dictionary^ [i].message_header, file^);
            IF library_member_header = NIL THEN
              error (' ', premature_end_of_file, 33, occ$end_of_line);
            IFEND;
            process_msg_module_procedure (library_member_header, file);

          = llc$panel_module =
            library_member_header := #PTR (module_dictionary^ [i].panel_header, file^);
            IF library_member_header = NIL THEN
              error (' ', premature_end_of_file, 33, occ$end_of_line);
            IFEND;
            process_panel_module_procedure (library_member_header, file);

          = llc$applic_command_procedure =
            application_member_header := #PTR (module_dictionary^ [i].applic_command_header, file^);
            IF application_member_header = NIL THEN
              error (' ', premature_end_of_file, 33, occ$end_of_line);
            IFEND;
            process_applic_command_proc (application_member_header, file);

          = llc$applic_program_description =
            application_member_header := #PTR (module_dictionary^ [i].applic_program_header, file^);
            IF application_member_header = NIL THEN
              error (' ', premature_end_of_file, 33, occ$end_of_line);
            IFEND;
            process_applic_program_descrip (application_member_header, file);

          = llc$applic_command_description =
            application_member_header := #PTR (module_dictionary^ [i].applic_command_description_hdr, file^);
            IF application_member_header = NIL THEN
              error (' ', premature_end_of_file, 33, occ$end_of_line);
            IFEND;
            process_applic_command_descrip (application_member_header, file);

          ELSE

{ error already flagged

          CASEND;

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


      PROCEND process_library_modules;
?? OLDTITLE ??
?? EJECT ??

      VAR
        library_header: ^llt$object_library_header,
        library_hdr: ^llt$object_library_header_v1_0,
        entry_point_dictionary: ^llt$entry_point_dictionary,
        command_dictionary: ^llt$command_dictionary,
        function_dictionary: ^llt$function_dictionary,
        help_module_dictionary: ^llt$help_module_dictionary,
        message_module_dictionary: ^llt$message_module_dictionary,
        panel_dictionary: ^llt$panel_dictionary,
        module_dictionary: ^llt$module_dictionary,
        module_dictionary_size: 0 .. llc$max_modules_in_library,
        dictionary_size: integer,
        library_dictionary: ^llt$object_library_dictionaries,
        i: 0 .. llc$max_dictionaries_on_library;


      NEXT library_header IN file;
      IF library_header = NIL THEN
        error (' ', premature_end_of_file, 33, occ$end_of_line);
        RETURN;
      IFEND;

      ocp$output ('-', 'object library version:', 23, occ$continue);
      ocp$output (' ', library_header^.version, STRLENGTH (library_header^.version), occ$end_of_line);

      IF library_header^.version = llc$object_library_version THEN
        NEXT library_dictionary: [1 .. library_header^.number_of_dictionaries] IN file;
        IF library_dictionary = NIL THEN
          error (' ', premature_end_of_file, 33, occ$end_of_line);
          RETURN;
        IFEND;

        FOR i := LOWERBOUND (library_dictionary^) TO UPPERBOUND (library_dictionary^) DO

          CASE library_dictionary^ [i].kind OF

          = llc$module_dictionary =
            module_dictionary := #PTR (library_dictionary^ [i].module_dictionary, file^);
            dictionary_size := UPPERBOUND (module_dictionary^);
            STRINGREP (strng, length, dictionary_size);
            ocp$output (' ', 'number of modules:', 18, occ$continue);
            ocp$output (' ', strng, length, occ$end_of_line);

          = llc$entry_point_dictionary =
            entry_point_dictionary := #PTR (library_dictionary^ [i].entry_point_dictionary, file^);
            dictionary_size := UPPERBOUND (entry_point_dictionary^);
            STRINGREP (strng, length, dictionary_size);
            ocp$output (' ', 'number of entry points:', 24, occ$continue);
            ocp$output (' ', strng, length, occ$end_of_line);

          = llc$command_dictionary =
            command_dictionary := #PTR (library_dictionary^ [i].command_dictionary, file^);
            dictionary_size := UPPERBOUND (command_dictionary^);
            STRINGREP (strng, length, dictionary_size);
            ocp$output (' ', 'number of commands:', 19, occ$continue);
            ocp$output (' ', strng, length, occ$end_of_line);

          = llc$function_dictionary =
            function_dictionary := #PTR (library_dictionary^ [i].function_dictionary, file^);
            dictionary_size := UPPERBOUND (function_dictionary^);
            STRINGREP (strng, length, dictionary_size);
            ocp$output (' ', 'number of functions:', 20, occ$continue);
            ocp$output (' ', strng, length, occ$end_of_line);

          = llc$help_module_dictionary =
            help_module_dictionary := #PTR (library_dictionary^ [i].help_module_dictionary, file^);
            dictionary_size := UPPERBOUND (help_module_dictionary^);
            STRINGREP (strng, length, dictionary_size);
            ocp$output (' ', 'number of help modules:', 23, occ$continue);
            ocp$output (' ', strng, length, occ$end_of_line);

          = llc$message_module_dictionary =
            message_module_dictionary := #PTR (library_dictionary^ [i].message_module_dictionary, file^);
            dictionary_size := UPPERBOUND (message_module_dictionary^);
            STRINGREP (strng, length, dictionary_size);
            ocp$output (' ', 'number of message modules:', 26, occ$continue);
            ocp$output (' ', strng, length, occ$end_of_line);

          = llc$panel_dictionary =
            panel_dictionary := #PTR (library_dictionary^ [i].panel_dictionary, file^);
            dictionary_size := UPPERBOUND (panel_dictionary^);
            STRINGREP (strng, length, dictionary_size);
            ocp$output (' ', 'number of forms:', 16, occ$continue);
            ocp$output (' ', strng, length, occ$end_of_line);

          CASEND;

        FOREND;


        FOR i := LOWERBOUND (library_dictionary^) TO UPPERBOUND (library_dictionary^) DO

          CASE library_dictionary^ [i].kind OF

          = llc$module_dictionary =
            module_dictionary := #PTR (library_dictionary^ [i].module_dictionary, file^);
            module_dictionary_size := UPPERBOUND (module_dictionary^);
            dictionary_size := UPPERBOUND (module_dictionary^);
            process_module_dictionary (dictionary_size, module_dictionary);

          = llc$entry_point_dictionary =
            entry_point_dictionary := #PTR (library_dictionary^ [i].entry_point_dictionary, file^);
            dictionary_size := UPPERBOUND (entry_point_dictionary^);
            process_entry_point_dictionary (dictionary_size, entry_point_dictionary);

          = llc$command_dictionary =
            command_dictionary := #PTR (library_dictionary^ [i].command_dictionary, file^);
            dictionary_size := UPPERBOUND (command_dictionary^);
            process_command_dictionary (dictionary_size, command_dictionary);

          = llc$function_dictionary =
            function_dictionary := #PTR (library_dictionary^ [i].function_dictionary, file^);
            dictionary_size := UPPERBOUND (function_dictionary^);
            process_function_dictionary (dictionary_size, function_dictionary);

          = llc$help_module_dictionary =
            help_module_dictionary := #PTR (library_dictionary^ [i].help_module_dictionary, file^);
            dictionary_size := UPPERBOUND (help_module_dictionary^);
            process_help_module_dictionary (dictionary_size, help_module_dictionary);

          = llc$message_module_dictionary =
            message_module_dictionary := #PTR (library_dictionary^ [i].message_module_dictionary, file^);
            dictionary_size := UPPERBOUND (message_module_dictionary^);
            process_msg_module_dictionary (dictionary_size, message_module_dictionary);

          = llc$panel_dictionary =
            panel_dictionary := #PTR (library_dictionary^ [i].panel_dictionary, file^);
            dictionary_size := UPPERBOUND (panel_dictionary^);
            process_panel_dictionary (dictionary_size, panel_dictionary);

          CASEND;

        FOREND;

        process_library_modules (module_dictionary_size, module_dictionary, file);

      ELSEIF library_header^.version = 'V1.0' THEN

        RESET file;
        NEXT library_hdr IN file;

        STRINGREP (strng, length, library_hdr^.number_of_modules);
        ocp$output (' ', 'number of modules:', 18, occ$continue);
        ocp$output (' ', strng, length, occ$end_of_line);

        STRINGREP (strng, length, library_hdr^.number_of_entry_points);
        ocp$output (' ', 'number of entry points:', 23, occ$continue);
        ocp$output (' ', strng, length, occ$end_of_line);

        module_dictionary := #PTR (library_hdr^.module_dictionary, file^);
        IF module_dictionary = NIL THEN
          error (' ', premature_end_of_file, 33, occ$end_of_line);
          RETURN;
        IFEND;

        process_module_dictionary (library_hdr^.number_of_modules, module_dictionary);

        entry_point_dictionary := #PTR (library_hdr^.entry_point_dictionary, file^);
        IF entry_point_dictionary = NIL THEN
          error (' ', premature_end_of_file, 33, occ$end_of_line);
          RETURN;
        IFEND;

        process_entry_point_dictionary (library_hdr^.number_of_entry_points, entry_point_dictionary);

        process_library_modules (library_hdr^.number_of_modules, module_dictionary, file);

      ELSE
        error (' ', 'INVALID OBJECT LIBRARY VERSION', 30, occ$end_of_line);
        RETURN;
      IFEND;

    PROCEND process_object_library;
?? OLDTITLE ??
?? NEWTITLE := '  ERROR', EJECT ??

    PROCEDURE error
      (    filler: string ( * );
           error_strng: string ( * );
           size: oct$output_line_size;
           end_of_line: boolean);


      VAR
        strng: string (255),
        length: integer;


      IF NOT error_header_printed THEN
        ocp$output (occ$double_space, '**** ERROR', 10, occ$continue);

        number_of_errors_detected := number_of_errors_detected + 1;
        STRINGREP (strng, length, number_of_errors_detected);
        ocp$output ('', strng (1, length), length, occ$continue);

        ocp$output ('', ' - ', 3, occ$continue);
        error_header_printed := TRUE;
      IFEND;

      ocp$output (filler, error_strng, size, occ$continue);

      IF end_of_line THEN
        ocp$output ('', '.', 1, occ$end_of_line);
        error_header_printed := FALSE;
      IFEND;


    PROCEND error;
?? OLDTITLE ??
?? NEWTITLE := '  WARNING', EJECT ??

    PROCEDURE warning
      (    filler: string ( * );
           warning_strng: string ( * );
           size: oct$output_line_size;
           end_of_line: boolean);


      VAR
        out_string: string (121),
        str_length: integer;


      IF NOT warning_header_printed THEN
        ocp$output (occ$double_space, '**** WARNING', 12, occ$continue);

        number_of_warnings_detected := number_of_warnings_detected + 1;
        STRINGREP (out_string, str_length, number_of_warnings_detected);
        ocp$output ('', out_string (1, str_length), str_length, occ$continue);

        ocp$output ('', ' - ', 3, occ$continue);
        warning_header_printed := TRUE;
      IFEND;

      ocp$output (filler, warning_strng, size, occ$continue);

      IF end_of_line THEN
        ocp$output ('', '.', 1, occ$end_of_line);
        warning_header_printed := FALSE;
      IFEND;


    PROCEND warning;
?? OLDTITLE ??
?? NEWTITLE := '  OBTAIN_OBJECT_FILE' ??
?? EJECT ??

    PROCEDURE obtain_object_file
      (    file_reference: fst$file_reference;
       VAR file_name: ost$name;
       VAR file: ^SEQ ( * );
       VAR file_contents: amt$file_contents;
       VAR status: ost$status);

      VAR
        attachment_options: array [1 .. 3] of fst$attachment_option,
        cycle_attribute_values: fst$cycle_attribute_values,
        file_id: amt$file_identifier,
        ignore_user_defined_attr_size: fst$user_defined_attribute_size,
        resolved_file_reference: fst$resolved_file_reference,
        segment: amt$segment_pointer,
        validation_attributes: array [1 .. 2] of fst$file_cycle_attribute;


      validation_attributes [1].selector := fsc$file_contents_and_processor;
      validation_attributes [1].file_contents := fsc$object_library;
      validation_attributes [1].file_processor := osc$null_name;
      validation_attributes [2].selector := fsc$file_contents_and_processor;
      validation_attributes [2].file_contents := fsc$object_data;
      validation_attributes [2].file_processor := osc$null_name;
      attachment_options [1].selector := fsc$access_and_share_modes;
      attachment_options [1].access_modes.selector := fsc$specific_access_modes;
      attachment_options [1].access_modes.value := $fst$file_access_options [fsc$read];
      attachment_options [1].share_modes.selector := fsc$specific_share_modes;
      attachment_options [1].share_modes.value := $fst$file_access_options [fsc$read, fsc$execute];
      attachment_options [2].selector := fsc$open_share_modes;
      attachment_options [2].open_share_modes := $fst$file_access_options [fsc$read, fsc$execute];
      attachment_options [3].selector := fsc$create_file;
      attachment_options [3].create_file := FALSE;

      fsp$open_file (file_reference, amc$segment, ^attachment_options, NIL, NIL, ^validation_attributes, NIL,
            file_id, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      fsp$get_open_information (file_id, NIL, NIL, NIL, ^cycle_attribute_values, NIL,
            ^resolved_file_reference, NIL, ignore_user_defined_attr_size, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      file_name := resolved_file_reference.path (resolved_file_reference.file_name.index,
            resolved_file_reference.file_name.size);
      file_contents := cycle_attribute_values.file_contents;

      amp$get_segment_pointer (file_id, amc$sequence_pointer, segment, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      file := segment.sequence_pointer;
      RESET file;

    PROCEND obtain_object_file;
?? OLDTITLE ??
?? EJECT ??

{ PROCEDURE (ocm$disot) display_object_text, disot (
{   file, f: file = lgo
{   output, o: file = $output
{   display_hex_records, dhr: boolean = true
{   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,
        default_value: string (3),
      recend,
      type2: record
        header: clt$type_specification_header,
        default_value: string (7),
      recend,
      type3: record
        header: clt$type_specification_header,
        default_value: string (4),
      recend,
      type4: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [89, 4, 7, 14, 0, 9, 538],
    clc$command, 7, 4, 0, 0, 0, 0, 4, 'OCM$DISOT'], [
    ['DHR                            ',clc$abbreviation_entry, 3],
    ['DISPLAY_HEX_RECORDS            ',clc$nominal_entry, 3],
    ['F                              ',clc$abbreviation_entry, 1],
    ['FILE                           ',clc$nominal_entry, 1],
    ['O                              ',clc$abbreviation_entry, 2],
    ['OUTPUT                         ',clc$nominal_entry, 2],
    ['STATUS                         ',clc$nominal_entry, 4]],
    [
{ 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, 3,
  clc$optional_default_parameter, 0, 3],
{ PARAMETER 2
    [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, 3,
  clc$optional_default_parameter, 0, 7],
{ PARAMETER 3
    [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$optional_default_parameter, 0, 4],
{ 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$file_type],
    'lgo'],
{ PARAMETER 2
    [[1, 0, clc$file_type],
    '$output'],
{ PARAMETER 3
    [[1, 0, clc$boolean_type],
    'true'],
{ PARAMETER 4
    [[1, 0, clc$status_type]]];

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

    CONST
      p$file = 1,
      p$output = 2,
      p$display_hex_records = 3,
      p$status = 4;

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


    VAR
      file_name: ost$name,
      file_contents: amt$file_contents,
      file: ^SEQ ( * ),
      page_header: string (59),
      strng: string (121),
      length: integer,
      record_number: integer,
      warning_header_printed: [STATIC] boolean := FALSE,
      number_of_warnings_detected: [STATIC] integer := 0,
      error_header_printed: [STATIC] boolean := FALSE,
      number_of_errors_detected: [STATIC] integer := 0;

    VAR
      display_hex_records: boolean,
      module_info: record
        version: string (4),
        greatest_section_ordinal: llt$section_ordinal,
        section_definition: ^array [0 .. * ] of ^llt$section_definition,
      recend;


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

    display_hex_records := pvt [p$display_hex_records].value^.boolean_value.value;

    ocp$initialize_oc_environment (status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    obtain_object_file (pvt [p$file].value^.file_value^, file_name, file, file_contents, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    page_header (1, * ) := 'OBJECT LISTING of ******* - ';
    IF file_contents = fsc$object_library THEN
      page_header (19, 7) := 'LIBRARY';
    ELSE
      page_header (19, 7) := ' FILE  ';
    IFEND;
    page_header (29, 31) := file_name;

    ocp$open_output_file (pvt [p$output].value^.file_value^, ^page_header, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    IF file_contents = fsc$object_library THEN
      process_object_library (file);
    ELSE
      process_object_file (file);
    IFEND;

    STRINGREP (strng, length, number_of_warnings_detected);
    ocp$output ('0', '  NUMBER OF WARNINGS DETECTED:', 30, occ$continue);
    ocp$output (' ', strng, length, occ$end_of_line);

    STRINGREP (strng, length, number_of_errors_detected);
    ocp$output ('0', '  NUMBER OF ERRORS DETECTED:', 28, occ$continue);
    ocp$output (' ', strng, length, occ$end_of_line);
    ocp$output (' ', '  ', 2, occ$end_of_line);
    ocp$output (' ', '  ', 2, occ$end_of_line);

    ocp$close_output_file (status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  PROCEND ocp$list_object_file;
?? OLDTITLE ??
MODEND ocm$list_object_file;
