?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE Object Code Management : Correction Generation' ??
MODULE ocm$construct_breaklist;

{ PURPOSE:
{   This module contains the procedures that build a breaklist, which is an array
{   where each element contains distinguishing information about a specific location
{   in an object library.

?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc llt$deferred_common_blocks
*copyc llt$deferred_entry_points
*copyc llt$information_element
*copyc llt$load_module
*copyc occ$breaklist
*copyc occ$generate_predictor
*copyc oce$metapatch_generator_errors
*copyc oct$breaklist
*copyc oct$module_directory
*copyc oct$module_map
*copyc ost$message_template
*copyc ost$mtm_condition_codes
*copyc ost$mtm_condition_names
*copyc ost$mtm_header
*copyc ost$name
*copyc ost$status
*copyc pmt$program_name
?? POP ??
*copyc ocp$convert_information_element
*copyc osp$set_status_abnormal
?? OLDTITLE ??
?? NEWTITLE := 'build_adr_breaklist_items', EJECT ??

{ PURPOSE:
{   The purpose of this request is to build breaklist items pointing
{ to the address formulation records in the object library.

  PROCEDURE build_adr_breaklist_items
    (    p_object_library: ^SEQ ( * );
         current_module: oct$module_map_item;
         binding_section: llt$section_ordinal;
     VAR breaklist_seq_p: ^SEQ ( * );
     VAR breaklist_index: oct$breaklist_length);

    VAR
      actual_parameters: ^llt$actual_parameters,
      adr: ^llt$address_formulation,
      adr_found: boolean,
      bit_string_insertion: ^llt$bit_string_insertion,
      breaklist_item: ^oct$breaklist_item,
      current_object_text_descriptor: ^llt$object_text_descriptor,
      current_section_definition: ^llt$section_definition,
      deferred_common_blocks: ^llt$deferred_common_blocks,
      deferred_entry_points: ^llt$deferred_entry_points,
      ending_offset: 0 .. 7fffffff(16),
      entry_definition: ^llt$entry_definition,
      external_linkage: ^llt$external_linkage,
      formal_parameters: ^llt$formal_parameters,
      i: llt$number_of_sections,
      j: 1 .. llc$max_adr_items,
      no_more_section_definitions: boolean,
      object_library: ^SEQ ( * ),
      object_text_descriptor: ^llt$object_text_descriptor,
      obsolete_formal_parameters: ^llt$obsolete_formal_parameters,
      replication: ^llt$replication,
      section_definition: ^llt$section_definition,
      section_map: ^llt$section_map_items,
      text: ^llt$text;

    object_library := p_object_library;
    no_more_section_definitions := FALSE;
    RESET object_library TO current_module.section_definitions;
    REPEAT
      NEXT object_text_descriptor IN object_library;
      CASE object_text_descriptor^.kind OF
      = llc$section_definition, llc$allotted_section_definition, llc$unallocated_common_block =
        NEXT section_definition IN object_library;
        IF section_definition^.kind <> llc$binding_section THEN
          current_object_text_descriptor := object_text_descriptor;
          current_section_definition := section_definition;
          REPEAT
            NEXT object_text_descriptor IN object_library;
            CASE object_text_descriptor^.kind OF
            = llc$section_definition, llc$allotted_section_definition, llc$unallocated_common_block =
              NEXT section_definition IN object_library;

            = llc$external_linkage =
              NEXT external_linkage: [1 .. object_text_descriptor^.number_of_ext_items] IN object_library;

            = llc$entry_definition =
              NEXT entry_definition IN object_library;

            = llc$deferred_entry_points =
              NEXT deferred_entry_points: [1 .. object_text_descriptor^.number_of_entry_points] IN
                    object_library;

            = llc$deferred_common_blocks =
              NEXT deferred_common_blocks: [1 .. object_text_descriptor^.number_of_common_blocks] IN
                    object_library;

            = llc$obsolete_formal_parameters =
              NEXT obsolete_formal_parameters: [[REP object_text_descriptor^.sequence_length OF cell]] IN
                    object_library;

            = llc$formal_parameters =
              NEXT formal_parameters: [[REP object_text_descriptor^.sequence_length OF cell]] IN
                    object_library;

            = llc$actual_parameters =
              NEXT actual_parameters: [[REP object_text_descriptor^.sequence_length OF cell]] IN
                    object_library;

            = llc$text =
              NEXT text: [1 .. object_text_descriptor^.number_of_bytes] IN object_library;

            = llc$replication =
              NEXT replication: [1 .. object_text_descriptor^.number_of_bytes] IN object_library;

            = llc$bit_string_insertion =
              NEXT bit_string_insertion IN object_library;

            = llc$address_formulation =
              NEXT adr: [1 .. object_text_descriptor^.number_of_adr_items] IN object_library;
              IF (adr^.value_section = current_section_definition^.section_ordinal) AND
                    (adr^.dest_section = binding_section) THEN
                section_map := #PTR (current_module.section_maps^ [adr^.value_section].map, object_library^);
                i := 1;
                FOR j := 1 TO object_text_descriptor^.number_of_adr_items DO
                  adr_found := FALSE;
                  WHILE (NOT adr_found) AND (i <= current_module.section_maps^ [adr^.value_section].
                        number_of_items) AND (section_map^ [i].offset <= adr^.
                        item [object_text_descriptor^.number_of_adr_items].value_offset) DO
                    ending_offset := section_map^ [i].offset + section_map^ [i].length;
                    IF (adr^.item [j].value_offset >= section_map^ [i].offset) AND (adr^.item [j].
                          value_offset < ending_offset) THEN
                      adr_found := TRUE;
                      NEXT breaklist_item IN breaklist_seq_p;
                      breaklist_index := breaklist_index + 1;
                      breaklist_item^.module_name := current_module.name;
                      breaklist_item^.major_name := current_module.
                            component_info^ [section_map^ [i].component].name;
                      breaklist_item^.minor_name := current_section_definition^.name;
                      breaklist_item^.kind := occ$adr;
                      breaklist_item^.section_ordinal := current_module.change_list^ [adr^.dest_section];
                      breaklist_item^.secondary_section_ordinal := current_module.
                            change_list^ [adr^.value_section];
                      breaklist_item^.offset := #OFFSET (^adr^.item [j]);
                    ELSE
                      i := i + 1;
                    IFEND;
                  WHILEND;
                FOREND;

              ELSEIF (adr^.dest_section = current_section_definition^.section_ordinal) AND
                    (current_object_text_descriptor^.kind = llc$section_definition) THEN
                section_map := #PTR (current_module.section_maps^ [adr^.dest_section].map, object_library^);
                i := 1;
                FOR j := 1 TO object_text_descriptor^.number_of_adr_items DO
                  adr_found := FALSE;
                  WHILE NOT adr_found AND (i <= current_module.section_maps^ [adr^.dest_section].
                        number_of_items) AND (section_map^ [i].offset <= adr^.
                        item [object_text_descriptor^.number_of_adr_items].dest_offset) DO
                    ending_offset := section_map^ [i].offset + section_map^ [i].length;
                    IF (adr^.item [j].dest_offset >= section_map^ [i].offset) AND (adr^.item [j].
                          dest_offset < ending_offset) THEN
                      adr_found := TRUE;
                      NEXT breaklist_item IN breaklist_seq_p;
                      breaklist_index := breaklist_index + 1;
                      breaklist_item^.module_name := current_module.name;
                      breaklist_item^.major_name := current_module.
                            component_info^ [section_map^ [i].component].name;
                      breaklist_item^.minor_name := current_section_definition^.name;
                      breaklist_item^.kind := occ$adr;
                      breaklist_item^.section_ordinal := current_module.change_list^ [adr^.dest_section];
                      breaklist_item^.secondary_section_ordinal := current_module.
                            change_list^ [adr^.value_section];
                      breaklist_item^.offset := #OFFSET (^adr^.item [j]);
                    ELSE
                      i := i + 1;
                    IFEND;
                  WHILEND;
                FOREND;
              IFEND;
            ELSE
              ;
            CASEND;
          UNTIL object_text_descriptor^.kind = llc$transfer_symbol;
          RESET object_library TO current_section_definition;
          NEXT section_definition IN object_library;
        IFEND;
      ELSE
        no_more_section_definitions := TRUE;
      CASEND;
    UNTIL no_more_section_definitions;

  PROCEND build_adr_breaklist_items;
?? OLDTITLE ??
?? NEWTITLE := 'build_load_module_breaklist', EJECT ??

{ PURPOSE:
{   The purpose of this request is to build breaklist items for a load
{ module.

  PROCEDURE build_load_module_breaklist
    (    current_module: oct$module_map_item;
         p_object_library: ^SEQ ( * );
         interpretive_element: ^llt$object_text_descriptor;
     VAR breaklist_seq_p: ^SEQ ( * );
     VAR breaklist_index: oct$breaklist_length;
     VAR status: ost$status);

    VAR
      actual_parameters: ^llt$actual_parameters,
      adr: ^llt$address_formulation,
      application_identifier: ^llt$application_identifier,
      binding_section: llt$section_ordinal,
      binding_template: ^llt$binding_template,
      breaklist_item: ^oct$breaklist_item,
      bsi: ^llt$bit_string_insertion,
      debug_table_fragment: ^llt$debug_table_fragment,
      deferred_common_blocks: ^llt$deferred_common_blocks,
      deferred_entry_points: ^llt$deferred_entry_points,
      deferred_index: 1 .. llc$max_deferred_entry_points,
      entry_definition: ^llt$entry_definition,
      external_linkage: ^llt$external_linkage,
      formal_parameters: ^llt$formal_parameters,
      identification: ^llt$identification,
      length: integer,
      libraries: ^llt$libraries,
      line_address_table: ^llt$line_address_table,
      m68000_absolute: ^llt$68000_absolute,
      message: string (100),
      object_library: ^SEQ ( * ),
      object_text_descriptor: ^llt$object_text_descriptor,
      obsolete_formal_parameters: ^llt$obsolete_formal_parameters,
      obsolete_line_address_table: ^llt$obsolete_line_address_table,
      obsolete_segment_definition: ^llt$obsolete_segment_definition,
      relocation: ^llt$relocation,
      replication: ^llt$replication,
      section_definition: ^llt$section_definition,
      segment_definition: ^llt$segment_definition,
      supplemental_debug_tables: ^llt$supplemental_debug_tables,
      symbol_table: ^llt$symbol_table,
      text: ^llt$text;

    status.normal := TRUE;
    object_library := p_object_library;

    binding_section := occ$invalid_section_ordinal;

    RESET object_library TO interpretive_element;
    REPEAT
      NEXT object_text_descriptor IN object_library;
      CASE object_text_descriptor^.kind OF
      = llc$identification =
        NEXT identification IN object_library;
      = llc$application_identifier =
        NEXT application_identifier IN object_library;
      = llc$libraries =
        NEXT libraries: [1 .. object_text_descriptor^.number_of_libraries] IN object_library;
      = llc$section_definition, llc$allotted_section_definition, llc$unallocated_common_block =
        NEXT section_definition IN object_library;
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := current_module.name;
        breaklist_item^.major_name := occ$section_definition;
        breaklist_item^.minor_name := section_definition^.name;
        breaklist_item^.offset := #OFFSET (object_text_descriptor);
        breaklist_item^.kind := occ$secdef;
        breaklist_item^.section_ordinal := current_module.change_list^ [section_definition^.section_ordinal];
        breaklist_item^.secondary_section_ordinal := 0;

        IF (section_definition^.kind <> llc$binding_section) AND
              (object_text_descriptor^.kind <> llc$allotted_section_definition) AND
              NOT current_module.bound_module THEN
          build_text_bl_for_unbound (section_definition^.section_ordinal, section_definition^.name,
                current_module, object_library, breaklist_seq_p, breaklist_index, status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;

        ELSEIF section_definition^.kind = llc$binding_section THEN
          binding_section := section_definition^.section_ordinal;
        IFEND;
      = llc$external_linkage =
        NEXT external_linkage: [1 .. object_text_descriptor^.number_of_ext_items] IN object_library;
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := current_module.name;
        breaklist_item^.major_name := occ$external_linkage;
        breaklist_item^.minor_name := external_linkage^.name;
        breaklist_item^.offset := #OFFSET (object_text_descriptor);
        breaklist_item^.kind := occ$ext;
        breaklist_item^.section_ordinal := 0;
        breaklist_item^.secondary_section_ordinal := 0;

      = llc$entry_definition =
        NEXT entry_definition IN object_library;
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := current_module.name;
        breaklist_item^.major_name := occ$entry_definition;
        breaklist_item^.minor_name := entry_definition^.name;
        breaklist_item^.offset := #OFFSET (object_text_descriptor);
        breaklist_item^.kind := occ$ept;
        breaklist_item^.section_ordinal := current_module.change_list^ [entry_definition^.section_ordinal];
        breaklist_item^.secondary_section_ordinal := 0;

      = llc$deferred_entry_points =
        NEXT deferred_entry_points: [1 .. object_text_descriptor^.number_of_entry_points] IN object_library;
        FOR deferred_index := 1 TO object_text_descriptor^.number_of_entry_points DO
          NEXT breaklist_item IN breaklist_seq_p;
          breaklist_index := breaklist_index + 1;
          breaklist_item^.module_name := current_module.name;
          breaklist_item^.major_name := occ$deferred_entry_point;
          breaklist_item^.minor_name := deferred_entry_points^ [deferred_index].name;
          breaklist_item^.offset := #OFFSET (^deferred_entry_points^ [deferred_index]);
          breaklist_item^.kind := occ$deferred_ept;
          breaklist_item^.section_ordinal := current_module.change_list^
                [deferred_entry_points^ [deferred_index].section_ordinal];
          breaklist_item^.secondary_section_ordinal := 0;
        FOREND;

      = llc$deferred_common_blocks =
        NEXT deferred_common_blocks: [1 .. object_text_descriptor^.number_of_common_blocks] IN object_library;
        FOR deferred_index := 1 TO object_text_descriptor^.number_of_common_blocks DO
          NEXT breaklist_item IN breaklist_seq_p;
          breaklist_index := breaklist_index + 1;
          breaklist_item^.module_name := current_module.name;
          breaklist_item^.major_name := occ$deferred_common_block;
          breaklist_item^.minor_name := deferred_common_blocks^ [deferred_index].name;
          breaklist_item^.offset := #OFFSET (^deferred_common_blocks^ [deferred_index]);
          breaklist_item^.kind := occ$deferred_common_blk;
          breaklist_item^.section_ordinal := 0;
          breaklist_item^.secondary_section_ordinal := 0;
        FOREND;

      = llc$segment_definition, llc$allotted_segment_definition =
        NEXT segment_definition IN object_library;
        section_definition := ^segment_definition^.section_definition;
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := current_module.name;
        breaklist_item^.major_name := occ$section_definition;
        breaklist_item^.minor_name := section_definition^.name;
        breaklist_item^.offset := #OFFSET (object_text_descriptor);
        breaklist_item^.kind := occ$secdef;
        breaklist_item^.section_ordinal := current_module.change_list^ [section_definition^.section_ordinal];
        breaklist_item^.secondary_section_ordinal := 0;

        IF (section_definition^.kind <> llc$binding_section) AND
              (object_text_descriptor^.kind = llc$segment_definition) AND NOT current_module.bound_module THEN
          build_text_bl_for_unbound (section_definition^.section_ordinal, section_definition^.name,
                current_module, object_library, breaklist_seq_p, breaklist_index, status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;
        IFEND;

      = llc$obsolete_segment_definition, llc$obsolete_allotted_seg_def =
        NEXT obsolete_segment_definition IN object_library;
        section_definition := ^obsolete_segment_definition^.section_definition;
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := current_module.name;
        breaklist_item^.major_name := occ$section_definition;
        breaklist_item^.minor_name := section_definition^.name;
        breaklist_item^.offset := #OFFSET (object_text_descriptor);
        breaklist_item^.kind := occ$secdef;
        breaklist_item^.section_ordinal := current_module.change_list^ [section_definition^.section_ordinal];
        breaklist_item^.secondary_section_ordinal := 0;

        IF (section_definition^.kind <> llc$binding_section) AND
              (object_text_descriptor^.kind = llc$obsolete_segment_definition) AND
              NOT current_module.bound_module THEN
          build_text_bl_for_unbound (section_definition^.section_ordinal, section_definition^.name,
                current_module, object_library, breaklist_seq_p, breaklist_index, status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;
        IFEND;

      = llc$obsolete_formal_parameters =
        NEXT obsolete_formal_parameters: [[REP object_text_descriptor^.sequence_length OF cell]] IN
              object_library;

      = llc$formal_parameters =
        NEXT formal_parameters: [[REP object_text_descriptor^.sequence_length OF cell]] IN object_library;

      = llc$actual_parameters =
        NEXT actual_parameters: [[REP object_text_descriptor^.sequence_length OF cell]] IN object_library;

      = llc$text =
        NEXT text: [1 .. object_text_descriptor^.number_of_bytes] IN object_library;

      = llc$replication =
        NEXT replication: [1 .. object_text_descriptor^.number_of_bytes] IN object_library;

      = llc$bit_string_insertion =
        NEXT bsi IN object_library;

      = llc$address_formulation =
        NEXT adr: [1 .. object_text_descriptor^.number_of_adr_items] IN object_library;
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := current_module.name;
        breaklist_item^.major_name := occ$address_formulation;
        breaklist_item^.minor_name := osc$null_name;
        breaklist_item^.offset := #OFFSET (object_text_descriptor);
        breaklist_item^.kind := occ$adr;
        breaklist_item^.section_ordinal := current_module.change_list^ [adr^.dest_section];
        breaklist_item^.secondary_section_ordinal := current_module.change_list^ [adr^.value_section];

      = llc$binding_template =
        NEXT binding_template IN object_library;

      = llc$relocation =
        NEXT relocation: [1 .. object_text_descriptor^.number_of_rel_items] IN object_library;

      = llc$cybil_symbol_table_fragment =
        NEXT debug_table_fragment: [[REP object_text_descriptor^.sequence_length OF cell]] IN object_library;

      = llc$symbol_table =
        NEXT symbol_table: [[REP object_text_descriptor^.sequence_length OF cell]] IN object_library;

      = llc$supplemental_debug_tables =
        NEXT supplemental_debug_tables: [[REP object_text_descriptor^.sequence_length OF cell]] IN
              object_library;

      = llc$68000_absolute =
        NEXT m68000_absolute: [[REP object_text_descriptor^.number_of_68000_bytes OF cell]] IN object_library;
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := current_module.name;
        breaklist_item^.major_name := occ$motorola_68000_absolute;
        breaklist_item^.minor_name := osc$null_name;
        breaklist_item^.offset := #OFFSET (object_text_descriptor);
        breaklist_item^.kind := occ$m68000;
        breaklist_item^.section_ordinal := 0;
        breaklist_item^.secondary_section_ordinal := 0;

      = llc$line_table =
        NEXT line_address_table: [1 .. object_text_descriptor^.number_of_line_items] IN object_library;

      = llc$obsolete_line_table =
        NEXT obsolete_line_address_table: [1 .. object_text_descriptor^.number_of_line_items] IN
              object_library;

      = llc$transfer_symbol =
        ;

      ELSE
        STRINGREP (message, length, object_text_descriptor^.kind);
        osp$set_status_abnormal (occ$status_id, oce$unexpected_record_kind, message (1, length), status);
        RETURN;

      CASEND;
    UNTIL object_text_descriptor^.kind = llc$transfer_symbol;
    IF current_module.bound_module THEN
      build_text_breaklist_items (object_library, current_module, breaklist_seq_p, breaklist_index, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      build_adr_breaklist_items (object_library, current_module, binding_section, breaklist_seq_p,
            breaklist_index);
    IFEND;

  PROCEND build_load_module_breaklist;
?? OLDTITLE ??
?? NEWTITLE := 'build_module_map', EJECT ??

{ PURPOSE:
{   The purpose of this request is to build a directory containing
{ information about each module.  The directory contains the module
{ name, module kind, pointer to section definitions, greatest section
{ ordinal, whether the module is bound, a pointer to the section maps,
{ and the section number change vectors.

  PROCEDURE build_module_map
    (    p_object_library: ^SEQ ( * );
         module_directory: ^oct$module_directory;
         original_object_library: boolean;
     VAR module_map: ^oct$module_map;
     VAR status: ost$status);

    VAR
      found: boolean,
      i: llt$module_index,
      identification: ^llt$identification,
      info_element_header: ^llt$info_element_header,
      information_element: llt$info_element_header,
      interpretive_element: ^llt$object_text_descriptor,
      j: llt$section_ordinal,
      module_dictionary: ^llt$module_dictionary,
      module_header: ^llt$load_module_header,
      object_library: ^SEQ ( * ),
      object_library_dictionaries: ^llt$object_library_dictionaries,
      object_library_header: ^llt$object_library_header,
      object_text_descriptor: ^llt$object_text_descriptor,
      section_number_changes: ^oct$change_list;

    status.normal := TRUE;

    object_library := p_object_library;

    RESET object_library;
    NEXT object_library_header IN object_library;
    NEXT object_library_dictionaries: [1 .. object_library_header^.number_of_dictionaries] IN object_library;
    found := FALSE;
    i := 1;
    WHILE NOT found AND (i <= object_library_header^.number_of_dictionaries) DO
      IF object_library_dictionaries^ [i].kind = llc$module_dictionary THEN
        found := TRUE;
      ELSE
        i := i + 1;
      IFEND;
    WHILEND;
    IF NOT found THEN
      RETURN;
    IFEND;
    module_dictionary := #PTR (object_library_dictionaries^ [i].module_dictionary, object_library^);
    ALLOCATE module_map: [1 .. UPPERBOUND (module_dictionary^)];
    FOR i := 1 TO UPPERBOUND (module_dictionary^) DO
      module_map^ [i].kind := module_dictionary^ [i].kind;
      module_map^ [i].name := module_dictionary^ [i].name;
      CASE module_dictionary^ [i].kind OF
      = llc$load_module =
        module_map^ [i].section_definitions := NIL;
        module_map^ [i].greatest_section_ordinal := 0;
        module_map^ [i].bound_module := FALSE;
        module_map^ [i].change_list := NIL;
        module_map^ [i].section_maps := NIL;
        module_map^ [i].component_info := NIL;
        module_header := #PTR (module_dictionary^ [i].module_header, object_library^);
        IF llc$interpretive_element IN module_header^.elements_defined THEN
          interpretive_element := #PTR (module_header^.interpretive_element, object_library^);
          RESET object_library TO interpretive_element;
          NEXT object_text_descriptor IN object_library;
          IF object_text_descriptor^.kind <> llc$identification THEN
            osp$set_status_abnormal (occ$status_id, oce$id_record_expected, '', status);
            RETURN;
          IFEND;
          NEXT identification IN object_library;
          IF llc$section_element IN module_header^.interpretive_header.elements_defined THEN
            module_map^ [i].section_definitions := #PTR (module_header^.interpretive_header.
                  section_definitions, object_library^);
          IFEND;
          module_map^ [i].greatest_section_ordinal := identification^.greatest_section_ordinal;
          IF original_object_library AND (module_directory^ [i].last_section_ordinal <>
                occ$invalid_section_ordinal) THEN
            ALLOCATE section_number_changes: [0 .. module_directory^ [i].last_section_ordinal];
            FOR j := 0 TO module_directory^ [i].last_section_ordinal DO
              section_number_changes^ [j] := module_directory^ [i].section_number_change_list^ [j];
            FOREND;
          ELSE
            ALLOCATE section_number_changes: [0 .. identification^.greatest_section_ordinal];
            FOR j := 0 TO identification^.greatest_section_ordinal DO
              section_number_changes^ [j] := j;
            FOREND;
          IFEND;
          module_map^ [i].change_list := section_number_changes;
        IFEND;
        IF llc$information_element IN module_header^.elements_defined THEN
          info_element_header := #PTR (module_header^.information_element, object_library^);
          IF info_element_header^.version = llc$info_element_version THEN
            information_element := info_element_header^;
          ELSE
            ocp$convert_information_element (info_element_header, information_element);
          IFEND;

          IF information_element.number_of_section_maps > 0 THEN
            module_map^ [i].section_maps := #PTR (information_element.section_maps, object_library^);
          IFEND;
          IF information_element.number_of_components > 0 THEN
            module_map^ [i].component_info := #PTR (information_element.component_ptr, object_library^);
            module_map^ [i].bound_module := TRUE;
          IFEND;
        IFEND;
      ELSE
        ;
      CASEND;
    FOREND;
  PROCEND build_module_map;
?? OLDTITLE ??
?? NEWTITLE := 'build_text_bl_for_unbound', EJECT ??

{ PURPOSE:
{   The purpose of this request is to build text breaklist items pointing
{ to the text, replication and bit string insertion records in an unbound
{ library.

  PROCEDURE build_text_bl_for_unbound
    (    section_ordinal: llt$section_ordinal;
         section_name: pmt$program_name;
         current_module: oct$module_map_item;
         p_object_library: ^SEQ ( * );
     VAR breaklist_seq_p: ^SEQ ( * );
     VAR breaklist_index: oct$breaklist_length;
     VAR status: ost$status);

    VAR
      actual_parameters: ^llt$actual_parameters,
      adr: ^llt$address_formulation,
      binding_template: ^llt$binding_template,
      bit_string_insertion: ^llt$bit_string_insertion,
      breaklist_item: ^oct$breaklist_item,
      debug_table_fragment: ^llt$debug_table_fragment,
      deferred_common_blocks: ^llt$deferred_common_blocks,
      deferred_entry_points: ^llt$deferred_entry_points,
      entry_definition: ^llt$entry_definition,
      external_linkage: ^llt$external_linkage,
      formal_parameters: ^llt$formal_parameters,
      length: integer,
      libraries: ^llt$libraries,
      line_address_table: ^llt$line_address_table,
      m68000_absolute: ^llt$68000_absolute,
      message: string (100),
      object_library: ^SEQ ( * ),
      object_text_descriptor: ^llt$object_text_descriptor,
      obsolete_formal_parameters: ^llt$obsolete_formal_parameters,
      obsolete_line_address_table: ^llt$obsolete_line_address_table,
      obsolete_segment_definition: ^llt$obsolete_segment_definition,
      relocation: ^llt$relocation,
      replication: ^llt$replication,
      section_definition: ^llt$section_definition,
      segment_definition: ^llt$segment_definition,
      supplemental_debug_tables: ^llt$supplemental_debug_tables,
      symbol_table: ^llt$symbol_table,
      text: ^llt$text,
      text_breaklist_made: boolean;

    status.normal := TRUE;

    object_library := p_object_library;

    RESET object_library TO current_module.section_definitions;
    text_breaklist_made := FALSE;
    REPEAT
      NEXT object_text_descriptor IN object_library;
      CASE object_text_descriptor^.kind OF
      = llc$section_definition, llc$allotted_section_definition, llc$unallocated_common_block =
        NEXT section_definition IN object_library;

      = llc$segment_definition, llc$allotted_segment_definition =
        NEXT segment_definition IN object_library;

      = llc$obsolete_segment_definition, llc$obsolete_allotted_seg_def =
        NEXT obsolete_segment_definition IN object_library;

      = llc$external_linkage =
        NEXT external_linkage: [1 .. object_text_descriptor^.number_of_ext_items] IN object_library;

      = llc$entry_definition =
        NEXT entry_definition IN object_library;

      = llc$deferred_entry_points =
        NEXT deferred_entry_points: [1 .. object_text_descriptor^.number_of_entry_points] IN object_library;

      = llc$deferred_common_blocks =
        NEXT deferred_common_blocks: [1 .. object_text_descriptor^.number_of_common_blocks] IN object_library;

      = llc$obsolete_formal_parameters =
        NEXT obsolete_formal_parameters: [[REP object_text_descriptor^.sequence_length OF cell]] IN
              object_library;

      = llc$formal_parameters =
        NEXT formal_parameters: [[REP object_text_descriptor^.sequence_length OF cell]] IN object_library;

      = llc$actual_parameters =
        NEXT actual_parameters: [[REP object_text_descriptor^.sequence_length OF cell]] IN object_library;

      = llc$text =
        NEXT text: [1 .. object_text_descriptor^.number_of_bytes] IN object_library;
        IF (text^.section_ordinal = section_ordinal) AND NOT text_breaklist_made THEN
          NEXT breaklist_item IN breaklist_seq_p;
          breaklist_index := breaklist_index + 1;
          breaklist_item^.module_name := current_module.name;
          breaklist_item^.major_name := osc$null_name;
          breaklist_item^.minor_name := section_name;
          breaklist_item^.offset := #OFFSET (object_text_descriptor);
          breaklist_item^.kind := occ$text;
          breaklist_item^.section_ordinal := current_module.change_list^ [section_ordinal];
          breaklist_item^.secondary_section_ordinal := 0;
          text_breaklist_made := TRUE;
        IFEND;

      = llc$bit_string_insertion =
        NEXT bit_string_insertion IN object_library;
        IF (bit_string_insertion^.section_ordinal = section_ordinal) AND NOT text_breaklist_made THEN
          NEXT breaklist_item IN breaklist_seq_p;
          breaklist_index := breaklist_index + 1;
          breaklist_item^.module_name := current_module.name;
          breaklist_item^.major_name := osc$null_name;
          breaklist_item^.minor_name := section_name;
          breaklist_item^.offset := #OFFSET (object_text_descriptor);
          breaklist_item^.kind := occ$text;
          breaklist_item^.section_ordinal := current_module.change_list^ [section_ordinal];
          breaklist_item^.secondary_section_ordinal := 0;
          text_breaklist_made := TRUE;
        IFEND;

      = llc$replication =
        NEXT replication: [1 .. object_text_descriptor^.number_of_bytes] IN object_library;
        IF (replication^.section_ordinal = section_ordinal) AND NOT text_breaklist_made THEN
          NEXT breaklist_item IN breaklist_seq_p;
          breaklist_index := breaklist_index + 1;
          breaklist_item^.module_name := current_module.name;
          breaklist_item^.major_name := osc$null_name;
          breaklist_item^.minor_name := section_name;
          breaklist_item^.offset := #OFFSET (object_text_descriptor);
          breaklist_item^.kind := occ$text;
          breaklist_item^.section_ordinal := current_module.change_list^ [section_ordinal];
          breaklist_item^.secondary_section_ordinal := 0;
          text_breaklist_made := TRUE;
        IFEND;

      = llc$address_formulation =
        NEXT adr: [1 .. object_text_descriptor^.number_of_adr_items] IN object_library;

      = llc$binding_template =
        NEXT binding_template IN object_library;

      = llc$libraries =
        NEXT libraries: [1 .. object_text_descriptor^.number_of_libraries] IN object_library;

      = llc$relocation =
        NEXT relocation: [1 .. object_text_descriptor^.number_of_rel_items] IN object_library;

      = llc$cybil_symbol_table_fragment =
        NEXT debug_table_fragment: [[REP object_text_descriptor^.sequence_length OF cell]] IN object_library;

      = llc$symbol_table =
        NEXT symbol_table: [[REP object_text_descriptor^.sequence_length OF cell]] IN object_library;

      = llc$supplemental_debug_tables =
        NEXT supplemental_debug_tables: [[REP object_text_descriptor^.sequence_length OF cell]] IN
              object_library;

      = llc$68000_absolute =
        NEXT m68000_absolute: [[REP object_text_descriptor^.number_of_68000_bytes OF cell]] IN object_library;

      = llc$line_table =
        NEXT line_address_table: [1 .. object_text_descriptor^.number_of_line_items] IN object_library;

      = llc$obsolete_line_table =
        NEXT obsolete_line_address_table: [1 .. object_text_descriptor^.number_of_line_items] IN
              object_library;

      = llc$transfer_symbol =
        ;

      ELSE
        STRINGREP (message, length, object_text_descriptor^.kind);
        osp$set_status_abnormal (occ$status_id, oce$unexpected_record_kind, message (1, length), status);
        RETURN;
      CASEND;
    UNTIL object_text_descriptor^.kind = llc$transfer_symbol;

  PROCEND build_text_bl_for_unbound;
?? OLDTITLE ??
?? NEWTITLE := 'build_text_breaklist_items', EJECT ??

{ PURPOSE:
{   The purpose of this request is to build breaklist items pointing
{ to the text records in a bound module.

  PROCEDURE build_text_breaklist_items
    (    p_object_library: ^SEQ ( * );
         current_module: oct$module_map_item;
     VAR breaklist_seq_p: ^SEQ ( * );
     VAR breaklist_index: oct$breaklist_length;
     VAR status: ost$status);

    VAR
      end_of_section_definitions: boolean,
      object_library: ^SEQ ( * ),
      object_text_descriptor: ^llt$object_text_descriptor,
      section_definition: ^llt$section_definition,
      section_name: pmt$program_name,
      section_ordinal: llt$section_ordinal;

    status.normal := TRUE;

    object_library := p_object_library;

    end_of_section_definitions := FALSE;
    RESET object_library TO current_module.section_definitions;
    REPEAT
      NEXT object_text_descriptor IN object_library;
      CASE object_text_descriptor^.kind OF
      = llc$allotted_section_definition =
        NEXT section_definition IN object_library;

      = llc$section_definition, llc$unallocated_common_block =
        NEXT section_definition IN object_library;
        IF section_definition^.kind <> llc$binding_section THEN
          section_ordinal := section_definition^.section_ordinal;
          section_name := section_definition^.name;
          find_text_records (object_library, section_ordinal, section_name, current_module, breaklist_seq_p,
                breaklist_index, status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;
        IFEND;
      ELSE
        end_of_section_definitions := TRUE;
      CASEND;
    UNTIL end_of_section_definitions;

  PROCEND build_text_breaklist_items;
?? OLDTITLE ??
?? NEWTITLE := 'construct_code_breaklist', EJECT ??

{ PURPOSE:
{   The purpose of this request is to build breaklist items pointing
{ into the code section of the object library.

  PROCEDURE construct_code_breaklist
    (    p_object_library: ^SEQ ( * );
         module_map: ^oct$module_map;
     VAR breaklist_seq_p: ^SEQ ( * );
     VAR breaklist_index: oct$breaklist_length);

    VAR
      breaklist_item: ^oct$breaklist_item,
      code_section_found: boolean,
      end_of_section_definitions: boolean,
      first_record: ^llt$object_text_descriptor,
      i: llt$module_index,
      j: llt$number_of_sections,
      object_library: ^SEQ ( * ),
      obsolete_segment_definition: ^llt$obsolete_segment_definition,
      section_definition: ^llt$section_definition,
      section_map: ^llt$section_map_items,
      segment_definition: ^llt$segment_definition;

    object_library := p_object_library;

    FOR i := 1 TO UPPERBOUND (module_map^) DO
      IF module_map^ [i].kind = llc$load_module THEN
        IF NOT module_map^ [i].bound_module THEN
          end_of_section_definitions := FALSE;
          IF module_map^ [i].section_definitions = NIL THEN
            RETURN;
          IFEND;
          RESET object_library TO module_map^ [i].section_definitions;
          REPEAT
            NEXT first_record IN object_library;
            CASE first_record^.kind OF
            = llc$section_definition, llc$unallocated_common_block =
              NEXT section_definition IN object_library;
            = llc$allotted_section_definition =
              NEXT section_definition IN object_library;
              IF section_definition^.kind = llc$code_section THEN
                NEXT breaklist_item IN breaklist_seq_p;
                breaklist_index := breaklist_index + 1;
                breaklist_item^.module_name := module_map^ [i].name;
                breaklist_item^.major_name := osc$null_name;
                breaklist_item^.minor_name := section_definition^.name;
                breaklist_item^.offset := first_record^.allotted_section;
                breaklist_item^.kind := occ$code;
                breaklist_item^.section_ordinal := module_map^ [i].
                      change_list^ [section_definition^.section_ordinal];
                breaklist_item^.secondary_section_ordinal := 0;
              IFEND;
            = llc$segment_definition =
              NEXT segment_definition IN object_library;
            = llc$allotted_segment_definition =
              NEXT segment_definition IN object_library;
              section_definition := ^segment_definition^.section_definition;
              IF section_definition^.kind = llc$code_section THEN
                NEXT breaklist_item IN breaklist_seq_p;
                breaklist_index := breaklist_index + 1;
                breaklist_item^.module_name := module_map^ [i].name;
                breaklist_item^.major_name := osc$null_name;
                breaklist_item^.minor_name := section_definition^.name;
                breaklist_item^.offset := first_record^.allotted_segment;
                breaklist_item^.kind := occ$code;
                breaklist_item^.section_ordinal := module_map^ [i].
                      change_list^ [section_definition^.section_ordinal];
                breaklist_item^.secondary_section_ordinal := 0;
              IFEND;

            = llc$obsolete_segment_definition =
              NEXT obsolete_segment_definition IN object_library;

            = llc$obsolete_allotted_seg_def =
              NEXT obsolete_segment_definition IN object_library;
              section_definition := ^obsolete_segment_definition^.section_definition;
              IF section_definition^.kind = llc$code_section THEN
                NEXT breaklist_item IN breaklist_seq_p;
                breaklist_index := breaklist_index + 1;
                breaklist_item^.module_name := module_map^ [i].name;
                breaklist_item^.major_name := osc$null_name;
                breaklist_item^.minor_name := section_definition^.name;
                breaklist_item^.offset := first_record^.allotted_segment;
                breaklist_item^.kind := occ$code;
                breaklist_item^.section_ordinal := module_map^ [i].
                      change_list^ [section_definition^.section_ordinal];
                breaklist_item^.secondary_section_ordinal := 0;
              IFEND;
            ELSE
              end_of_section_definitions := TRUE;
            CASEND;
          UNTIL end_of_section_definitions;
        ELSE
          code_section_found := FALSE;
          end_of_section_definitions := FALSE;
          IF module_map^ [i].section_definitions = NIL THEN
            RETURN;
          IFEND;
          RESET object_library TO module_map^ [i].section_definitions;
          REPEAT
            NEXT first_record IN object_library;
            CASE first_record^.kind OF
            = llc$section_definition, llc$unallocated_common_block =
              NEXT section_definition IN object_library;
            = llc$allotted_section_definition =
              NEXT section_definition IN object_library;
              IF section_definition^.kind = llc$code_section THEN
                code_section_found := TRUE;
                IF module_map^ [i].section_maps <> NIL THEN
                  section_map := #PTR (module_map^ [i].section_maps^ [section_definition^.section_ordinal].
                        map, object_library^);
                  FOR j := 1 TO module_map^ [i].section_maps^ [section_definition^.section_ordinal].
                        number_of_items DO
                    NEXT breaklist_item IN breaklist_seq_p;
                    breaklist_index := breaklist_index + 1;
                    breaklist_item^.module_name := module_map^ [i].name;
                    breaklist_item^.major_name := module_map^ [i].component_info^ [section_map^ [j].
                          component].name;
                    breaklist_item^.minor_name := section_map^ [j].name;
                    breaklist_item^.offset := first_record^.allotted_section + section_map^ [j].offset;
                    breaklist_item^.kind := occ$code;
                    breaklist_item^.section_ordinal := module_map^ [i].
                          change_list^ [section_definition^.section_ordinal];
                    breaklist_item^.secondary_section_ordinal := 0;
                  FOREND;
                IFEND;
              IFEND;
            ELSE
              end_of_section_definitions := TRUE;
            CASEND;
          UNTIL code_section_found OR end_of_section_definitions;
        IFEND;
      IFEND;
    FOREND;

  PROCEND construct_code_breaklist;
?? OLDTITLE ??
?? NEWTITLE := 'construct_dictionary_bl', EJECT ??

{ PURPOSE:
{   The purpose of this request is to build breaklist items pointing
{ to the beginning of the object library, and to all the dictionaries
{ in the object library.

  PROCEDURE construct_dictionary_bl
    (    p_object_library: ^SEQ ( * );
     VAR breaklist_seq_p: ^SEQ ( * );
     VAR breaklist_index: oct$breaklist_length;
     VAR status: ost$status);

    VAR
      breaklist_item: ^oct$breaklist_item,
      command_dictionary: ^llt$command_dictionary,
      entry_point_dictionary: ^llt$entry_point_dictionary,
      function_dictionary: ^llt$function_dictionary,
      help_module_dictionary: ^llt$help_module_dictionary,
      i: 0 .. llc$max_dictionaries_on_library,
      length: integer,
      message: string (100),
      message_module_dictionary: ^llt$message_module_dictionary,
      module_dictionary: ^llt$module_dictionary,
      object_library: ^SEQ ( * ),
      ol_dictionaries: ^llt$object_library_dictionaries,
      ol_header: ^llt$object_library_header,
      panel_dictionary: ^llt$panel_dictionary;

    object_library := p_object_library;

    NEXT breaklist_item IN breaklist_seq_p;
    breaklist_index := breaklist_index + 1;
    breaklist_item^.module_name := occ$starting_breaklist;
    breaklist_item^.major_name := osc$null_name;
    breaklist_item^.minor_name := osc$null_name;
    breaklist_item^.offset := 0;
    breaklist_item^.kind := occ$object_library_header;
    breaklist_item^.section_ordinal := 0;
    breaklist_item^.secondary_section_ordinal := 0;

    RESET object_library;
    NEXT ol_header IN object_library;
    NEXT ol_dictionaries: [1 .. ol_header^.number_of_dictionaries] IN object_library;

    FOR i := 1 TO ol_header^.number_of_dictionaries DO
      CASE ol_dictionaries^ [i].kind OF
      = llc$module_dictionary =
        module_dictionary := #PTR (ol_dictionaries^ [i].module_dictionary, object_library^);
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := occ$module_dictionary;
        breaklist_item^.major_name := osc$null_name;
        breaklist_item^.minor_name := osc$null_name;
        breaklist_item^.offset := #OFFSET (module_dictionary);
        breaklist_item^.kind := occ$dictionary;
        breaklist_item^.section_ordinal := 0;
        breaklist_item^.secondary_section_ordinal := 0;

      = llc$entry_point_dictionary =
        entry_point_dictionary := #PTR (ol_dictionaries^ [i].entry_point_dictionary, object_library^);
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := occ$entry_point_dictionary;
        breaklist_item^.major_name := osc$null_name;
        breaklist_item^.minor_name := osc$null_name;
        breaklist_item^.offset := #OFFSET (entry_point_dictionary);
        breaklist_item^.kind := occ$dictionary;
        breaklist_item^.section_ordinal := 0;
        breaklist_item^.secondary_section_ordinal := 0;

      = llc$command_dictionary =
        command_dictionary := #PTR (ol_dictionaries^ [i].command_dictionary, object_library^);
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := occ$command_dictionary;
        breaklist_item^.major_name := osc$null_name;
        breaklist_item^.minor_name := osc$null_name;
        breaklist_item^.offset := #OFFSET (command_dictionary);
        breaklist_item^.kind := occ$dictionary;
        breaklist_item^.section_ordinal := 0;
        breaklist_item^.secondary_section_ordinal := 0;

      = llc$function_dictionary =
        function_dictionary := #PTR (ol_dictionaries^ [i].function_dictionary, object_library^);
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := occ$function_dictionary;
        breaklist_item^.major_name := osc$null_name;
        breaklist_item^.minor_name := osc$null_name;
        breaklist_item^.offset := #OFFSET (function_dictionary);
        breaklist_item^.kind := occ$dictionary;
        breaklist_item^.section_ordinal := 0;
        breaklist_item^.secondary_section_ordinal := 0;

      = llc$help_module_dictionary =
        help_module_dictionary := #PTR (ol_dictionaries^ [i].help_module_dictionary, object_library^);
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := occ$help_module_dictionary;
        breaklist_item^.major_name := osc$null_name;
        breaklist_item^.minor_name := osc$null_name;
        breaklist_item^.offset := #OFFSET (help_module_dictionary);
        breaklist_item^.kind := occ$dictionary;
        breaklist_item^.section_ordinal := 0;
        breaklist_item^.secondary_section_ordinal := 0;

      = llc$message_module_dictionary =
        message_module_dictionary := #PTR (ol_dictionaries^ [i].message_module_dictionary, object_library^);
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := occ$message_module_dictionary;
        breaklist_item^.major_name := osc$null_name;
        breaklist_item^.minor_name := osc$null_name;
        breaklist_item^.offset := #OFFSET (message_module_dictionary);
        breaklist_item^.kind := occ$dictionary;
        breaklist_item^.section_ordinal := 0;
        breaklist_item^.secondary_section_ordinal := 0;

      = llc$panel_dictionary =
        panel_dictionary := #PTR (ol_dictionaries^ [i].panel_dictionary, object_library^);
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := occ$panel_dictionary;
        breaklist_item^.major_name := osc$null_name;
        breaklist_item^.minor_name := osc$null_name;
        breaklist_item^.offset := #OFFSET (panel_dictionary);
        breaklist_item^.kind := occ$dictionary;
        breaklist_item^.section_ordinal := 0;
        breaklist_item^.secondary_section_ordinal := 0;

      ELSE
        STRINGREP (message, length, ol_dictionaries^ [i].kind);
        osp$set_status_abnormal (occ$status_id, oce$unexpected_record_kind, message (1, length), status);
        RETURN;
      CASEND;
    FOREND;

  PROCEND construct_dictionary_bl;
?? OLDTITLE ??
?? NEWTITLE := 'construct_information_bl', EJECT ??

{ PURPOSE:
{   The purpose of this request is to build breaklist items pointing
{ into the information element of the object library.

  PROCEDURE construct_information_bl
    (    p_object_library: ^SEQ ( * );
         module_map: ^oct$module_map;
         original_object_library: boolean;
         p_int_ol: ^SEQ ( * );
     VAR breaklist_seq_p: ^SEQ ( * );
     VAR breaklist_index: oct$breaklist_length);

    VAR
      address_name: ost$name,
      binding_template_int: ^llt$binding_section_template,
      binding_templates: ^llt$binding_section_template,
      breaklist_item: ^oct$breaklist_item,
      found: boolean,
      i: llt$module_index,
      info_element_header: ^llt$info_element_header,
      information_element: llt$info_element_header,
      int_ol: ^SEQ ( * ),
      j: 0 .. llc$max_rel_items,
      k: llt$number_of_sections,
      l: llt$number_of_sections,
      load_module_header: ^llt$load_module_header,
      module_dictionary: ^llt$module_dictionary,
      object_library: ^SEQ ( * ),
      object_library_dictionaries: ^llt$object_library_dictionaries,
      object_library_header: ^llt$object_library_header,
      relocation_int: ^llt$relocation,
      relocation_ptr: ^llt$relocation,
      section_map_items: ^llt$section_map_items,
      section_maps: ^llt$section_maps;

?? NEWTITLE := '[INLINE] convert_address_type_to_name', EJECT ??
    PROCEDURE [INLINE] convert_address_type_to_name
      (    address_type: llt$address_type;
       VAR address_name: ost$name);

      CASE address_type OF
      = llc$byte_positive =
        address_name := 'BYTE_POSITIVE';
      = llc$two_byte_positive =
        address_name := 'TWO_BYTE_POSITIVE';
      = llc$four_byte_positive =
        address_name := 'FOUR_BYTE_POSITIVE';
      = llc$eight_byte_positive =
        address_name := 'EIGHT_BYTE_POSITIVE';
      = llc$byte_signed =
        address_name := 'BYTE_SIGNED';
      = llc$two_byte_signed =
        address_name := 'TWO_BYTE_SIGNED';
      = llc$four_byte_signed =
        address_name := 'FOUR_BYTE_SIGNED';
      = llc$eight_byte_signed =
        address_name := 'EIGHT_BYTE_SIGNED';
      ELSE
      CASEND;

    PROCEND convert_address_type_to_name;
?? OLDTITLE ??
?? EJECT ??
    object_library := p_object_library;
    int_ol := p_int_ol;

    RESET object_library;
    NEXT object_library_header IN object_library;
    NEXT object_library_dictionaries: [1 .. object_library_header^.number_of_dictionaries] IN object_library;
    found := FALSE;
    i := 1;
    WHILE NOT found AND (i <= object_library_header^.number_of_dictionaries) DO
      IF object_library_dictionaries^ [i].kind = llc$module_dictionary THEN
        found := TRUE
      ELSE
        i := i + 1;
      IFEND;
    WHILEND;
    IF NOT found THEN
      RETURN;
    IFEND;
    module_dictionary := #PTR (object_library_dictionaries^ [i].module_dictionary, object_library^);
    FOR i := 1 TO UPPERBOUND (module_dictionary^) DO
      IF module_dictionary^ [i].kind = llc$load_module THEN
        load_module_header := #PTR (module_dictionary^ [i].module_header, object_library^);
        IF llc$information_element IN load_module_header^.elements_defined THEN
          info_element_header := #PTR (load_module_header^.information_element, object_library^);
          NEXT breaklist_item IN breaklist_seq_p;
          breaklist_index := breaklist_index + 1;
          breaklist_item^.module_name := module_map^ [i].name;
          breaklist_item^.major_name := occ$info_element_header;
          breaklist_item^.minor_name := osc$null_name;
          breaklist_item^.offset := #OFFSET (info_element_header);
          breaklist_item^.kind := occ$info_element;
          breaklist_item^.section_ordinal := 0;
          breaklist_item^.secondary_section_ordinal := 0;

          IF info_element_header^.version = llc$info_element_version THEN
            information_element := info_element_header^;
          ELSE
            ocp$convert_information_element (info_element_header, information_element);
          IFEND;

          IF information_element.number_of_rel_items > 0 THEN
            relocation_ptr := #PTR (information_element.relocation_ptr, object_library^);
            IF original_object_library THEN
              relocation_int := #PTR (information_element.relocation_ptr, int_ol^);
            IFEND;
            FOR j := 1 TO information_element.number_of_rel_items DO
              NEXT breaklist_item IN breaklist_seq_p;
              breaklist_index := breaklist_index + 1;
              breaklist_item^.module_name := module_map^ [i].name;
              convert_address_type_to_name (relocation_ptr^ [j].address, address_name);
              breaklist_item^.major_name := address_name;
              breaklist_item^.minor_name := osc$null_name;
              breaklist_item^.offset := #OFFSET (^relocation_ptr^ [j]);
              breaklist_item^.kind := occ$rel;
              breaklist_item^.section_ordinal := module_map^ [i].change_list^ [relocation_ptr^ [j].
                    section_ordinal];
              IF original_object_library THEN
                breaklist_item^.secondary_section_ordinal := relocation_int^ [j].offset;
              ELSE
                breaklist_item^.secondary_section_ordinal := relocation_ptr^ [j].offset;
              IFEND;
            FOREND;
          IFEND;

          IF information_element.number_of_template_items > 0 THEN
            binding_templates := #PTR (information_element.binding_template_ptr, object_library^);
            IF original_object_library THEN
              binding_template_int := #PTR (information_element.binding_template_ptr, int_ol^);
            IFEND;
            FOR j := 1 TO information_element.number_of_template_items DO
              NEXT breaklist_item IN breaklist_seq_p;
              breaklist_index := breaklist_index + 1;
              breaklist_item^.module_name := module_map^ [i].name;
              breaklist_item^.major_name := occ$binding_template_records;
              breaklist_item^.offset := #OFFSET (^binding_templates^ [j]);
              breaklist_item^.kind := occ$bti;
              IF binding_templates^ [j].kind = llc$current_module THEN
                breaklist_item^.minor_name := osc$null_name;
                breaklist_item^.section_ordinal := module_map^ [i].change_list^ [binding_templates^ [j].
                      section_ordinal];
                IF original_object_library THEN
                  breaklist_item^.secondary_section_ordinal := binding_template_int^ [j].offset;
                ELSE
                  breaklist_item^.secondary_section_ordinal := binding_templates^ [j].offset;
                IFEND;
              ELSEIF binding_templates^ [j].kind = llc$external_reference THEN
                breaklist_item^.minor_name := binding_templates^ [j].name;
                breaklist_item^.section_ordinal := 0;
                breaklist_item^.secondary_section_ordinal := 0;
              IFEND;
            FOREND;
          IFEND;

          IF module_map^ [i].bound_module THEN
            IF information_element.number_of_components > 0 THEN
              FOR k := 1 TO information_element.number_of_components DO
                NEXT breaklist_item IN breaklist_seq_p;
                breaklist_index := breaklist_index + 1;
                breaklist_item^.module_name := module_map^ [i].name;
                breaklist_item^.major_name := occ$component_header;
                breaklist_item^.minor_name := module_map^ [i].component_info^ [k].name;
                breaklist_item^.offset := #OFFSET (^module_map^ [i].component_info^ [k]);
                breaklist_item^.kind := occ$component;
                breaklist_item^.section_ordinal := 0;
                breaklist_item^.secondary_section_ordinal := 0;
              FOREND;
            IFEND;

            IF information_element.number_of_section_maps > 0 THEN
              section_maps := #PTR (information_element.section_maps, object_library^);
              FOR k := 0 TO information_element.number_of_section_maps - 1 DO
                NEXT breaklist_item IN breaklist_seq_p;
                breaklist_index := breaklist_index + 1;
                breaklist_item^.module_name := module_map^ [i].name;
                breaklist_item^.major_name := occ$section_map_header;
                breaklist_item^.minor_name := osc$null_name;
                breaklist_item^.offset := #OFFSET (^section_maps^ [k]);
                breaklist_item^.kind := occ$section_map;
                breaklist_item^.section_ordinal := module_map^ [i].change_list^ [k];
                breaklist_item^.secondary_section_ordinal := 0;
              FOREND;
              FOR k := 0 TO information_element.number_of_section_maps - 1 DO
                section_map_items := #PTR (section_maps^ [k].map, object_library^);
                FOR l := 1 TO section_maps^ [k].number_of_items DO
                  NEXT breaklist_item IN breaklist_seq_p;
                  breaklist_index := breaklist_index + 1;
                  breaklist_item^.module_name := module_map^ [i].name;
                  IF module_map^ [i].component_info <> NIL THEN
                    breaklist_item^.major_name := module_map^ [i].component_info^ [section_map_items^ [l].
                          component].name;
                  ELSE
                    breaklist_item^.major_name := osc$null_name;
                  IFEND;
                  breaklist_item^.minor_name := section_map_items^ [l].name;
                  breaklist_item^.offset := #OFFSET (^section_map_items^ [l]);
                  breaklist_item^.kind := occ$section_map;
                  breaklist_item^.section_ordinal := module_map^ [i].change_list^ [k];
                  breaklist_item^.secondary_section_ordinal := 0;
                FOREND;
              FOREND;
            IFEND;
          IFEND;
        IFEND;
      IFEND;
    FOREND;

  PROCEND construct_information_bl;
?? OLDTITLE ??
?? NEWTITLE := 'construct_interpretive_bl', EJECT ??

{ PURPOSE:
{   The purpose of this request is to build breaklist items pointing
{ into the interpretive element of the object library.

  PROCEDURE construct_interpretive_bl
    (    p_object_library: ^SEQ ( * );
         module_map: ^oct$module_map;
     VAR breaklist_seq_p: ^SEQ ( * );
     VAR breaklist_index: oct$breaklist_length;
     VAR status: ost$status);

    VAR
      application_member_header: ^llt$application_member_header,
      breaklist_item: ^oct$breaklist_item,
      found: boolean,
      i: llt$module_index,
      interpretive_element: ^llt$object_text_descriptor,
      load_module_header: ^llt$load_module_header,
      member_header: ^llt$library_member_header,
      message_header: ^llt$library_member_header,
      module_dictionary: ^llt$module_dictionary,
      object_library: ^SEQ ( * ),
      object_library_dictionaries: ^llt$object_library_dictionaries,
      object_library_header: ^llt$object_library_header;

    status.normal := TRUE;

    object_library := p_object_library;

    RESET object_library;
    NEXT object_library_header IN object_library;
    NEXT object_library_dictionaries: [1 .. object_library_header^.number_of_dictionaries] IN object_library;
    found := FALSE;
    i := 1;
    WHILE NOT found AND (i <= object_library_header^.number_of_dictionaries) DO
      IF object_library_dictionaries^ [i].kind = llc$module_dictionary THEN
        found := TRUE
      ELSE
        i := i + 1;
      IFEND;
    WHILEND;
    IF NOT found THEN
      RETURN;
    IFEND;

    module_dictionary := #PTR (object_library_dictionaries^ [i].module_dictionary, object_library^);
    FOR i := 1 TO UPPERBOUND (module_dictionary^) DO
      CASE module_dictionary^ [i].kind OF
      = llc$load_module =
        load_module_header := #PTR (module_dictionary^ [i].module_header, object_library^);
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := module_map^ [i].name;
        breaklist_item^.major_name := occ$load_module_header;
        breaklist_item^.minor_name := osc$null_name;
        breaklist_item^.offset := #OFFSET (load_module_header);
        breaklist_item^.kind := occ$module_header;
        breaklist_item^.section_ordinal := 0;
        breaklist_item^.secondary_section_ordinal := 0;

        IF llc$interpretive_element IN load_module_header^.elements_defined THEN
          interpretive_element := #PTR (load_module_header^.interpretive_element, object_library^);

          build_load_module_breaklist (module_map^ [i], object_library, interpretive_element, breaklist_seq_p,
                breaklist_index, status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;
        IFEND;
      = llc$command_procedure =
        member_header := #PTR (module_dictionary^ [i].command_header, object_library^);
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := module_map^ [i].name;
        breaklist_item^.major_name := occ$command_header;
        breaklist_item^.minor_name := osc$null_name;
        breaklist_item^.offset := #OFFSET (member_header);
        breaklist_item^.kind := occ$command_proc;
        breaklist_item^.section_ordinal := 0;
        breaklist_item^.secondary_section_ordinal := 0;

      = llc$program_description =
        member_header := #PTR (module_dictionary^ [i].program_header, object_library^);
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := module_map^ [i].name;
        breaklist_item^.major_name := occ$program_header;
        breaklist_item^.minor_name := osc$null_name;
        breaklist_item^.offset := #OFFSET (member_header);
        breaklist_item^.kind := occ$program_des;
        breaklist_item^.section_ordinal := 0;
        breaklist_item^.secondary_section_ordinal := 0;

      = llc$function_procedure =
        member_header := #PTR (module_dictionary^ [i].function_header, object_library^);
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := module_map^ [i].name;
        breaklist_item^.major_name := occ$function_header;
        breaklist_item^.minor_name := osc$null_name;
        breaklist_item^.offset := #OFFSET (member_header);
        breaklist_item^.kind := occ$function_proc;
        breaklist_item^.section_ordinal := 0;
        breaklist_item^.secondary_section_ordinal := 0;

      = llc$command_description =
        member_header := #PTR (module_dictionary^ [i].command_description_header, object_library^);
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := module_map^ [i].name;
        breaklist_item^.major_name := occ$command_description_header;
        breaklist_item^.minor_name := osc$null_name;
        breaklist_item^.offset := #OFFSET (member_header);
        breaklist_item^.kind := occ$command_des;
        breaklist_item^.section_ordinal := 0;
        breaklist_item^.secondary_section_ordinal := 0;

      = llc$function_description =
        member_header := #PTR (module_dictionary^ [i].function_description_header, object_library^);
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := module_map^ [i].name;
        breaklist_item^.major_name := occ$function_description_header;
        breaklist_item^.minor_name := osc$null_name;
        breaklist_item^.offset := #OFFSET (member_header);
        breaklist_item^.kind := occ$function_des;
        breaklist_item^.section_ordinal := 0;
        breaklist_item^.secondary_section_ordinal := 0;

      = llc$message_module { and llc$help_module} =
        message_header := #PTR (module_dictionary^ [i].message_header, object_library^);
        construct_mtm_breaklist (message_header, module_dictionary^ [i].name, object_library, breaklist_seq_p,
              breaklist_index);
      = llc$panel_module =
        member_header := #PTR (module_dictionary^ [i].panel_header, object_library^);
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := module_map^ [i].name;
        breaklist_item^.major_name := occ$panel_header;
        breaklist_item^.minor_name := osc$null_name;
        breaklist_item^.offset := #OFFSET (member_header);
        breaklist_item^.kind := occ$panel_mod;
        breaklist_item^.section_ordinal := 0;
        breaklist_item^.secondary_section_ordinal := 0;

      = llc$applic_command_procedure =
        application_member_header := #PTR (module_dictionary^ [i].applic_command_header, object_library^);
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := module_map^ [i].name;
        breaklist_item^.major_name := occ$command_header;
        breaklist_item^.minor_name := osc$null_name;
        breaklist_item^.offset := #OFFSET (application_member_header);
        breaklist_item^.kind := occ$app_command_proc;
        breaklist_item^.section_ordinal := 0;
        breaklist_item^.secondary_section_ordinal := 0;

      = llc$applic_program_description =
        application_member_header := #PTR (module_dictionary^ [i].applic_program_header, object_library^);
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := module_map^ [i].name;
        breaklist_item^.major_name := occ$program_header;
        breaklist_item^.minor_name := osc$null_name;
        breaklist_item^.offset := #OFFSET (application_member_header);
        breaklist_item^.kind := occ$app_program_des;
        breaklist_item^.section_ordinal := 0;
        breaklist_item^.secondary_section_ordinal := 0;

      = llc$applic_command_description =
        application_member_header := #PTR (module_dictionary^ [i].applic_command_description_hdr,
              object_library^);
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := module_map^ [i].name;
        breaklist_item^.major_name := occ$command_description_header;
        breaklist_item^.minor_name := osc$null_name;
        breaklist_item^.offset := #OFFSET (application_member_header);
        breaklist_item^.kind := occ$app_command_des;
        breaklist_item^.section_ordinal := 0;
        breaklist_item^.secondary_section_ordinal := 0;

      ELSE
        ;
      CASEND;
    FOREND;

  PROCEND construct_interpretive_bl;
?? OLDTITLE ??
?? NEWTITLE := 'construct_mtm_breaklist', EJECT ??

{ PURPOSE:
{   The purpose of this request is to build breaklist items for
{   a message template or a help module.

  PROCEDURE construct_mtm_breaklist
    (    message_header: ^llt$library_member_header;
         module_name: pmt$program_name;
         p_object_library: ^SEQ ( * );
     VAR breaklist_seq_p: ^SEQ ( * );
     VAR breaklist_index: oct$breaklist_length);

    VAR
      breaklist_item: ^oct$breaklist_item,
      code: ost$name,
      condition_codes: ^ost$mtm_condition_codes,
      condition_names: ^ost$mtm_condition_names,
      k: 0 .. osc$max_status_condition_code + 1,
      member: ^SEQ ( * ),
      member_header: ^SEQ ( * ),
      mtm_header: ^ost$mtm_header,
      object_library: ^SEQ ( * ),
      size: integer,
      template: ^ost$message_template;

    object_library := p_object_library;

    NEXT breaklist_item IN breaklist_seq_p;
    breaklist_index := breaklist_index + 1;
    breaklist_item^.module_name := module_name;
    breaklist_item^.major_name := occ$message_template_module;
    breaklist_item^.minor_name := osc$null_name;
    breaklist_item^.offset := #OFFSET (message_header);
    breaklist_item^.kind := occ$library_member_header;
    breaklist_item^.section_ordinal := 0;
    breaklist_item^.secondary_section_ordinal := 0;

    member_header := #PTR (message_header^.member, object_library^);
    NEXT breaklist_item IN breaklist_seq_p;
    breaklist_index := breaklist_index + 1;
    breaklist_item^.module_name := module_name;
    breaklist_item^.major_name := message_header^.name;
    breaklist_item^.minor_name := osc$null_name;
    breaklist_item^.offset := #OFFSET (member_header);
    breaklist_item^.kind := occ$mtm_header;
    breaklist_item^.section_ordinal := 0;
    breaklist_item^.secondary_section_ordinal := 0;

    RESET object_library TO member_header;
    NEXT member: [[REP message_header^.member_size OF cell]] IN object_library;
    RESET member;
    NEXT mtm_header IN member;
    IF mtm_header^.number_of_codes > 0 THEN
      NEXT condition_codes: [0 .. mtm_header^.number_of_codes - 1] IN member;

      FOR k := 0 TO mtm_header^.number_of_codes - 1 DO
        STRINGREP (code, size, condition_codes^ [k].code);
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := module_name;
        breaklist_item^.major_name := occ$mtm_condition_code;
        breaklist_item^.minor_name := code (1, size);
        breaklist_item^.offset := #OFFSET (^condition_codes^ [k]);
        breaklist_item^.kind := occ$mtm_cc;
        breaklist_item^.section_ordinal := 0;
        breaklist_item^.secondary_section_ordinal := 0;
      FOREND;
    IFEND;

    IF mtm_header^.number_of_names > 0 THEN
      NEXT condition_names: [0 .. mtm_header^.number_of_names - 1] IN member;
      FOR k := 0 TO mtm_header^.number_of_names - 1 DO
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := module_name;
        breaklist_item^.major_name := occ$mtm_condition_name;
        breaklist_item^.minor_name := condition_names^ [k].name;
        breaklist_item^.offset := #OFFSET (^condition_names^ [k]);
        breaklist_item^.kind := occ$mtm_cn;
        breaklist_item^.section_ordinal := 0;
        breaklist_item^.secondary_section_ordinal := 0;
      FOREND;

      FOR k := 0 TO mtm_header^.number_of_names - 1 DO
        template := #PTR (condition_names^ [k].template, member^);
        NEXT breaklist_item IN breaklist_seq_p;
        breaklist_index := breaklist_index + 1;
        breaklist_item^.module_name := module_name;
        breaklist_item^.major_name := occ$message_template;
        breaklist_item^.minor_name := condition_names^ [k].name;
        breaklist_item^.offset := #OFFSET (template);
        breaklist_item^.kind := occ$mess_temp;
        breaklist_item^.section_ordinal := 0;
        breaklist_item^.secondary_section_ordinal := 0;
      FOREND;
    IFEND;

  PROCEND construct_mtm_breaklist;
?? OLDTITLE ??
?? NEWTITLE := 'construct_read_breaklist', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to construct breaklist items in
{ the working storage sections of the object library.

  PROCEDURE construct_read_breaklist
    (    p_object_library: ^SEQ ( * );
         module_map: ^oct$module_map;
     VAR breaklist_seq_p: ^SEQ ( * );
     VAR breaklist_index: oct$breaklist_length);

    VAR
      breaklist_item: ^oct$breaklist_item,
      first_record: ^llt$object_text_descriptor,
      i: llt$module_index,
      j: llt$number_of_sections,
      no_more_section_definitions: boolean,
      object_library: ^SEQ ( * ),
      obsolete_segment_definition: ^llt$obsolete_segment_definition,
      section_definition: ^llt$section_definition,
      section_map: ^llt$section_map_items,
      segment_definition: ^llt$segment_definition;

    object_library := p_object_library;

    FOR i := 1 TO UPPERBOUND (module_map^) DO
      IF module_map^ [i].kind = llc$load_module THEN
        no_more_section_definitions := FALSE;
        IF module_map^ [i].section_definitions = NIL THEN
          RETURN;
        IFEND;
        RESET object_library TO module_map^ [i].section_definitions;
        REPEAT
          NEXT first_record IN object_library;
          CASE first_record^.kind OF
          = llc$section_definition, llc$unallocated_common_block =
            NEXT section_definition IN object_library;
          = llc$allotted_section_definition =
            NEXT section_definition IN object_library;
            IF section_definition^.kind = llc$working_storage_section THEN
              IF module_map^ [i].bound_module THEN
                IF module_map^ [i].section_maps <> NIL THEN
                  section_map := #PTR (module_map^ [i].section_maps^ [section_definition^.section_ordinal].
                        map, object_library^);
                  FOR j := 1 TO module_map^ [i].section_maps^ [section_definition^.section_ordinal].
                        number_of_items DO
                    IF section_map^ [j].length > 0 THEN
                      NEXT breaklist_item IN breaklist_seq_p;
                      breaklist_index := breaklist_index + 1;
                      breaklist_item^.module_name := module_map^ [i].name;
                      breaklist_item^.major_name := module_map^ [i].component_info^ [section_map^ [j].
                            component].name;
                      breaklist_item^.minor_name := section_definition^.name;
                      breaklist_item^.offset := first_record^.allotted_section + section_map^ [j].offset;
                      breaklist_item^.kind := occ$read;
                      breaklist_item^.section_ordinal := module_map^ [i].
                            change_list^ [section_definition^.section_ordinal];
                      breaklist_item^.secondary_section_ordinal := 0;
                    IFEND;
                  FOREND;
                IFEND;
              ELSE
                NEXT breaklist_item IN breaklist_seq_p;
                breaklist_index := breaklist_index + 1;
                breaklist_item^.module_name := module_map^ [i].name;
                breaklist_item^.major_name := osc$null_name;
                breaklist_item^.minor_name := section_definition^.name;
                breaklist_item^.offset := first_record^.allotted_section;
                breaklist_item^.kind := occ$read;
                breaklist_item^.section_ordinal := module_map^ [i].
                      change_list^ [section_definition^.section_ordinal];
                breaklist_item^.secondary_section_ordinal := 0;
              IFEND;
            IFEND;
          = llc$segment_definition =
            NEXT segment_definition IN object_library;
          = llc$allotted_segment_definition =
            NEXT segment_definition IN object_library;
            section_definition := ^segment_definition^.section_definition;
            IF section_definition^.kind = llc$working_storage_section THEN
              IF module_map^ [i].bound_module THEN
                IF module_map^ [i].section_maps <> NIL THEN
                  section_map := #PTR (module_map^ [i].section_maps^ [section_definition^.section_ordinal].
                        map, object_library^);
                  FOR j := 1 TO module_map^ [i].section_maps^ [section_definition^.section_ordinal].
                        number_of_items DO
                    IF section_map^ [j].length > 0 THEN
                      NEXT breaklist_item IN breaklist_seq_p;
                      breaklist_index := breaklist_index + 1;
                      breaklist_item^.module_name := module_map^ [i].name;
                      breaklist_item^.major_name := module_map^ [i].component_info^ [section_map^ [j].
                            component].name;
                      breaklist_item^.minor_name := section_definition^.name;
                      breaklist_item^.offset := first_record^.allotted_segment + section_map^ [j].offset;
                      breaklist_item^.kind := occ$read;
                      breaklist_item^.section_ordinal := module_map^ [i].
                            change_list^ [section_definition^.section_ordinal];
                      breaklist_item^.secondary_section_ordinal := 0;
                    IFEND;
                  FOREND;
                IFEND;
              ELSE
                NEXT breaklist_item IN breaklist_seq_p;
                breaklist_index := breaklist_index + 1;
                breaklist_item^.module_name := module_map^ [i].name;
                breaklist_item^.major_name := osc$null_name;
                breaklist_item^.minor_name := section_definition^.name;
                breaklist_item^.offset := first_record^.allotted_segment;
                breaklist_item^.kind := occ$read;
                breaklist_item^.section_ordinal := module_map^ [i].
                      change_list^ [section_definition^.section_ordinal];
                breaklist_item^.secondary_section_ordinal := 0;
              IFEND;
            IFEND;
          = llc$obsolete_segment_definition =
            NEXT obsolete_segment_definition IN object_library;
          = llc$obsolete_allotted_seg_def =
            NEXT obsolete_segment_definition IN object_library;
            section_definition := ^obsolete_segment_definition^.section_definition;
            IF section_definition^.kind = llc$working_storage_section THEN
              IF module_map^ [i].bound_module THEN
                IF module_map^ [i].section_maps <> NIL THEN
                  section_map := #PTR (module_map^ [i].section_maps^ [section_definition^.section_ordinal].
                        map, object_library^);
                  FOR j := 1 TO module_map^ [i].section_maps^ [section_definition^.section_ordinal].
                        number_of_items DO
                    IF section_map^ [j].length > 0 THEN
                      NEXT breaklist_item IN breaklist_seq_p;
                      breaklist_index := breaklist_index + 1;
                      breaklist_item^.module_name := module_map^ [i].name;
                      breaklist_item^.major_name := module_map^ [i].component_info^ [section_map^ [j].
                            component].name;
                      breaklist_item^.minor_name := section_definition^.name;
                      breaklist_item^.offset := first_record^.allotted_segment + section_map^ [j].offset;
                      breaklist_item^.kind := occ$read;
                      breaklist_item^.section_ordinal := module_map^ [i].
                            change_list^ [section_definition^.section_ordinal];
                      breaklist_item^.secondary_section_ordinal := 0;
                    IFEND;
                  FOREND;
                IFEND;
              ELSE
                NEXT breaklist_item IN breaklist_seq_p;
                breaklist_index := breaklist_index + 1;
                breaklist_item^.module_name := module_map^ [i].name;
                breaklist_item^.major_name := osc$null_name;
                breaklist_item^.minor_name := section_definition^.name;
                breaklist_item^.offset := first_record^.allotted_segment;
                breaklist_item^.kind := occ$read;
                breaklist_item^.section_ordinal := module_map^ [i].
                      change_list^ [section_definition^.section_ordinal];
                breaklist_item^.secondary_section_ordinal := 0;
              IFEND;
            IFEND;
          ELSE
            no_more_section_definitions := TRUE;
          CASEND;
        UNTIL no_more_section_definitions;
      IFEND;
    FOREND;

  PROCEND construct_read_breaklist;
?? OLDTITLE ??
?? NEWTITLE := 'find_text_records', EJECT ??

{ PURPOSE:
{   The purpose of this request is to build breaklist items pointing
{ to the text records in a bound object library.

  PROCEDURE find_text_records
    (    object_library: ^SEQ ( * );
         section_ordinal: llt$section_ordinal;
         section_name: pmt$program_name;
         current_module: oct$module_map_item;
     VAR breaklist_seq_p: ^SEQ ( * );
     VAR breaklist_index: oct$breaklist_length;
     VAR status: ost$status);

    VAR
      breaklist_item: ^oct$breaklist_item,
      bsi: ^llt$bit_string_insertion,
      found: boolean,
      i: llt$number_of_sections,
      object_text_descriptor: ^llt$object_text_descriptor,
      offset: integer,
      replication: ^llt$replication,
      section_map: ^llt$section_map_items,
      text: ^llt$text;

    status.normal := TRUE;

    object_text_descriptor := current_module.section_definitions;
    section_map := #PTR (current_module.section_maps^ [section_ordinal].map, object_library^);
    FOR i := 1 TO current_module.section_maps^ [section_ordinal].number_of_items DO
      IF section_map^ [i].length > 0 THEN
        offset := 0;
        found := TRUE;
        WHILE found AND (offset = 0) DO
          get_next_text_rep_bsi (section_ordinal, object_library, found, object_text_descriptor, text,
                replication, bsi, status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;
          IF NOT found THEN
            object_text_descriptor := current_module.section_definitions;
          ELSE
            IF object_text_descriptor^.kind = llc$bit_string_insertion THEN
              IF section_map^ [i].offset <= bsi^.offset THEN
                offset := #OFFSET (object_text_descriptor);
              ELSEIF (section_map^ [i].offset > bsi^.offset) AND
                    (section_map^ [i].offset < (bsi^.offset + ((bsi^.bit_length + bsi^.bit_offset) DIV 8)))
                    THEN
                osp$set_status_abnormal (occ$status_id, oce$section_map_invalid_pointer,
                      'bit_string_insertion', status);
                RETURN;
              IFEND;
            ELSEIF object_text_descriptor^.kind = llc$replication THEN
              IF section_map^ [i].offset <= replication^.offset THEN
                offset := #OFFSET (object_text_descriptor);
              ELSEIF (section_map^ [i].offset > replication^.offset) AND
                    (section_map^ [i].offset < (replication^.offset +
                    object_text_descriptor^.number_of_bytes)) THEN
                osp$set_status_abnormal (occ$status_id, oce$section_map_invalid_pointer, 'replication',
                      status);
                RETURN;
              IFEND;
            ELSEIF object_text_descriptor^.kind = llc$text THEN
              IF section_map^ [i].offset <= text^.offset THEN
                offset := #OFFSET (object_text_descriptor);
              ELSEIF (section_map^ [i].offset > text^.offset) AND
                    (section_map^ [i].offset < (text^.offset + object_text_descriptor^.number_of_bytes)) THEN
                offset := #OFFSET (^text^.byte) + section_map^ [i].offset - text^.offset;
              IFEND;
            IFEND;
          IFEND;
        WHILEND;
        IF offset <> 0 THEN
          NEXT breaklist_item IN breaklist_seq_p;
          breaklist_index := breaklist_index + 1;
          breaklist_item^.module_name := current_module.name;
          breaklist_item^.major_name := current_module.component_info^ [section_map^ [i].component].name;
          breaklist_item^.minor_name := section_name;
          breaklist_item^.offset := offset;
          breaklist_item^.kind := occ$text;
          breaklist_item^.section_ordinal := current_module.change_list^ [section_ordinal];
          breaklist_item^.secondary_section_ordinal := 0;
        IFEND;
      IFEND;
    FOREND;
  PROCEND find_text_records;
?? OLDTITLE ??
?? NEWTITLE := 'get_next_text_rep_bsi', EJECT ??

{ PURPOSE:
{   The purpose of this request is find the next text, replication or
{ bit string insertion record pair having the given section ordinal.

  PROCEDURE get_next_text_rep_bsi
    (    section_ordinal: llt$section_ordinal;
         p_object_library: ^SEQ ( * );
     VAR found: boolean;
     VAR object_text_descriptor: ^llt$object_text_descriptor;
     VAR text: ^llt$text;
     VAR replication: ^llt$replication;
     VAR bsi: ^llt$bit_string_insertion;
     VAR status: ost$status);

    VAR
      actual_parameters: ^llt$actual_parameters,
      adr: ^llt$address_formulation,
      binding_template: ^llt$binding_template,
      debug_table_fragment: ^llt$debug_table_fragment,
      deferred_common_blocks: ^llt$deferred_common_blocks,
      deferred_entry_points: ^llt$deferred_entry_points,
      entry_definition: ^llt$entry_definition,
      external_linkage: ^llt$external_linkage,
      formal_parameters: ^llt$formal_parameters,
      length: integer,
      libraries: ^llt$libraries,
      line_address_table: ^llt$line_address_table,
      m68000_absolute: ^llt$68000_absolute,
      message: string (100),
      object_library: ^SEQ ( * ),
      obsolete_formal_parameters: ^llt$obsolete_formal_parameters,
      obsolete_line_address_table: ^llt$obsolete_line_address_table,
      obsolete_segment_definition: ^llt$obsolete_segment_definition,
      ppu_absolute: ^llt$ppu_absolute,
      relocation: ^llt$relocation,
      section_definition: ^llt$section_definition,
      segment_definition: ^llt$segment_definition,
      supplemental_debug_tables: ^llt$supplemental_debug_tables,
      symbol_table: ^llt$symbol_table;

    status.normal := TRUE;

    object_library := p_object_library;

{ Skip over the the already processed object library record pair.

    found := FALSE;
    RESET object_library TO object_text_descriptor;
    NEXT object_text_descriptor IN object_library;
    CASE object_text_descriptor^.kind OF
    = llc$section_definition, llc$allotted_section_definition, llc$unallocated_common_block =
      NEXT section_definition IN object_library;
    = llc$segment_definition, llc$allotted_segment_definition =
      NEXT segment_definition IN object_library;
    = llc$obsolete_segment_definition, llc$obsolete_allotted_seg_def =
      NEXT obsolete_segment_definition IN object_library;
    = llc$external_linkage =
      NEXT external_linkage: [1 .. object_text_descriptor^.number_of_ext_items] IN object_library;
    = llc$entry_definition =
      NEXT entry_definition IN object_library;
    = llc$deferred_entry_points =
      NEXT deferred_entry_points: [1 .. object_text_descriptor^.number_of_entry_points] IN object_library;
    = llc$deferred_common_blocks =
      NEXT deferred_common_blocks: [1 .. object_text_descriptor^.number_of_common_blocks] IN object_library;
    = llc$obsolete_formal_parameters =
      NEXT obsolete_formal_parameters: [[REP object_text_descriptor^.sequence_length OF cell]] IN
            object_library;
    = llc$formal_parameters =
      NEXT formal_parameters: [[REP object_text_descriptor^.sequence_length OF cell]] IN object_library;
    = llc$actual_parameters =
      NEXT actual_parameters: [[REP object_text_descriptor^.sequence_length OF cell]] IN object_library;
    = llc$text =
      NEXT text: [1 .. object_text_descriptor^.number_of_bytes] IN object_library;
    = llc$replication =
      NEXT replication: [1 .. object_text_descriptor^.number_of_bytes] IN object_library;
    = llc$bit_string_insertion =
      NEXT bsi IN object_library;
    = llc$address_formulation =
      NEXT adr: [1 .. object_text_descriptor^.number_of_adr_items] IN object_library;
    = llc$binding_template =
      NEXT binding_template IN object_library;
    = llc$libraries =
      NEXT libraries: [1 .. object_text_descriptor^.number_of_libraries] IN object_library;
    = llc$relocation =
      NEXT relocation: [1 .. object_text_descriptor^.number_of_rel_items] IN object_library;
    = llc$cybil_symbol_table_fragment =
      NEXT debug_table_fragment: [[REP object_text_descriptor^.sequence_length OF cell]] IN object_library;
    = llc$symbol_table =
      NEXT symbol_table: [[REP object_text_descriptor^.sequence_length OF cell]] IN object_library;
    = llc$supplemental_debug_tables =
      NEXT supplemental_debug_tables: [[REP object_text_descriptor^.sequence_length OF cell]] IN
            object_library;
    = llc$ppu_absolute =
      NEXT ppu_absolute: [0 .. object_text_descriptor^.number_of_words - 1] IN object_library;
    = llc$68000_absolute =
      NEXT m68000_absolute: [[REP object_text_descriptor^.number_of_68000_bytes OF cell]] IN object_library;
    = llc$line_table =
      NEXT line_address_table: [1 .. object_text_descriptor^.number_of_line_items] IN object_library;
    = llc$obsolete_line_table =
      NEXT obsolete_line_address_table: [1 .. object_text_descriptor^.number_of_line_items] IN object_library;
    = llc$transfer_symbol =
      RETURN;
    ELSE
      STRINGREP (message, length, object_text_descriptor^.kind);
      osp$set_status_abnormal (occ$status_id, oce$unexpected_record_kind, message (1, length), status);
      RETURN;
    CASEND;

{ Find the next TEXT, REPLICATION, or BIT STRING INSERTION record with section_ordinal.

    WHILE NOT found AND (object_text_descriptor^.kind <> llc$transfer_symbol) DO
      NEXT object_text_descriptor IN object_library;
      CASE object_text_descriptor^.kind OF
      = llc$section_definition, llc$allotted_section_definition, llc$unallocated_common_block =
        NEXT section_definition IN object_library;
      = llc$segment_definition, llc$allotted_segment_definition =
        NEXT segment_definition IN object_library;
      = llc$obsolete_segment_definition, llc$obsolete_allotted_seg_def =
        NEXT obsolete_segment_definition IN object_library;
      = llc$external_linkage =
        NEXT external_linkage: [1 .. object_text_descriptor^.number_of_ext_items] IN object_library;
      = llc$entry_definition =
        NEXT entry_definition IN object_library;
      = llc$deferred_entry_points =
        NEXT deferred_entry_points: [1 .. object_text_descriptor^.number_of_entry_points] IN object_library;
      = llc$deferred_common_blocks =
        NEXT deferred_common_blocks: [1 .. object_text_descriptor^.number_of_common_blocks] IN object_library;
      = llc$obsolete_formal_parameters =
        NEXT obsolete_formal_parameters: [[REP object_text_descriptor^.sequence_length OF cell]] IN
              object_library;
      = llc$formal_parameters =
        NEXT formal_parameters: [[REP object_text_descriptor^.sequence_length OF cell]] IN object_library;
      = llc$actual_parameters =
        NEXT actual_parameters: [[REP object_text_descriptor^.sequence_length OF cell]] IN object_library;
      = llc$text =
        NEXT text: [1 .. object_text_descriptor^.number_of_bytes] IN object_library;
        IF text^.section_ordinal = section_ordinal THEN
          found := TRUE;
        IFEND;
      = llc$replication =
        NEXT replication: [1 .. object_text_descriptor^.number_of_bytes] IN object_library;
        IF replication^.section_ordinal = section_ordinal THEN
          found := TRUE;
        IFEND;
      = llc$bit_string_insertion =
        NEXT bsi IN object_library;
        IF bsi^.section_ordinal = section_ordinal THEN
          found := TRUE;
        IFEND;
      = llc$address_formulation =
        NEXT adr: [1 .. object_text_descriptor^.number_of_adr_items] IN object_library;
      = llc$binding_template =
        NEXT binding_template IN object_library;
      = llc$libraries =
        NEXT libraries: [1 .. object_text_descriptor^.number_of_libraries] IN object_library;
      = llc$relocation =
        NEXT relocation: [1 .. object_text_descriptor^.number_of_rel_items] IN object_library;
      = llc$cybil_symbol_table_fragment =
        NEXT debug_table_fragment: [[REP object_text_descriptor^.sequence_length OF cell]] IN object_library;
      = llc$symbol_table =
        NEXT symbol_table: [[REP object_text_descriptor^.sequence_length OF cell]] IN object_library;
      = llc$supplemental_debug_tables =
        NEXT supplemental_debug_tables: [[REP object_text_descriptor^.sequence_length OF cell]] IN
              object_library;
      = llc$ppu_absolute =
        NEXT ppu_absolute: [0 .. object_text_descriptor^.number_of_words - 1] IN object_library;
      = llc$68000_absolute =
        NEXT m68000_absolute: [[REP object_text_descriptor^.number_of_68000_bytes OF cell]] IN object_library;
      = llc$line_table =
        NEXT line_address_table: [1 .. object_text_descriptor^.number_of_line_items] IN object_library;
      = llc$obsolete_line_table =
        NEXT obsolete_line_address_table: [1 .. object_text_descriptor^.number_of_line_items] IN
              object_library;
      = llc$transfer_symbol =
        ;
      ELSE
        STRINGREP (message, length, object_text_descriptor^.kind);
        osp$set_status_abnormal (occ$status_id, oce$unexpected_record_kind, message (1, length), status);
        RETURN;
      CASEND;
    WHILEND;
  PROCEND get_next_text_rep_bsi;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] ocp$construct_breaklist', EJECT ??
*copy och$construct_breaklist

  PROCEDURE [XDCL] ocp$construct_breaklist
    (    p_object_library: ^SEQ ( * );
         module_directory: ^oct$module_directory;
         original_object_library: boolean;
         p_int_ol: ^SEQ ( * );
     VAR breaklist: ^oct$breaklist;
     VAR breaklist_seq_p: ^SEQ ( * );
     VAR breaklist_index: oct$breaklist_length;
     VAR status: ost$status);

    VAR
      i: oct$breaklist_length,
      index: oct$breaklist_length,
      int_ol: ^SEQ ( * ),
      j: llt$module_index,
      module_map: ^oct$module_map,
      object_library: ^SEQ ( * );

    status.normal := TRUE;

    object_library := p_object_library;
    int_ol := p_int_ol;

    build_module_map (object_library, module_directory, original_object_library, module_map, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    RESET breaklist_seq_p;
    breaklist_index := 0;
    construct_dictionary_bl (object_library, breaklist_seq_p, breaklist_index, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    construct_code_breaklist (object_library, module_map, breaklist_seq_p, breaklist_index);

    construct_read_breaklist (object_library, module_map, breaklist_seq_p, breaklist_index);

    construct_interpretive_bl (object_library, module_map, breaklist_seq_p, breaklist_index, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    construct_information_bl (object_library, module_map, original_object_library, int_ol, breaklist_seq_p,
          breaklist_index);

    FOR j := 1 TO UPPERBOUND (module_map^) DO
      IF (module_map^ [j].kind = llc$load_module) AND (module_map^ [j].change_list <> NIL) THEN
        FREE module_map^ [j].change_list;
      IFEND;
    FOREND;
    FREE module_map;

    RESET breaklist_seq_p;
    NEXT breaklist: [1 .. breaklist_index] IN breaklist_seq_p;

    sort_breaklist (breaklist_index, breaklist);

    i := 1;
    index := 1;
    WHILE i <= breaklist_index DO
      WHILE (i < breaklist_index) AND (breaklist^ [i].offset = breaklist^ [i + 1].offset) DO
        i := i + 1;
      WHILEND;
      breaklist^ [index] := breaklist^ [i];
      IF index > 1 THEN
        breaklist^ [index - 1].length := breaklist^ [index].offset - breaklist^ [index - 1].offset;
      IFEND;
      index := index + 1;
      i := i + 1;
    WHILEND;
    breaklist_index := index - 1;

    breaklist^ [breaklist_index].length := #SIZE (object_library^) - breaklist^ [breaklist_index].offset;
  PROCEND ocp$construct_breaklist;
?? OLDTITLE ??
?? NEWTITLE := 'sort_breaklist', EJECT ??

{ PURPOSE:
{   The purpose of this request is to sort the breaklist.

  PROCEDURE sort_breaklist
    (    number: integer;
     VAR breaklist: ^oct$breaklist);

    VAR
      i: integer,
      j: integer,
      key: llt$section_offset,
      left: integer,
      right: integer,
      temp: oct$breaklist_item;

    IF number <= 1 THEN
      RETURN;
    ELSEIF number = 2 THEN
      IF breaklist^ [1].offset > breaklist^ [2].offset THEN
        temp := breaklist^ [1];
        breaklist^ [1] := breaklist^ [2];
        breaklist^ [2] := temp;
      IFEND;
      RETURN;
    IFEND;

    left := (number DIV 2) + 1;
    right := number;

  /outer_loop/
    WHILE TRUE DO
      IF left > 1 THEN
        left := left - 1;
        temp := breaklist^ [left];
        key := breaklist^ [left].offset;
      ELSE
        temp := breaklist^ [right];
        key := breaklist^ [right].offset;
        breaklist^ [right] := breaklist^ [1];
        right := right - 1;
        IF right = 1 THEN
          breaklist^ [right] := temp;
          RETURN;
        IFEND;
      IFEND;

      j := left;

    /inner_loop/
      WHILE TRUE DO
        i := j;
        j := j + j;
        IF j < right THEN
          IF (breaklist^ [j].offset < breaklist^ [j + 1].offset) THEN
            j := j + 1;
          IFEND;
        ELSEIF j > right THEN
          EXIT /inner_loop/;
        IFEND;

        IF key >= breaklist^ [j].offset THEN
          EXIT /inner_loop/;
        IFEND;

        breaklist^ [i] := breaklist^ [j];
      WHILEND /inner_loop/;

      breaklist^ [i] := temp;
    WHILEND /outer_loop/;

  PROCEND sort_breaklist;
?? OLDTITLE ??
MODEND ocm$construct_breaklist
