?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE Object Code Management : Analyze Object Library' ??
MODULE ocm$anaol_library_scanners;

{ PURPOSE:
{   This module contains the routines for analyzing information from 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$section_address
*copyc oct$anaol_types
?? POP ??
*copyc ocp$internal_error
*copyc ocp$abort_if_segment_overflow
*copyc ocp$abort_if_premature_eof
*copyc ocp$abort_with_structure_error
*copyc ocp$convert_information_element
?? OLDTITLE ??
?? NEWTITLE := 'Global Declarations Declared by This Module', EJECT ??

  VAR
    ocv$library_sequence: [XREF] ^SEQ ( * );

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

  PROCEDURE find_module_dictionary
    (    object_library: ^oct$object_library;
     VAR module_dictionary: ^llt$module_dictionary);


    VAR
      object_library_header: ^llt$object_library_header,
      library_dictionary: ^llt$object_library_dictionaries,
      i: integer;


    RESET object_library^.sequence;

    NEXT object_library_header IN object_library^.sequence;
    ocp$abort_if_premature_eof (^object_library_header, object_library^.file);

    IF (object_library_header^.version <> llc$object_library_version) THEN
      ocp$abort_with_structure_error ('Invalid object library version', object_library^.file);
    IFEND;

    NEXT library_dictionary: [1 .. object_library_header^.number_of_dictionaries] IN object_library^.sequence;
    ocp$abort_if_premature_eof (^library_dictionary, object_library^.file);

    FOR i := LOWERBOUND (library_dictionary^) TO UPPERBOUND (library_dictionary^) DO
      CASE library_dictionary^ [i].kind OF
      = llc$module_dictionary =
        module_dictionary := #PTR (library_dictionary^ [i].module_dictionary, object_library^.sequence^);
        RETURN;
      ELSE
      CASEND;
    FOREND;

    module_dictionary := NIL;


  PROCEND find_module_dictionary;
?? OLDTITLE ??
?? NEWTITLE := 'build_load_module_list', EJECT ??

  PROCEDURE build_load_module_list
    (    object_library: ^oct$object_library;
         module_dictionary: ^llt$module_dictionary);


    VAR
      library_sequence: ^SEQ ( * ),
      i: integer,
      module_item: ^oct$module_item;


    library_sequence := ocv$library_sequence;
    object_library^.number_of_modules := 0;

    NEXT module_item IN library_sequence;
    ocp$abort_if_segment_overflow (^module_item);

    module_item^.name := '* Head of Module List *';
    module_item^.load_module_header := NIL;
    module_item^.interpretive_records := NIL;
    module_item^.record_analysis := NIL;

    IF (module_dictionary <> NIL) THEN
      FOR i := LOWERBOUND (module_dictionary^) TO UPPERBOUND (module_dictionary^) DO
        CASE module_dictionary^ [i].kind OF
        = llc$load_module =
          NEXT module_item IN library_sequence;
          ocp$abort_if_segment_overflow (^module_item);

          object_library^.number_of_modules := object_library^.number_of_modules + 1;

          module_item^.name := module_dictionary^ [i].name;
          module_item^.load_module_header := #PTR (module_dictionary^ [i].module_header,
                object_library^.sequence^);
          module_item^.interpretive_records := #PTR (module_item^.load_module_header^.interpretive_element,
                object_library^.sequence^);
          ocp$abort_if_premature_eof (^module_item^.interpretive_records, object_library^.file);

          module_item^.record_analysis := NIL;
        ELSE
        CASEND;
      FOREND;
    IFEND;

    NEXT object_library^.module_list: [0 .. object_library^.number_of_modules] IN ocv$library_sequence;
    ocp$abort_if_segment_overflow (^object_library^.module_list);


  PROCEND build_load_module_list;
?? OLDTITLE ??
?? NEWTITLE := 'build_object_module_list', EJECT ??

  PROCEDURE build_object_module_list
    (    object_library: ^oct$object_library);


    VAR
      module_list: oct$module_item,
      module_item: ^oct$module_item,
      object_file: ^SEQ ( * ),
      object_text_descriptor: ^llt$object_text_descriptor,
      identification: ^llt$identification,
      analysis_options: oct$anaol_display_options,
      record_analysis: ^oct$record_analysis,
      i: integer;


    object_library^.number_of_modules := 0;

    module_item := ^module_list;
    module_item^.name := '* Head of Module List *';
    module_item^.load_module_header := NIL;
    module_item^.interpretive_records := NIL;
    module_item^.record_analysis := NIL;
    module_item^.link := NIL;

    RESET object_library^.sequence;

    analysis_options := -$oct$anaol_display_options []; { Temporary }

    REPEAT
      object_file := object_library^.sequence;
      NEXT object_text_descriptor IN object_file;
      NEXT identification IN object_file;

      IF (identification <> NIL) THEN
        PUSH module_item^.link;
        module_item := module_item^.link;
        ocp$abort_if_segment_overflow (^module_item);

        object_library^.number_of_modules := object_library^.number_of_modules + 1;

        module_item^.name := identification^.name;
        module_item^.load_module_header := NIL;
        module_item^.interpretive_records := object_text_descriptor;
        module_item^.record_analysis := NIL;
        module_item^.link := NIL;

        initialize_record_analysis (record_analysis);
        analyze_interpretive_records (object_library, module_item, record_analysis, analysis_options);

        update_record_analysis (record_analysis, object_library^.record_analysis^);
        module_item^.record_analysis := record_analysis;
      IFEND;
    UNTIL (identification = NIL);

    NEXT object_library^.module_list: [0 .. object_library^.number_of_modules] IN ocv$library_sequence;
    ocp$abort_if_segment_overflow (^object_library^.module_list);

    module_item := ^module_list;
    FOR i := 0 TO object_library^.number_of_modules DO
      object_library^.module_list^ [i] := module_item^;
      module_item := module_item^.link;
    FOREND;


  PROCEND build_object_module_list;
?? OLDTITLE ??
?? NEWTITLE := 'initialize_record_analysis', EJECT ??

  PROCEDURE initialize_record_analysis
    (VAR record_analysis: ^oct$record_analysis);


    VAR
      record_kind: llt$object_record_kind;


    NEXT record_analysis IN ocv$library_sequence;
    ocp$abort_if_segment_overflow (^record_analysis);

    record_analysis^.total := 0;

    FOR record_kind := LOWERBOUND (record_analysis^.kind) TO UPPERBOUND (record_analysis^.kind) DO
      record_analysis^.kind [record_kind].number := 0;
      record_analysis^.kind [record_kind].number_of_items := 0;
    FOREND;

    record_analysis^.sections := NIL;
    record_analysis^.performance_problems := $oct$anaol_performance_problems [];

  PROCEND initialize_record_analysis;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] ocp$initialize_object_library', EJECT ??

  PROCEDURE [XDCL] ocp$initialize_object_library
    (    file_structure_is_library: boolean;
         object_library: ^oct$object_library);


    VAR
      module_dictionary: ^llt$module_dictionary;


    initialize_record_analysis (object_library^.record_analysis);

    IF file_structure_is_library THEN
      find_module_dictionary (object_library, module_dictionary);

      build_load_module_list (object_library, module_dictionary);
    ELSE
      build_object_module_list (object_library);
    IFEND;


  PROCEND ocp$initialize_object_library;
?? OLDTITLE ??
?? NEWTITLE := 'update_record_analysis', EJECT ??

  PROCEDURE update_record_analysis
    (    record_analysis: ^oct$record_analysis;
     VAR updated_analysis: oct$record_analysis);


    VAR
      record_kind: llt$object_record_kind;


    updated_analysis.total := updated_analysis.total + record_analysis^.total;

    FOR record_kind := LOWERBOUND (record_analysis^.kind) TO UPPERBOUND (record_analysis^.kind) DO
      updated_analysis.kind [record_kind].number := updated_analysis.kind [record_kind].number +
            record_analysis^.kind [record_kind].number;
      updated_analysis.kind [record_kind].number_of_items :=
            updated_analysis.kind [record_kind].number_of_items +
            record_analysis^.kind [record_kind].number_of_items;
    FOREND;


  PROCEND update_record_analysis;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_module_for_performance', EJECT ??

  PROCEDURE analyze_module_for_performance
    (    object_module: boolean;
         identification: ^llt$identification;
         ra: ^oct$record_analysis);


    VAR
      binder_or_prelinker: [STATIC, READ] set of llt$module_generator :=
            [llc$object_library_generator, llc$virtual_environment_linker],

      i: integer;


    IF (object_module) THEN
      ra^.performance_problems := ra^.performance_problems +
            $oct$anaol_performance_problems [occ$object_module];
    ELSEIF (identification <> NIL) THEN
      IF (identification^.generator_id = llc$object_library_generator) THEN
        ra^.performance_problems := ra^.performance_problems +
              $oct$anaol_performance_problems [occ$bound_module];
      ELSEIF (identification^.generator_id <> llc$virtual_environment_linker) THEN
        ra^.performance_problems := ra^.performance_problems +
              $oct$anaol_performance_problems [occ$load_module];
      IFEND;
    IFEND;

    IF (ra^.kind [llc$symbol_table].number > 0) THEN
      ra^.performance_problems := ra^.performance_problems +
            $oct$anaol_performance_problems [occ$symbol_tables];
    IFEND;

    IF (ra^.kind [llc$line_table].number > 0) THEN
      ra^.performance_problems := ra^.performance_problems + $oct$anaol_performance_problems
            [occ$line_tables];
    IFEND;

    IF (ra^.kind [llc$supplemental_debug_tables].number > 0) THEN
      ra^.performance_problems := ra^.performance_problems +
            $oct$anaol_performance_problems [occ$supplemental_debug_tables];
    IFEND;

    IF ((ra^.kind [llc$actual_parameters].number + ra^.kind [llc$formal_parameters].
          number + ra^.kind [llc$obsolete_formal_parameters].number) > 0) THEN
      ra^.performance_problems := ra^.performance_problems +
            $oct$anaol_performance_problems [occ$parameter_checking];
    IFEND;

    IF (ra^.kind [llc$libraries].number > 0) THEN
      ra^.performance_problems := ra^.performance_problems +
            $oct$anaol_performance_problems [occ$runtime_libraries];
    IFEND;

    IF (ra^.sections <> NIL) THEN
      FOR i := LOWERBOUND (ra^.sections^) TO UPPERBOUND (ra^.sections^) DO
        IF (ra^.sections^ [i].definition <> NIL) THEN
          IF (ra^.sections^ [i].definition^.name (1, 4) = 'DBB$') THEN
            ra^.performance_problems := ra^.performance_problems +
                  $oct$anaol_performance_problems [occ$opt_debug];
          IFEND;

          IF (identification <> NIL) AND (identification^.generator_id <> llc$virtual_environment_linker) THEN
            IF ((ra^.sections^ [i].bytes_initialized + ra^.sections^ [i].externals_in +
                  ra^.sections^ [i].addresses_in + ra^.sections^ [i].addresses_to) = 0) THEN
              ra^.performance_problems := ra^.performance_problems +
                    $oct$anaol_performance_problems [occ$unreferenced_sections];
            IFEND;
          IFEND;
        IFEND;
      FOREND;
    IFEND;


    IF (identification <> NIL) THEN
      IF (identification^.generator_id IN binder_or_prelinker) THEN
        IF (ra^.kind [llc$entry_definition].number > 1) THEN
          ra^.performance_problems := ra^.performance_problems +
                $oct$anaol_performance_problems [occ$multiple_entry_points];
        IFEND;

{ The following code is dependent on the commentary string in the identification record.
{ Some generators do not indicate optimization level or runtime checking options in the
{ commentary string (for example, FORTRAN at Release 1.4.1 indicates optimization but not
{ runtime checking) so these can't be checked here.

      ELSEIF (identification^.generator_id = llc$cybil) OR
            (identification^.generator_id = llc$obsolete_cybil) THEN
        i := 1;

      /runtime_checking_search/
        WHILE ((i + 6) <= #SIZE (identification^.commentary)) DO
          IF (identification^.commentary (i, 3) = 'RC=') THEN
            IF (identification^.commentary (i, 7) <> 'RC=NONE') THEN
              ra^.performance_problems := ra^.performance_problems +
                    $oct$anaol_performance_problems [occ$runtime_checking];
            IFEND;
            EXIT /runtime_checking_search/;
          IFEND;

          i := i + 1;
        WHILEND /runtime_checking_search/;

      /optimization_search/
        WHILE ((i + 4) <= #SIZE (identification^.commentary)) DO
          IF (identification^.commentary (i, 4) = 'OPT=') THEN
            IF (identification^.commentary (i + 4) = 'L') THEN
              ra^.performance_problems := ra^.performance_problems +
                    $oct$anaol_performance_problems [occ$opt_low];
            ELSEIF (identification^.commentary (i + 4) = 'D') THEN
              ra^.performance_problems := ra^.performance_problems +
                    $oct$anaol_performance_problems [occ$opt_debug];
            IFEND;
            EXIT /optimization_search/;
          IFEND;

          i := i + 1;
        WHILEND /optimization_search/;
      ELSEIF (identification^.generator_id = llc$fortran) THEN
        i := 1;

      /ftn_optimization_search/
        WHILE ((i + 4) <= #SIZE (identification^.commentary)) DO
          IF (identification^.commentary (i, 4) = 'OPT=') THEN
            IF (identification^.commentary (i + 4) = 'L') THEN
              ra^.performance_problems := ra^.performance_problems +
                    $oct$anaol_performance_problems [occ$opt_low];
            ELSEIF (identification^.commentary (i + 4) = 'D') THEN
              ra^.performance_problems := ra^.performance_problems +
                    $oct$anaol_performance_problems [occ$opt_debug];
            IFEND;
            EXIT /ftn_optimization_search/;
          IFEND;

          i := i + 1;
        WHILEND /ftn_optimization_search/;


      IFEND;
    IFEND;


  PROCEND analyze_module_for_performance;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_interpretive_records', EJECT ??

  PROCEDURE analyze_interpretive_records
    (    object_library: ^oct$object_library;
         module_item: ^oct$module_item;
         record_analysis: ^oct$record_analysis;
         analysis_options: oct$anaol_display_options);



    VAR
      identification: ^llt$identification; { Used for performance analysis



?? NEWTITLE := 'analyze_object_text_descriptor', EJECT ??

    PROCEDURE analyze_object_text_descriptor
      (VAR kind: llt$object_record_kind;
       VAR size: integer);

      VAR
        object_text_descriptor: ^llt$object_text_descriptor;

      NEXT object_text_descriptor IN object_library^.sequence;
      ocp$abort_if_premature_eof (^object_text_descriptor, object_library^.file);

      CASE object_text_descriptor^.kind OF
      = llc$identification, llc$section_definition, llc$bit_string_insertion, llc$entry_definition,
            llc$binding_template, llc$transfer_symbol, llc$obsolete_segment_definition,
            llc$segment_definition, llc$unallocated_common_block, llc$application_identifier =
        size := 0;
      = llc$libraries =
        size := object_text_descriptor^.number_of_libraries;
      = llc$allotted_section_definition =
        size := object_text_descriptor^.allotted_section;
      = llc$allotted_segment_definition, llc$obsolete_allotted_seg_def =
        size := (object_text_descriptor^.allotted_segment * 100000000(16)) +
              object_text_descriptor^.allotted_segment_length;
      = llc$text, llc$replication =
        size := object_text_descriptor^.number_of_bytes;
      = llc$relocation =
        size := object_text_descriptor^.number_of_rel_items;
      = llc$address_formulation =
        size := object_text_descriptor^.number_of_adr_items;
      = llc$external_linkage =
        size := object_text_descriptor^.number_of_ext_items;
      = llc$obsolete_line_table, llc$line_table =
        size := object_text_descriptor^.number_of_line_items;
      = llc$obsolete_formal_parameters, llc$formal_parameters, llc$actual_parameters,
            llc$cybil_symbol_table_fragment, llc$68000_absolute, llc$symbol_table, llc$form_definition,
            llc$supplemental_debug_tables =
        size := object_text_descriptor^.sequence_length;
      = llc$ppu_absolute =
        size := object_text_descriptor^.number_of_words;
      = llc$deferred_entry_points =
        size := object_text_descriptor^.number_of_entry_points;
      = llc$deferred_common_blocks =
        size := object_text_descriptor^.number_of_common_blocks;
      ELSE
        ocp$abort_with_structure_error ('Invalid object record kind', object_library^.file);
      CASEND;


      kind := object_text_descriptor^.kind;

      IF (occ$display_record_analysis IN analysis_options) THEN
        record_analysis^.total := record_analysis^.total + 1;
        record_analysis^.kind [kind].number := record_analysis^.kind [kind].number + 1;

        IF (kind <> llc$allotted_section_definition) AND (kind <> llc$allotted_segment_definition) AND
              (kind <> llc$obsolete_allotted_seg_def) AND (kind <> llc$replication) THEN
          record_analysis^.kind [kind].number_of_items := record_analysis^.kind [kind].number_of_items + size;
        IFEND;
      IFEND;


    PROCEND analyze_object_text_descriptor;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_identification_record', EJECT ??

    PROCEDURE analyze_identification_record
      (VAR module_kind: llt$module_kind);


      VAR
        i: llt$section_ordinal;


      NEXT identification IN object_library^.sequence;
      ocp$abort_if_premature_eof (^identification, object_library^.file);


      IF (identification^.object_text_version <> 'V1.2') AND
            (identification^.object_text_version <> 'V1.3') AND
            (identification^.object_text_version <> 'V1.4') THEN
        ocp$abort_with_structure_error ('Invalid object text version', object_library^.file);
      IFEND;

      IF (identification^.object_text_version < 'V1.4') AND (identification^.generator_id = llc$cybil) THEN
        ocp$abort_with_structure_error ('CYBIL must be > V1.3', object_library^.file);
      IFEND;

      IF (identification^.kind < LOWERVALUE (llt$module_kind)) OR
            (identification^.kind > UPPERVALUE (llt$module_kind)) THEN
        ocp$abort_with_structure_error ('Invalid module kind', object_library^.file);
      IFEND;


      module_kind := identification^.kind;

      IF (occ$display_record_analysis IN analysis_options) THEN
        NEXT record_analysis^.sections: [0 .. identification^.greatest_section_ordinal] IN
              ocv$library_sequence;
        ocp$abort_if_segment_overflow (^ocv$library_sequence);

        FOR i := 0 TO identification^.greatest_section_ordinal DO
          record_analysis^.sections^ [i].allotted := FALSE;
          record_analysis^.sections^ [i].unallocated_common_block := FALSE;
          record_analysis^.sections^ [i].segment_definition := FALSE;
          record_analysis^.sections^ [i].definition := NIL;
          record_analysis^.sections^ [i].bytes_initialized := 0;
          record_analysis^.sections^ [i].externals_in := 0;
          record_analysis^.sections^ [i].addresses_in := 0;
          record_analysis^.sections^ [i].addresses_to := 0;
          record_analysis^.sections^ [i].internal_binding_section_ptrs := 0;
        FOREND;
      IFEND;


    PROCEND analyze_identification_record;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_section_definition', EJECT ??

    PROCEDURE analyze_section_definition;


      VAR
        section_definition: ^llt$section_definition;


      NEXT section_definition IN object_library^.sequence;
      ocp$abort_if_premature_eof (^section_definition, object_library^.file);


      IF (occ$display_record_analysis IN analysis_options) THEN
        record_analysis^.sections^ [section_definition^.section_ordinal].definition := section_definition;
      IFEND;


    PROCEND analyze_section_definition;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_allotted_section_def', EJECT ??

    PROCEDURE analyze_allotted_section_def
      (    allotted_section: ost$relative_pointer);


      VAR
        section_definition: ^llt$section_definition;


      NEXT section_definition IN object_library^.sequence;
      ocp$abort_if_premature_eof (^section_definition, object_library^.file);


      IF (occ$display_record_analysis IN analysis_options) THEN
        record_analysis^.sections^ [section_definition^.section_ordinal].allotted := TRUE;
        record_analysis^.sections^ [section_definition^.section_ordinal].allotted_section := allotted_section;
        record_analysis^.sections^ [section_definition^.section_ordinal].definition := section_definition;
        record_analysis^.sections^ [section_definition^.section_ordinal].bytes_initialized :=
              section_definition^.length;
      IFEND;


    PROCEND analyze_allotted_section_def;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_unallocated_common_bl', EJECT ??

    PROCEDURE analyze_unallocated_common_bl;


      VAR
        section_definition: ^llt$section_definition;


      NEXT section_definition IN object_library^.sequence;
      ocp$abort_if_premature_eof (^section_definition, object_library^.file);


      IF (occ$display_record_analysis IN analysis_options) THEN
        record_analysis^.sections^ [section_definition^.section_ordinal].unallocated_common_block := TRUE;
        record_analysis^.sections^ [section_definition^.section_ordinal].definition := section_definition;
      IFEND;


    PROCEND analyze_unallocated_common_bl;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_segment_definition', EJECT ??

    PROCEDURE analyze_segment_definition
      (    kind: llt$object_record_kind);


      VAR
        obsolete_segment_definition: ^llt$obsolete_segment_definition,
        section_definition: ^llt$section_definition,
        segment_definition: ^llt$segment_definition;


      IF (kind = llc$segment_definition) THEN
        NEXT segment_definition IN object_library^.sequence;
        ocp$abort_if_premature_eof (^segment_definition, object_library^.file);

        section_definition := ^segment_definition^.section_definition;

      ELSE
        NEXT obsolete_segment_definition IN object_library^.sequence;
        ocp$abort_if_premature_eof (^obsolete_segment_definition, object_library^.file);

        section_definition := ^obsolete_segment_definition^.section_definition;
      IFEND;


      IF (occ$display_record_analysis IN analysis_options) THEN
        record_analysis^.sections^ [section_definition^.section_ordinal].definition := section_definition;
        record_analysis^.sections^ [section_definition^.section_ordinal].segment_definition := TRUE;
      IFEND;


    PROCEND analyze_segment_definition;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_allotted_segment_def', EJECT ??

    PROCEDURE analyze_allotted_segment_def
      (    kind: llt$object_record_kind;
           allotted_section: ost$segment_length;
           allotted_section_length: ost$segment_length);


      VAR
        obsolete_segment_definition: ^llt$obsolete_segment_definition,
        section_definition: ^llt$section_definition,
        segment_definition: ^llt$segment_definition;


      IF (kind = llc$allotted_segment_definition) THEN
        NEXT segment_definition IN object_library^.sequence;
        ocp$abort_if_premature_eof (^segment_definition, object_library^.file);

        section_definition := ^segment_definition^.section_definition;

      ELSE
        NEXT obsolete_segment_definition IN object_library^.sequence;
        ocp$abort_if_premature_eof (^obsolete_segment_definition, object_library^.file);

        section_definition := ^obsolete_segment_definition^.section_definition;
      IFEND;


      IF (occ$display_record_analysis IN analysis_options) THEN
        record_analysis^.sections^ [section_definition^.section_ordinal].allotted := TRUE;
        record_analysis^.sections^ [section_definition^.section_ordinal].allotted_section := allotted_section;
        record_analysis^.sections^ [section_definition^.section_ordinal].segment_definition := TRUE;
        record_analysis^.sections^ [section_definition^.section_ordinal].definition := section_definition;
        IF (allotted_section_length = 0) THEN
          record_analysis^.sections^ [section_definition^.section_ordinal].bytes_initialized :=
                section_definition^.length;
        ELSE
          record_analysis^.sections^ [section_definition^.section_ordinal].bytes_initialized :=
                allotted_section_length;
        IFEND;
      IFEND;


    PROCEND analyze_allotted_segment_def;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_libraries_record', EJECT ??

    PROCEDURE analyze_libraries_record
      (    number_of_libraries: 1 .. llc$max_libraries);


      VAR
        libraries: ^llt$libraries;


      NEXT libraries: [1 .. number_of_libraries] IN object_library^.sequence;
      ocp$abort_if_premature_eof (^libraries, object_library^.file);


    PROCEND analyze_libraries_record;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_text_record', EJECT ??

    PROCEDURE analyze_text_record
      (    number_of_bytes: 1 .. osc$max_segment_length);


      VAR
        text: ^llt$text;


      NEXT text: [1 .. number_of_bytes] IN object_library^.sequence;
      ocp$abort_if_premature_eof (^text, object_library^.file);


      IF (occ$display_record_analysis IN analysis_options) THEN
        record_analysis^.sections^ [text^.section_ordinal].bytes_initialized := record_analysis^.
              sections^ [text^.section_ordinal].bytes_initialized + number_of_bytes;
      IFEND;


    PROCEND analyze_text_record;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_replication_record', EJECT ??

    PROCEDURE analyze_replication_record
      (    number_of_bytes: 1 .. osc$max_segment_length);


      VAR
        replication: ^llt$replication;


      NEXT replication: [1 .. number_of_bytes] IN object_library^.sequence;
      ocp$abort_if_premature_eof (^replication, object_library^.file);


      IF (occ$display_record_analysis IN analysis_options) THEN
        record_analysis^.kind [llc$replication].number_of_items :=
              record_analysis^.kind [llc$replication].number_of_items +
              (replication^.count * number_of_bytes);
        record_analysis^.sections^ [replication^.section_ordinal].bytes_initialized :=
              record_analysis^.sections^ [replication^.section_ordinal].bytes_initialized +
              (replication^.count * number_of_bytes);
      IFEND;


    PROCEND analyze_replication_record;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_bit_insertion_record', EJECT ??

    PROCEDURE analyze_bit_insertion_record;


      VAR
        bit_insertion: ^llt$bit_string_insertion;


      NEXT bit_insertion IN object_library^.sequence;
      ocp$abort_if_premature_eof (^bit_insertion, object_library^.file);


    PROCEND analyze_bit_insertion_record;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_entry_definition_record', EJECT ??

    PROCEDURE analyze_entry_definition_record;


      VAR
        entry_definition: ^llt$entry_definition;


      NEXT entry_definition IN object_library^.sequence;
      ocp$abort_if_premature_eof (^entry_definition, object_library^.file);


    PROCEND analyze_entry_definition_record;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_deferred_entry_pt_rec', EJECT ??

    PROCEDURE analyze_deferred_entry_pt_rec
      (    number_of_entry_points: 1 .. llc$max_deferred_entry_points);

      VAR
        deferred_entry_points: ^llt$deferred_entry_points;


      NEXT deferred_entry_points: [1 .. number_of_entry_points] IN object_library^.sequence;
      ocp$abort_if_premature_eof (^deferred_entry_points, object_library^.file);


    PROCEND analyze_deferred_entry_pt_rec;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_deferred_common_blk_rec', EJECT ??

    PROCEDURE analyze_deferred_common_blk_rec
      (    number_of_common_blocks: 1 .. llc$max_deferred_common_blocks);

      VAR
        deferred_common_blocks: ^llt$deferred_common_blocks;


      NEXT deferred_common_blocks: [1 .. number_of_common_blocks] IN object_library^.sequence;
      ocp$abort_if_premature_eof (^deferred_common_blocks, object_library^.file);


    PROCEND analyze_deferred_common_blk_rec;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_relocation_record', EJECT ??

    PROCEDURE analyze_relocation_record
      (    number_of_rel_items: llt$number_of_info_elements);


      VAR
        relocation: ^llt$relocation;


      NEXT relocation: [1 .. number_of_rel_items] IN object_library^.sequence;
      ocp$abort_if_premature_eof (^relocation, object_library^.file);
    PROCEND analyze_relocation_record;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_obsolete_form_parm_rec', EJECT ??

    PROCEDURE analyze_obsolete_form_parm_rec
      (    sequence_length: ost$segment_length);


      VAR
        obsolete_formal_parameters: ^llt$obsolete_formal_parameters;


      NEXT obsolete_formal_parameters: [[REP sequence_length OF cell]] IN object_library^.sequence;
      ocp$abort_if_premature_eof (^obsolete_formal_parameters, object_library^.file);


    PROCEND analyze_obsolete_form_parm_rec;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_formal_parameter_record', EJECT ??

    PROCEDURE analyze_formal_parameter_record
      (    sequence_length: ost$segment_length);


      VAR
        formal_parameters: ^llt$formal_parameters;


      NEXT formal_parameters: [[REP sequence_length OF cell]] IN object_library^.sequence;
      ocp$abort_if_premature_eof (^formal_parameters, object_library^.file);


    PROCEND analyze_formal_parameter_record;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_actual_parameter_record', EJECT ??

    PROCEDURE analyze_actual_parameter_record
      (    sequence_length: ost$segment_length);


      VAR
        actual_parameters: ^llt$actual_parameters;


      NEXT actual_parameters: [[REP sequence_length OF cell]] IN object_library^.sequence;
      ocp$abort_if_premature_eof (^actual_parameters, object_library^.file);


    PROCEND analyze_actual_parameter_record;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_address_formulation', EJECT ??

    PROCEDURE analyze_address_formulation
      (    number_of_adr_items: 1 .. llc$max_adr_items);


      VAR
        address_formulation: ^llt$address_formulation,
        i: 1 .. llc$max_adr_items;


      NEXT address_formulation: [1 .. number_of_adr_items] IN object_library^.sequence;
      ocp$abort_if_premature_eof (^address_formulation, object_library^.file);


      IF (occ$display_record_analysis IN analysis_options) THEN
        record_analysis^.sections^ [address_formulation^.dest_section].addresses_in :=
              record_analysis^.sections^ [address_formulation^.dest_section].addresses_in +
              number_of_adr_items;

        FOR i := 1 TO number_of_adr_items DO
          IF (address_formulation^.item [i].kind = llc$external_proc) THEN
            record_analysis^.sections^ [address_formulation^.dest_section].addresses_in :=
                  record_analysis^.sections^ [address_formulation^.dest_section].addresses_in + 1;
          IFEND;
        FOREND;

        record_analysis^.sections^ [address_formulation^.value_section].addresses_to :=
              record_analysis^.sections^ [address_formulation^.value_section].addresses_to +
              number_of_adr_items;
      IFEND;


    PROCEND analyze_address_formulation;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_external_linkage', EJECT ??

    PROCEDURE analyze_external_linkage
      (    number_of_ext_items: 1 .. llc$max_ext_items);


      VAR
        runtime_library_ids: [STATIC, READ] array [1 .. 9] of string (2) := ['AA', 'BC', 'CB', 'CY', 'DB',
              'FL', 'ML', 'PA', 'SM'],
        runtime_checkers: [STATIC, READ] array [1 .. 5] of pmt$program_name := [
              {} 'FLP$CHECK_ARRAY_BOUNDS         ', {} 'FLP$MOVE_CHARACTERS_CHECK      ',
              {} 'FLP$COMPARE_FIXED_CHECK        ', {} 'FLP$COMPARE_USER_CHECK         ',
              {} 'FLP$SUBSTRING_CHECK            '],

        external: ^llt$external_linkage,
        i: integer;


      NEXT external: [1 .. number_of_ext_items] IN object_library^.sequence;
      ocp$abort_if_premature_eof (^external, object_library^.file);

      IF (occ$display_record_analysis IN analysis_options) THEN
        FOR i := 1 TO number_of_ext_items DO
          record_analysis^.sections^ [external^.item [i].section_ordinal].externals_in :=
                record_analysis^.sections^ [external^.item [i].section_ordinal].externals_in +
                number_of_ext_items;
        FOREND;

        IF (external^.name (4) = '$') THEN
          IF NOT (occ$runtime_library_calls IN record_analysis^.performance_problems) THEN

          /runtime_library_call_search/
            FOR i := LOWERBOUND (runtime_library_ids) TO UPPERBOUND (runtime_library_ids) DO
              IF (external^.name (1, 2) = runtime_library_ids [i]) THEN
                IF (external^.name (1, 2) <> 'CY') OR ((external^.name <> 'CYP$ERROR') AND (external^.name <>
                      'CYP$NIL')) THEN
                  record_analysis^.performance_problems := record_analysis^.performance_problems +
                        $oct$anaol_performance_problems [occ$runtime_library_calls];

                  EXIT /runtime_library_call_search/;
                IFEND;
              IFEND;
            FOREND /runtime_library_call_search/;
          IFEND;

          IF NOT (occ$runtime_checking IN record_analysis^.performance_problems) THEN
            IF (external^.name (1, 3) = 'FLP') THEN

            /runtime_checking_search/
              FOR i := LOWERBOUND (runtime_checkers) TO UPPERBOUND (runtime_checkers) DO
                IF (external^.name = runtime_checkers [i]) THEN
                  record_analysis^.performance_problems := record_analysis^.performance_problems +
                        $oct$anaol_performance_problems [occ$runtime_checking];

                  EXIT /runtime_checking_search/;
                IFEND;
              FOREND /runtime_checking_search/;
            IFEND;
          IFEND;
        IFEND;
      IFEND;


    PROCEND analyze_external_linkage;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_binding_template_record', EJECT ??

    PROCEDURE analyze_binding_template_record;


      VAR
        binding_template: ^llt$binding_template;


      NEXT binding_template IN object_library^.sequence;
      ocp$abort_if_premature_eof (^binding_template, object_library^.file);

    PROCEND analyze_binding_template_record;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_form_definition', EJECT ??

    PROCEDURE analyze_form_definition;

      VAR
        record_kind: llt$object_record_kind;

      IF record_kind = llc$form_definition THEN
        ocp$abort_with_structure_error ('Form definition found in module', object_library^.file);
      IFEND;
    PROCEND analyze_form_definition;

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

    PROCEDURE analyze_68000_absolute
      (    number_of_68000_bytes: 1 .. llc$maximum_68000_address);


      VAR
        m68000_absolute: ^llt$68000_absolute;


      NEXT m68000_absolute: [[REP number_of_68000_bytes OF cell]] IN object_library^.sequence;
      ocp$abort_if_premature_eof (^m68000_absolute, object_library^.file);


    PROCEND analyze_68000_absolute;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_ppu_absolute', EJECT ??

    PROCEDURE analyze_ppu_absolute
      (    number_of_words: llt$ppu_address);


      VAR
        ppu_absolute: ^llt$ppu_absolute;


      NEXT ppu_absolute: [0 .. (number_of_words - 1)] IN object_library^.sequence;
      ocp$abort_if_premature_eof (^ppu_absolute, object_library^.file);


    PROCEND analyze_ppu_absolute;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_cybil_symbol_table', EJECT ??

    PROCEDURE analyze_cybil_symbol_table
      (    sequence_length: ost$segment_length);


      VAR
        debug_table_fragment: ^llt$debug_table_fragment;


      NEXT debug_table_fragment: [[REP sequence_length OF cell]] IN object_library^.sequence;
      ocp$abort_if_premature_eof (^debug_table_fragment, object_library^.file);


    PROCEND analyze_cybil_symbol_table;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_obsolete_line_table', EJECT ??

    PROCEDURE analyze_obsolete_line_table
      (    number_of_line_items: llt$line_address_table_size);


      VAR
        obsolete_line_address_table: ^llt$obsolete_line_address_table;


      NEXT obsolete_line_address_table: [1 .. number_of_line_items] IN object_library^.sequence;
      ocp$abort_if_premature_eof (^obsolete_line_address_table, object_library^.file);


    PROCEND analyze_obsolete_line_table;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_line_table', EJECT ??

    PROCEDURE analyze_line_table
      (    number_of_line_items: llt$line_address_table_size);


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


      NEXT line_address_table: [1 .. number_of_line_items] IN object_library^.sequence;
      ocp$abort_if_premature_eof (^line_address_table, object_library^.file);


    PROCEND analyze_line_table;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_symbol_table', EJECT ??

    PROCEDURE analyze_symbol_table
      (    sequence_length: ost$segment_length);


      VAR
        symbol_table: ^llt$symbol_table;


      NEXT symbol_table: [[REP sequence_length OF cell]] IN object_library^.sequence;
      ocp$abort_if_premature_eof (^symbol_table, object_library^.file);


    PROCEND analyze_symbol_table;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_supplemental_dtables', EJECT ??

    PROCEDURE analyze_supplemental_dtables
      (    sequence_length: ost$segment_length);


      VAR
        supplemental_debug_tables: ^llt$supplemental_debug_tables;


      NEXT supplemental_debug_tables: [[REP sequence_length OF cell]] IN object_library^.sequence;
      ocp$abort_if_premature_eof (^supplemental_debug_tables, object_library^.file);


    PROCEND analyze_supplemental_dtables;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_transfer_symbol_record', EJECT ??

    PROCEDURE analyze_transfer_symbol_record;


      VAR
        transfer_symbol: ^llt$transfer_symbol;


      NEXT transfer_symbol IN object_library^.sequence;
      ocp$abort_if_premature_eof (^transfer_symbol, object_library^.file);


    PROCEND analyze_transfer_symbol_record;
?? OLDTITLE ??
?? EJECT ??

    VAR
      record_kind: llt$object_record_kind,
      module_kind: llt$module_kind,
      size: integer;


    analyze_object_text_descriptor (record_kind, size);
    IF record_kind <> llc$identification THEN
      ocp$abort_with_structure_error ('IDR must be first record of module', object_library^.file);
    IFEND;

    analyze_identification_record (module_kind);
    CASE module_kind OF
    = llc$iou =
      analyze_object_text_descriptor (record_kind, size);
      IF (record_kind <> llc$ppu_absolute) THEN
        ocp$abort_with_structure_error ('PPU ABSOLUTE expected in module', object_library^.file);
      IFEND;

      analyze_ppu_absolute (size);
      RETURN; { ---->

    = llc$mi_virtual_state, llc$vector_virtual_state, llc$motorola_68000, llc$motorola_68000_absolute,
          llc$vector_extended_state =
      { Valid kind } ;
    ELSE
      ocp$internal_error ('Unselected module kind - ANALYZE_INTERPRETIVE_RECORDS');
    CASEND;

    REPEAT
      analyze_object_text_descriptor (record_kind, size);

      CASE record_kind OF
      = llc$identification =
        ocp$abort_with_structure_error ('Duplicate IDR record', object_library^.file);
      = llc$libraries =
        analyze_libraries_record (size);
      = llc$section_definition =
        analyze_section_definition;
      = llc$allotted_section_definition =
        analyze_allotted_section_def (size);
      = llc$unallocated_common_block =
        analyze_unallocated_common_bl;
      = llc$segment_definition, llc$obsolete_segment_definition =
        analyze_segment_definition (record_kind);
      = llc$allotted_segment_definition, llc$obsolete_allotted_seg_def =
        analyze_allotted_segment_def (record_kind, (size DIV 100000000(16)), (size MOD 100000000(16)));
      = llc$text =
        analyze_text_record (size);
      = llc$replication =
        analyze_replication_record (size);
      = llc$bit_string_insertion =
        analyze_bit_insertion_record;
      = llc$entry_definition =
        analyze_entry_definition_record;
      = llc$deferred_entry_points =
        analyze_deferred_entry_pt_rec (size);
      = llc$deferred_common_blocks =
        analyze_deferred_common_blk_rec (size);
      = llc$relocation =
        analyze_relocation_record (size);
      = llc$obsolete_formal_parameters =
        analyze_obsolete_form_parm_rec (size);
      = llc$formal_parameters =
        analyze_formal_parameter_record (size);
      = llc$actual_parameters =
        analyze_actual_parameter_record (size);
      = llc$obsolete_line_table =
        analyze_obsolete_line_table (size);
      = llc$cybil_symbol_table_fragment =
        analyze_cybil_symbol_table (size);
      = llc$line_table =
        analyze_line_table (size);
      = llc$symbol_table =
        analyze_symbol_table (size);
      = llc$supplemental_debug_tables =
        analyze_supplemental_dtables (size);
      = llc$address_formulation =
        analyze_address_formulation (size);
      = llc$external_linkage =
        analyze_external_linkage (size);
      = llc$binding_template =
        analyze_binding_template_record;
      = llc$form_definition =
        analyze_form_definition;
      = llc$68000_absolute =
        analyze_68000_absolute (size);
      = llc$transfer_symbol =
        analyze_transfer_symbol_record;
      ELSE
        ocp$abort_with_structure_error ('Invalid CPU record kind', object_library^.file);
      CASEND;

    UNTIL (record_kind = llc$transfer_symbol);

    IF (occ$display_record_analysis IN analysis_options) THEN
      analyze_module_for_performance ((module_item^.load_module_header = NIL), identification,
            record_analysis);
    IFEND;

  PROCEND analyze_interpretive_records;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] ocp$analyze_load_module', EJECT ??

  PROCEDURE [XDCL] ocp$analyze_load_module
    (    object_library: ^oct$object_library;
         module_item: ^oct$module_item;
         display_options: oct$anaol_display_options);


?? NEWTITLE := 'analyze_information_records', EJECT ??

    PROCEDURE analyze_information_records;

?? NEWTITLE := 'analyze_relocation_items', EJECT ??

      PROCEDURE analyze_relocation_items
        (    relocation: ^llt$relocation,
             number_of_rel_items: llt$number_of_info_elements);

        TYPE
          t$q_field = packed record
            q: -7fff(16) .. 7fff(16),
          recend;

        VAR
          temp: integer,
          found: boolean,
          hi: llt$number_of_info_elements,
          i: llt$number_of_info_elements,
          j: llt$number_of_info_elements,
          lo: llt$number_of_info_elements,
          mid: llt$number_of_info_elements,
          offset: llt$section_offset,
          q_field_p: ^t$q_field,
          relocation_value: t$q_field,
          relocation_values: ^array [1 .. * ] of t$q_field,
          last_relocation_value: llt$number_of_info_elements;


        IF (occ$display_record_analysis IN analysis_options) THEN
          IF (occ$count_internal_binding_refs IN analysis_options) THEN
            PUSH relocation_values: [1 .. number_of_rel_items];
            last_relocation_value := 0;
            FOR i := 1 TO number_of_rel_items DO
              IF (relocation^ [i].container = llc$180_q_field) AND (relocation^ [i].address =
                    llc$byte_signed) THEN
                IF record_analysis^.sections^ [relocation^ [i].section_ordinal].allotted THEN
                  offset := record_analysis^.sections^ [relocation^ [i].section_ordinal].allotted_section +
                        relocation^ [i].offset;
                  q_field_p := #ADDRESS (#RING (object_library^.sequence),
                        #SEGMENT (object_library^.sequence), offset);
                  relocation_value.q := (q_field_p^.q DIV 8) * 8;

                  lo := 1;
                  hi := last_relocation_value;
                  found := FALSE;

                  WHILE (NOT found) AND (lo <= hi) DO
                    temp := lo + hi;
                    mid := temp DIV 2;
                    IF relocation_value.q = relocation_values^ [mid].q THEN
                      found := TRUE;
                    ELSEIF relocation_value.q > relocation_values^ [mid].q THEN
                      lo := mid + 1;
                    ELSE
                      hi := mid - 1;
                    IFEND;
                  WHILEND;

                  IF NOT found THEN
                    FOR j := last_relocation_value DOWNTO lo DO
                      relocation_values^ [j + 1] := relocation_values^ [j];
                    FOREND;
                    last_relocation_value := last_relocation_value + 1;
                    relocation_values^ [lo] := relocation_value;
                    record_analysis^.sections^ [relocation^ [i].relocating_section].
                          internal_binding_section_ptrs := record_analysis^.
                          sections^ [relocation^ [i].relocating_section].internal_binding_section_ptrs + 1;
                  IFEND;
                IFEND;
              IFEND;
            FOREND;
          IFEND;
          record_analysis^.total := record_analysis^.total + 1;
          record_analysis^.kind [llc$relocation].number := record_analysis^.kind [llc$relocation].number + 1;
          record_analysis^.kind [llc$relocation].number_of_items :=
                record_analysis^.kind [llc$relocation].number_of_items + number_of_rel_items;
        IFEND;


      PROCEND analyze_relocation_items;
?? OLDTITLE ??
?? NEWTITLE := 'analyze_binding_template_items', EJECT ??

      PROCEDURE analyze_binding_template_items
        (    number_of_template_items: llt$number_of_info_elements);


        VAR
          i: integer;


        IF (occ$display_record_analysis IN analysis_options) THEN
          record_analysis^.total := record_analysis^.total + 1;
          record_analysis^.kind [llc$binding_template].number :=
                record_analysis^.kind [llc$binding_template].number + 1;
          record_analysis^.kind [llc$binding_template].number_of_items := record_analysis^.
                kind [llc$binding_template].number_of_items + number_of_template_items;
        IFEND;


      PROCEND analyze_binding_template_items;
?? OLDTITLE ??
?? EJECT ??

      VAR
        relocation: ^llt$relocation,
        binding_template: ^llt$binding_section_template,
        info_element_header: ^llt$info_element_header,
        new_header: llt$info_element_header;


      IF (llc$information_element IN module_item^.load_module_header^.elements_defined) THEN
        info_element_header := #PTR (module_item^.load_module_header^.information_element,
              object_library^.sequence^);
        ocp$abort_if_premature_eof (^info_element_header, object_library^.file);

        IF info_element_header^.version <> llc$info_element_version THEN
          ocp$convert_information_element (info_element_header, new_header);

          info_element_header := ^new_header;
        IFEND;

        IF info_element_header^.number_of_rel_items <> 0 THEN
          relocation := #PTR (info_element_header^.relocation_ptr, object_library^.sequence^);
          ocp$abort_if_premature_eof (^relocation, object_library^.file);

          RESET object_library^.sequence TO relocation;
          analyze_relocation_items (relocation, info_element_header^.number_of_rel_items);
        IFEND;

        IF info_element_header^.number_of_template_items <> 0 THEN
          binding_template := #PTR (info_element_header^.binding_template_ptr, object_library^.sequence^);
          ocp$abort_if_premature_eof (^binding_template, object_library^.file);

          RESET object_library^.sequence TO binding_template;
          analyze_binding_template_items (info_element_header^.number_of_template_items);
        IFEND;
      IFEND;


    PROCEND analyze_information_records;
?? OLDTITLE ??
?? EJECT ??

    VAR
      analysis_options: oct$anaol_display_options,
      record_analysis: ^oct$record_analysis;


    IF occ$count_internal_binding_refs IN display_options THEN
      analysis_options := -$oct$anaol_display_options [];
    ELSE
      analysis_options := -$oct$anaol_display_options []; { Temporary }
      analysis_options := analysis_options - $oct$anaol_display_options [occ$count_internal_binding_refs];
    IFEND;
    IF (module_item^.record_analysis = NIL) THEN
      initialize_record_analysis (record_analysis);

      RESET object_library^.sequence TO module_item^.interpretive_records;

      analyze_interpretive_records (object_library, module_item, record_analysis, analysis_options);

      analyze_information_records;

      update_record_analysis (record_analysis, object_library^.record_analysis^);
      module_item^.record_analysis := record_analysis;
    IFEND;


  PROCEND ocp$analyze_load_module;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] ocp$get_binding_section_refs', EJECT ??

  PROCEDURE [XDCL] ocp$get_binding_section_refs
    (    object_library: ^oct$object_library;
     VAR count: 0 .. llc$max_binding_items);

    VAR
      display_options: [STATIC, READ] oct$anaol_display_options := [occ$count_internal_binding_refs],
      i: llt$section_ordinal,
      next_module: ^oct$module_item,
      sections: ^oct$sections;


    count := 0;

    next_module := object_library^.module_list^ [occ$head_of_list].link;

    WHILE (next_module <> NIL) DO
      ocp$analyze_load_module (object_library, next_module, display_options);

      sections := next_module^.record_analysis^.sections;

      IF sections <> NIL THEN

      /find_binding_section/
        FOR i := LOWERBOUND (sections^) TO UPPERBOUND (sections^) DO
          IF (sections^ [i].definition <> NIL) AND (sections^ [i].definition^.kind = llc$binding_section) THEN
            count := count + sections^ [i].internal_binding_section_ptrs;
            EXIT /find_binding_section/;
          IFEND;
        FOREND /find_binding_section/;
      IFEND;

      next_module := next_module^.link;
    WHILEND;

  PROCEND ocp$get_binding_section_refs;
?? OLDTITLE ??
MODEND ocm$anaol_library_scanners;

