Programmer's ROM - The Computer Language Library/programmersrom.iso/ada/manage/rttest.dat

Text File | 1988-05-03 | 57.7 KB | 1,492 lines

--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--checkout.com
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
$ SET NOON
$ DIFFERENCE RUN3.RPT; ;1
$ DIFFERENCE RUN4.RPT; ;1
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--cleanup.com
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
$SET NOON
$DELETE *.*PR;*
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--reqstest.com
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
$ ! ReqsRef test command file.
$ set verify
$ ! ---> The following two lines are installation dependent ---->
$ set default [nosc.work.tools.reqsref.test]
$ reqsref := $user1:[nosc.work.tools.reqsref]reqsref.exe
$ !
$ ! First, run REQSREF over the test input files:
$ REQSREF(("*.ADA", "*.SPC"));
$ REQSREF(("MTEST.BDY", "NONAME.SOM"), REPORT => NOREPORT);
$ REQSREF(("TEST2.SUB"), ("*.*PR"), OUTPUT => "RUN3.RPT");
$ REQSREF(PAIRS_FILES => ("*.*PR"), REPORT => LOCATION, OUTPUT => "RUN4.RPT");
$ !
$ ! The following test should generate three error messages, as follows:
$ !
$ ! ?? Invalid paragraph string at line 4, column 29.
$ ! ?? Invalid document id at line 7, column 29.
$ ! ?? Invalid document id at line 10, column 33.
$ !
$ SET NOON
$ REQSREF(("BADREFS.DAT"));
$ !
$ ! Next, compare the output with a previous run (that was checked by hand)
$ !
$ DIFFERENCE RUN3.RPT; ;1
$ DIFFERENCE RUN4.RPT; ;1
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--testrun.com
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
$SET ON
$REQSREF (("*.ADA", "*.SPC"));
$REQSREF (("MTEST.BDY", "NONAME.SOM"), REPORT => NOREPORT);
$REQSREF (("TEST2.SUB"), ("*.*PR"), OUTPUT => "RUN3.RPT");
$REQSREF (PAIRS_FILES => ("*.*PR"), REPORT => LOCATION, OUTPUT => "RUN4.RPT");
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--ktest.spc
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
package kTest is

procedure P;
-- Test one ref per line, all possible flag chars, with and without
-- extra spaces:
--| Requirements_Satisfied: Doc.Name.P 1
--|+Requirements_Satisfied: Doc.Name.P 2
--|-Requirements_Satisfied: Doc.Name.P 3
--|+ Requirements_Satisfied: Doc.Name.P.Plus 2
--|- Requirements_Satisfied: Doc.Name.P.Minus 3

procedure Q;
-- Test multiple refs per line:
--| Requirements_Satisfied: Doc.Name.Q 1, Doc.Name.Q 2, Doc.Name.Q 3

procedure R;
-- Test multiple refs and multiple lines:
--| Requirements_Satisfied: Doc.Name.R 1, Doc.Name.R 2, Doc.Name.R 3
--| Requirements_Satisfied: Doc.Name.R 1.1, Doc.Name.R 2.1, Doc.Name.R 3.1
--| Requirements_Satisfied: Doc.Name.R 1.2, Doc.Name.R 2.2, Doc.Name.R 3.2

procedure S;
-- Test multiple refs and continuation lines, with and without trailing comma
--| Requirements_Satisfied: Doc.Name.S 1, Doc.Name.S 2, Doc.Name.S 3,
--| Doc.Name.S 1.1, Doc.Name.S 2.1, Doc.Name.S 3.1
--| Doc.Name.S 1.2, Doc.Name.S 2.2, Doc.Name.S 3.2


-- Now, same tests check ! in place of |

procedure P1;
--!    Requirements_Satisfied:    Doc.Name.P    1
--!+Requirements_Satisfied:    Doc.Name.P    2
--!-Requirements_Satisfied:    Doc.Name.P    3
--!+    Requirements_Satisfied:    Doc.Name.P.Plus    2
--!-    Requirements_Satisfied:    Doc.Name.P.Minus    3

procedure Q1;
--! Requirements_Satisfied: Doc.Name.Q1 1, Doc.Name.Q1 2, Doc.Name.Q1 3

procedure R1;
--! Requirements_Satisfied: Doc.Name.R1 1, Doc.Name.R1 2, Doc.Name.R1 3
--! Requirements_Satisfied: Doc.Name.R1 1.1, Doc.Name.R1 2.1, Doc.Name.R1 3.1
--! Requirements_Satisfied: Doc.Name.R1 1.2, Doc.Name.R1 2.2, Doc.Name.R1 3.2

procedure S1;
--! Requirements_Satisfied: Doc.Name.S1 1, Doc.Name.S1 2, Doc.Name.S1 3,
--! Doc.Name.S1 1.1, Doc.Name.S1 2.1, Doc.Name.S1 3.1
--! Doc.Name.S1 1.2, Doc.Name.S1 2.2, Doc.Name.S1 3.2

-- Uppercase keyword:
procedure UC;
--| Requirements_Satisfied: Doc.Name.UC 1

-- Lower case keyword:
procedure LC;
--| Requirements_Satisfied: Doc.Name.LC 1

procedure Ref_1_2_no_3;
--| Requirements_Satisfied: Ref 1
--| Ref 2
-- This comment causes the next comment to be ignored:
--| Ref 3

end KTest;
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--mtest.spc
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
with reqsref_utilities;  use reqsref_utilities;
with text_io;
--| Requirements Satisfied:a 9
with binarytrees;
with heap_sort;
with document_ref;

package merge_pkg is
--| Requirements Satisfied:   one.two 4.5
type file_ptr is access text_io.file_type;
--| Requirements Satisfied:   red 89
subtype path is sl.list;              -- A list which contains the components
--| Requirements Satisfied: u.v 1.2.3

type req_record is
   record
      ref: document_ref.reference_string;
      source_file_name: sp.string_type;
      pairs_file_name: sp.string_type;
      pairs_file: file_ptr;
      location_string: sp.string_type;
   end record;
--| Requirements Satisfied: requirement 5
type seq is array (integer range <>) of req_record;

package file_tree_pkg is new binarytrees(
                      itemtype => path,
                      "<"       => reqsref_utilities.lessthan);
package ftp renames file_tree_pkg;


ref_width: constant integer := 30;    -- maximal number of characters in a
                                      -- reference string
file_name_width: constant integer := 60; -- maximal number of characters in
                                         -- a file pathname
unit_width: constant integer := 40;   -- maximal number of characters in a
                                      -- program unit name
file_tree: ftp.tree;

procedure location_merge(pairs_files: in sl.list);   -- list of pairs files
-- Raises:
--| Requirements Satisfied: u.v 1.2.3
-- Requires:
-- The files in pairs_list must be pairs files, e. i. files created by
-- REQSREF containing pairs of Requirement-Cited and Location-in-Code.
-- Effects:
-- This procedure is called when the sort_by parameter is set to LOCATION.
-- It sorts the pairs files alphabetically. Then from each file it gets those
-- lines which contain pairs sorted by location and passes them to
-- proccess_ location_line.

procedure requirement_merge (pairs_files: in sl.list);  -- list of pairs files
--| Requirements Satisfied: that (6) 9
-- Raises:

-- Requires:
-- The files in pairs_list must be pairs files, e.i. files created by
-- REQSREF, containing pairs of Requirement-Cited and Location-in-Code.

-- Effects:
-- This procedure is called when the sort_by parameter is set to REQUIREMENT.
-- It merges the pairs which are sorted by requirement so that a report can
-- be generated. The records are first sorted by REQUIREMENT then by file
-- names, then by line numbers.

procedure process_location_line (
                      line: in sp.string_type);  -- A string whose first
                                                 -- part is a requirement,
                                                 -- followed by a list of Ada
                                                 -- locations and line numbers

-- Raises:

-- Requires:

-- Effects:
-- Gets the requirements, Ada unit names and line numbers of the requirement
-- in the file from LINE and prints the information to the report file.

procedure process_req_line (line: in sp.string_type;  -- A string whose first
                                                      -- part is an Ada unit
                                                      -- name. That is followed
                                                      -- by a list of
                                                      -- requirements and their
                                                      -- line_numbers in the
                                                      -- file.
                            req : in out req_record); -- The record whose
                                                      -- fields are to hold
                                                      -- information from
                                                      -- line
-- Raises:

-- Requires:

-- Effects:
-- Takes Requirement and Location from line and assigns them to the
-- appropriate fields of req.

procedure print_record (req: in req_record);   -- Record to be printed
-- Raises:
-- Requires:
-- Effects:
-- Prints information from the req_record to the report file.


function get_path (file_name: in sp.string_type) -- complete file name
                   return path;
-- Raises:

-- Requires:

-- Efects:
-- Returns a list of the components of the file name.


function image   -- list of components of a file name
                return string;
-- Raises:

-- Requires:

-- Effects:
-- Returns string which contains the file name


function req_less_eq (x: req_record;
                      y: req_record)
                      return boolean;
-- Raises:
-- Requires:
-- Effects:
-- This comparison function compares the reference_string fields and the
-- file_name fields of x and y. It returns true if x.ref , y.ref, or if
-- in case of their equality x.file_name <= y.file_name.


procedure req_sort is new heap_sort  ;
-- Requires:

-- Effects:
-- Sorts an array of req_records first by reference strings then by file
-- names.

-- Raises:
-- Requires:
-- Effects:
-- For a given pairs file name this function returns the corresponding source
-- file name.

end merge_pkg;
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--sort.spc
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
-- $Source: /nosc/work/abstractions/sort/RCS/sort.spc,v $
-- $Revision: 1.2 $ -- $Date: 85/01/31 16:43:49 $ -- $Author: ron $

-- $Source: /nosc/work/abstractions/sort/RCS/sort.spc,v $
-- $Revision: 1.2 $ -- $Date: 85/01/31 16:43:49 $ -- $Author: ron $

generic
    type item_type is private;
        --| Component type of array to be sorted.

    with function "<="(x, y: item_type) return boolean;
        --| Required to totally order item_type;

    type index_type is (<>);
        --| Index type of array to be sorted.
--| Requirements_Satisfied:a.c 4
    type sequence is array(index_type range <>) of item_type;
        --| Type of array to be sorted.

procedure heap_sort(s: in out sequence) --| Requirements_Satisfied: now 4
                                        ;--| Requirements_Satisfied:heute 3
    --| Overview:
    --| Heap sort is an O(n lg n) guaranteed time sorting algorithm.
    --| This procedure provides heap sort for arrays of arbitrary index
    --| and component type.
--| Requirements_Satisfied:b.c 99
    --| Notes:
    --| Programmer: Ron Kownacki

    --| Effects:
    --|     Let s1 and s2 denote the value of s before and after an
    --| invocation of heap_sort.  Then s1 and s2 have the following
    --| properties:
    --|   1. For i,j in s'range, i <= j implies that s2(i) <= s2(j).
    --|   2. s2(s'first) through s2(s'last) is a permutation of
    --|      s1(s'first) through s1(s'last).
    --|
    --| Requires:
    --|     <= must form a total order over item_type.
    --|
    --| Algorithm:
    --|     The algorithm is described in Knuth, vol 3, and Aho et al,
    --| The Design and Analysis of Computer Algorithms.
    --| Requirements_Satisfied:u.v 1.2.3

--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--sptest.spc
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
Package Delim_Test is

-- See if spaces can be used to separate requirement strings:

procedure P;
--| Requirement: Doc.Name 1.1 Doc.Name 1.2

end Delim_Test;
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--b910acab.ada
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
-- B910ACA-B.ADA

-- CHECK THAT THE IDENTIFIER OF A SINGLE TASK NAMES A TASK OBJECT
-- NOT A TASK TYPE.
--
--
--

-- WEI  3/ 4/82
-- RJK  2/ 1/84     ADDED TO ACVC

PROCEDURE B910ACA IS

     I : INTEGER;

     TASK T IS  --| Requirements Satisfied: a.b.c 7
          ENTRY E;
     END T;

     THIS_TASK : T;    -- ERROR: T DENOTES A TASK OBJECT, NOT A TYPE.

     TASK BODY T IS
     --| Requirements_Satisfied: a.n 11
     BEGIN
          ACCEPT E;
     END T;

BEGIN
     T.E;                   -- OK.
     I := T'STORAGE_SIZE;   -- OK.
     I := T.E'COUNT;        -- ERROR: NOT INSIDE TASK.
     I := T'SIZE;           -- OK.
END B910ACA;
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--rtest.ada
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
-------SPEC---------------------------------------------------------------
function REQSREF return INTEGER   --|Requirements_Satisfied:bill(7) 5
; --|Requirements_Satisfied:hans 6
--------BODY---------------------------------------------------------------
with reqs; use reqs;  --Thea 8
with string_lists;
with Standard_interface;
with string_pkg;  use string_pkg;
--|Requirements_Satisfied:Thea 5
with file_manager;
with Text_io;
with host_lib;

function REQSREF --|Requirements_Satisfied:here 3.2
 return INTEGER is
--|Requirements_Satisfied:one.two 888

package SP  renames string_pkg;
package FM  renames file_manager;
package stringtype is new standard_interface.string_argument("string");
package SORT is new STANDARD_INTERFACE.ENUMERATED_ARGUMENT(
                              ENUM_TYPE    => SORT_TYPE,
                              ENUM_TYPE_NAME => "sort_type");
Reqsr:   Standard_Interface.Process_Handle;
--|Requirements_Satisfied:STRING 88

output_file : SP.string_type;
SOURCE_LIST : STRING_LISTS.LIST;
--PAIRS_LIST  : STRING_LISTS.LIST;
SORT_KIND : SORT_TYPE;
--report    : boolean;
debug_string : SP.string_type;
report_string : SP.string_type;
SOURCE_ARG: SP.STRING_TYPE;
PAIRS_ARG: SP.STRING_TYPE;
OUTPUT_ARG : SP.STRING_TYPE;
FILE:      SP.STRING_TYPE;
Iter:      string_lists.listiter;

    procedure parse_file_names (input : in out SP.string_type;
                 list  : in out string_lists.list) is


    position : natural := 1;
    prev_pos : natural := 1;
    --|Requirements_Satisfied: a.b(1)33
        temp_pos : natural := 1;
    output   : SP.string_type;
    name     : SP.string_type;
    length   : natural;
    file_names : string_lists.list;

    name_error : exception;        -- raised when a name is enclosed by

procedure TRY is
I: INTEGER;
begin
--|Requirements_Satisfied: this 5
TEXT_IO.PUT("done");
end try;                    -- only one quote

    begin
        SP.mark;
        loop
        -- get each element of a comma separated list.
        -- the list must not be empty to start with.
            exit when position = 0;

               position := SP.match_c (input, ',', prev_pos);
        -- match the next comma, 0 indicates there isn't one
            if position = 0 then
            name := SP.substr (input,
                       prev_pos,
                       (SP.length (input)- (prev_pos - 1) ));
        else
            name := SP.substr (input,
                       prev_pos,
                       position - prev_pos);
        end if;
        length :=  SP.length (name);
        if SP.equal (SP.substr (name, 1, 1), """") and
           SP.equal (SP.substr (name, length, 1), """") then
            output := output & name & ", ";
            name := SP.substr (name, 2, length-2);
        elsif SP.equal (SP.substr (name, 1, 1), """") or
              SP.equal (SP.substr (name, length, 1), """") then
            raise name_error;
        else
            output := output & """" & name & """, ";
        end if;
        begin
            file_names := FM.expand (name,
                         FM.No_Version
                        );
            string_lists.Attach (list,
                        file_names);
            exception
            when FM.file_not_found =>
                Text_io.Put ("File ");
                Text_io.put (SP.value (name));
                TEXT_IO.PUT_LINE (" does not exist.");
                exit;
            when FM.device_not_ready =>
                Text_io.put ("Device not ready: ");
                Text_io.put_line (SP.value (name));
                exit;
            when FM.directory_not_found =>
                Text_io.put ("Directory not found: ");
                Text_io.put_line (SP.value (name));
                exit;
            when FM.Expand_error | FM.parse_error =>
                Text_io.put ("File name error: ");
                Text_io.put_line (SP.value (name));
                exit;
            end;
        -- skip any spaces after the comma.
        temp_pos := SP.match_not_c (input, ' ', position+1);
            prev_pos := temp_pos;
    end loop;
    input := SP.make_persistent (SP.upper (SP.substr (
                        output,
                             1,
                             SP.length (output)-2)));
      -- substring because output will always have an extra ', ' on
      -- the end which we want to strip off.

    SP.release;

     end ;
     --|Requirements_Satisfied:last_string 97


begin  -- reqsref
--|Requirements_Satisfied:test 110.1
        sp.mark;
        Host_Lib.Set_Error;

        Standard_Interface.Define_Process(
    Proc    => Reqsr,
    Name    => "Requirements_Reference",
    Help    => "Reqsrefs Ada source file");
--|Requirements_Satisfied:Very_long_requirement_string(65) 1.2.3
    Stringtype.Define_Argument(
    Proc => Reqsr,
    Name => "source_files",
    Help => "Names of the input source files");

    Stringtype.Define_Argument(
    Proc    => Reqsr,
    Name    => "output",
    Default => "",
    Help    => "Name of the report file (defaults to standard output)");

        sort.Define_Argument(
    Proc    => Reqsr,
    Name    => "sort",
    Default => requirement,
    Help    => "requirement or location (defaults to requirement)");

    Standard_Interface.Define_Help(
    Proc => Reqsr,
    HELP => "    Put help here");

    STANDARD_INTERFACE.APPEND_HELP(
        PROC => REQSR,
        help => "more help");

        Standard_Interface.Parse_Line(Reqsr);

        SOURCE_ARG := STRINGTYPE.GET_ARGUMENT(
                          PROC => REQSR,
                          NAME => "source_files");
        OUTPUT_ARG := STRINGTYPE.GET_ARGUMENT(
                          PROC => REQSR,
                          NAME => "output");


        SP.Release;




        PARSE_FILE_NAMES (source_arg, SOURCE_LIST);
        --parse_file_names (pairs_arg, pairs_list);
        output_file := SP.make_persistent (output_arg);
    --SORT_KIND := SORT_TYPE'VALUE (SP.VALUE (ARG_ARRAY (4)));
        --report    := boolean'value (sp.value (arg_array (5)));

    --debug_string := arg_array (1);

        if not string_lists.IsEmpty (source_list) then
        ITER := STRING_LISTS.MAKELISTITER (SOURCE_LIST);
            while STRING_LISTS.MORE (ITER) loop
                begin
                    string_lists.next (iter, file);
                    DO_SOURCE_FILE (FILE);
                end;
            end loop;
    else
        Text_io.put_line ("No input files: not generating a report.");
        end if;



    return host_lib.return_code(Host_lib.success);

    exception
--|Requirements_Satisfied: new(4)4.5
        when STANDARD_INTERFACE.PROCESS_HELP =>
            return HOST_LIB.RETURN_CODE(HOST_LIB.INFORMATION);
        when STANDARD_INTERFACE.ABORT_PROCESS =>
            return host_lib.return_code(host_lib.error);
--    when internal_error =>
--        Text_io.put ("Compile_Order internal error");
--    when others =>
--        Text_io.put ("Compile_Order internal error");

end reqsref;
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--mtest.bdy
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
with paginated_output;
package body merge_pkg is
--| Requirements Satisfied
--| green 3
 package PO renames paginated_output;
--| Requirements_Satisfied
--| another (4) 8
package int_io is new text_io.integer_io (integer);
int_string: string(1..6);
last: integer;
source_file_name: sp.string_type;
--
--
function get_path (file_name: in sp.string_type) return path is
--| Requirements Satisfied:     u.v 1.2.3
   position: natural := 8;
--
   prev_pos: natural := 8;
   temp_pos: natural := sp.match_c (file_name, ']', 1);
   component: sp.string_type := sp.create ("");
   path_name: sl.list := sl.create;

   begin
      sp.mark;
      loop
         exit when position >= temp_pos;
         position := sp.match_c(file_name, '.', prev_pos);
         if position > temp_pos then
            position := temp_pos;
         end if;
         component := sp.substr(file_name,
                                prev_pos,
                                position - prev_pos);
         path_name := sl.attach(path_name, component);
         prev_pos := position + 1;
      end loop;
      component := sp.substr(file_name,
                             prev_pos,
                             sp.length(file_name)  - (prev_pos -1));
      path_name := sl.attach(path_name, component);
      return path_name;
   end get_path;

function image return string is
--| Requirements_Satisfied:
--| u.v 1.2.3
   index: integer;
   s: sp.string_type := sp.create("[");
   t: sp.string_type;
   iter: sl.listiter := sl.makelistiter(path_name);
   begin
      for index in 1 .. sl.length(path_name) - 2 loop
         sl.next(iter, t);
         s := sp."&"(s, t);
         s := sp."&"(s, ".");
      end loop;
      sl.next(iter, t);
      s := sp."&"(s, t);
      s := sp."&"(s,"]");
      sl.next(iter, t);
      s := sp."&"(s,t);
      return sp.value(s);
   end image;

   procedure location_merge (pairs_files: in sl.list) is

   -- This procedure sorts and reada pairs files. A pairs file is a file
   -- created by REQSREF, which contains two sections: pairs sorted by
   -- requirement and the same pairs sorted by location. '@' is used to
   -- separate these sections. Location_merge is only interested in the
   -- second part of a pairs file, the pairs sorted by location.
   -- The elements of the pairs_files list are first sorted and stored in a
   -- binary tree. Then each file is opened and read line by line. When the
   -- separator '@' is found the following lines are passed to process_
   -- location_line in order to be printed.

      present: boolean;
      max_line: integer := 1000;
      line: string (1..max_line);
      str: sp.string_type;
      pairs_file: text_io.file_type;
      path_name: path;
      list_iter: sl.listiter;
      root: ftp.tree;
      file_iter: ftp.treeiter;

      begin
      -- sort the pairs_files
         file_tree := ftp.create;
         list_iter := sl.makeListIter(pairs_files);
         while sl.more (list_iter) loop
            sl.next(list_iter, str);
            path_name := get_path (str);
            ftp.insertnode (path_name, file_tree, root, present);
         end loop;

         -- For each pairs file get the stored information line by line.
         file_iter := ftp.maketreeIter(file_tree);
         while ftp.more(file_iter) loop
            ftp.next(file_iter, path_name);
            text_io.open (file => pairs_file,
                          mode => text_io.in_file,
                          name => image(path_name));

            text_io.set_input(pairs_file);
            str := sp.create (image (path_name));
            source_file_name := get_source_file_name (str);
--| Requirements Satisfied: u.v 1.2.3
            -- Skip over the first part of the file which contains the
            -- pairs sorted by reqrequirement.
            loop
               text_io.get_line (pairs_file, line, last);
               exit when line(1) = '@';
            end loop;
            while not text_io.end_of_file (pairs_file) loop
               text_io.get_line (pairs_file, line, last);
               process_location_line (sp.create(line));
            end loop;
            text_io.close (pairs_file);
         end loop;
      end location_merge;

   procedure process_location_line (line: in sp.string_type) is

   -- This procedure takes a location line and extracts from it the
   -- location (which is a full Ada name) and the reference strings with
   -- their line numbers. These items are then printed to the report file.
   -- '%' separates the location from the list of reference strings. Two
   -- reference strings are separated by '$', and ',' is used to separate
   -- a reference string and its line number.

      location_string: sp.string_type;
      req_string     : sp.string_type;
      number: integer;
      line_number    : sp.string_type;
      position, prev_pos : natural := 1;
      temp_pos: positive;

      begin
         position := sp.match_c (line,
                                 '%',
                                 prev_pos);
         location_string := sp.substr(line,
                                      prev_pos,
                                      position - prev_pos);
         prev_pos := position + 1;
--| Requirements Satisfied
--| u.v 1.2.3
         loop
            position := sp.match_c (line,
                                    ',',
                                    prev_pos);
            exit when position = 0 ;
            req_string := sp.substr (line,
                                     prev_pos,
                                     position - prev_pos);
            prev_pos := position + 1;
            position := sp.match_c (line,
                                    '$',
                                    prev_pos);
            line_number := sp.substr (line,
                                      prev_pos,
                                      position - prev_pos);

            prev_pos := position + 1;
            po.put (source_file_name);
            po.space (file_name_width - sp.length (source_file_name));
            po.put (location_string);
            po.space(unit_width - sp.length (location_string));
            po.put (req_string);
            po.space (ref_width - sp.length (req_string));
            int_io.get (sp.value(line_number),
                        number,
                        temp_pos);
            int_io.put (int_string, number );
            po.put_line ( int_string);
            exit when prev_pos >= last;
         end loop;
      end process_location_line;

   function req_less_eq (x: req_record;
                         y: req_record) return boolean is
      p: path := get_path (x.pairs_file_name);
      q: path := get_path (y.pairs_file_name);
      begin
         if document_ref."<" (x.ref, y.ref) then
            return true;
         elsif document_ref.eq (x.ref, y.ref) then
            if lessthan(p, q) then
               return true;
            else
               return false;
            end if;
         else
            return false;
         end if;
      end req_less_eq;

   procedure requirement_merge (pairs_files: in sl.list) is

   -- Algorithm:
   -- Assign the file names in the pairs_files list to the file_name
   -- fields of the records in req_array. For each element x in req_array
   -- open the corresponding pairs file, read its first line and assign
   -- the appropriate strings to x.ref and x.location_string (see
   -- process_req_line). Sort the records in req_array tirst by requirements
   -- then by file names. Pass the first record to print_record.
   -- Let start be 1.
   -- while more records are found loop
   --     read the next line from req_array(start).file.
   --     if the end of the relevant information in that file is found then
   --        start := start + 1
   --        pass req_array(start) to print_record.
   --        read next line from req_array(start).file
   --     end if
   --     replace req_array(start) with the new record.
   --     insert new record in proper place in req_array.
   --     pass req_array(start) to print_record.
   -- ene loop

      subtype pairs_file_seq is seq (1 .. sl.length (pairs_files));

      max_line: integer := 1000;
      str: sp.string_type;
      line: string(1 .. max_line);
      i: natural;
      start: natural := 1;
      iter: sl.listIter := sl.MakeListIter (pairs_files);
      req_array: pairs_file_seq;

      begin
         i := 0;
         while sl.more (iter) loop
            i := i + 1;
            sl.next (iter, req_array(i).pairs_file_name);
            req_array(i).source_file_name := get_source_file_name (
                                             req_array(i).pairs_file_name);
            req_array(i).pairs_file := new text_io.file_type;
            text_io.open (
                  file => req_array(i).pairs_file.all,
                  name => sp.value(req_array(i).pairs_file_name),
                  mode => text_io.in_file);
            text_io.get_line (req_array(i).pairs_file.all, line, last);
            str := sp.substr (sp.create (line), 1, last);
            process_req_line (str,
                              req_array(i));
         end loop;
         req_sort (req_array);
         print_record (req_array(start));
         loop
            text_io.get_line(req_array(start).pairs_file.all, line, last);
            if line(1) = '@' then
               text_io.close (req_array(start).pairs_file.all);
               exit when start = sl.length (pairs_files);
               start := start + 1;
               print_record (req_array(start));
               text_io.get_line (req_array(start).pairs_file.all, line, last);
            end if;
            exit when line(1) = '@';
            str := sp.substr (sp.create (line), 1, last);
            process_req_line (str,
                              req_array(start));
            req_sort (req_array);
            print_record (req_array(start));
         end loop;
      end requirement_merge;

   procedure process_req_line (line: in sp.string_type;
                               req: in out req_record) is

   -- This procedure looks at a req_line and extracts the reference
   -- string and the locations from it. The reference string is assigned to
   -- req.ref and the location part is assigned to req.location_string.
   -- '%' separates the reference string from the list of locations.

      position: natural := 1;
      prev_pos: natural := 1;
      i: natural := 1;
      str: sp.string_type;
      begin
         position := sp.match_c (line, '%', prev_pos);
         str := sp.substr (line, prev_pos,
                           position - prev_pos);
         document_ref.scan (s => sp.value(str),
                            index => i,
                            rs => req.ref);
         prev_pos := position + 1;
         req.location_string := sp.substr (line, prev_pos,
                                       sp.length (line) - position);
      end process_req_line;

   procedure print_record (req: in req_record) is

   -- This prints information from req to the report file. req.location_string
   -- contains Ada unit names and the line numbers of the requirements.
   -- '$' separates two locations, and ',' separates a unit name from a line
   -- number.

      location_string: sp.string_type;
      line_number: sp.string_type;
      position: natural := 1;
      temp_pos: natural;
      number: integer;
      prev_pos: natural := 1;
      str: sp.string_type;
      refstr: sp.string_type;

      begin
         refstr := sp.create (document_ref.image (req.ref));
         loop
            position := sp.match_c (req.location_string, ',', prev_pos);
            exit when position = 0;
            location_string := sp.substr (req.location_string, prev_pos,
                                          position - prev_pos);
            prev_pos := position + 1;
            position := sp.match_c (req.location_string, '$', prev_pos);
            line_number := sp.substr (req.location_string, prev_pos,
                                          position - prev_pos);

            prev_pos := position + 1;
            po.put (refstr);
            po.space (ref_width - sp.length (refstr));
            po.put (req.source_file_name);
            po.space (file_name_width - sp.length (req.source_file_name));
            po.put (location_string);
            po.space (unit_width - sp.length (location_string));
            int_io.get (sp.value (line_number),
                        number,
                        temp_pos);
            int_io.put (int_string, number);
            po.put_line (int_string);
            exit when prev_pos >= last;
         end loop;

      end print_record;

   function get_source_file_name (
                    pairs_file_name: in sp.string_type)
                    return sp.string_type is
      suffix: sp.string_type;

      begin
         suffix := sp.substr (
                   pairs_file_name, sp.length(pairs_file_name) - 2, 3);
         if sp.equal (suffix, "APR") then
            suffix := sp.create ("ADA");
         elsif sp.equal (suffix, "BPR") then
            suffix := sp.create ("BDY");
         elsif sp.equal (suffix, "DPR") then
            suffix := sp.create ("DAT");
         elsif sp.equal (suffix, "SPR") then
            suffix := sp.create ("SPC");
         elsif sp.equal (suffix, "UPR") then
            suffix := sp.create ("SUB");
         else
            Text_io.put_line (text_io.standard_output,
                              sp.value (pairs_file_name) &
                              " is not a pairs_file.");
      end if;
      return (sp."&" (
              sp.substr (pairs_file_name, 1, sp.length (pairs_file_name) - 3),
              suffix));
   end get_source_file_name;

end merge_pkg;
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--noname.som
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
-- B83A01C.ADA


-- CHECK THAT A STATEMENT LABEL INSIDE AN ACCEPT STATEMENT CANNOT BE
--    THE SAME AS A STATEMENT LABEL OUTSIDE IT.


-- RM 02/05/80


PROCEDURE  B83A01C  IS

     TASK  TASK1  IS
                     --| Requirements_Satisfied: name_5 (1.2) 1.2
          ENTRY  E1 ;
          ENTRY  E2 ;
    END  TASK1 ;

     TASK BODY  TASK1  IS
     BEGIN

          << LAB_OUTSIDE_INACCEPT >>             NULL ;
                      --| Requirements_Satisfied: name_5(1.2) 1.1
          BEGIN

               << LAB_INBLOCK_INACCEPT >>        NULL ;

               FOR  I  IN  1..2  LOOP
                    << LAB_INBLOCKLOOP_INACCEPT>>NULL ;
               END LOOP;

          END ;

          FOR  I  IN  INTEGER  LOOP
               << LAB_INLOOP_INACCEPT >>         NULL ;
          END LOOP;

          <<L1>> null;
          if I = 2 then
               I := 7;
      else
               goto L;
          end if;
          goto L1;
          <<L>> null;

          ACCEPT  E1  DO
               << LAB_OUTSIDE_INACCEPT >>        NULL ;-- ERROR: DUPLIC.
               << LAB_INBLOCK_INACCEPT >>        NULL ;-- ERROR: DUPLIC.
               << LAB_INBLOCKLOOP_INACCEPT>>     NULL ;-- ERROR: DUPLIC.
               << LAB_INLOOP_INACCEPT >>         NULL ;-- ERROR: DUPLIC.
               << LAB_INACCEPT_INACCEPT >>       NULL ;
          END  E1 ;

          ACCEPT  E2  DO
               << LAB_INACCEPT_INACCEPT >>       NULL ;-- ERROR: DUPLIC.
          END  E2 ;

     END  TASK1 ;

BEGIN

          <<L1>> null;
--| Requirements_Satisfied: name.name(1.9.66).name(1.2) 6
          if I = 2 then
               I := 7;

--| Requirements_Satisfied: name.name(1.9.66).name(1.2) 6
      else
               goto L;
          end if;
          goto L1;
          <<L>> null;

     NULL ;

END B83A01C ;
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--mtest.bpr
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
USER1:[NOSC.RELEASES.V0301.REQSREF.TEST]MTEST.BDY
another(4) 8%merge_pkg, 7$
green 3%merge_pkg, 4$
u.v 1.2.3%merge_pkg.get_path, 15$merge_pkg.image, 46$merge_pkg.location_merge, 108$merge_pkg.process_location_line, 148$
@
merge_pkg%another(4) 8, 7$green 3, 4$
merge_pkg.get_path%u.v 1.2.3, 15$
merge_pkg.image%u.v 1.2.3, 46$
merge_pkg.location_merge%u.v 1.2.3, 108$
merge_pkg.process_location_line%u.v 1.2.3, 148$
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--rtest.apr
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
USER1:[NOSC.RELEASES.V0301.REQSREF.TEST]RTEST.ADA
a.b(1) 33%REQSREF.parse_file_names, 46$
bill(7) 5%REQSREF, 2$
hans 6%REQSREF, 3$
here 3.2%REQSREF, 14$
last_string 97%REQSREF.parse_file_names, 130$
new(4) 4.5%REQSREF, 208$
one.two 888%REQSREF, 16$
STRING 88%REQSREF, 25$
test 110.1%REQSREF, 134$
Thea 5%, 9$
this 5%REQSREF.parse_file_names.TRY, 58$
Very_long_requirement_string(65) 1.2.3%REQSREF, 142$
@
%Thea 5, 9$
REQSREF%bill(7) 5, 2$hans 6, 3$here 3.2, 14$new(4) 4.5, 208$one.two 888, 16$STRING 88, 25$test 110.1, 134$Very_long_requirement_string(65) 1.2.3, 142$
REQSREF.parse_file_names%a.b(1) 33, 46$last_string 97, 130$
REQSREF.parse_file_names.TRY%this 5, 58$
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--b910acab.apr
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
USER1:[NOSC.RELEASES.V0301.REQSREF.TEST]B910ACAB.ADA
a.b.c 7%B910ACA.T, 16$
a.n 11%B910ACA.T, 23$
@
B910ACA.T%a.b.c 7, 16$a.n 11, 23$
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--noname.pr
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
USER1:[NOSC.RELEASES.V0301.REQSREF.TEST]NONAME.SOM
name.name(1.9.66).name(1.2) 6%B83A01C, 64$B83A01C, 68$
name_5(1.2) 1.1%B83A01C.TASK1, 23$
name_5(1.2) 1.2%B83A01C.TASK1, 14$
@
B83A01C%name.name(1.9.66).name(1.2) 6, 64$name.name(1.9.66).name(1.2) 6, 68$
B83A01C.TASK1%name_5(1.2) 1.1, 23$name_5(1.2) 1.2, 14$
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--ktest.spr
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
USER1:[NOSC.RELEASES.V0301.REQSREF.TEST]KTEST.SPC
Doc.Name.LC 1%kTest.LC, 57$
Doc.Name.P 1%kTest.P, 6$kTest.P1, 32$
Doc.Name.P 2%kTest.P, 7$kTest.P1, 33$
Doc.Name.P 3%kTest.P, 8$kTest.P1, 34$
Doc.Name.P.Minus 3%kTest.P, 10$kTest.P1, 36$
Doc.Name.P.Plus 2%kTest.P, 9$kTest.P1, 35$
Doc.Name.Q 1%kTest.Q, 14$
Doc.Name.Q 2%kTest.Q, 14$
Doc.Name.Q 3%kTest.Q, 14$
Doc.Name.Q1 1%kTest.Q1, 39$
Doc.Name.Q1 2%kTest.Q1, 39$
Doc.Name.Q1 3%kTest.Q1, 39$
Doc.Name.R 1%kTest.R, 18$
Doc.Name.R 1.1%kTest.R, 19$
Doc.Name.R 1.2%kTest.R, 20$
Doc.Name.R 2%kTest.R, 18$
Doc.Name.R 2.1%kTest.R, 19$
Doc.Name.R 2.2%kTest.R, 20$
Doc.Name.R 3%kTest.R, 18$
Doc.Name.R 3.1%kTest.R, 19$
Doc.Name.R 3.2%kTest.R, 20$
Doc.Name.R1 1%kTest.R1, 42$
Doc.Name.R1 1.1%kTest.R1, 43$
Doc.Name.R1 1.2%kTest.R1, 44$
Doc.Name.R1 2%kTest.R1, 42$
Doc.Name.R1 2.1%kTest.R1, 43$
Doc.Name.R1 2.2%kTest.R1, 44$
Doc.Name.R1 3%kTest.R1, 42$
Doc.Name.R1 3.1%kTest.R1, 43$
Doc.Name.R1 3.2%kTest.R1, 44$
Doc.Name.S 1%kTest.S, 24$
Doc.Name.S 1.1%kTest.S, 25$
Doc.Name.S 1.2%kTest.S, 26$
Doc.Name.S 2%kTest.S, 24$
Doc.Name.S 2.1%kTest.S, 25$
Doc.Name.S 2.2%kTest.S, 26$
Doc.Name.S 3%kTest.S, 24$
Doc.Name.S 3.1%kTest.S, 25$
Doc.Name.S 3.2%kTest.S, 26$
Doc.Name.S1 1%kTest.S1, 47$
Doc.Name.S1 1.1%kTest.S1, 48$
Doc.Name.S1 1.2%kTest.S1, 49$
Doc.Name.S1 2%kTest.S1, 47$
Doc.Name.S1 2.1%kTest.S1, 48$
Doc.Name.S1 2.2%kTest.S1, 49$
Doc.Name.S1 3%kTest.S1, 47$
Doc.Name.S1 3.1%kTest.S1, 48$
Doc.Name.S1 3.2%kTest.S1, 49$
Doc.Name.UC 1%kTest.UC, 53$
Ref 1%kTest.Ref_1_2_no_3, 60$
Ref 2%kTest.Ref_1_2_no_3, 61$
@
kTest.LC%Doc.Name.LC 1, 57$
kTest.P%Doc.Name.P 1, 6$Doc.Name.P 2, 7$Doc.Name.P 3, 8$Doc.Name.P.Minus 3, 10$Doc.Name.P.Plus 2, 9$
kTest.P1%Doc.Name.P 1, 32$Doc.Name.P 2, 33$Doc.Name.P 3, 34$Doc.Name.P.Minus 3, 36$Doc.Name.P.Plus 2, 35$
kTest.Q%Doc.Name.Q 1, 14$Doc.Name.Q 2, 14$Doc.Name.Q 3, 14$
kTest.Q1%Doc.Name.Q1 1, 39$Doc.Name.Q1 2, 39$Doc.Name.Q1 3, 39$
kTest.R%Doc.Name.R 1, 18$Doc.Name.R 1.1, 19$Doc.Name.R 1.2, 20$Doc.Name.R 2, 18$Doc.Name.R 2.1, 19$Doc.Name.R 2.2, 20$Doc.Name.R 3, 18$Doc.Name.R 3.1, 19$Doc.Name.R 3.2, 20$
kTest.R1%Doc.Name.R1 1, 42$Doc.Name.R1 1.1, 43$Doc.Name.R1 1.2, 44$Doc.Name.R1 2, 42$Doc.Name.R1 2.1, 43$Doc.Name.R1 2.2, 44$Doc.Name.R1 3, 42$Doc.Name.R1 3.1, 43$Doc.Name.R1 3.2, 44$
kTest.Ref_1_2_no_3%Ref 1, 60$Ref 2, 61$
kTest.S%Doc.Name.S 1, 24$Doc.Name.S 1.1, 25$Doc.Name.S 1.2, 26$Doc.Name.S 2, 24$Doc.Name.S 2.1, 25$Doc.Name.S 2.2, 26$Doc.Name.S 3, 24$Doc.Name.S 3.1, 25$Doc.Name.S 3.2, 26$
kTest.S1%Doc.Name.S1 1, 47$Doc.Name.S1 1.1, 48$Doc.Name.S1 1.2, 49$Doc.Name.S1 2, 47$Doc.Name.S1 2.1, 48$Doc.Name.S1 2.2, 49$Doc.Name.S1 3, 47$Doc.Name.S1 3.1, 48$Doc.Name.S1 3.2, 49$
kTest.UC%Doc.Name.UC 1, 53$
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--mtest.spr
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
USER1:[NOSC.RELEASES.V0301.REQSREF.TEST]MTEST.SPC
a 9%, 3$
one.two 4.5%merge_pkg, 9$
red 89%merge_pkg, 11$
requirement 5%merge_pkg, 23$
that(6) 9%merge_pkg.requirement_merge, 53$
u.v 1.2.3%merge_pkg, 13$merge_pkg.location_merge, 42$
@
%a 9, 3$
merge_pkg%one.two 4.5, 9$red 89, 11$requirement 5, 23$u.v 1.2.3, 13$
merge_pkg.location_merge%u.v 1.2.3, 42$
merge_pkg.requirement_merge%that(6) 9, 53$
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--sort.spr
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
USER1:[NOSC.RELEASES.V0301.REQSREF.TEST]SORT.SPC
a.c 4%, 16$
b.c 99%, 26$
heute 3%, 21$
now 4%heap_sort, 20$
u.v 1.2.3%, 44$
@
%a.c 4, 16$b.c 99, 26$heute 3, 21$u.v 1.2.3, 44$
heap_sort%now 4, 20$
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--test2.sub
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--with text_io;
--| Requirements_Satisfied:    AUI 99
with ParserDeclarations;
with reqsref_Utilities;

separate (Lex)
function GetNextNonCommentToken return PD.ParseStackElement is

        use reqsref_Utilities;

    begin
--| Requirements_Satisfied: a 9
        loop
            CST := GetNextSourceToken;

            if (CST.gram_sym_val = PT.PackageTokenValue) OR
               (CST.gram_sym_val = PT.ProcedureTokenValue) OR
               (CST.gram_sym_val = PT.FunctionTokenValue) OR
               (CST.gram_sym_val = PT.TaskTokenValue) then

--| Requirements_Satisfied:first 3.5
                Ident_Flag := True;

            elsif (CST.gram_sym_val = PT.IdentifierTokenValue) OR
                  (CST.gram_sym_val = PT.StringTokenValue) then

                if Ident_Flag then
                    Identifier := CST.lexed_token.text;
                    Ident_Flag := False;
                end if;

            end if;

            if (CST.gram_sym_val = PT.Comment_TokenValue) then
                if (is_docref(pd.get_source_text(cst.lexed_token.text))) then
                   Text_io.put_line (pd.get_source_text(CST.lexed_token.text));
                end if;
            end if;


            exit when (CST.gram_sym_val = PT.EOF_TokenValue) or
                      (CST.gram_sym_val /= PT.Comment_TokenValue);


        end loop;

        Previous_Line := CST.lexed_token.srcpos_line;

--| Requirements_Satisfied:           a.b(1) 1.2
--| Requirements_Satisfied:first 3.5
-- TEXT_IO.Put_Line(PD.Dump_Parse_Stack_Element(CST));
--| Requirements_Satisfied:a(1).b.c(2)5.5
--| Requirements_Satisfied:u.v 1.2.3

        return CST; -- return the token that is not a comment
    end GetNextNonCommentToken;
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--test2.upr
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
USER1:[NOSC.RELEASES.V0301.REQSREF.TEST]TEST2.SUB
a 9%GetNextNonCommentToken, 12$
a.b(1) 1.2%GetNextNonCommentToken, 49$
a(1).b.c(2) 5.5%GetNextNonCommentToken, 52$
AUI 99%, 2$
first 3.5%GetNextNonCommentToken, 21$GetNextNonCommentToken, 50$
u.v 1.2.3%GetNextNonCommentToken, 53$
@
%AUI 99, 2$
GetNextNonCommentToken%a 9, 12$a.b(1) 1.2, 49$a(1).b.c(2) 5.5, 52$first 3.5, 21$first 3.5, 50$u.v 1.2.3, 53$
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--run3.rpt
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

REQUIREMENTS_REFERENCE                             01/24/86  12:17:25   Page   1
Reqsref Report
Requirement         File             Line   Unit

a 9                 MTEST.SPC           3
a 9                 TEST2.SUB          12   GetNextNonCommentToken
a.b(1) 1.2          TEST2.SUB          49   GetNextNonCommentToken
a.b(1) 33           RTEST.ADA          46   REQSREF.parse_file_names
a.b.c 7             B910ACAB.ADA       16   B910ACA.T
a(1).b.c(2) 5.5     TEST2.SUB          52   GetNextNonCommentToken
a.c 4               SORT.SPC           16
a.n 11              B910ACAB.ADA       23   B910ACA.T
another(4) 8        MTEST.BDY           7   merge_pkg
AUI 99              TEST2.SUB           2
b.c 99              SORT.SPC           26
bill(7) 5           RTEST.ADA           2   REQSREF
Doc.Name.LC 1       KTEST.SPC          57   kTest.LC
Doc.Name.P 1        KTEST.SPC           6   kTest.P
Doc.Name.P 1        KTEST.SPC          32   kTest.P1
Doc.Name.P 2        KTEST.SPC           7   kTest.P
Doc.Name.P 2        KTEST.SPC          33   kTest.P1
Doc.Name.P 3        KTEST.SPC           8   kTest.P
Doc.Name.P 3        KTEST.SPC          34   kTest.P1
Doc.Name.P.Minus 3  KTEST.SPC          10   kTest.P
Doc.Name.P.Minus 3  KTEST.SPC          36   kTest.P1
Doc.Name.P.Plus 2   KTEST.SPC           9   kTest.P
Doc.Name.P.Plus 2   KTEST.SPC          35   kTest.P1
Doc.Name.Q 1        KTEST.SPC          14   kTest.Q
Doc.Name.Q 2        KTEST.SPC          14   kTest.Q
Doc.Name.Q 3        KTEST.SPC          14   kTest.Q
Doc.Name.Q1 1       KTEST.SPC          39   kTest.Q1
Doc.Name.Q1 2       KTEST.SPC          39   kTest.Q1
Doc.Name.Q1 3       KTEST.SPC          39   kTest.Q1
Doc.Name.R 1        KTEST.SPC          18   kTest.R
Doc.Name.R 1.1      KTEST.SPC          19   kTest.R
Doc.Name.R 1.2      KTEST.SPC          20   kTest.R
Doc.Name.R 2        KTEST.SPC          18   kTest.R
Doc.Name.R 2.1      KTEST.SPC          19   kTest.R
Doc.Name.R 2.2      KTEST.SPC          20   kTest.R
Doc.Name.R 3        KTEST.SPC          18   kTest.R
Doc.Name.R 3.1      KTEST.SPC          19   kTest.R
Doc.Name.R 3.2      KTEST.SPC          20   kTest.R
Doc.Name.R1 1       KTEST.SPC          42   kTest.R1
Doc.Name.R1 1.1     KTEST.SPC          43   kTest.R1
Doc.Name.R1 1.2     KTEST.SPC          44   kTest.R1
Doc.Name.R1 2       KTEST.SPC          42   kTest.R1
Doc.Name.R1 2.1     KTEST.SPC          43   kTest.R1
Doc.Name.R1 2.2     KTEST.SPC          44   kTest.R1
Doc.Name.R1 3       KTEST.SPC          42   kTest.R1
Doc.Name.R1 3.1     KTEST.SPC          43   kTest.R1
Doc.Name.R1 3.2     KTEST.SPC          44   kTest.R1
Doc.Name.S 1        KTEST.SPC          24   kTest.S
Doc.Name.S 1.1      KTEST.SPC          25   kTest.S
Doc.Name.S 1.2      KTEST.SPC          26   kTest.S
Doc.Name.S 2        KTEST.SPC          24   kTest.S
Doc.Name.S 2.1      KTEST.SPC          25   kTest.S
Doc.Name.S 2.2      KTEST.SPC          26   kTest.S
Doc.Name.S 3        KTEST.SPC          24   kTest.S
Doc.Name.S 3.1      KTEST.SPC          25   kTest.S
Doc.Name.S 3.2      KTEST.SPC          26   kTest.S
Doc.Name.S1 1       KTEST.SPC          47   kTest.S1
Doc.Name.S1 1.1     KTEST.SPC          48   kTest.S1
Doc.Name.S1 1.2     KTEST.SPC          49   kTest.S1
REQUIREMENTS_REFERENCE                             01/24/86  12:17:25   Page   2
Reqsref Report
Requirement         File             Line   Unit

Doc.Name.S1 2       KTEST.SPC          47   kTest.S1
Doc.Name.S1 2.1     KTEST.SPC          48   kTest.S1
Doc.Name.S1 2.2     KTEST.SPC          49   kTest.S1
Doc.Name.S1 3       KTEST.SPC          47   kTest.S1
Doc.Name.S1 3.1     KTEST.SPC          48   kTest.S1
Doc.Name.S1 3.2     KTEST.SPC          49   kTest.S1
Doc.Name.UC 1       KTEST.SPC          53   kTest.UC
first 3.5           TEST2.SUB          21   GetNextNonCommentToken
first 3.5           TEST2.SUB          50   GetNextNonCommentToken
green 3             MTEST.BDY           4   merge_pkg
hans 6              RTEST.ADA           3   REQSREF
here 3.2            RTEST.ADA          14   REQSREF
heute 3             SORT.SPC           21
last_string 97      RTEST.ADA         130   REQSREF.parse_file_names
name.name(1.9.66).name(1.2) 6
                    NONAME.SOM         64   B83A01C
name.name(1.9.66).name(1.2) 6
                    NONAME.SOM         68   B83A01C
name_5(1.2) 1.1     NONAME.SOM         23   B83A01C.TASK1
name_5(1.2) 1.2     NONAME.SOM         14   B83A01C.TASK1
new(4) 4.5          RTEST.ADA         208   REQSREF
now 4               SORT.SPC           20   heap_sort
one.two 4.5         MTEST.SPC           9   merge_pkg
one.two 888         RTEST.ADA          16   REQSREF
red 89              MTEST.SPC          11   merge_pkg
Ref 1               KTEST.SPC          60   kTest.Ref_1_2_no_3
Ref 2               KTEST.SPC          61   kTest.Ref_1_2_no_3
requirement 5       MTEST.SPC          23   merge_pkg
STRING 88           RTEST.ADA          25   REQSREF
test 110.1          RTEST.ADA         134   REQSREF
that(6) 9           MTEST.SPC          53   merge_pkg.requirement_merge
Thea 5              RTEST.ADA           9
this 5              RTEST.ADA          58   REQSREF.parse_file_names.TRY
u.v 1.2.3           MTEST.BDY          15   merge_pkg.get_path
u.v 1.2.3           MTEST.BDY          46   merge_pkg.image
u.v 1.2.3           MTEST.BDY         108   merge_pkg.location_merge
u.v 1.2.3           MTEST.BDY         148   merge_pkg.process_location_line
u.v 1.2.3           MTEST.SPC          13   merge_pkg
u.v 1.2.3           MTEST.SPC          42   merge_pkg.location_merge
u.v 1.2.3           SORT.SPC           44
u.v 1.2.3           TEST2.SUB          53   GetNextNonCommentToken
Very_long_requirement_string(65) 1.2.3
                    RTEST.ADA         142   REQSREF
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--run4.rpt
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

REQUIREMENTS_REFERENCE                             01/24/86  12:18:24   Page   1
Reqsref Report
File             Line   Unit                               Requirement

B910ACAB.ADA       16   B910ACA.T                          a.b.c 7
B910ACAB.ADA       23   B910ACA.T                          a.n 11
KTEST.SPC          57   kTest.LC                           Doc.Name.LC 1
KTEST.SPC           6   kTest.P                            Doc.Name.P 1
KTEST.SPC           7   kTest.P                            Doc.Name.P 2
KTEST.SPC           8   kTest.P                            Doc.Name.P 3
KTEST.SPC          10   kTest.P                            Doc.Name.P.Minus 3
KTEST.SPC           9   kTest.P                            Doc.Name.P.Plus 2
KTEST.SPC          32   kTest.P1                           Doc.Name.P 1
KTEST.SPC          33   kTest.P1                           Doc.Name.P 2
KTEST.SPC          34   kTest.P1                           Doc.Name.P 3
KTEST.SPC          36   kTest.P1                           Doc.Name.P.Minus 3
KTEST.SPC          35   kTest.P1                           Doc.Name.P.Plus 2
KTEST.SPC          14   kTest.Q                            Doc.Name.Q 1
KTEST.SPC          14   kTest.Q                            Doc.Name.Q 2
KTEST.SPC          14   kTest.Q                            Doc.Name.Q 3
KTEST.SPC          39   kTest.Q1                           Doc.Name.Q1 1
KTEST.SPC          39   kTest.Q1                           Doc.Name.Q1 2
KTEST.SPC          39   kTest.Q1                           Doc.Name.Q1 3
KTEST.SPC          18   kTest.R                            Doc.Name.R 1
KTEST.SPC          19   kTest.R                            Doc.Name.R 1.1
KTEST.SPC          20   kTest.R                            Doc.Name.R 1.2
KTEST.SPC          18   kTest.R                            Doc.Name.R 2
KTEST.SPC          19   kTest.R                            Doc.Name.R 2.1
KTEST.SPC          20   kTest.R                            Doc.Name.R 2.2
KTEST.SPC          18   kTest.R                            Doc.Name.R 3
KTEST.SPC          19   kTest.R                            Doc.Name.R 3.1
KTEST.SPC          20   kTest.R                            Doc.Name.R 3.2
KTEST.SPC          42   kTest.R1                           Doc.Name.R1 1
KTEST.SPC          43   kTest.R1                           Doc.Name.R1 1.1
KTEST.SPC          44   kTest.R1                           Doc.Name.R1 1.2
KTEST.SPC          42   kTest.R1                           Doc.Name.R1 2
KTEST.SPC          43   kTest.R1                           Doc.Name.R1 2.1
KTEST.SPC          44   kTest.R1                           Doc.Name.R1 2.2
KTEST.SPC          42   kTest.R1                           Doc.Name.R1 3
KTEST.SPC          43   kTest.R1                           Doc.Name.R1 3.1
KTEST.SPC          44   kTest.R1                           Doc.Name.R1 3.2
KTEST.SPC          60   kTest.Ref_1_2_no_3                 Ref 1
KTEST.SPC          61   kTest.Ref_1_2_no_3                 Ref 2
KTEST.SPC          24   kTest.S                            Doc.Name.S 1
KTEST.SPC          25   kTest.S                            Doc.Name.S 1.1
KTEST.SPC          26   kTest.S                            Doc.Name.S 1.2
KTEST.SPC          24   kTest.S                            Doc.Name.S 2
KTEST.SPC          25   kTest.S                            Doc.Name.S 2.1
KTEST.SPC          26   kTest.S                            Doc.Name.S 2.2
KTEST.SPC          24   kTest.S                            Doc.Name.S 3
KTEST.SPC          25   kTest.S                            Doc.Name.S 3.1
KTEST.SPC          26   kTest.S                            Doc.Name.S 3.2
KTEST.SPC          47   kTest.S1                           Doc.Name.S1 1
KTEST.SPC          48   kTest.S1                           Doc.Name.S1 1.1
KTEST.SPC          49   kTest.S1                           Doc.Name.S1 1.2
KTEST.SPC          47   kTest.S1                           Doc.Name.S1 2
KTEST.SPC          48   kTest.S1                           Doc.Name.S1 2.1
KTEST.SPC          49   kTest.S1                           Doc.Name.S1 2.2
KTEST.SPC          47   kTest.S1                           Doc.Name.S1 3
KTEST.SPC          48   kTest.S1                           Doc.Name.S1 3.1
KTEST.SPC          49   kTest.S1                           Doc.Name.S1 3.2
KTEST.SPC          53   kTest.UC                           Doc.Name.UC 1
MTEST.BDY           7   merge_pkg                          another(4) 8
REQUIREMENTS_REFERENCE                             01/24/86  12:18:24   Page   2
Reqsref Report
File             Line   Unit                               Requirement

MTEST.BDY           4   merge_pkg                          green 3
MTEST.BDY          15   merge_pkg.get_path                 u.v 1.2.3
MTEST.BDY          46   merge_pkg.image                    u.v 1.2.3
MTEST.BDY         108   merge_pkg.location_merge           u.v 1.2.3
MTEST.BDY         148   merge_pkg.process_location_line    u.v 1.2.3
MTEST.SPC           3                                      a 9
MTEST.SPC           9   merge_pkg                          one.two 4.5
MTEST.SPC          11   merge_pkg                          red 89
MTEST.SPC          23   merge_pkg                          requirement 5
MTEST.SPC          13   merge_pkg                          u.v 1.2.3
MTEST.SPC          42   merge_pkg.location_merge           u.v 1.2.3
MTEST.SPC          53   merge_pkg.requirement_merge        that(6) 9
NONAME.SOM         64   B83A01C                            name.name(1.9.66).name(1.2) 6
NONAME.SOM         68   B83A01C                            name.name(1.9.66).name(1.2) 6
NONAME.SOM         23   B83A01C.TASK1                      name_5(1.2) 1.1
NONAME.SOM         14   B83A01C.TASK1                      name_5(1.2) 1.2
RTEST.ADA           9                                      Thea 5
RTEST.ADA           2   REQSREF                            bill(7) 5
RTEST.ADA           3   REQSREF                            hans 6
RTEST.ADA          14   REQSREF                            here 3.2
RTEST.ADA         208   REQSREF                            new(4) 4.5
RTEST.ADA          16   REQSREF                            one.two 888
RTEST.ADA          25   REQSREF                            STRING 88
RTEST.ADA         134   REQSREF                            test 110.1
RTEST.ADA         142   REQSREF                            Very_long_requirement_string(65) 1.2.3
RTEST.ADA          46   REQSREF.parse_file_names           a.b(1) 33
RTEST.ADA         130   REQSREF.parse_file_names           last_string 97
RTEST.ADA          58   REQSREF.parse_file_names.TRY       this 5
SORT.SPC           16                                      a.c 4
SORT.SPC           26                                      b.c 99
SORT.SPC           21                                      heute 3
SORT.SPC           44                                      u.v 1.2.3
SORT.SPC           20   heap_sort                          now 4
TEST2.SUB           2                                      AUI 99
TEST2.SUB          12   GetNextNonCommentToken             a 9
TEST2.SUB          49   GetNextNonCommentToken             a.b(1) 1.2
TEST2.SUB          52   GetNextNonCommentToken             a(1).b.c(2) 5.5
TEST2.SUB          21   GetNextNonCommentToken             first 3.5
TEST2.SUB          50   GetNextNonCommentToken             first 3.5
TEST2.SUB          53   GetNextNonCommentToken             u.v 1.2.3
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--badrefs.dat
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
package badrefs is

Procedure P;
--| Requirements_Satisfied: Doc_Name.No_Para

Procedure Q;
--| Requirements_Satisfied: 2

Procedure R;
--| Requirements_Satisfied: D 1, 2, 3


end badrefs;