EP1200894A1

EP1200894A1 - Method and arrangement for determining a total error description of at least one part of a computer programme and computer programme product and computer-readable storage medium

Info

Publication number: EP1200894A1
Application number: EP00929272A
Authority: EP
Inventors: Peter Liggesmeyer
Original assignee: Siemens AG
Current assignee: Siemens AG
Priority date: 1999-06-02
Filing date: 2000-04-03
Publication date: 2002-05-02
Also published as: US7047523B1; WO2000075780A1

Abstract

A control flow description and a data flow description are determined from the part of the computer programme concerned and programme elements are selected from said part of the computer programme. An element error description is determined for each selected programme element using a stored error description that is allocated to each reference element, this element error description describing the possible errors of the respective programme element. The total error description is then determined from the element error descriptions, taking into account the control flow description and the data flow description.

Description

description

Method and arrangement for determining an overall error description of at least part of a computer program, as well as computer program product and computer-readable storage medium

The invention relates to a method and an arrangement for determining an overall error description of at least part of a computer program as well as a computer product and a computer-readable storage medium.

Such a method and such an arrangement are known from [1].

It is known from [1] to determine an overall error description in the form of an overall error tree for a computer program with the aid of a computer. A control flow description in the form of a control flow graph is determined for the computer program. For various program elements of the computer program, an element error description is determined using a stored error description, which is assigned to a stored reference element. The error description of a reference element describes possible errors of the respective reference element. The overall error description is determined from the element error descriptions in the form of element error trees, taking into account the control flow graph for the computer program.

The method and the arrangement from [1] have the following disadvantages in particular. The overall fault tree determined is incomplete with regard to the faults examined and their causes and is therefore unreliable. Thus, this procedure cannot be used sensibly for safety-critical applications in the context of fault tree generation for a computer program. The individual fault trees that are assigned to reference elements, incomplete and therefore unreliable.

An overview of so-called slicing can be found in [2]. Slicing corresponds to the analysis that is carried out when searching for the cause of a malfunction of a computer program. This procedure checks whether the misconduct was caused by an instruction that is currently being viewed. If this is not the case, the statements that supply data for the statement or control its execution are checked. This process continues until no more processes exist, that is, input data of the computer program are reached. So-called slices are determined during slicing. A slice is used to show which instructions are influenced in which way by a value under consideration. In the following, the term slicing is always understood to mean backward slicing.

From [3] it is known to determine a control flow description and a data flow description for a computer program. In [3] this representation is used as the basis for so-called data flow-oriented testing of the computer program. The instructions (nodes) of the control flow graph are assigned data flow attributes (data flow description) which describe the type of data accesses contained in the instructions of the computer program. A distinction is made between write access and read access. Write accesses are called definitions (def). Read accesses are referred to as references. If a read access is made in a decision, this access is referred to as a predictive reference (p-use, predicate use). Read access in a calculation of a value is called a calculation reference (c-use, computational use).

Fundamentals of a fault tree are known from [4]. As described in [4], there is a structure under a fault tree understand the logical relationships between input variables of the fault tree, which input variables lead to a given undesired event.

Various methods for fault tree analysis are also known from [5].

The invention is based on the problem of determining an overall fault description which is more reliable than a determination of an overall fault tree known according to the method from [1].

The problem is solved by the method and by the arrangement with the features according to the independent claims, as well as by the computer product and the computer-readable

Storage medium with the features according to the independent claims solved.

In a method for determining an overall error description of at least part of a computer program by a computer, at least the part of the computer program is stored. A control flow description and a data flow description for the part of the computer program are determined and program elements are selected from the part of the computer program. An element error description is determined for each selected program element using a stored error description. The error description is assigned to a reference element. The element error description describes possible errors of the respective program element. An error description of a reference element describes possible errors of the respective reference element. The overall error description is determined from the element error descriptions taking into account the control flow description and the data flow description. An arrangement for determining an overall fault description of at least part of a computer program has a processor which is set up in such a way that the following method steps can be carried out: at least the part of the computer program is stored,

a control flow description and a data flow description are determined for the part of the computer program,

- program elements are selected from the part of the computer program,

for each selected program element, an element error description is determined using a stored error description, which is assigned to a reference element, with which possible errors of the respective program element are described,

possible errors of the respective reference element are described with an error description of a reference element,

- The total error description is determined from the element error descriptions taking into account the control flow description and the data flow description.

A computer program product comprises a computer readable storage medium on which a program is stored that enables a computer after it has been stored in a memory of the

Computer has been loaded to perform the following steps to determine an overall error description of at least part of a computer program:

At least the part of the computer program is stored, a control flow description and a data flow description for the part of the computer program are determined,

- Program elements are selected from the part of the computer program, - For each selected program element, an element error is used using a stored error description, which is assigned to a reference element. ler description determined with which possible errors of the respective program element are described,

- an error description of a reference element describes possible errors of the respective reference element,

- From the element error descriptions, the overall error description is determined taking into account the control flow description and the data flow description.

A program is stored on a computer-readable storage medium, which enables a computer, after it has been loaded into a memory of the computer, to carry out the following steps to determine an overall error description of at least part of a computer program: At least the part of the computer program is stored,

- program elements are selected from the part of the computer program,

The invention now makes it possible to determine a reliable overall error description for a computer program or a part thereof, taking into account the peculiarities of a computer program. Since the determined overall fault description is much more reliable than that according to The method can be determined from [1] overall error description, the invention is also suitable for security-critical applications, ie in particular for determining an overall error description of a security-critical computer program.

Preferred developments of the invention result from the dependent claims.

The control flow description and / or the data flow description can be in the form of a control flow graph or a data flow graph.

The error description can be in the form of a stored error tree and the element error description can be determined as an element error tree. In this case, the overall error description can be determined as an overall error tree.

This further development enables a standardized description of an error description, which makes it considerably easier for a user of the error description to analyze it.

The overall error description can be used in a further development for error analysis of the part of the computer program.

This further development has the particular advantage that an automated, reliable error analysis, and in the case of the error descriptions in the form of error trees, even an analysis of the error description "standardized" according to the error tree analysis method is possible.

In a further embodiment, the overall error description is determined as an overall error tree and the overall error tree is changed with regard to predefinable framework conditions. The change can be made by adding a supplementary fault tree.

An embodiment of the invention is shown in the figures and is explained in more detail below:

Show it

1 shows a computer with which the method according to the embodiment is carried out; FIG. 2 shows a flow chart in which the individual method steps of the method according to the exemplary embodiment are shown; FIG. 3 shows a general fault tree, as it is principally formed for a reference element; 4a to 4c a control flow graph (FIG. 4a), a slice (FIG. 4b) and a fault tree (FIG. 4c) for an instruction sequence as a reference element of a computer program;

5a to 5c a control flow graph (FIG. 5a), a slice (FIG. 5b) and an error tree (FIG. 5c) for a selection sequence as a reference element of a computer program; 6a to 6c a control flow graph (FIG. 6a), a slice (FIG. 6b) and an error tree (FIG. 6c) for a loop as a reference element of a computer program; FIG. 7 shows a control flow graph with a data flow graph for a computer program according to the exemplary embodiment;

Figures 8a and 8b a slice of the output of the variable max

(FIG. 8a) or a slice for the variable avr (FIG. 8b) for the program according to the exemplary embodiment; FIG. 9 shows the slice for the variable avr, in which a structure of the loop is highlighted from the program of the exemplary embodiment; FIG. 10 shows an error tree for the assumption that the variable avr is incorrect; FIG. 11 shows the overall fault construction according to FIG. 10, redundant events from the overall fault tree according to FIG. 10 having been combined into one event.

Fig.l shows a computer 100 with which the method described below is carried out.

The computer 100 has a processor 101 which is connected to a memory 102 via a bus 103. An input / output interface 106 is also connected to the bus 103.

A computer program 104 is stored in the memory 102, for which an overall error description is determined in the manner described below. A program 105 is also stored in the memory 102, by means of which the method described below is implemented. Furthermore, error descriptions 115 are different in the memory

Reference elements of a computer program saved. An error description of a reference element describes possible errors of the respective reference element. Various reference elements and error descriptions assigned to the reference elements are explained in detail below.

A keyboard 108 is connected to the input / output interface 106 via a first connection 107. The input / output interface 106 is connected to a computer mouse 110 via a second connection 109, and the input / output interface 106 is connected to a screen 112 via a third connection 111, on which the determined overall error description of the computer program 104 is displayed. Via a fourth connection 113, the input

/ Output cut parts 106 connected to an external storage medium 114. 2 shows in a block diagram the procedure according to the exemplary embodiment described below.

A control flow graph 201 and a data flow graph 202 for the computer program 104 are determined from the stored computer program 104.

Individual program elements are selected from the computer program (step 203). For each selected program element, an element error description is determined using a stored error description that is assigned to a reference element corresponding to the selected program element (step 204). The element error description describes possible errors of the selected program element.

Starting from an error event to be examined in the computer program (undesired event) specified by a user, in a last step (step 205) an overall error description of the computer program for the error case to be examined is determined from the element error descriptions, taking into account the control flow graph and the data flow graph .

The determined overall fault tree is displayed to the user on the screen 112.

3 shows the basic procedure for creating an error tree, as was used in the context of the starting example, to form the error trees described below for the reference elements.

For an event 301 selected by a user, it is to be determined how the selected faulty event can arise. In a computer program, an erroneous output of a variable can be a selected erroneous event (undesirable event) 301 are caused by a control flow error 303 and / or a data error 304 (INCLUSIVE-OR link 302).

A control flow error 303 is to be understood as an incorrect control of the processing of the respective variables.

The data flow error 304 is to be understood as an error that arises from incorrect data during processing.

The data flow error 304 can arise again in the processing step currently under consideration (block 306) and / or it can already have been present and can only be retained by error propagation (block 307) (INCLUSIVE-OR link 305).

Based on these considerations, the corresponding error tree, a slice describing the instruction and a control flow graph are presented for the following elements of a computer program:

- a sequence of instructions,

- a selection element,

- a loop element.

Statement sequence

The instruction sequence 401 has the three instructions shown in FIG. In a first instruction 402, the value 3 is assigned to a first variable j (j: = 3). A second instruction 403 assigns the value 2 to a second variable k (k: = 2). A third instruction 404 forms a sum over the first variable and the second variable (i: = j + k). A slice 410 is formed for this instruction sequence 401 in accordance with the procedure from [2], as is shown in FIG. B. The first instruction 402 and the second instruction 403 both affect the third instruction 404, which is represented by two arrows 411, 412 in the slice 410.

For the control flow graph 401, the fault tree 420 shown in FIG. C results for the following predetermined undesired event 421:

"Variable i is incorrect after the third statement".

The faulty event 421 may have been generated by an error in the considered third instruction 404 even with data correct up to this instruction step (element 422 in FIG. 4c). However, the erroneous event 421 can also be caused by corrupted input data of the third instruction, i.e. by INCLUSIVE-ORing 424 the events that the second variable k after the second

Instruction was incorrect (element 425) and / or that the first variable j was incorrect after the first instruction 402 (element 426). The result of the first INCLUSIVE-OR link 424 is included or linked to the event that the third instruction is faulty (INCLUSIVE-OR link 423).

Selection element

With a selection element as a reference element, the possibility of errors in the data flows and the control flows within the computer program must be taken into account.

In FIGS. 5 a to 5 c there is a control flow graph 501 (see FIG. 5 a), a slice 520 (see FIG. 5 b) and an error tree 540 (see Fig. 5c) for an If-Then-Else statement as a selection element.

The control flow graph 501 comprises the following six instructions: a first instruction 502 with which the value 3 is assigned to a first variable j (j: = 3),

a second instruction 503, with which a predeterminable value is assigned to a second variable k (k: = ...),

a third instruction 504, in which it is checked whether the second variable k has a value greater than 0; if the value of the second variable is greater than 0, the instruction branches to a fourth instruction 505, otherwise to a fifth instruction 506,

the fourth instruction 505, in which a third variable i is assigned the value of the second variable k (i: = k),

a fifth instruction 506 in which the third variable i is assigned the value of the second variable k with a negative sign (i: = - k),

a sixth instruction 507 in which the third variable i is processed in any way.

The control flow graph 501 shown in FIG. 5 a results in the slice 520 shown in FIG. 5 b for the selection element.

Solid edges in the slice 520 represent a data dependency of the different instructions from one another.

Control dependencies of the corresponding instructions from one another are indicated with dashed edges.

The following definitions apply to the two edge types:

- Dashed edges, hereinafter referred to as control edges, are directed from instructions which contain a predictive reference (failure constructs, loop control) to the instructions which are directly controlled, ie to those instructions which are only executed if the predicate has a certain value. Control edges are only drawn between the control instruction and immediately nested instructions. If another control level is nested in a controlled block, no control edges are drawn that cover more than one level. Since a control relationship is transitive, this indirect control can be inferred from the slice by using transitivity. - Solid edges, hereinafter referred to as data flow edges, are directed from instructions in which a variable is defined to instructions in which this variable is referenced. The considered variable must not be redefined between the definition and the reference. This is known as the path free of definition with regard to the variables under consideration.

The slice is determined by searching the control flow graph against the edge direction for the definition of the variables under consideration, based on the instruction with the variables under consideration, for which the undesired event is specified. If there are computational references to the definition, the process continues recursively until no additional nodes are found. The dependencies between statements found in this way are data dependencies. If a node under consideration is in a block, the execution of which is directly controlled by a decision, this represents a control dependency. For the predictive references of the variables involved in the decision, nodes with corresponding definitions - that is, data flow dependencies - are recursively searched for have further control dependencies.

5b shows the slice 520 belonging to the failure element with corresponding control edges and data flow edges. 5c shows the error tree 540 for the specified event "the third variable i is faulty before the 6th instruction" 541.

The following events lead to faulty event 541 in INCLUSIVE-OR operation 542:

an AND operation 543 of the events that the decision according to the third instruction 504 is true (element 544) and a result of an INCLUSIVE-OR operation 545 of the events that the fourth instruction 505 is incorrect (element 546) and / or the first variable j is incorrect after the first instruction 502 (element 547);

an AND operation 550 of the events that the decision according to the third instruction 504 is wrong (element 551) with a result of an INCLUSIVE-OR operation 552 of the events that the fifth instruction is faulty (element 553) and / or that the first variable j after the first instruction 502 is incorrect (element 554);

an INCLUSIVE-OR link 560 of the events: the decision according to the third instruction 504 is incorrect (element 561) and / or the second variable k is incorrect after the second instruction 503 (element 562).

Multiple selection element

A multiple selection element as a reference element can be treated according to the above-described scheme by breaking the multiple selection into a cascade of two-sided selection elements which are processed in accordance with the above procedure, in order thus to determine an error tree for a multiple selection element.

loop FIGS. 6 a to 6 c show an error tree 601 (see FIG. 6 a), the corresponding slice 620 (see FIG. 6 b) and the associated error tree 640 (see FIG. 6 c) for the reference element of a loop.

The control flow graph 601 for a loop element has the following seven instructions:

- A first instruction 602, with which a value i is assigned to a first variable i (i: = 0), - a second instruction 603, with which a value is freely assigned to a second variable j (j: = ...),

a third instruction 604, by means of which a third variable k is given a further value (k: = ...),

a fourth instruction 605, which specifies as a loop instruction a condition that a fifth instruction and a sixth instruction are carried out as long as the value of the second variable is j> 0 (WHILE j> 0 DO),

a fifth instruction 606, in which the first variable i is assigned a value which results from the sum of the previous value of the first variable and the product of the second variable and the third variable (i: = i + k * j) ,

a sixth instruction 607, by means of which the second variable j is assigned a value which is obtained by reducing the original value of the second variable j by the value 1 (j: = j − 1),

a seventh instruction 608, in which the first variable i is further processed in a predefinable manner (...: = i ...).

FIG. 6b shows the corresponding slice 620 for the control flow graph 601 shown in FIG. 6a with associated control flow edges and data flow edges.

The fault tree 640 shown in FIG. 6c is formed for the predetermined event 641 that the "first variable i before the seventh instruction is faulty". The error tree 640 results from the INCLUSIVE-OR link 642 of the following four events:

A first event 643, which describes that the first variable i is incorrect after the first instruction 602, an AND operation 644 from the events that the

Loop body has been run through at least twice (element 645) and the event that the sixth instruction 607 is incorrect (646),

- an AND operation 650 of the event that the loop body was executed at least once (element 651) and an IΝCLUSIVE-OR operation 652 following four events: a) the fifth instruction 606 is faulty (element 653), b) the first variable i is incorrect after the first instruction (element 654) c) the second variable j is incorrect after the second instruction (element 655), d) the third variable k is incorrect after the third instruction (element 656), an IΝCLUSIVE-OR operation 660 of the following three events: e) the decision according to the fourth instruction 605 is incorrect (element 661), f) the second variable j is incorrect after the second instruction 603 (element 662), g) an AND Link 663 of the events that the sixth instruction is incorrect (element 664) with the event that the loop body has been run through at least once (element 665).

The error trees described above, which are assigned to the individual reference elements, are stored in the memory 102 as error trees 115. 7 shows a control flow graph 700 for the following computer program:

input (n); input (a); max: = 0; sum: = 0; i: = 2;

WHILE i = n DO IF max <a [i]

THEN max: = a [i] sum: = sum + a [i] i: = i + 1 avr: = sum / n; output (max); Output (avr);

For the control flow graph 700 shown in FIG. 7 with 13 instructions (reference numerals 1, 2, 3, ..., 13), FIG. 8a shows the associated slice 800 for the variable max and FIG. 8b shows the associated slice 810 for the variable avr . The numbering of the individual instructions in the slices corresponds to the numbering of the individual instructions in the control flow graph 700 from FIG. 7.

FIG. 9 shows the slice 900 for the variable avr, as shown in FIG. 8b. The structure of the loop element contained in the program shown above is highlighted in bold. This structure corresponds to the slice shown in FIG. 6b for a loop element.

An overall fault tree 1000 for the computer program shown above is shown in FIG. The overall fault tree for the computer program is generated by instantiating the corresponding fault tree that is assigned to the reference element that corresponds to the selected program element. By proceeding backwards starting from the predetermined undesired event, the overall error tree 1000 is thus determined using the error trees assigned to the reference elements.

In Fig. 10, the fault tree 1000 is related to the event that "the variable avr is faulty before the thirteenth instruction" (element 1001). The variable avr may be incorrect before the thirteenth instruction 13 due to at least one of the following three events, as is also shown in the slice 900 for the variable avr shown in FIG. 9 (INCLUSIVE-OR operation 1002):

- An input variable n is incorrect after the first instruction 1 (element 1003), - The eleventh instruction 11 is incorrect (element 1004),

- The value of the variable sum before the eleventh instruction 11 is incorrect (element 1005).

The variable sum is faulty before the eleventh instruction 11 (element 1005) if at least one of the following events is fulfilled (INCLUSIVE-OR link 1006):

- The variable sum is incorrect after the fourth statement 4 (element 1007),

an AND operation 1008 of the event that the loop body has been executed at least twice (element

1009) with the event that the tenth instruction 10 is incorrect (element 1010),

an AND operation 1011 of the event that the loop body has been executed at least once (element 1012) with the result of an INCLUSIVE-OR operation 1013 of the following four events: a) the ninth instruction 9 is incorrect (element 1014), b) the variable sum is incorrect after the fourth instruction 4 (element 1015), c) the variable i is incorrect after the fifth instruction 5 (element 1016), d) the variable a is incorrect after the second instruction 2 (element 1017),

- An INCLUSIVE-OR operation 1018 of the following events: e) the decision according to the sixth instruction is incorrect (element 1019), f) the variable i is incorrect after the fifth instruction (element 1020), g) the variable is n after the first instruction is faulty (element 1021), h) an AND operation 1022 of the event that the 10th instruction is faulty (element 1023) with the event that the loop body has been executed at least once (element 1024).

The error tree 1000 from FIG. 10 is changed so that events that are shown several times in the error tree 1000 are combined to form a node of a cause and effect graph 1100 (see FIG. 11).

A fault tree analysis method as described in [5] is applied to the fault tree 1000 shown in FIG. 10, as a result of which an analysis of the computer program with regard to a predetermined undesired event is analyzed.

Alternatives and further possible uses of the exemplary embodiment described above are shown below.

The overall fault tree generated with the method described above can be used for various purposes:

- Description of the error generation or misbehavior propagation by part of a computer program as part of a security analysis or a reliability analysis of the computer program,

- Analysis of software error mechanisms, for example in the context of test case generation. Furthermore, a computer program in the programming language C ++ is specified with which the method according to the exemplary embodiment is implemented:

# ιnclude "AS_GraphKante.h"

D dinclude <ιostream>

D

0 ostreamS Operator «(ostreamS os, const GraphKanteC & Kante) 0 os« Kan e.KantenTyp; o return os;

0} π π / π / i / i π ππ / ππ / π / π / ππ / ππ / ππ / π / iπi / ππ / ii in /// ////////////// ///////

I / class for creating edges in the slice graph. // There are two types of edges: // 1. Control flow edges KFK // 2. Data flow edges DFK

// This class also meets the nice requirements for the STL.

// // ππ / ππiππiππi / πiππ / π / π in π / ππi / π / πi / ππ ///////// ///////// //////

II 1997-09-12 Andreas Steinhorst ππmiiimmiπiππimmmiπimmmiiiiπm take m mπiiππiiiim Olfndef _GraphNodeHeader Kdefine _GraphNodeHeader

Kmclude <ιostream> «include" KFGListNode.h "usmg namespace std; class GraphNodeC: public KFGListNodeC {public:

// GraphNodeC! ) {); friend ostreamS Operator «(ostreamS os, const GraphNodeCS Node); );

# endιf /////////////////////// iπ / iπ / i / π in ππ / π / iimπ in // in π π ////// //// //// _/ // _//// o

// Class for creating a slice. This class becomes an empty object

D

// inherited from the class graph. O

// The corners of the graph / slice have the same structure as the lists in the KFG. // The edges are of type EdgeTypeT; A class GraphKanteC could not be integrated into the class Graph for reasons that are invisible to me. // // III l / ll _1/1/1/1/1 / _{HL /} / _/ H H II _IIII 1997-09-12 Andreas Horst stone ππmimπimπimmimmmmmmmπiπimimπim / mπimimiim flifdef _SlιceHeader #else # defιne _SlιceHeader

# ιnclude "graph.h" Kinclude "AS_GraphKante.h" // »lnclude" AS GraphNode.h "Hinclude" KFGListNode.h "(fmclude" KFGList.h "

// using namespace std;

// typedef enum (DFK, KFK} EdgesTypeT; class SliceC: public graph <KFGLιstNodeC, GraphKanteC> {public:

SliceC () {}; void sliceForLoops (KFGListC SL ₂ , KFGListC:: iterator LOOPIT); KFGListC:: iterator defineVariableToSlice (KFGListC SL ₂ );

// void buildTestGraph (KFGListC s L2); void fmdAllDefs (KFGListC S Ll, KFGListC:: iterator ITER);

KFGListC:: iterator findUpperLimit (KFGListC s Ll, KFGListC:: iterator ITER, KFGP UseListC:: iterator PUSEIT);

KFGListC:: iterator fmdLowerLimit (KFGListC & Ll, KFGListC:: iterator ITER, KFGListC :: iterator UPPERLIMIT);

KFGListC:: iterator findLowerLimitFromCUse (KFGListC S Ll, KFGListC: -.iterator ITER, KFGListC:: iterator UPPERLIMIT); KFGListC:: iterator findUpperLimitFromCUse (KFGListC S Ll, KFGListC:: iterator ITER,

KFGUseListC:: iterator USEIT); int checkForNodes (int NodeNumber); void KFKPUseToCUse (KFGListC:: ιterator PUSEIT, int LoopEnd); void fmdDefToCUse (KFGListC S Ll, KFGListC:: iterator ITER); void deflnLooplKFGListC S Ll, KFGListC:: iterator ITER); void startBuildSlice (KFGListC S Ll); void sliceExpendl); );

«Endif πiiiimi miiπimiii mm in m mmmi / i / mi um

II With some changes taken from "The C ++ Standard Template Library".

//

// Template class graph for creating directed or non-aligned

// graph. The graph consists of a vector E for all corners. Each // vector element consists of a pair: the corner and the set of

// successor.

// The set of successors is represented by the STL data type map; the

// Key to an edge type / edge value is the number of a subsequent one

// corner. // III

# ιfndef _graphHeader

# defιne _graphHeader

# ιnclude <assert.h> (tinclude <map> flinclude <stack>

# ιnclude <vector> iinclude "checkvec.h"

(finclude <ιostream> «include" AS_GraphNode.h "using namespace std;

// Empty parameter class with a minimum set of operations // if no edge weights are required. struct Empty {public:

Empty (mt = 0) () bool operator <(const Empty) const {return true; )

// Empty operations so that input / output is formulated in general

// can be

// ostreamS operator «(ostreamS os, const Emptys) {return os; ) // istream Operator »(istream is, Emptys) {return ιs; (template <class corner type, class edge type> class Graph (public: typedef map <ιnt, edge type, less <int>>successor; typedef paιr <corner type, successor>Corner; typedef checkedVector <corner> graph type;

// typedef vector <corner> graph type; typedef graph type:: iterator iterator; typedef graph type:: const_ιterator const_ιterator; Graph (bool g, ostreamS os = cerr)

: dishes (g), pOut (Soε) {}

Graph () {} sιze_t sιze () const {return C.sιze (); } bool isDirected () const {return directed;} iterator beginl) {return C.beginf);} iterator end () {return C.endO;} Eckes Operator [] (int l) {return C [ι);} sιze_t Number of edges (); int ιnsert (const corner type e); void insert (const corner type el, const corner type e ₂ , const edge type value); void verbmdeEckendnt el, int e ₂ , // via corner numbers const edge type value); void set-oriented (bool value); // new method for directed / undirected graphs,

// which is not used. void check (ostreamS = cout); void cycle and context (ostreamS = cout); private: bool directed;

Graph type C; // container ostream * pOut;

};

// Function that checks whether it is a directed or undirected // graph and outputs the number of corners and edges. template <class corner type, class edge type> void graph <corner type, edge type>:: check (ostream os) {os «" The graph is "; // if ('IsDirected ()) // os «" un "; os «" and "" sιze () «" knots and "

«Number of edges ()« "edgesNn"; // cycle and context (os);

// method that sets a value whether the graph is directed or undirected. template <class corner type, class edge type> void graph <corner type, edge type>:: set-oriented (bool value) directed = value;

// function calculates the number of edges in graph template <class corner type, class edge type> sιze_t graph <corner type, edge type>:: number of edges () {sιze_t edges = 0; iterator temp «begm (); whιle (temp '= end ())

Edges + = (* temp ++). second.size (); Hi t ('directed) // edges / = 2; return edges; } // Insert a corner in the graph if it does not already exist. template <class corner type, class edge type> int graph <corner type, edge type>:: ιnsert (const corner type e) f fordnt i = 0; l <sιze (); ++ ι) if (e == C [ι) .first) return i;

// if not found, insert: C.push_back (corner le, successor!))); return sιze () - l;

// Insert an edge in the graph by first inserting the corners. template <class corner type, class edge type> void graph <corner type, edge type>:: insert (const corner type el, const corner type e ₂ , const edge type value)

{int posl = insert (el); int pos2 = insert (e2); verbmdeEckenlposl, pos2, value);

// Connect the two newly inserted corners with an edge. template <class corner type, class edge type> void graph <corner type, edge type>:: verbindeEcken (int posl, int pos2, const edge type value) (

(Clposl) .second) [pos2] «value;

// if (Igenchtet) // automatically enter the opposite direction

// (C (pos2] .second) [posl] = value;

/ * Cycle and context!) Works with the depth search. In contrast to CLR p. 47S, recursion was not used because this stack overflow occurred with large graphs (e.g. MILES.DAT with more than 40 nodes).

Replicating the recursion with its own stack enables processing of the entire file

MILES.DAT (128 knots). The stack depth corresponds to the number of edges

+ 1 for undirected graphs. * / template-class corner type, class edge type> void graph <corner type, edge type>:: Cycle and context (ostreamS os) int cycles - 0; int number of components = 0; stack <ιnt, ector <ιnt>> Cornerstack; // corners to visit

// assign the status Not Visited to all corners enum EckStatus (not visited, visited, edited); vector <EckStatus> corner state (size (), not visited);

// visit all corners fordnt l = 0; l <sιze (); ++ i) if (corner state d] == not visited)

<

Number of components ++;

// put it on the stack for editing

CornersStack.pushd);

// Process stack while ('CornersStack. Empty () int dieEcke = CornersStack. Top (); CornersStack. Pop (); if (Corners state [DieEcke] »= visited)

Corner condition [dιeEcke] = processed; ice if (corner state [dιeEcke] == not visited)

(

Corner condition [dieEcke] = visited; // new corner, mark for processed identifier cornersStack.push (dieEcke);

// reserve successor:

Graph <corner type, edge type>:: Successor: -.iterator start = operator [) (dieEcke) .second.beginf), end = operator [] (dieEcke) .second. end (); while (start! = end) (int Nachf «= (* start). first; if (EckausStand [Nachf] == visited) (

++ cycles; // someone was already here! (* pOut) «" at least corner "« Operator [] (ref). first «" is in one cycleNn "; } if (corner state [ref] == not visited)

EckenStack.pus (ref); ++ start; }}

} // Stack Empty? } // for () ... i (corner state ... if (directed) (if (number of components == 1) os «" The graph is strongly connected. \ n "; else os« "The graph is not or weak "" connected. \ n "; else os« "The graph has"

«Number of components

«" Component (s). "« Endl; os «" The graph has "; if (cycles == 0) os «" none "; os «" cycles. " «Final;

// Output the graph. template <class corner type, class edge type> ostream operator «(ostreamS os,

Graph <corner type, edge type> s G)

<ofstream target ("FaultTree.uwg"); ostream_ιterator <uwgknotenC> POSIT (Zιel); ostream_ιterator <uwgknotenC> POSIT2 (target);

// Display the corners with successors

Target «" %% UWG "« endl «" \ "V0. l \ "~ \" error tree \ "- \" A.Steιnhorst \ "" «endl« "%% BEGIN" «endl; fordnt l = 0; l <G.sizeO; ++ ι) (

POΞIT ++ = G [ι]. first; / * os «G [ι]. first «"<"; Graph <corner type, edge type>:: successor:: ιterator startN = G [ι] .second.begin (), endeN = G [ι] .second. end (); while (startN! = endN) (os «G [(* startN) .first) .first« '' // corner «( ^» startN) .second «''; // Edge value * POSIT2 ++ = G [(* startN) .first] .first;

// * EDGE ++ = (* startN) .second; ++ startN; } os «"> \ n "; * / ^« POSIT ++;

) requires u = 0; u <G.sizef); ++ u) (

Graph <corner type, edge type>:: successor:: ιterator startN = G [u] .second.begin! ), endN - G [u] .second. end (); while (startN! = endN) (

Target «" %% EDGE: "« G [u]. fitst.getGatterldent () «", "

«G [(* startN) .first] .first.getGatterldent ()« "/ 0;" «Final;

++ startN;

Target «" %% PROBSLIST "« endl «" %% END "« endl; return os;

«Endif

(dfdef _KFGDefHeader

G

#else

O

«Define _KFGDefHeader

D

"Include <strιng> D

#include <ιostream> D using namespace std;

D

D typedef char StringT [256]; 0 D class KFGDefC. (D private: O D

StringT Def; D int ScopeLevelD; public:

KFGDefC () strcpy (Def, "- unknown -"); ScopeLevelD = 0; };

KFGDefC (char _Def [], int _ScopeLevelD) strcpy (Def, _Def); ScopeLevelD =

_ScopeLevelD; ); void setDeffchar _Def []) (strcpy (Def, _Def);} char * getDefO (return Def;} int getScopeLevelD () (return ScopeLevelD;} bool Operator == (const KFGDefCS other) const

(return ((strcmp (Def, other. Def) ~ 0) s (Scope-

LevelD == other .ScopeLevelD)); }; bool operator '= (const KFGDefCS other) const

(return '(* thιs == other);}; bool operator <(const KFGDefCS other) const

{return (strcmp (Def, other. Def) <0);}; bool operator> (const KFGDefCS other) const (return (strcmpfDef, other.Def)>0);); friend ostreamS Operator «(ostreamS os, const KFGDefCS Node); };

"Endi iπ / π / πiπ π iπ / π π ππ / i ////////// ///////////////////////// /////// //////////////// o

II class for help list to create a KFG from it.

// This class meets the nice requirements for the STL;

// i.e. for a class T applies // 0. It supports the copy constructor T (const T),

// 1. the assignment operator TS operator = (const TS),

// 2. the comparison operator bool operator == (const T, Sconst TS) and

// 3. the unequal operator! ■ =

// in such a way that: // (a) (TRUE} T a (b) (a - = b}

// (b) (TRUE} a = b (a - b}

// (c) {a == a}

// (d) {a == b <==> b == a}

// (e) ((a == b) AND (b == c) ==> (a == c)} // (f) (a! = b <==> NOT (a— b)} ;

//

// In addition, all functions, especially getName equality preservmg, i.e.

// (g) {a == b ==> a. getName () == b. getName ()}

//

// iimiii mmiπimiim m mπiimmimmimπimiimiπ

II 1997-08-25 Andreas Steinhorst mmπiiiiimmmmimπimiiiimi ππ / ii / imiiiiiiiiiii »lfdef _KFGLιneNodeHeader

«Eise« def ine _KFGLmeNodeHeader

(f include <string> ftinclude <ιostream> using namespace std; typedef char StringL [1000]; class KFGLmeNodeC private:

StringL name; int LineNumber; publlc:

KFGLmeNodeC () (strcpy (name, "- unknown -

LineNumber = 0;

KFGLmeNodeC (char _Name []) (strcpy (Name, _Name); LineNumber

0; };

KFGLmeNodeC (char _Name [], int _LmeNumber)

(strcpy (name, _Name); LineNumber =

LineNumber; void setName (char _Name []) (strcpy (Name, _Name);}; char * getName () (return Name;}; int getLineNumber () (return LineNumber;}; bool Operator == (const KFGLineNodeCS other) const

(return (strcmp (Name, other.Name) == 0) S (LineNumber == other.LineNumber)); }; bool operator '= (const KFGL eNodeCS other) const (return' (* thιs

== other); }; bool operator <(const KFGLmeNodeCS other) const

(return (strcmp (Name, other.Name) <0);}; bool Operator> (const KFGLmeNodeCS other) const

(return (strcmp (Name, other.Name)> 0);}; friend ostreamS Operator «(ostreamS os, const KFGLmeNodeCS Node);

};

#endif π / ππiππiπ / ππ / ππiππ / ππ / ππiππiππ / ππ / ππiπ / ππ / πi / ππi / π / ππ

II class for the list that represents the KFG.

// This class meets the nice requirements for the STL; // i.e. applies to a class T.

// 0. It supports the copy constructor T (const TS),

// 1. the assignment operator TS operator = (const TS),

// 2. the comparison operator bool operator == (const T, sconst T) and

// 3. the unequal operator '= // in such a way that:

// (a) (TRUE} T a (b) (a == b}

// (b) (TRUE} a = b (a == b}

// (c) (a == a}

// (.d). (. a == b <==> b - a} // ((ee)) ((((aa ==== bb)) AANNDD ((bb ==== cc)) ==== >> (a == c)

// (f) {a '= b <==> NOT (a - == b)};

//

// In addition, all functions, especially getStatement equality preservmg, d.

// (g) (a == b ==> a. getStatement () == b. getStatement ()} //

// im mimimii mim / take mm ιι ιι 11 ιι im ι im in ιι ι / in ι ιι ιι ι / ιι /

II 1997-09-01 Andreas Steinhorst ππiπmimπiπimπimiπmiiii ιι min / im m im ιι in mmiiimπi ffifdef _KFGLιstHeader #else

(fdefine _KFGLιstHeader dinclude <strιng> tdnclude <ιostream> linclude <stdιo.h> ftinclude <list>

(linclude <fstream> ftinclude <ιterator> (fmclude "KFGListNode.h"

"Include" KFGTokenList.h "

# ιnclude "KFGProgList.h" using namespace std; class KFGListC: public lιst <KFGLιstNodeC> (int number_defs, number_Uses, number_P_Uses, number of declarations; int loop decisions, decisions, counting loop decisions; int instructions; publlc: KFGListC () (}; void TokenLιst2KFn); node (S) void node identifier (KFGListC:: iterator KFG); void list output!); void addLmelnToList (); void addLιneToKFG (KFGProgLιstC S LP); int count declarations (KFGTokenLιstC S TL); void base size file ();

}; class KFGDefListC: public list <KFGDefC> (}; class KFGUseListC: public reads <KFGUseC> (}; class KFGP_UseLιstC: public reads <KFGUseC> (};

# endιf ffinclude <stπng> D

Oinclude <ιostream> «mclude <lιst>ffinclude" KFGNode.h "us g namespace std; typedef reads <KFGNodeC>KFGListeT; extern void KFGListeAusgabe (KFGListeT); /////////// //// ι iππ in ππ π / π n / n ι n / n // ιι / // in / ιι π // π // iπ / ππ /// /////// _/ //

0

// Class for the nodes in the control flow graph.

// This class meets the nice requirements for the STL;

// i.e. for a class T applies 1 / 0. It supports the copy constructor T (const TS),

// 1. the assignment operator TS operator = (const TS),

// 2. the comparison operator bool operator == (const T, Sconst Ts) and

// 3. the unequal operator! =

// in such a way that: // (a) (TRUE} T a (b) (a == b}

// (b) (TRUE} a = b (a == b}

// (c) (a == a}

// (d) (a == b <==> b == a}

// (e) ((a == b) AND (b == c) ==> (a == c)} // (f) (a! = b <==> NOT (a == b) };

//

// In addition, all functions, especially getStatement equality preservmg, i.e.

// (g) (a == b ==> a. getStatement () == b. getStatement ()}

// // II llll / IIIIHIIII St.

II 1997-08-25 Andreas Steinhorst iπ / π / π / π / π / iπ iππ IΠΠI / ΠΠ ι in / π ι // π / π / π ///////////// // //// ////// _// // _//// difdef _KFGNodeLιstHeader „eise (fdefme _KFGNodeLιstHeader finclude <strιng> dinclude <ιostream>

(finclude <list> (finclude "KFGUse.h" ftmclude "KFGDef.h" using namespace std; typedef char StringT [256]; typedef char CodeLineT [256]; typedef enum (NO, LC, BL, EL, IFC, BTh , ETh, BEI, EE1, OP, DOWL, DOWLC, SWITCH, CASE, ENDCASE, BDEFA, ENDDEFA, RETURN, BRE AK) KFGNodeTypeT; typedef enum (LOOP, THEN, ELSE, NONE} node IDT; class KFGListNodeC ( protected: // private: static int DummyNodeNr; int NodeNr; int level; int node number; int LineNr; StringT Statement; CodeLineT CodeLine; KFGNodeTypeT KFGNodeType; Node identifierT node identifier; public: reads <KFGUseC>Uses; reads <KFGDefC>Defs; reads <KFGUseC>P_Uses;

KFGListNodeCO (strcpy (Statement, "- unknown -");

Level = 0; KFGNodeType =

NO;

NodeNr = Dummy myNodeNr ++;

Node number = 0; Node identifier =

NONE;

LineNr ■ = 0; strcpy (CodeLine, "—unknown—"); };

KFGLιstNodeC (char _Statement [], KFGNodeTypeT _KFGNodeType) strcpy (statement, _Statement);

Level = 0;

KFGNodeType =

_KFGNodeType;

NodeNr = Dummy myNodeNr ++;

Node number = 0; Node identifier =

NONE;

LineNr = 0; strcpy (CodeLine, "—unknown—"); };

KFGLιstNodeC (char _Statement [], KFGNodeTypeT _KFGNodeType, int _Level)

(strcpy (statement, _statement); Level = _Level; KFGNodeType =

_KFGNodeType;

NodeNr = Dummy myNodeNr ++;

Node number = 0; Node identifier - NONE;

LineNr = 0; strcpy (CodeLine, "—unknown—"); };

KFGListNodeCIchar _Statement KFGNodeTypeT _KFGNodeType, int _Level, int _LmeNr)

(strcpy (statement, _statement); Level = _Level; KFGNodeType =

_KFGNodeType;

NodeNr = Dummy myNodeNr ++;

Node number = 0; Node identifier =

NONE;

LineNr = LineNr; strcpy (CodeLine, "—unknown—");}; from the setStatement (char _Statement []) strcpy (Statement, _Statement); }; void setCodeL e (char _CodeLιne []) strcpy (CodeLine, _CodeLιne); }; void setKFGKnotenNummer (int _KnotenNr)

(Node number _ node number;); void setKnotIdent

Node ID _ node ID; }; int getNodeNumber () (return NodeNumber;}; char * getStatement!) (return Statement;}; char * getCodeL e () (return CodeLme;}; int getLevel () (return Level;}; int getNodeNrl) (return NodeNr; }; int getLιneNr () (return LineNr;};

NodeIdentT getNodeIdent () (return

KFGNodeTypeT getKFGNodeType () (return KFGNodeType;}; bool Operator == (const KFGListNodeCS other) const

(return ((strcm tStatement, other .Statement) == 0)

S (Level - other. Level) S (KFGNodeType == other. KFGNodeType) s (NodeNr == other. NodeNr)); }; bool operator '= (const KFGListNodeCS other) const

(return! (* thιs == other);}; bool Operator <(const KFGListNodeCS other) const (strcm l Statement, other. Statement) <0); }; bool Operator> (const KFGListNodeCS other) const return (strcmpIStatement, other. Statement)> 0); }; friend ostreamS Operator «(ostreamS os, const KFGListNodeCS Node);

jfendif

// ftinclude <strιng> // fl clude <ιostream> // «include" KFGList.h "

// us g namespace std;

// class KFGListOpC: public KFGListeC (

// public:

// void KFGListOut (KFGListeT S L)

// (

// KFGListeT:: iterator I = L.beginO;

// while (I '• = L.end!)) // cout «* I ++« '';

// cout «" sιze () = "« L. size O «endl;

//} ^//);

IIII II IIII 111 Uli III I I Hill II llllll 1111 III I II

D

// Class for help list to create a KFG from it. Q

// This class meets the nice requirements for the STL;

// i.e. applies to a class T.

// 0. It supports the copy constructor T (const TS),

// 1. the assignment operator Ts operator = (const Ts), // 2. the comparison operator bool operator == (const T, Sconst T) and

// 3. the unequal operator! =

// in such a way that:

// (a) {TRUE} T a (b) (a - b)

// (b) (TRUE} a = b (a == b} // (c) (a - a}

// (d) (a == b <==> b == a}

// (e) ((a == b) AND (b - c) -> (a == c)}

// (f) {a '= b <==> NOT (a == b)};

// // In addition, all functions, especially getName equality preservmg, i.e.

// (g) (a = b ==> a.getName!) == b. getName!)}

//

// // II II III III III II 1997-08-25 Andreas Steinhorst

HIHI 111 ιι um um ιι ι in ι IIII 11 m 11 ιι ι ιι ι m IIII um m ffifdef _KFGNodeHeader «eise ffdef e _KFGNodeHeader ff clude <stπng> ffinclude <ιostream> using namespace std; typedef char StringT [256]; class KFGNodeC (private:

StringT Name; int ScopeLevel; public:

KFGNodeCO (strcpy (name, "- unknown -"); ScopeLevel = 0;

/ * cout «" NodeC creates "« endl; * /};

KFGNodeCIchar _Name []) (strcpy (Name, _Name);

ScopeLevel = 0; ); KFGNodeCIchar _Name [], int _ScopeLevel)

(strcpy (name,

_Surname ) ;

ScopeLevel = ScopeLevel; }; void setName (char _Name []) (strcpy (Name, _Name);}; char * getName!) {return Name; }; int getScopeLevel () (return ScopeLevel;}; bool Operator == (const KFGNodeCS other) const

{return ((strcmplName, other. Name) == 0) S (ScopeLevel

== other. ScopeLevel)); }; bool operator '= (const KFGNodeCS other) const return! (* thιs

== other) bool operator <(const KFGNodeCS other) const {return (strcm lName, other.Name) <0); }; bool operator> (const KFGNodeCS other) const return (strcmplName, other.Name)> 0); }; friend ostreamS Operator «(ostreamS os, const KFGNodeCS Node);

}; ftendif ff ifdef _KFGNodelHeader D ffelse

D ππiππ / ππ / ππiππ / ππ / ππi / π / ππ / π / ππii / ππ / π / π / π π in // ////////////

I I class for help list to create a KFG from it.

// 0. It supports the copy constructor T (const Ts),

// 1. the assignment operator TS operator = (const TS),

// 2. the comparison operator bool operator == (const T, const TS) and

// 3. the unequal operator '= // in such a way that:

// (a) <TRUE} T a (b) (a == b}

// (b) (TRUE} a = b (a == b}

// (c) (a == a}

// (d) (a == b <==> b == a) // (e) ((a == b) AND (b == c) ==> (a == c)}

// (f) (a! = b <==> NOT (a == b)};

//

// In addition, all functions, especially getName equality preservmg, i.e.

// (g) (a == b ==> a. getName!) == b. getName!)} //

//

// 1111111111111111111111111111 lll / 1 / llll / 1 Hill I at 111 / /

II 1997-08-25 Andreas Steinhorst ππππmmiπmiπmm mim // im / m IIII ιι m in ιι ff ifdef _KFGNodelHeader ffelse ftdefine _KFGNodelHeader ffinclude <stnng> ffinclude <ιostream> us g namespace std; typedef char StringT [256]; class KFGLlstNodeC (private: StringT Name; int ScopeLevel; list <KFGUseC> Uses; list <KFGDefC> Defs; public:

KFGLlstNodeC () (strcpy (name, "- unknown -"); ScopeLevel = 0;

/ * cout «" NodeC creates "« endl; * /};

KFGLlstNodeC (char _Name []) (strcpy (Name, _Name);

ScopeLevel = 0; }; KFGLlstNodeC (char _Name [], int _ScopeLevel)

(strcpy (name, name); ScopeLevel ■

ScopeLevel; }; void setName (char _Name []) strcpy (name, _Name); }; char * getName!) (return Name;); int getScopeLevel () (return ScopeLevel;}; bool Operator == (const KFGListNodeCS other) const

(return ((strcmplName, other. ame) == 0)

S (ScopeLevel = «other. ScopeLevel)); }; bool Operator! = (const KFGListNodeCS other) const

(return '(* thιs == other);}; bool Operator <(const KFGListNodeCS other) const return (strcmplName, other.Name) <0); }; bool operator> (const KFGListNodeCS other) const return (strcmplName, other.Name)> 0); ); friend ostreamS Operator «(ostreamS os, const KFGListNodeCS Node);

ffendlf flifdef KFGNodelHeader 0

»Ice

D

III lllll III 11 lllll III II I II III 11 lllll 11 II I III 111 III I II I II IIII II II I II

0 // class for help list to create a KFG from it.

D

// This class meets the nice requirements for the STL;

// i.e. applies to a class T.

// 0. It supports the copy constructor T (const TS), II I. the assignment operator Ts operator = (const TS),

// 2. the comparison operator bool operator == (const T, Sconst TS) and

// 3. the unequal operator! =

// in such a way that:

// (a) (TRUE) T a (b) (a - b) // (b) (TRUE} a = b (a == b}

// (c) {a - a)

// (d) (a == b <==> b == a}

// (e) ((a = - b) AND (b == c) ==> (a == c)}

// (f) (a '= b <==> NOT (ab - b)}; //

// In addition, all functions, especially getName equality preservmg, i.e.

// (g) (a ~ b -> a. getName () == b. getName!)}

//

// ππiππ / ππiππiππiππiiπ / π / iiiiπ IIII π / π iiiiππ ////// ////////

II 1997-08-25 Andreas Steinhorst mimiiiπmiiπiiππmimiiiii πimmm ππ m //////////// im im ff ifdef _KFGNodelHeader »eise ffdefine KFGNodelHeader ffinclude <strmg> ffinclude <ιostream> using namespace std; typedef char StringT [256]; class KFGLlstNodeC {private:

StringT Name; int ScopeLevel; list <KFGUseC>Uses; list <KFGDefC>Defs; public:

KFGLlstNodeC! ) (strcpy (Name, known ScopeLevel = 0;

/ * cout «" NodeC creates "« endl; * /};

KFGLlstNodeC (char _Name [)) (strcpy (Name, _Name);

ScopeLevel = 0; ); KFGLlstNodeC (char _Name [], int _ScopeLevel)

(strcpy (name, _Name);

ScopeLevel = ScopeLevel; ); - void setNamelchar _Name []) (strcpy (Name, _Name);}; char * getName!) (return Name;), - int getScopeLevel () (return ScopeLevel;); bool operator == (const KFGListNodeCS other) const

(return ((strcmplName, other.Name) == 0) S (ScopeLevel

== other. ScopeLevel)); }; bool Operator! = (const KFGListNodeCS other) const

(return! (* thιs == other);); bool operator <(const KFGListNodeCS other) const

(return (strcmplName, other.Name) <0); }; bool Operator> (const KFGListNodeCS other) const

{return (strcmp (Name, other.Name)> 0); ); friend ostreamS Operator «(ostreamS os, const KFGListNodeCS Node);

); ffendif

// class for a list from STL. KFGListeC inherits all properties // from the list created with STL <KFGNodeC>. «Lfdef _KFGProgLιstHeader (quietly« define _KFGProgListHeader ffinclude <strιng> ffinclude <ιostream> ffinclude <stdιo.h> flinclude <lιst> ffinclude <fstream> ffinclude <ιterator> namfinespodehsting using KFNclodGlist using the class; using the FinNodeGlist; KFNclingGlist using the name; using the FinNodeGlead; KFNclodGlist using the "; KFGLιneNodeC> (public:

KFGProgListC!) (); // void KFGListeAusgabel);

// void KFGTokenListToKFGList (); ); ffendif

// class for a list from STL. KFGListeC inherits all properties D

// from the list created with STL, <KFGNodeC>. D difdef _KFGTokenListHeader D

»Else D ffdefine KFGTokenListHeader ü

D

D ffinclude <stnng>

D ffinclude <ιostream>

O ffinclude <stdιo.h> ffinclude <lιst> ffinclude <fstream> ffinclude <ιterator>

# ιnclude "KFGTokenNode.h" usmg namespace std; class KFGTokenListC: public reads <KFGTokenNodeC> (public:

KFGTokenListC!) (}; Void KFGListeAusgabel);

// void KFGTokenListToKFGList ();

}; ffendif

III 11 III IIII II 111 II IIII III II II III 11111 II II 11 III 1111111111 II III III I III I III III

D // Class for help list to create a KFG from it.

D

// This class meets the nice requirements for the STL;

D

// 1. the assignment operator TS operator = (const Ts),

// 2. the comparison operator bool operator == (const T, Sconst TS) and

// 3. the unequal operator '=

// in such a way that: // (a) (TRUE} T a (b) (a - = b)

// (b) <TRUE} a = b (a == b)

// (c) (a == a)

// (d) {a == b <==> b == a}

// (e) ((a == b) AND (b == c) ==> (a == c)) // (f) (a '= b <==> NOT (a == b) };

//

// In addition, all functions, especially getName equality preservmg, i.e.

// (g) (a == b ==> a.getNameO == b. getName!))

//

// lllll I I II II II II I I II II II II II I I I I I III I I I I I I I I I I I I I II II I I I I I III I II II I I I III I /

II 1997-08-25 Andreas Stemhorst

/ / ιι ιι IIIII in m mπiπiimπm mm / 1 ii / 11 m ι ιι 11 mπimiiim ffifdef _KFGTokenNodeHeader ffelse (fdefme KFGTokenNodeHeader ffinclude <strιng> ffinclude <ιostream> usmg namespace std; typedef char StringT [256); typedef enum (N, PL, IF, BT, ET, BE, EE, FOR, BF, EF, WHILE, BW, EW, SW, CA, ECA, BRK, RET, DEFA, EDEFA, DO, BDOW, DOWS, NL , DEF, BFUNC, EFUNC, TD, OUT, FOR_D, PF) TokenNodeTypeT; class KFGTokenNodeC (private:

StringT Name;

TokenNodeTypeT TokenNodeType; int ScopeLevel; int LineNumber; public:

KFGTokenNodeC () {strcpy (name, "- un- known -")

ScopeLevel = 0; TokenNodeType =

N;

LineNumber = 0; );

KFGTokenNodeC (char _Name [], TokenNodeTypeT _TokenNodeType)

(strcpy (name,

_Surname ) ;

ScopeLevel - 0; TokenNodeType

_TokenNodeType;

LineNumber = 0;);

KFGTokenNodeC (char _Name [], int _ScopeLevel, TokenNodeTypeT TokenNodeType)

(strcpy (name,

_Surname) ; ScopeLevel = _ScopeLevel;

TokenNodeType = TokenNodeType; LineNumber = 0;

KFGTokenNodeC (char _Name [], t _ScopeLevel, TokenNodeTypeT _TokenNodeType, int LineNumber)

(strcpy (name,

_Surname ) ; ScopeLevel = _ScopeLevel;

TokenNodeType _TokenNodeType; LineNumber = LineNumber; ); void setNamelchar _Name []) (strcpy (Name, _Name);); char * getName () (return Name;}; int getScopeLevel () (return ScopeLevel;); mt getLineNumber () (return LineNumber;); TokenNodeTypeT getTokenNodeType () (return TokenNodeType;}; bool Operator == (const KFGTokenNodeCS other) const return ((strcmplName, other. Name) == 0)

S (ScopeLevel == other. ScopeLevel)

S (TokenNodeType == other. TokenNodeType)); }; bool operator '= (const KFGTokenNodeCS other) const (return '(* thιs - = other);); bool Operator <(const KFGTokenNodeCS other) const (return

(strcmplName, other.Name) <0); }; bool operator> (const KFGTokenNodeCS other) const

(return (strcmplName, other.Name)> 0); ); friend ostreamS Operator «(ostreamS os, const KFGTokenNodeCS Node); ); ffendif ff ifdef _KFGUseHeader D »eise

D

»Define _KFGUseHeader D D

»Include <stπng>

D

»Include <ιostream>

O o usmg namespace std; D

G typedef char StringT [256]; D

D class KFGUseC (α private:

D D

StringT Use;

D int ScopeLevelU; D

D public: D

KFGUseC () (strcpy (Use, "- unknown -");

ScopeLevelU = 0; );

KFGUseC (char _Use [], int _ScopeLevelU) (strcpy (Use, _Use);

ScopeLevelU = _ScopeLevelU; }; void setUse (char _Use []) (strcpy (Use, _Use);) char * getUse I) (return Use;) int getScopeLevelU () (return ScopeLevelU;} bool Operator == (const KFGUseCS other) const

(return ((strcmp (Use, other. Use) - 0) s (ScopeLevelU == other. ScopeLevelU));); bool operator '= (const KFGUseCS other) const

(return '(* thιs == other);}; bool operator <(const KFGUseCS other) const

(return (strcmplUse, other.Use) <0); ); bool operator> (const KFGUseCS other) const f return (strcmplUse, other.Use)> 0); ); friend ostreamS Operator «I ostreamS os, const KFGUseCS Node);

};

»Endif

»Ifndef _uwggraphC D

»Def e uwggraphC D

0

»Mclude <graph. h> D »include" uwgknoten. h "D

»Include" uwgkante. H "0» include "AS Slice. H" using namespace std; class uwggraphC: public graph <uwgknotenC, uwgkanteC> (public:

Short mt folded; uwggraphC! ) {}; SliceC:: iterator findOutputNode (SliceC s Sl);

SliceC:: iterator definelterator (SliceC S Sl, mt SliceNr); void addFirstNodesToFTISliceC s Sl, int NodeNo, int Posl);

SliceC:: iterator returnCondNode (SliceC S Sl, mt SliceNr); mt checkUWGNode (ιnt SliceNr); void Slice SliceC S Sl) t void startBuildFT (SliceC S Sl); void buildInLoopTree (SliceC S Sl, int Posl, SliceC:: iterator SLPUSE, SliceC:: iterator SLNODE); void buιldIn_Dl_Part (SliceC S Sl, int posOR_Dl, SliceC:: iterator SLPUSE, SliceC:: iterator SLNODE, int D2_RefNr); SliceC:: ιterator f dOutmostPUse (SliceC S Sl, SliceC:: iterator SLPUSE); int checkPUsesl (SliceC S Sl, SliceC:: iterator SLPUSE, SliceC:: iterator SLPUSEREF); mt checkPUses2 (SliceC S Sl, SliceC:: ιterator SLPUSE, SliceC:: ιterator

SLPUSEREF);

SliceC:: iterator fιnd_Dl_Node (SliceC S Sl, SliceC:: iterator SLPUSE, SliceC:: ιterator SLNODE); void addAllDlNodes (SliceC S Sl, SliceC:: iterator SLNODE, int posGatter, int D2_RefNr);

SliceC:: ιterator findLastPUse (SliceC S Sl, int SliceNr);

SliceC:: iterator fmdLastPUse2 (SliceC S Sl, int SliceNr, mt RefNr); void checkLoopOrCondl SliceC S Sl, SliceC:: ιterator SLl, SliceC:: ιterator SLORIG, int Posil); void buildIn_D2_Part (SliceC S Sl, int posOR_D2, SliceC:: iterator SLl, SliceC:: iterator SLPUSE, int nodeNoD2); int fιndD2Node (SliceC S Sl, SliceC:: iterator PUSE); t buildlnlfTree (SliceC s Sl, SliceC:: ιterator SLIF, SliceC:: iterator SLORIG, int posl);

SliceC:: iterator lookForNextPUse (SliceC S Sl, SliceC:: ιterator SNODE, SliceC:: iterator SLPUSE); void buιld_IFKF_Part (SliceC S Sl, t posKFOR, SliceC:: iterator SLPUSE); void build_Al_Part (SliceC S Sl, int posIFDFOR, SliceC:: iterator SLIF, SliceC:: iterator SLORIG); void buιldD2_IFKF_Part (SliceC S Sl, int posKFOR, SliceC:: iterator SLPUSE); void buιldD2_Al_Part (SliceC S Sl, int posIFDFOR, SliceC:: iterator SLIF, SliceC:: ιterator SLNODE); int buιldD2InIfTree (SliceC S Sl, SliceC:: ιterator SLIF, SliceC:: iterator SLORIG, int posl); void buιldLoopKF_Part (SliceC S Sl, mt posAND_KF, int posLOOP_KF, int posD2, SliceC:: iterator SLOOP); mt buιldIn_LoopKF_ANDPart (SliceC S Sl, int posAND_KF, SliceC:: ιterator

SLPUSE); void buildIn_LoopKF_ORPart (SliceC S Sl, int posAND_KF, SliceC:: iterator SLl, int nodeNoD2);

};

»Endi

»Lfndef _uwgkanteC» def e _uwgkanteC

»Include <ιostream using namespace std; class uwgkanteC (public:

Short int folded; int Number; uwgkanteC () {}; uwgkanteC (mt _Number) {Number = _Number; bool operator == (const uwgkanteCS other) const

(return (Number - other. Number);}; bool Operator '= (const uwgkanteCS other) const

(return '(* thιs == other);); bool operator <(const uwgkanteCS other) const

(return (Number == other. umber);}; bool Operator> (const uwgkanteCS other) const

(return (Number == other.Number);); friend ostreamS Operator «(ostreamS os, const uwgkanteCS Node);

»Endif »Lfndef _uwgknotenC

D

»Define _uwgknotenC

D

D ffinclude <iostream> const int maxKnotentextLength = 128; const mt maxBemerkLength = 1000; const mt maxWahrVarLength = 16; typedef struct ww (

Short mt value; struct ww * next; } TMCSValue; typedef struct el (struct ftgatter * unabElement; struct ww * next; struct el * nextel;) TMinSet; typedef enum (AND, OR, CAUSE, EFFECT, NOT] NodeldentT; usmg namespace std; class uwgknotenC (public: static int DummyNr; t Gatterldent; t outof; int CauseNr; char gattertext [maxKnotentextLength]; char Gatternemerkung [maxBemerkLength]; double char; var true [maxWahrVarLength];

NodeldentT Nodeldent; uwgknotenC () (Nodeldent = EFFECT;

CauseNr = 0; strcpy (gate text, "- unknown -"); strcpy (gate remark, "—none" ");

Gatterldent = DummyNr ++; }; uwgknotenC (NodeldentT _NodeIdent)

(Nodeldent = _NodeIdent;

CauseNr = 0; strepyl gate text, "- unknown -"); strepyl gate remark, "—none—");

Gatterldent = DummyNr ++; ); uwgknotenC (NodeldentT _NodeIdent, t _CauseNr / *, char _gattertext [] * / ₎

(Nodeldent = _NodeIdent;

CauseNr = CauseNr; strepyl gate text, "- unknown -"); strepyl gate remark, "—none—"); / * strcpy (gattertext, _gattertext); * /

Gatterldent

DummyNr ++; }; uwgknotenC (NodeldentT _NodeIdent, t _CauseNr, char _gattertex [], char _gatterbemerkung [])

(Nodeldent = _NodeIdent; CauseNr =

_CauseNr; strepyl gate text, "- unknown -"); strepylgattertext, _gattertext); strepyl gate remark, _gate remark);

Gatterldent DummyNr ++; }; uwgknotenC (NodeldentT _NodeIdent, int _CauseNr, char _gattertext (])

(Nodeldent = _NodeIdent;

CauseNr = _CauseNr;

/ * strcpy (gattertext, "- unknown -"); * / strepylgattertext, _gattertext); strepyl gate remark, "—none—");

Gatterldent DummyNr ++; ); uwgknotenC (NodeldentT _NodeIdent, ehar _gattertext [], char

_gatter remark [])

(Nodeldent =

Nodeldent; CauseNr = 0; strepylgattertext, _gattertext); strepyl gate remark, _gate remark);

Gatterldent DummyNr ++; ); uwgknotenC (NodeldentT _NodeIdent, char _gattertext [])

(Nodeldent = _NodeIdent; CauseNr = 0; strepylgattertext, _gattertext); strepyl gate remark, "—none—"); Gatterldent «

DummyNr ++; }; int getCauseNrl) (return CauseNr;}; mt getGatterldent () (return Gatterldent;);

NodeldentT getNodeldent I) const (return Nodeldent;); bool operator == (const uwgknotenCS other) eonst

(return ((CauseNr == other. CauseNr) S (Nodeldent == other. Nodeldent) s

(strcmplgattertext, other. gattertext) == 0) / * S (Gatterl- dent == other.Gatterldent) * /); ); bool operator '= (const uwgknotenCS other) const

(return! (* thιs

== other); ); bool Operator <(const uwgknotenCS other) const (return (Gatterldent <other.Gatterldent);); bool operator> (const uwgknotenCS other) const (return (Gatterldent>other.Gatterldent);}; friend ostreamS Operator «(ostreamS os, const uwgknotenCS Node);

»Endif

»Include" AS_GraphKante.h "

D

"Include <ιostream> ostreamS Operator" (ostreamS os, const GraphKanteC S edge)) os "edge. Edge type; return os; }

»Include" AS_GraphNode.h "

D

»Include <ιostream>

0

D ostreamS Operator «(ostreamS os, const GraphNodeCS Node) (0 os« endl «Node.NodeNr; return os;

}

»Include" AS Slice. H "D

»Include <ιostream>

0

»Include <ιterator>

0 »include <algoπthm>

D

»Include" uwggraph.h "

Do using namespace std; D

D

IIFO: Function for selecting the variable for which an error tree is to be created. D

// A pointer to the selected node is returned. KFGListC:: iterator SliceC:: defιneVarιableToSlιce (KFGListC S L2) (int Number = 0;

KFGListC:: iterator KFGI = L2.begin (); KFGListC:: iterator VARDEFI = L2.begιn (); KFGUseListC:: iterator USEIT; while (KFGI! = L2.end ()) (

USEIT = KFGI-> Uses.begιn (); if (KFGI-> getKFGNodeType () == OP) (cout «KFGI-> getKnotNumber ()« ":" «USEIT-> getUse ()« endl;;)

KFGI ++; } cout «" Enter the node number em and press RETURN: "; cm »Number; while (KFGI '= L2.begιn ()) (if (KFGI-> getKnotenNummer () == Number) (

VARDEFI = KFGI,} KFGI--; if (VARDEFI-> getKFGNodeType () == OP) (cout «" Node No .: "« VARDEFI-> getKnotNumber () «was selected endl; return VARDEFI; ice

VARDEFI = L2.beginl); eout «" This node is not an output node, the program is terminated. "

«Final; exιt (l); return VARDEFI; )

// Fl: Find P-Use node, add it to the slice and pull a KFK. // input: iterator on the C-Use or D-Use, KFG list; void SliceC:: slιceForLoops (KFGListC S L2, KFGListC:: iterator LOOPIT) (int HLevel; int check = 0; int node number = 0; KFGListC:: iterator HELPIT = LOOPIT; while ((LOOPIT-> getKFGNodeType ()! = LC SS LOOPIT-> getKFGNodeType ()! = IFC) ||

(LOOPIT-> getLevel ()! = HELPIT-> getLevel ())) {LOOPIT—;

}

NodeNumber = LOOPIT-> getNodeNr (); check = checkForNodes (node number);

// insert (* LOOPIT, * HELPIT, KFK); insert («HELPIT, * LOOPIT, KFK); // reverse direction of the edge so that each node knows its predecessors.

// cout «" insertedNodeFla: "« LOOPIT-> getNodeNr () «endl; // cout «" insertedNodeFla: "« HELPIT-> getNodeNr () «endl« endl; if (check == 0) {fιndAHDefs (L2, LOOPIT);

}

HLevel = LOOPIT-> getLevel (); while (LOOPIT-> getLevel ()> 2) (check = 0;

HELPIT = LOOPIT; whil e ((LOOPIT-> getKFGNodeType () '= LC S S LOOPIT-> getKFGNodeType ()' = IFC) I I (LOOPIT-> getLevel ()> = HELPIT-> getLevel ())) (LOOPIT—;

}

NodeNumber = LOOPIT-> getNodeNr (); check = checkForNodes (node number);

// insert (* LOOPIT, * HELPIT, KFK); insert ( ^» HELPIT, ^» LOOPIT, KFK); // reverse direction of the edge, so ₃ eder

Knot knows its predecessor.

// cout «" insertedNodeFlb: "« LOOPIT-> getNodeNr () «endl;

// cout «" insertedNodeFlb: "« HELPIT-> getNodeNr () «endl« endl; if (check == 0) (fmdAHDefs (L2, LOOPIT);

}

HLevel = LOOPIT-> getLevel ();

// F2: Find all D-Uses for a P-Use, add them to the slice and pull DFK. // input: iterator on the node with the P-use list, KFG list; void SliceC:: findAHDefs (KFGListC S Ll, KFGListC:: iterator ITER) {int AktLevel; int dummylf = 0; int NodeNumberEnd = 0; AktLevel = ITER-> getLevel (); KFGListC:: iterator HELPIT = ITER; KFGListC:: iterator HELPIF = ITER;

KFGListC:: iterator HELPLOOP = ITER; KFGListC:: iterator UPPERLIMIT = ITER; KFGPJJseListC:: iterator PUSEIT; PUSEIT = ITER-> P_Uses.begιn (); KFGDefListC:: iterator DEFIT1; if (ITER-> getKFGNodeType () == LC) <while ((HELPLOOP-> getKFGNodeType ()> = EL) || (HELPLOOP-> getLevel {)! = Akt- Level)) {

HELPLOOP ++; }

HELPIT = HELPLOOP;

NodeNumberEnd = HELPLOOP-> getNodeNr (); while (PUSEIT '= ITER-> P_Uses.end ()) (

UPPERLIMIT = fmdUpperLimit (Ll, ITER, PUSEIT); HELPLOOP = fιndLowerLιmit (Ll, ITER, UPPERLIMIT); // insert ( ^» UPPERLIMIT, * ITER, DFK); insert ( ^» ITER, ^» UPPERLIMIT, DFK); // reverse direction of the edge, so ₃ eder

Knot knows its predecessor.

// cout «" added nodeF2a: "« UPPERLIMIT-> getNodeNr () «endl; // cout «" added node F2a: "« ITER-> getNodeNr () «endl; while (HELPLOOP ι = UPPERLIMIT) (HELPLOOP--; if (HELPLOOP-> getKFGNodeType () - EE1) {dummylf = 1;} if ((HELPLOOP-> getKFGNodeType () == ETh) SS (HELPLOOP-> getLevel I) <ITER-> getLevel I)) SS Idummylf == 0)) (

HELPIF = HELPLOOP; while ((HELPLOOP-> getKFGNodeType ()! = IFC) || (HELPLOOP-> getLevel () '= HELPIF-> getLevel ())) (

HELPLOOP--; } dummylf = 0; } if (HELPLOOP-> getKFGNodeType () == NO) (DEFIT1 = HELPLOOP-> Defs.begιn (); while (DEFIT1 '= HELPLOOP-> Defs.end ()) {if (strcmp (PUSEIT-> getUse () , DEFITl-> getDef ()) == 0) (// insert ( ^» HELPLOOP, * ITER, DFK); msert (* ITER, * HELPLOOP, DFK); // reverse direction of the edge so that each node knows its predecessors . defInLoopILl, HELPLOOP);

// cout «" added nodeF2b: "« HELPLOOP-> getNodeNr () «endl;

// cout «" added nodeF2b: "« ITER-

> getNodeNr () «endl« endl; if CHEL _J PPLLOOOOPP - >> UUsseess .. eemmppttyy II)))) ((fmdDefToCUselLl, HELPLOOP);

}}

DEFIT1 ++;

}

PUSEIT ++; } KFKPUseToCUse (ITER, node number end);

// F5: function searches for the first def above a p-use or c-uses and

// returns an iterator to this upper limit when searching all defs //.

KFGListC:: iterator SliceC:: findUpperLimit (KFGListC S Ll, KFGListC:: iterator ITER, KFGP_UseLιstC:: iterator PUSEIT) (int dummy = 0; mt dummyl = 0; mt dummylf = 0; int AktLevel = 0;

KFGListC :: iterator HELPDEF = ITER; KFGListC :: iterator HELPLOOP = ITER;

KFGListC :: iterator HELPIF = ITER; KFGListC :: iterator HELPIT = ITER; KFGListC :: iterator HELPDEFRETURN = ITER; KFGDefListC:: iterator DEFIT; AktLevel = ITER-> getLevel ();

// find the first defs above the p-use. while ((HELPDEF! = Ll.beginO) SS (dummy '= 1)) (HELPDEF--; if (HELPLOOP-> getKFGNodeType () == EE1) (dummyl f = 1;

) if I (HELPDEF-> getKFGNodeType () == ETh) S (HELPDEF-> getLevel () <ITER-> getLevel ()) SS (dummylf == 0)) (

HELPIF = HELPDEF; while ((HELPDEF-> getKFGNodeType () '= IFC) II (HELPDEF-> getLevel ()' =

HELPIF-> getLevel ())) (

HELPDEF—; dummylf = 0;

} if (HELPDEF-> getKFGNodeType () == NO) (DEFIT = HELPDEF-> Defs.begιn (); if (strcmp (DEFIT-> getDef (), PUSEIT-> getUse ()) == 0) (

HELPDEFRETURN = HELPDEF; dummy = 1; )}} if ((HELPDEF == Ll.begmO) SS (HELPDEF-> getKFGNodeType () == NO)) (DEFIT = HELPDEF-> Defs.begm (); if (strcmp (DEFIT-> getDef (), PUSEIT -> getUse ()) ~ 0) (HELPDEFRETURN = HELPDEF; dummy = 1;

}}

// find the outermost loop, if it exists at all, if (ITER-> getLevel ()> 2) (while ((HELPIT '= Ll.endO) SS (dummyl' = 1)) {

HELPIT ++; if ((HELPIT-> getKFGNodeType () == EL) SS (HELPIT-> getLevel () <Akt- Level)) (

HELPLOOP = HELPIT; if (HELPIT-> getLevel ()> 2) (

AktLevel = HELPIT-> getLevel (]

} else dummyl = 1; }

)}

HELPIT ■ = HELPLOOP;

// go to the beginning of the outermost loop: while I (HELPIT-> getKFGNodeType () '= LC) II (HELPIT-> getLevel ()' = HELPLOOP-

> getLevel I))) (

HELPIT—; )

// if the def node found is outside the outermost loop and // its ScopeLevel is greater than that of the outermost loop, look for it

// there is another def node above, if (HELPDEF-> getNodeNr ()> HELPIT-> getNodeNr ()) (if (HELPDEF-> getLevel ()> = HELPIT-> getLevel ()) (dummy = 0 ; while ((HELPDEF '= Ll.begmO) SS (dummy' = 1)) (

HELPDEF—;

DEFIT = HELPDEF-> Defs.begιn (); if (strcmplDEFIT-> getDe (), PUSEIT-> getUse ()) == 0) (HELPDEFRETURN = HELPDEF; dummy = 1;

))})} return HELPDEFRETURN;

// F6: Function searches, depending on the upper end, the lower end of the range by // looking for the defs.

// An iterator is returned to the lower limit.

KFGListC:: iterator SliceC:: findLowerLimit (KFGListC S Ll, KFGListC:: iterator ITER, KFGListC:: ιterator UPPERLIMIT) (int dummyl = 0; int AktLevel «0;

KFGListC:: iterator HELPIT = ITER; KFGListC:: iterator HELPLOOP = ITER; KFGListC:: iterator LOWERLIMIT = ITER;

AktLevel = ITER-> getLevel I); if (ITER-> getKFGNodeType () == LC) (while ((HELPLOOP-> getKFGNodeType ()> = EL) || (HELPLOOP-> getLevel () ^ Akt- Level)) (HELPLOOP ++;

}} // find the end of the outermost loop. if (ITER-> getLevel ()> 2) (while I (HELPIT! = Ll.end (l) SS (dummyl! = 1)) (HELPIT ++; if ((HELPIT-> getKFGNodeType () == EL) SS ( HELPIT-> getLevel () <Akt- Level)) {

HELPLOOP = HELPIT; if (HELPIT-> getLevel ()> 2) (

AktLevel = HELPIT-> getLevel (); ) ice <dummyl = 1; }}} HELPIT = HELPLOOP; // HELPLOOP points to the end of the outermost loop, otherwise to the p-use. while ((HELPIT-> getKFGNodeType ()> = LC) || (HELPIT-> getLevel ()! = HELPLOOP-> getLevel ())) (

HELPIT—; } // HELPIT points to the

Beginning of the outermost loop. if (HELPIT-> getNodeNr () <UPPERLIMIT-> getNodeNr ()) (

LOWERLIMIT = HELPLOOP; // if the upper limit is outside the loops. else

AktLevel = UPPERLIMIT-> getLevel (); while | (HELPLOOP-> getKFGNodeType () ι = EL) II (HELPLOOP-> getLevel () <=

AktLevel)) (HELPLOOP—;

LOWERLIMIT = HELPLOOP; // if the upper limit is within the loop. ice (

LOWERLIMIT = HELPLOOP; } return LOWERLIMIT;

// F3: Function pulls a KFK from P-Use to all C-Uses that are in the same // loop or branching level. // input: iterator on P-Use node. void SliceC:: KFKPUseToCUse (KFGListC:: iterator PUSEIT, t SchielfenEnde) (SliceC:: iterator SLl = begιn (); SliceC:: iterator SLHELP = beginl); KFGListC :: iterator ITER = PUSEIT;

KFGUseLiεtC:: iterator USEIT; KFGPJJseListC:: iterator PUSEIT2; KFGUseListC :: iterator CUSEIT2; int node level; int node number;

NodeNumber = PUSEIT-> getNodeNr (); NodeLevel = PUSEIT-> getLevel (); while I (* SL1). first. getNodeNr ()! = node number) SL1 ++; SLHELP - SLl;

SLl - begin (); while (SLl '= end ()) {if ((node number> (* SL1). first. getNodeNr ()) SS (loop end <(* SL1) .first. getNodeNr!))) (if (((* SL1) .first. getKFGNodeType!) == NO) SS ((* SL1). first. getLevel ()

== node level)) (

// insert (( ^« SLHELP) .first, (* SL1) .first, KFK); insert! (* SL1). first, (* SLHELP). first, KFK); // reverse direction of the edge so that each node knows its predecessors. // cout «" addednodeF3: "«

(* SL1). first. getNodeNr! ) «Endl;

// cout «" added node F3: "« (* SLHELP). first. getNodeNr! ) «Endl; , '

SL1 ++;

)} // F4: seeking function when the node next to the defs not c-uses including to this _/ / c-uses all defs and pulls DFK from the found def for c-use. void SliceC:: indDefToCUse (KFGListC S Ll, KFGListC:: iterator ITER) {t HLevel; mt check = 0; t dummy = 0; int dummylf = 0; int node number = 0;

KFGListC:: iterator HELPIT «= ITER; KFGListC:: iterator HELPLOOP = ITER; KFGListC:: iterator HELPIF = ITER; KFGListC:: iterator LOWERLIMIT = ITER; KFGListC:: iterator UPPERLIMIT = ITER;

KFGDefListC:: iterator DEFIT1; KFGUseListC:: iterator USEIT1; USEIT1 = ITER-> Uses.begin (); HLevel = ITER-> getLevel (); while (USEIT1! = ITER-> Uses.end ()) (

UPPERLIMIT = findUpperLimitFromCUse (Ll, ITER, USEIT1); HELPIT - findLowerLimitFromCUse (Ll, ITER, UPPERLIMIT); UPPERLIMIT—;

// cout «" added node F4a: "« UPPERLIMIT-> getNodeNr () «endl; // cout «" added node F4a: "« ITER-> getNodeNr () «endl; while (HELPIT! = UPPERLIMIT) (if (HELPLOOP-> getKFGNodeType () == EE1) (dummylf = 1;} lf ((HELPIT-> getKFGNodeType () == ETh) SS (HELPIT-> getLevel () <= ITER -

> getLevel ()) SS (dummylf == 0)) (

HELPIF = HELPIT; while ((HELPIT-> getKFGNodeType () '= IFC) II (HELPIT-> getLevel ()! = HELPIF-> getLevel ())) (HELPIT—;

) dummylf »0;

} lf (HELPIT-> getKFGNodeType () == NO) (DEFIT1 = HELPIT-> Defs.beginl); lf (strcmp (DEFITl-> getDef I), USEITl-> getUse ()) == 0) (lf (! HELPIT-> Uses. emptyI)) (

Node number = HELPIT-> getNodeNr I); check = checkForNodes (node number); }

// insert (* HELPIT, * ITER, DFK); insert ( ^" ITER, ^" HELPIT, DFK); // reverse direction of the edge so that each node knows its predecessors. defInLoop (Ll, HELPIT); // cout «" addednodeF4b: "« HELPIT-

> getNodeNr () «endl;

// cout «" insertedNodeF b: "« ITER-> getNodeNr () «endl« endl; if (check == 0) (findDefToCUse | L1, HELPIT);

)}} HELPIT—; }

USEIT1 ++;

}

// F8: Function searches for the lower limit from which the defs can be searched for a c-use.

KFGListC:: iterator SliceC:: findLowerLimitFromCUse (KFGListC S Ll, KFGListC:: iterator ITER, KFGListC:: ιterator UPPERLIMIT) (int HLevel; int dummy = 0;

KFGListC :: iterator HELPIT = ITER; KFGListC :: iterator HELPLOOP = ITER; KFGListC:: iterator LOWERLIMIT = ITER;

KFGDefListC:: iterator DEFIT1; KFGUseListC:: iterator USEIT1; USEIT1 = ITER-> Uses. beginl); HLevel = ITER-> getLevel ();

// Is the c-use node in a loop? if (ITER-> getLevel ()> = 2) (while ((HELPIT! = Ll.endO) SS (dummy! «= 1)) (HELPIT ++; if ((HELPIT-> getKFGNodeType () == EL) SS ( HELPIT-> getLevel () <- HLevel)) {

HELPLOOP = HELPIT; lf IHELPIT-> getLevel ()> 2) (HLevel—; eise (dummy = 1;)}}

}

// The iterator HELPLOOP now points to the end of the outermost // loop surrounding the node, if there is one, otherwise the iterator points to the c-use node itself. _L f (HELPLOOP '= ITER) {

HELPIT = HELPLOOP; // iterator points to the end of the outermost

Loop. while ((HELPIT-> getKFGNodeType ()! = LC) || (HELPIT-> getLevel ()! = HELPLOOP-

> getLevel ())) (

HELPIT—; } if (HELPIT-> getNodeNr () <UPPERLIMIT-> getNodeNr ()) (LOWERLIMIT = HELPLOOP; // upper limit outside the outermost loop;

} else if (ITER-> getLevel () == UPPERLIMIT-> getLevel ()) (

LOWERLIMIT = ITER; // upper limit with the c-use in the same loop;

) else lf (ITER-> getLevel () <UPPERLIMIT-> getLevel ()) (

LOWERLIMIT = HELPLOOP; // upper limit in the same outer loop, but} // inside a different loop before the c-use; ice (

HLevel = UPPERLIMIT-> getLevel (); while ((HELPLOOP-> getKFGNodeType ()! - EL) II (HELPLOOP-> getLevel () <= HLevel)) (

HELPLOOP—; }

LOWERLIMIT = HELPLOOP; // upper limit in a lower loop than the c-use; }

} ice {

LOWERLIMIT = ITER; // there is no outer loop.

} return LOWERLIMIT;

)

// F7: Function searches for the upper limit up to which defs can be searched for a c-use //. The mode of operation is similar to the corresponding function for p-uses.

KFGListC:: iterator SliceC:: findUpperLimitFromCUse (KFGListC S Ll, KFGListC:: iterator ITERl, KFGUseListC :: iterator USEIT) (int dummy = 0; t dummyl = 0; int dummylf = 0; int AktLevel = 0;

KFGListC:: iterator HELPDEF = ITERl; KFGListC:: iterator HELPLOOP = ITERl; KFGListC:: iterator HELPIT = ITERl; KFGListC:: iterator HELPIF = ITERl;

KFGListC:: iterator HELPDEFRETURN = ITER1; KFGDefListC:: iterator DEFIT; AktLevel = ITERl-> getLevel ();

// cout «" processing node: "« ITERl-> getNodeNr () «endl; // find the first defs above the use. do (lf (HELPLOOP-> getKFGNodeType () - = EE1) (dummylf = 1; } _l f ((HELPDEF-> getKFGNodeType () == ETh) SS (HELPDEF-> getLevel () <= ITERl-> getLevel ()) & S (dummylf == 0)) f

HELPIF = HELPDEF; while ((HELPDEF-> getKFGNodeType ()! = IFC) II (HELPDEF-> getLevel I)! =

HELPIF-> getLevel I))) {

HELPDEF—; } dummylf = 0; _l ) f (HELPDEF-> getKFGNodeType () - = NO) (DEFIT = HELPDEF->Defs.beginl); lf (strcmp (DEFIT-> getDef (), USEIT-> getUse I)) == 0) (HELPDEFRETURN = HELPDEF; if (HELPDEF! = ITERl) (dummy = 1;})} HELPDEF—;

) while ((HELPDEF! = Ll.begmO) SS (dummy! = 1)); if ((HELPDEF == Ll.beginl)) SS (HELPDEF-> getKFGNodeType () == NO)) (DEFIT = HELPDEF-> Defs.begin (); _l f (stremp (DEFIT-> getDef (), USEIT- > getUse ()) == 0) {HELPDEFRETURN = HELPDEF;

}

HELPDEF = HELPDEFRETURN;

// cout «" first def: "« HELPDEFRETURN-> getNodeNr () «endl; // find the outermost loop, if it exists at all, if (ITERl-> getLevel ()> = 2) (while ((HELPIT! = Ll. end ()) SS (dummyl! = 1)) (HELPIT ++; lf ( (HELPIT-> getKFGNodeType () == EL) SS (HELPIT-> getLevel () <= Akt-Level))

HELPLOOP = HELPIT; lf (HELPIT-> getLevel ()> 2) (AktLevel—; eise {dummyl = 1;)}) HELPIT - HELPLOOP;

// cout «" End of the outermost loop: "« HELPIT-> getNodeNr () «endl; // go to the beginning of the outermost loop, if there is one; if (HELPLOOP-> getKFGNodeType () == EL) {while ((HELPIT-> getKFGNodeType ()! = LC) || (HELPIT-> getLevel ()! = HELPLOOP-> getLevel ())) (

HELPIT—; )

// cout «" Start of the outer loop: "« HELPIT-> getNodeNr () «endl; // if the def node found is outside the outermost loop, and

// its scope level is greater than that of the outermost loop, search. whether it

// there is another def node above. lf (HELPDEF-> getNodeNr ()> HELPIT-> getNodeNr I)) (lf (HELPDEF-> getLevel (1> = HELPIT-> getLevel ()) (dummy = 0; while ((HELPDEF! = Ll.begmO) SS (dummy! = 1)) (HELPDEF—; DEFIT = HELPDEF-> Defs.begιn (); if (strcmp (DEFIT-> getDe (), USEIT-> getUse ())

0)

HELPDEFRETURN = HELPDEF; dummy = 1;

// c-use within the outermost loop; else (if (HELPDEF-> getLevel ()>ITERl-> getLevel ()) (dummy = 0; while IHELPDEF> = HELPIT) ( HELPDEF—;

DEFIT = HELPDEF-> Def s. egin l); l f | strcmp (DEFIT-> getDef (), USEIT-> getUse ()]

0) <

HELPDEFRETURN = HELPDEF;

}})

// c-use in no loop, but in a branch; else (lf (HELPDEF-> getLevel |)> ITERl-> getLevel ()) (dummy = 0; while ((HELPDEF '= Ll.beginO) SS (dummy' = 1)) {

HELPDEF—;

DEFIT = HELPDEF-> Defs.beginl); lf (strcmp (DEFIT-> getDef (), USEIT-> getUse ()) == 0) {HELPDEFRETURN = HELPDEF; dummy = 1;

}

)}

// c-use in no loop; else (lf (HELPDEF-> getLevel ()> ITERl-> getLevel ()) (dummy = 0; while ((HELPDEF '= Ll.begmO) SS (dummy' = 1)) (

HELPDEF—;

DEFIT = HELPDEF-> Defs.beginl); if (strcmp (DEFIT-> getDef (), UΞEIT-> getUse ()) == 0) (HELPDEFRETURN = HELPDEF; dummy = 1;

)}} // cout «" UpperLimitFunction: "« HELPDEFRETURN-> getNodeNr () «endl; return HELPDEFRETURN;

// F9: Function checks whether a node already exists in the slice. If so, // a one is returned, otherwise a zero. // input: node number of the searched node; // Output: Integer 0 or 1; int SliceC:: checkForNodes (int NodeNumber) (mt dummy = 0;

SliceC:: iterator SLl = beginl); while ((SLl '= end ()) SS (dummy' = 1)) (lf ((* SL1) .first. getNodeNrO == NodeNumber) (dummy = 1;

SL1 ++;

) lf (dummy == 1) (return 1;} ice (return 0;}

// FlO: function examines whether em def is in a loop; if so, the // function Fl, which is looking for the p-use, is called. The first thing to do there is // to see whether the p-use found is already present in the slice. void SliceC:: defInLoop (KFGListC S Ll, KFGListC:: iterator ITER) (int dummyLoop = 0; KFGListC :: iterator HELPIT = ITER; while ((HELPIT '= Ll.beginO) SS (dummyLoop' = 1)) {HELPIT -; lf (((HELPIT-> getKFGNodeType () == LC) II (HELPIT-> getKFGNodeType () == IFC)) SS (HELPIT-> getLevel () == ITER-> getLevel ())) (sliceForLoops ( Ll, ITER); dummyLoop = 1;

// Fll: function receives the selected start node for the slice, // examines whether this node is in a loop; if yes, // the function "sliceForLoops" is called first, otherwise immediately "findDefToCUse" '. void SliceC:: startBuιldSlιce (KFGListC S Ll / *, KFGListC:: iterator OUTPUTIT * /) (mt dummyNode = 0;

KFGListC:: iterator STARTVARI = defineVariableToSlice (Ll); KFGListC :: iterator HELPOUT = STARTVARI; while ((HELPOUT '= Ll.beginO) SS (dummyNode! = 1)) (

HELPOUT--; lf (I (HELPOUT-> getKFGNodeType () == LC) II (HELPOUT-> getKFGNodeType |) IFC)) SS (HELPOUT-> getLevel () == STARTVARI-> getLevel I))) (SliceForLoops (Ll, STARTVARI) ; dummyNode = 1;

})

// cout «" Fll "« OUTPUTIT-> getNodeNr () «endl; findDefToCUse (Ll, STARTVARI); }

void SliceC:: slιceExpend () (ofstream target ("Slιce2. sie"); ostream_lterator <KFGLιstNodeC> POSITIZiel, "\ n"); // ostream_ιterator <KFGLιstNodeC> POSIT2 (Zιel, "\ n"); SliceC:: iterator SLC = beginl); while (SLC! - = end ()) (* POSIT ++ = (* SLC) .first;

SliceC:: Successor:: ιterator IT = ( ^« SLC) .second. begm (); SliceC:: Successor:: ιterator ITEND = (* SLC) .second. end (); while (IT! = ITEND) (

// a = (* IT) .first; ^" POSIT ++ = SLC [( ^« IT) .first] .first;

^» IT ++; ) ++ SLC;

«Include" KFGDef.h "

D

»Include <ιostream>

D

G ostreamS Operator «(ostreamS os, const KFGDefCS Node) (G os« "DEF:" «Node. Def« "" «Node. ScopeLevelD; α return os; α

»Include" KFGLineNode.h "

G

»Include <ιostream> ostreamS Operator« (ostreamS os, const KFGLmeNodeCS Node) (os «Node.Name« "" «Node. LineNumber« endl; return os;}

// Function that builds a KFG from KFGTokenList. D »Include <ιoεtream>

D

»Include" KFGList.h "

D

»Include" KFGTokenList.h "

»Include" KFGUse.h "

»Include" KFGDef.h "

»Include" KFGProgList.h "

»Include <algoπthm> void KFGListC:: TokenLιst2KFGLιst (KFGTokenListC S Ll) (int dummy;

KFGTokenListC:: iterator TLI = Ll.endO; KFGP_UseLιstC:: iterator P_USEI;

KFGUseListC:: iterator USEI; dummy = 0;

// while (strcmp (TLI-> getName (), "main") '= 0) {while ((TLI! = Ll.beginO) SS (dummy! = 1)) (l (TLI-> getTokenNodeType () - = N) {lf (strcmp (TLI-> getName (), "maιn") == 0) {dummy = 1;)} // TLI ++; switch (TLI-> getTokenNodeType ()) (case PL: (

TLI--; KFGLlstNodeC hNl ("NORMAL", NO, TLI-> getScopeLevel (), TLI-

> getLιneNumber ()); hNl. Defs .push_bac (KFGDefC (TLI-> getName (), TLI-> getScopeLevel ())); push_front (hNl); TLI—;

} break; / ^« Case IF: push_front (KFGLιstNodeC (" IF ", IFC, TLI-> getScopeLevel ())); TLI--; break; * / case BT:

// push_front (KFGLlstNodeC ("BT", BTh, TLI-> getScopeLevel ())); (TLI—;

// KFGP_UseLιstC:: iterator P_USEI;

KFGLlstNodeC hNl ("IFCOND", IFC, TLI-> getScopeLevel (), TLI-> getLιneNumber ()); while (TLI-> getTokenNodeType () '= IF) (KFGUseC hUsel ⁽ TLI-> getName ⁽⁾ , TLI-> getScopeLevel ());

P JSEI = f dlhNl. P_Uses.beginl), hNl. P_Uses.end (), hUsel); if I P_USEI == hNl. P_Uses. end ()) {hNl.P_Uses.push_back (hUsel); Number_P_Uses ++;

)

// HNl. P_Uses .push_back (KFGUseC (TLI -> getName (), TLI-> getScopeLevel ()));

TLI -; } push_front (hNl); Decisions ++; } break; case ET: push_front (KFGLlstNodeC ("ENDTHEN", ETh, TLI-> getScopeLevel ())); TLI--; break; case BE: push_front (KFGLlstNodeC ("BEGINELSE", BEI, TLI-> getScopeLevel ()));

TLI--; break; case EE: push_front (KFGLlstNodeC ("ENDELSE", EE1, TLI-> getScopeLevel ())); TLI—; break; / • case WHILE: push_front (KFGLlstNodeC ("WHILE", LC, TLI-> getScopeLevel ())); TLI--; break; * / case BW:

// push front (KFGLιstNodeC ("BW", BL, TLI-> getScopeLevel ())); ^{

TLI—;

// KFGP_UseLιstC:: ιterator PJJSEI;

KFGLlstNodeC hNl ("LOOPCOND", LC, TLI-> getSeopeLevel (), TLI-> getLιneNumber ()); while (TLI-> getTokenNodeType () '= WHILE) (

KFGUseC hUsel (TLI-> getName (), TLI-> getScopeLevel ()); PJJSEI = find (hNl.P Uses. Beginl), hNl. P_Uses. end (), hUsel); if (P_USEI == hNl.P_Uses.end ()) {hNl.P_Uses.push_back (hUsel);

Number_P_Uses ++; }

// HNl. P_Uses.push_back (KFGUseC (TLI-> getName (), TLI-> getScopeLevel ())); TLI--;

} push_front (hNl); Schieifenentscheidungen ++; } break; case EW: push_front (KFGLlstNodeC ("ENDLOOP", EL, TLI-> getScopeLevel ())); TLI—; break; case BDOW:

(

TLI—;

KFGLlstNodeC hNl ("DOWHILELOOPCOND", DOWLC.TLI-> getScopeLevel (), TLI-> getLιneNumber ()); while (TLI-> getTokenNodeType () '= DOWS) (

KFGUseC hUsel (TLI-> getName (), TLI-> getScopeLevel ()); P_USEI = fιnd (HNl. P_Uses.beginl), hNl. P_Uses.end (), hUsel); lf (PJJSEI == hNl.P_Uses.end ()) (hNl. PJJses.pushJ> ack! hUsel);

Number_P_Uses ++; } hNl. PJJses.pushJ-ack (KFGUseC (TLI-> getName (), TLI-> getScopeLevel I))); TLI—;

) push_front (hNl); } break; case DO: push_front (KFGLιstNodeC ("DOWHILELOOP", DOWL, TLI-> getScopeLevel ())); TLI -;

Loop decisions ++; break; case EF:

(

// TLI—; int HLevel;

HLevel = TLI-> getScopeLevel (); push_front (KFGLlstNodeC ("ENDLOOP", EL, LI-> getScopeLevel ()));

// while (TLI-> getTokenNodeType ()! = BF) (while ((TLI-> getTokenNodeType ()> = BF) II (TLI-> getScopeLevel I)! = HLevel)) (

TLI—; }

TLI—; if (TLI-> getTokenNodeType () == PF)

TLI--; KFGLlstNodeC hNl ("NORMAL", NO, TLI-> getScopeLevel (), TLI-> getLmeNumber ()); hNl.Defs.push_back (KFGDefC (TLI-> getName (), TLI-> getScopeLevel ()));

Number of J3efs ++; hNl.Uses.push_back (KFGUseC (TLI-> getName (), TLI-> getScopeLevel I)));

Number_use ++; push_front (hNl);

// while (TLI-> getTokenNodeType () '= EF) ( while ((TLI-> getTokenNodeType ()! = EF) II (TLI-

> getScopeLevel () '= HLevel)) {

TLI ++;

}

TLI—;

Counting loop decisions ++; Loop decisions ++; break; case FOR_D: (

TLI—;

KFGLlstNodeC hNl ("LOOPCOND", LC, TLI-> getScopeLevel (), TLI-> getLιneNumber ()); while (TLI-> getTokenNodeType ()! = DEF) {

KFGUseC hUsel (TLI-> getName (), TLI-> getScopeLevel ()); PJJSEI - = find (HNl. PJJses.beginl), hNl. PJJses. endl), hUsel); lf (PJJSEI - hNl.P_Uses.end ()) (hNl. PJJses .push_back (hUsel); number_P_Uses ++;} // hNl. PJJses.push_back (KFGUseC (TLI-> getName (), TLI-

> getScopeLevel ()));

TLI—; } push_front (hNl);

TLI--;

KFGLlstNodeC hN2 ("NORMAL", NO, (TLI-> getScopeLevel () -1), TLI-

> getLιneNumber ()); hN2.Defs.push_back (KFGDefC (TLI-> getName (), (TLI-> getScopeLevel () -!)));

Number_defs ++; push_front (hN2); TLI--; break; case RET:

// Just a preliminary implementation; still needs to be expanded

// in case there is an output after the RETURN. push_front (KFGLlstNodeC ("RETURN", RETURN, LI-> getScopeLevel ()));

TLI—; break; case NL:

TLI--;

// create nodes that contain defs and uses; lf (TLI-> getTokenNodeType () - = N) (

KFGLlstNodeC helpNodel ("NORMAL", NO, TLI-> getScopeLevel (), TLI-> getLιneNumber ());

TLI--; lf (TLI-> getTokenNodeType () == NL) (

TLI ++; helpNodel. Defs.push_back (KFGDefC (TLI-> getName (), TLI-

> getScopeLevel ()) I;

Number_defs ++; helpNodel .Uses .pushjoack (KFGUseC (TLI-> getName (), TLI-> getScopeLevel ()));

Number_use ++; TLI—;

} ice (

TLI ++; while (TLI-> getTokenNodeType () '= DEF) {KFGUseC hUsel (TLI-> getName (), TLI-> getScopeLevel ());

USEI = find (helpNodel.Uses. Beginl), helpNodel .Uses. end (), hUsel); lf (USEI == helpNodel. Uses. endl)) {helpNodel .Uses.push_back (hUsel); Number_use ++; }

// helpNodel. Uses.push_back (KFGUseC (TLI-

> getName (), TLI-> getScopeLevel O)); TLI—; } TLI--; helpNodel. Defs.push_bac (KFGDefC (TLI-> getName (), TLI-> getScopeLevel ()));

TLI—;

Number_defs ++; if (TLI-> getTokenNodeType () - N) (helpNodel.Defs.pop_front (); number_defs—; // in this case it is an array and

// therefore the last node must be deleted.

TLI ++; // To do this, the deleted node must be entered in the use list.

KFGUseC hUse2 (TLI-> getName (), TLI-> getScopeLevel ());

USEI - find (helpNodel.Uses. Begm (), helpNodel. Uses. End (), hUse2); lf (USEI == helpNodel.Uses. en ()) (helpNodel.Uses. ush_back (hUse2); Number of Uses ++;

TLI--; helpNodel.Defs.pushJ-ack (KFGDefC (TLI-

> getName (), TLI-> getScopeLevel ())); helpNodel.Uses.push_bac (KFGUseC (TLI-> getName (), TLI-> getScopeLevel ()));

Number_defs ++; NumberJJses ++; TLI--;

} push fron (helpNodel); }

// create nodes that only contain defs; else if (TLI-> getTokenNodeType () == DEF) (

TLI—;

KFGLlstNodeC helpNodel ("NORMAL", NO, TLI-> getScopeLevel (), TLI-

> getLιneNumber ()); helpNodel. Defs .push_back (KFGDefC (TLI-> getName (), TLI-> getScopeLevel ())); push_front (helpNodel);

Number_defs ++;

TLI--; ) else if (TLI-> getTokenNodeType () == PF) (

TLI—;

KFGLlstNodeC hNl ("NORMAL", NO, TLI-> getScopeLevel (), TLI-

> getLιneNumber ()); hNl.Defs.push_back (KFGDefC (TLI-> getName (), TLI-> getScopeLevel ())); hNl.Uses.push_back (KFGUseC (TLI-> getName (), TLI-> getScopeLevel ())); push_front (hNl);

Number_defs ++;

Number_use ++; }

// create node that contains output variables; ice (

TLI—;

KFGLlstNodeC helpNodel ("OUTPUT", OP, TLI-> getScopeLevel (), TLI-

> getLιneNumber ()); helpNodel .Uses. push_back (KFGUseC (TLI-> getName (), TLI-> getScopeLevel ())); push_front (helpNodel);

Number_use ++;

TLI—;

Instructions ++; break; default:

TLI—;

}

Node numbers ();

KFGListC :: iterator KFG = beginl);

Node identifier (KFG); addL elnToList ();

Number of declarations = count declarations (Ll); void KFGListC:: node numbers () (with node number = 1;

KFGListC:: iterator KFGI = beginl); while (KFGI '= end ()) (lf ((KFGl-> getKFGNodeType () == EL) II (KFGl-> getKFGNodeType () == ETh) II (KFGl-> getKFGNodeType () == BE1) II (KFGl -> getKFGNodeType () == EE1)) (KFG1 ++;

) ice (

KFGI-> setKFG node number (node number); Node number ++; KFG1 ++;

void KFGListC:: node identifier (KFGListC:: iterator KFG) int LOOPLevel = 0 int THENLevel = 0 int ELSELevel = 0 KFGListC:: iterator KFGI KFG; KFGListC:: iterator LOOPIT = KFG; KFGListC:: iterator IFIT KFG; KFGListC:: iterator ELSEIT = KFG; while (KFGI! = end ()) (switch (KFGl-> getKFGNodeType ()) case LC:

LOOPLevel = KFGl-> getLevel ();

KFG1 ++;

LOOPIT = KFGI; while ((KFGl-> getKFGNodeType ()! = EL) II (KFGl-> getLevel ()

LOOPLevel)) {

KFGl-> setKnotenIdent (LOOP); KFG1 ++; }

Node identifier (LOOPIT); } break; case IFC: <

THENLevel = KFGl-> getLevel ();

KFG1 ++;

IFIT = KFGI; while ((KFGl-> getKFGNodeType ()> = ETh) II (KFGl-> getLevel ()! = THENLevel))

KFGl-> setKnotenIdent (THEN);

KFG1 ++; } Node identifier (IFIT); } break; case AT: (

ELSELevel = KFGl-> getLevel (); KFG1 ++;

ELSEIT = KFGI; while ((KFGl-> getKFGNodeType ()! = EE1) || (KFGl-> getLevel (

! = ELSELevel))

KFGI-> setKnotenIdent (ELSE); KFG1 ++;

Node identifier (ELSEIT);

} break; default:

// cout «" Ouch "« endl;

KFG1 ++; ) // KFG1 ++; voiα KFGListC:: addLιneInToLιst () (mt number; char lιne [256]; KFGProgListC LP; _l fstream file ("CodeLine.dat"); if (! dateι)) (cout «" ERROR: Cannot open file 'CodeLine.dat' . "« Endl;

) eise (while (idatei.eof ()) (file.getlmelline, 255, '\ n'); for (int ι = 0; Kstrlen (line); ι ++) (lf (line (ι) == • "') (lιne [ι] ='\"; ⁾ if (lineli) - '(') (lιne (i] = ';';)} number = atoι (lιne);

KFGLmeNodeC hknotendine, number);

LP.push_back (hknoten);

// cout «line« "" «number« endl;

}} addLιneToKFG (LP);

void KFGListC:: addLιneToKFG (KFGProgListC S LP) {int dummy = 0; char help (256];

KFGListC:: iterator KFGI = end (); KFGProgListC:: iterator PROG1 = LP.endO; // KFGI—; while (KFGI! = begιn ()) (KFGI—; lf ((KFGl-> getKFGNodeType () == EL) || (KFGl-> getKFGNodeType () == ETh) II (KFGl-> getKFGNodeType () == BEI ) || (KFGl-> getKFGNodeType () == EE1)) (KFGI—;

} while ((PROG1 '= LP.beginO) SS (dummy' = 1)) (lf (KFGl-> getLmeNr () == PROGl-> getLmeNumber I)) (strcpy (help, PROGl-> getName ()); KFGl-> setCodeLιne (help);

PROG1—; dummy = 1; ) else {PROG1—;

PROG1 = LP. en l); dummy = 0;

int KFGListC:: count declarations (KFGTokenListC S TL) (int count = 0;

KFGTokenListC:: iterator TListI = TL.endO; while (strcmp (TLιstI-> getName (), "maιn") '= 0) (lf (TLιstI-> getTokenNodeType () == TD) f counter ++;}

TListI—; return counter;

// Function for outputting the KFGList on the screen and in a file "CFGList". void KFGListC:: Latest output () {ofstream target ("CFGLis. cfg"); ostream_ιterator <KFGLιstNodeC> Pos (Zιell, "\ n"); ostream_ιterator <KFGDefC> PosDIZiell, "\ n") ostream_ιterator <KFGUseC> PosUIZiell, "\ n"); ostream_ιterator <KFGUseC> PosPIZiell, "\ n"); KFGListC:: iterator KLI = beginl); KFGDefListC:: iterator DEF; KFGUseListC:: iterator USE; KFGPJJseListC:: iterator PJJSE; Target «" START "« endl «endl; while (KLI '= endO) (

Target «" Line "« KLI-> getLιneNr () «endl; Target «" line "« KLI-> getCodeLιne () «endl; Target «" node "« KLI-> getNodeNumber () «endl; Target «" node type "« KLI-> getKnotenIdent O «endl;

Target «KLI-> getStatement ()« ""«KLI-> getLevel ()« endl; // * Pos ++ - ^» KLI; DEF - KLI-> Defs.begin (); USE = KLI-> Uses.begin (); P_USE - KLI->P_Uses.beginl); while (DEF! »= KLI-> Defs.end ()) (// * PosD ++ = ^» DEF;

Target «" DEF: "« DEF-> getDef () «" "« DEF-> getScopeLevelD () «endl; DEF ++;

) while (USE! = KLI-> Uses.end ()) (// * PosU ++ = ^» USE;

Target «" USE: "" USE-> getUse () "" "" USE-> getScopeLevelU () "endl;

USE ++; } while (PJJSE '= KLI-> P_Uses.end ()) (// * PosP ++ = ^« P_USE; target« "P_USE:"«P_USE-> getUse ()« "" «

P_USE-> getScopeLevelU 0 «endl; PJJSE ++; )

Target «endl; KLI ++;

)

Target «" STOP "« endl «endl; Target «" BASIC SIZES: "« endl; Target «" Number of empty branches: "« "0" «endl; Target «" Number of decisions: "« Decisions «final;

Target «" number of instructions: "« instructions «endl; Target «" number of atomic predicates: "« decisions «final; Target «" Number of predicates: "« Decisions «final;

Target «" Number of atomic predicates, which are arithmetic relations: "« "0" «endl; Target «" Number of loop decisions: "« Loop decisions «endl;

Target «" Number of non-nested loop decisions: "« "0" «endl; Target «" number of counting loop decisions: "« counting loop decisions «endl;

Target «" Number of declarations of structured data types: "« "0" «endl; Target «" Number of declarations: "« Number_declarations «endl;

Target «" Number of real element declarations: "« "0"«endl; Target «" number of base type declarations: "« number_declarations «endl; Target «" number of defs: "« number_defs «endl; Target «" Number of Uses: "« Number_Uses «endl; Target «" Number of P-Uses: "« Number_P_Uses «endl« endl; base size file (); } void KFGListC:: basιsgroessenInDatei () (ofstream file ("Basisgroessen.bgd", ιos :: out); file «" 0 "« endl; file «decisions« endl; file «instructions« endl; file «decisions« endl; file «decisions« endl; file «" 0 "« endl; file «loop decisions« endl; file «" 0 "« endl; file «counting loop decisions« endl; file «" 0 "« endl; file «number_declarations« endl; file « "0"«endl; file« number_declarations «endl; file« "0"«endl; file« number_defs «endl; file« numberJJses «endl; file« number_P_Uses «endl; file «" 0 "« endl; file «" 0 "« endl; file «" 0 "« endl; file «" 0 "« endl; file «" 0 "« endl; file «" 0 "« endl; file «" 0 "« endl; file «" 0 "« endl;

»Include" KFGListe .h "D

D

KFGListeT KFGListe;

D α void KFGListeAusgabelKFGListeT S L) {0

KFGListeT:: iterator I = L.beginO; D whiled '= L.endl)) cout « ^» I ++ «''; cout «" sιze () = "« L.sizeO «endl; }

»Include" KFGListNode.h "

□

»Include <ιostream>

0

D ostreamS Operator «(ostreamS os, const KFGListNodeCS Node) (□ os« endl «" NodeNo: "« Node. NodeNo «" Type: "« Node. Node ID "endl« Node. Statement «" Level: "« Node. Level ; return os; int KFGLlstNodeC:: DummyNodeNr = l;

0

»Include" KFGNode.h "0

»Include <ιostream> D

□ ostreamS Operator «(ostreamS os, const KFGNodeCS Node)

D os «node. Name «" "« Node. ScopeLevel; return os; }

»Include" KFGTokenList.h "D void KFGTokenListC:: KFGLιsteAusgabe () (D ofstream destination ("CFGTokenList"); D ostream_ιterator <KFGTokenNodeC> oPos (Zιel, "\ n");

D

KFGTokenListC:: iterator I = beginl); 0 while (I! = Endl)) {// ^» oPos ++ - I-> getName ();

* oPos ++ = ^» I;

// cout «I-> getName ()« "" «I-> getScopeLevel ()« "" «I-> getTokenNodeType ()« endl; I ++; ) cout «" sizel) = "« sizeO «endl;

»Mclude" KFGTokenNode.h "» include <ιostream> ostreamS Operator «(ostreamS os, const KFGTokenNodeCS Node) (os« Node.Name «" "« Node. ScopeLevel «" "« Node. TokenNodeType «" «Node. IneNumber« endl; return os;

»Include" KFGUse.h "

0

»Include <ιostream> ostreamS Operator« (ostreamS os, const KFGUseCS Node) (os «" USE: "« Node. Use «" "« Node. ScopeLevelU; return os;

/ * D * Main program to test C ++ grammar and preprocessor D

* / π o »include" JLStr.h "

D

»Include" tokens.h "

0

»Include" DLGLexer.h "» include "BufferedCPreParser.h"

»Include" CPreToCPPBuffer.h "

»Include" JLTokenBuffer.h "

»Include" CPPParserSym.h "

»Mclude" KFGTokenList.h "« include "KFGList. H"

»Clude" graph.h "

»Mclude" AS_Slιce.h "

»Include" uwggraph.h "

«Clude" KFGProgList .h "» include <ιostream> static void usagelchar * progname); int maindnt arge, char * argv |]) {

// For reporting memory usage char * p = new char [100000); long heapl = (long) (void *) p; delete [] p;

// Parse command-line options JLStr includePath; JLStr definitions;

FILE «inputFile = stdin; bool doTraceParse = false; bool doTraeelnclude = false; bool doDump = false; char «progname = ^« argv; arge—; argv ++; ofstream file ("CodeLme.dat", ιos :: trunc); while (arge> 0)

(if (argv [0] [0] == • - ^• ) (switch (argv (0] [1]) (case 'I ": lf (argv [0] [2]! = 0) (

// argument is part of "-I" includePath + = ';'; includePath + = Sargv [0] [2); } else lf (arge> 1) arge—; argv ++; includePath + = ';'; includePath - ^« argv; ) ise (usage (progname);} break; case 'd': lf (strcmp | argv [0], "-dump") == 0)

(doDump = true;) break; case 'D': lf (argv [0] [2] '= 0) (

// argument is part of "-D" definitions + = ';'; definitions + = sargv | 0] [2);

} ice lf (arge> 1) (

// argument follows "-D" arge—; argv ++; definitions + = ';'; definitions = * argv; } eise (usage (progname);} break; case 't': lf (strcmp (* argv, "-traceParse") == 0) {doTraceParse = true;

) else lf (stremp (* argv, "-tracelnclude") == 0) (doTraeelnclude = true;) else {usage (progname);

} break; default: usage (progname); break;

)) ice (

// must be the input filename if (mputFile! = stdin)

(

// already have one usage (progname); )

FILE * fp = fopen (* argv, "r"); lf (fp - ZERO)

(fpnntf (stderr, "% s: cannot open% s for ιnput \ n", progname, * argv); exιt (O);

) putFile = fp;

} arge—; argv ++; }

// printf ("* s \ n% s \ n% s \ n", includePath, definitions, mputFile); // Create input stream, lexer DLGF _l lelnput mput (putFile); DLGLexer scanner (Sinput); FastToken tok; Scanner. setToken (stok);

// Create preprocessor parser. Note that the preprocessor parser has // a built-token buffer in the form of an put stack.

Buf eredCPreParser preprocessor (Sscanner); preprocessor. With ( ) ;

// set include path and defines directly for debugging if (includePath. lengthO ~ 0)

(includePath = "c: \\ devstudιo \\ vc \\ ιnclude; \\ msdev \\ devstudιo \\ vc \\ mfc \\ ιnclude"; if (defimt ons. length l) == 0)

<definitions =

"cplusplus;" "DATE = \" date \ ";"

"FILE = \" fιlename \ ";"

"LINE = 1;"

"TIME = \" tιme \ ";"

"TIMESTAMP = \" tιmestamp \ "; ' "_M_IX86 = 400;"

"_MSC_VER = 1100;" "_WIN32;"

"_INTEGRAL_MAX_BITS = 64"; }

// Set preprocessor options preprocessor. SetIncludePath (includePath); preprocessor. SetDefinitions (definitions); // Set options in parser to make it act Standard with MS Extensions preprocessor. SetOption (CPreParserImp:: OptMSExtensιons, true); preprocessor. SetOption (CPreParserlmp:: OptBool, true); preprocessor. SetOption (CPreParserlmp:: OptWCharT, true); preprocessor. SetOption (CPreParserlmp:: OptPragmas, true); preprocessor. SetOption! CPreParserlmp:: OptExpandPragmas, true); preprocessor. SetOption (CPreParserlmp:: OptTrackInclude, doTraeelnclude);

// Buffer to störe tokens Output by preprocessor CPreToCPPBu fer pιpe2 (Spreprocessor);

// Connect preprocessor to second token buffer so that the

// preprocessor can unilaterally squirt new tokens into the buffer preprocessor. SetBu er (pιpe2); // Token buffer for the usual backtrack ng, etc.

JLTokenBuffer pιpe3 (Spιpe2, CPPParserSym:: ConstLLK);

// Create the C ++ parser CPPParserSym parser (pιpe3);

// Set parser options to look like MSVC ++ parser. SetOption (CPPParserSym:: OptPragmaMSPackιng, true) parser. SetOption (CPPParserSym:: OptMSTypedefHack, true); //preprocessor.doTrace (doTraceParse); parser. doTrace (doTraceParse);

// Process top-level rule parser. With ( ) ;

KFGTokenListC Ll; parser. translatιon_unit (Ll);

// Close the input file stream if (mputFile '= stdin)

{fclose (mputFile); }

// For reporting memory usage // For reporting memory usage p = new char [100000]; long heap2 = (long) (void *) p; delete [] p; cout «" Approx heap usage before dump: "« (heap2 - heapl) «endl; if (doDump)

(

// Dump the scope hierarchy cout «" Dump of scope hierarchy "« endl; parser. DumpScopes (); cout «endl;

// For reporting memory usage // For reporting memory usage p = new char [100000]; long heap3 = (long) (void *) p; delete [] p; cout «" Approx heap usage after dump: "« (heap ₃ - heapl) «endl; Ll .KFGListeAusgabe (); // Ll .KFGTokenListToKFGList ();

KFGListC L2;

// KFGListC:: iterator Iter; L2. TokenLιst2KFGLιst (Ll); L2. Output List ();

SliceC Slice;

Slice. startBuildSlice (L2); // Slice. uιldTestGraph (L2); // cout «slice; uwggraphC uwggraph; //uwggraph.buildlfTree (Slice); uwggraph. startBuildFT (Slice); cout << uwggraph; return 0;

) static void usage (char * progname) (fprintf (stderr,

"usage:% s [-1 directories] [-D definitions] (-traceParse] [-tracelnclude] [-o ofile] | ιfιle] \ n" "-I directories- semicolon-separated list of include dιrectoπes \ n"

-D definitions: semicolon-separated list of definitions, lιke: \ n "symbol1; symbol2 = value2 \ n" -traceParse: output debugging ιnformatιon \ n "-tracelnclude: Output trace of include stack \ n" "-dump: dump type and scope harcharchy \ n "

"ifile: name of mput file (otherwise it uses stdιn) \ n", progname); exιt (l); )

«Include <ιostream> "Include <ιterator>" include <algorιthm>"include<fstream>" include "uwggraph. H" using namespace std;

SliceC:: iterator uwggraphC:: fmdOutputNode (SliceC s Sl) {t dummy - 0; SliceC:: iterator SLl - Sl.begmO;

SliceC:: iterator HELP = Sl.beginO; while ((SLl! = Sl.endO) SS (dummy! = 1)) (if I (* SL1) .first. getKFGNodeType!) ~ OP) HELP = SLl; dummy = 1;

}

SLl ++; } return HELP; }

void uwggraphC:: startBuιldFT (SliceC S Sl) (t posl - 0; int Posil = 0; mt SliceNr = 0; t LineNr = 0; int inLoop = 0; SlιceExit (Sl); char NodeText (128]; char remarkllOOO] ;

SliceC:: iterator SLl = f dOutputNode (Sl); SliceNr = ( ^» SLl). first. getNodeNumber (); LineNr = ( ^» SLl). first. getLineN O; sprintf (NodeText, "Op% d", SliceNr); strcpy (remark, SLl-> fιrst.getCodeLιne ()); // sprintf (remark, "Line% d", LineNr);

SliceC:: Successor:: ιterator BEGIN = ( ^» SLl) .second.beginl); SliceC:: Successor:: ιterator END »( ^« SLl) .second. end (); while (BEGIN '= END) (lf (BEGIN-> second == KFK) (uwgknotenC hknotenl (EFFECT, SliceNr, NodeText, remark); Posil = insert (hknotenl); SliceC:: ιterator SLPUSE = findLastPUse (Sl, SliceNr) ;

CheekLoopOrCondlSl, SLPUSE, SLl, Posil); mLoop = 1; BEGIN ++; } ice (

BEGIN ++; )} if (inLoop == 0) {uwgknotenC hknotenl (EFFECT, SliceNr, NodeText, remark); uwgknotenC hknoten2 (OR, "OR"); insert (hknotenl, hknoten2, 0); n3 (CAUSE, SliceNr, NodeText, remark); nodes3, 0); ISl, SliceNr, posl); } check (); 'void uwggraphC:: checkLoopOrCond (SliceC S Sl, SliceC:: iterator SLPUSE, SliceC:: iterator SLORIG, t Posl) {int PosRet = 0; switch (SLPUSE-> fιrst. getKFGNodeType!)) (case IFC:

PosRet = buildlnIfTreelSl, SLPUSE, SLORIG, Posl); // cout «" Testla: "« SLHELP-> fιrst .getKnotenNummer () «endl; break; case LC: buildInLoopTree (Sl, Posl, SLPUSE, SLORIG);

// cout «" Testlb: "« SLHELP-> fιrst .getKnotenNummer () «endl; break; default: cout «" Oops "« endl;

}

void uwggraphC:: addFιrstNodesToFT (ΞlιceC S Sl, t NodenNr, mt Posl) (int helpNr = 0; t ret - 0; mt pos - 0; int nodeNrl = 0; int LineNrl = 0; char NodeText [128]; char note [1000];

SliceC:: iterator NODE ■> definelterator (Sl, node number); SliceC:: Successor:: iterator BEGIN = NODE-> second.begιn (); SliceC:: Successor:: iterator END = NODE-> second.end (); while (BEGIN! = END) {helpNr = BEGIN-> first;

NodeNrl = Sl [helpNr]. first. getNodeNumber (); SliceC:: iterator N0DE1 = definelterator (Sl, nodesNrl); lf (NODEl-> fιrst.getLevel ()> 1) (

SliceC:: ιterator PUSE = findLastPUse (Sl, nodesNrl); switch (PUSE-> fιrst. getKFGNodeType ()) (case IFC: ret = buildlnIfTreelSl, PUSE, NODE1, Posl); break; case LC: buildInLoopTree (Sl, Posl, PUSE, NODE1); break; default: cout «" Something is wrong '"« endl; }) ice (

LineNrl = Sl [helpNr]. first. getLineNr (); sprintf (NodeText, "Op% d", nodesNrl); // sprintf (note, "Line% d", LineNrl); strcpy! remark, Sl (helpNr). first. getCodeLine ()); uwgknotenC hknotenl (CAUSE, nodesNrl, NodeText, remark); pos = insert (hknotenl); verbmdeEcken (Posl, pos, 0); addFirstNodesToFTISl, nodesNrl, Posl); }

BEGIN ++;

SliceC:: ιterator uwggraphC:: findLastPUse (SliceC S Sl, int SliceNr) (int helpNrl = 0; int SliceNrl = 0; SliceC:: ιterator SLl = definelterator (Sl, SliceNr);

SliceC:: ιterator SLHELP = SLl;

SliceC:: Successor:: iterator BEGIN = ( ^« SLl) .second. eginl); SliceC:: Successor:: ιterator END = ( ^« SLl) .second. endl); while (BEGIN '= END) (if (BEGIN-> second == KFK) (helpNrl = BEGIN->fιrst;

SliceNrl = Sl [helpNrl]. first .getNodeNumber ();

SLHELP = defιneIterator (Sl, SliceNrl); SLHELP = findLastPUse (Sl, SliceNrl);

BEGIN ++; } return SLHELP;

SliceC:: ιterator uwggraphC:: fιndLastPUse2 (SliceC S Sl, int SliceNr, int RefNr) (mt helpNrl = 0; lnt SliceNrl = 0; SliceC:: ιterator SLRETURN = definelterator (Sl, SliceNr);

SliceC:: ιterator SLHELP = SLRETURN;

SliceC:: Successor:: iterator BEGIN = SLRETURN-> second.begιn (); SliceC:: Successor: .iterator END = SLRETURN-> second. end (); while (BEGIN! = END) (lf (BEGIN-> second == KFK) (helpNrl = BEGIN->fιrst;

SliceNrl = Sl [helpNrl] .first. getNodeNumber (); SLHELP = definelterator (Sl, SliceNrl);

SLHELP = fιndLastPUse2 (Sl, SliceNrl, RefNr); lf (SLHELP-> fιrst. getKnotenNummer () '= RefNr) (

SLRETURN = SLHELP; }}

BEGIN ++;

} return SLRETURN;

}

SliceC:: iterator uwggraphC:: lookForNextPUse (SliceC S Sl, SliceC:: iterator SNODE, SliceC:: ιterator SLPUSE) (int helpNrl - 0; int helpNr2 = 0; int helpNr ₃ = 0; int dummy = 0; int dummyl = 0; int NodeNrl = 0; int NodeNo2 = 0; int RefNr = SLPUSE-> flrst. GetNodeNumber (); SliceC:: iterator HELP = SNODE; SliceC:: iterator RETURN = SNODE; SliceC:: successor:: ιterator BEGIN1 «SNODE ->second.beginl);

SliceC:: Successor:: ιterator END1 = SNODE-> second.end (); while I (BEGIN1 '= END1) SS (dummy! = 1)) (helpNrl = BEGINl-> first;

SliceC:: Successor:: ιterator BEGIN2 = Sl [helpNrl] .second. beginl); SliceC:: Successor:: ιterator END2 = Sl [helpNrl] -second. end (); while ((BEGIN2 '= END2) SS (dummyl' = 1) 1 (if (BEGIN2-> second == KFK) (helpNr2 = BEGIN2-> flrst; if (Sl [helpNr2] .first. etKnotenNummer () '= RefNr ) (NodeNrl = Sl | helpNr2]. First. GetNodeNumber ();

RETURN = definelterator (Sl, nodesNrl); SliceC:: Successor:: ιterator BEGIN3 = RETURN-

> second.begιn ();

SliceC:: Successor:: ιterator END3 = RETURN-> second. end (); select (BEGIN3 '= END ₃ ) (lf (BEGIN3-> second == KFK) (helpNr3 = BEGIN3->flrst; lf (Sl [helpNr3]. first. getKotenNummer () • - RefNr) {

NodeNo2 =

Sl [helpNr3]. first .getNodeNumber ();

RETURN = fιndLastPUse2 (Sl, NodeNr2, RefNr);

BEGIN3 ++; } dummyl = 1; dummy = 1;

) ice {

NodeNrl = Sl [helpNrl]. first. getNodeNumber (); HELP = definelterator (Sl, nodesNrl); RETURN = lookForNextPUse (Ξl, HELP, SLPUSE);

BEGIN2 ++; BEGIN1 ++;

} return RETURN;

SliceC:: iterator uwggraphC:: returnCondNode (SliceC S Sl, int SliceNr) int helpNr = 0; mt dummy = 0; mt dummy2 = 0; int SlιceNr2 = 0;

SliceC:: iterator SLl = definelterator | S1, SliceNr); SliceC:: iterator HELP = SLl;

SliceC:: successor :: iterator BEGIN = (* SL1) .second.beginl); SliceC:: Successor:: iterator END = ( ^» SLl) .second. end (); while ((BEGIN ι = END) SS (dummy! = 1)) {helpNr = BEGIN->first; SliceNr = Sl [helpNr]. first. getNodeNumber ();

HELP = definelteratorlSl, SliceNr);

SliceC:: Successor:: ιterator BEGIN2 = ( ^» HELP) .second. beginl); SliceC:: Successor:: ιterator END2 = ( ^» HELP) .second. endl); while ((BEGIN2! = END2) SS (dummy2! = D) (if (( ^» BEGIN2) .second == KFK) (helpNr = ( ^» BEGIN). first;

SlιceNr2 = Sl [helpNr]. first .getNodeNumber (); HELP = definelteratorlSl, SlιceNr2); dummy2 = 1; dummy = 1;

}

BEGIN2 ++; } BEGIN ++; return HELP;

// Function examines whether two control structures are nested or not. int uwggraphC:: checkPUsesl (SliceC S Sl, SliceC:: iterator SLPUSEREF, SliceC:: iterator SLPUSE) (int helpreturn ■ = 0; int nodeNumberRef - 0; int helpNrl = 0; int nodeNrl = 0;

NodeNumberRef = SLPUSE-> first. getNodeNumber (); SliceC:: Successor:: ιterator BEGIN1 = SLPUSEREF-> second.beginl); SliceC:: Successor:.-Iterator END1 = SLPUSEREF-> second.end (); while (BEGIN1! = END1) (lf (BEGINl-> second == KFK) (helpNrl = BEGINl-> fιrst;

NodeNrl = Sl [helpNrl]. first. getNodeNumber (); if (nodeNrl == nodeNumberRef) (helpreturn = 1;

} ice (

SLPUSEREF = de inelterator (Sl, nodesNrl); helpreturn = checkPUsesl (Sl, SLPUSEREF, SLPUSE);

)

BEGIN1 ++; } return helpreturn;

t uwggraphC:: checkPUses2 (SliceC S Sl, SliceC:: iterator SLPUSEREF, SliceC:: ιterator SLPUSE) {mt helpreturn = 0; mt NodeNumberRef = 0; int helpNrl = 0; int nodeNrl = 0; NodeNumberRef = SLPUSEREF-> first. getNodeNumber ();

SliceC:: Successor:: iterator BEGIN1 = SLPUSE-> second.begιn (); SliceC:: Successor:: iterator END1 = SLPUΞE-> second.end (); while (BEGIN1 '= END1) (if (BEGINl-> second == KFK) {helpNrl = BEGINl-> first;

NodeNrl = Sl [helpNrl]. first .get node number I); lf (nodeNrl == nodeNumberRef) (helpreturn = 1;} else (

SLPUSE = definelterator (Sl, nodesNrl); helpreturn = checkPUses2 (Sl, SLPUSEREF, SLPUSE); }

BEGIN1 ++; } return helpreturn;

int uwggraphC:: buιldInIfTree (SliceC S Sl, SliceC:: iterator SLIF, SliceC:: iterator SLORIG, int posl) (int pos2 = 0; int posIFOR = 0; int posIFDFOR - 0; int posIFKFOR - 0; int posIFDFORA2 - 0 ; char NodeText [128]; char remark [1000]; int nodeNo = SLIF-> fιrst. getKnotenNummer (); int LineNr = SLIF-> fιrst.getLιneNr (); sprintf (remark, "branching (% d)", LineNr ); strcpy (NodeText, SLIF-> fιrst.getCodeLιne ()); uwgknotenC hknotenl (OR, NodeText, remark); pos2 = insert (hknotenl); posIFOR = sizel) - 1; verbmdeEckenlposl, pos2.0); sprintf (NodeText, "Verzweιgung_KF (% d)", LineNr); uwgknotenC hknotenδ (OR, NodeText); posIFKFOR = inser (hnodeδ); connecting corners (pos2, posIFKFOR, 0); buιld_IFKF_Part (Sl, posIFKFOR, SLIF); switch (SLORIG-> flrst.getKnotenIdent ()) (case THEN: {sprintf (NodeText, "Verzweιgung_DF_Alt.l (% d)", LineNr); uwgknotenC hknoten2 (AND, NodeText); insert (hknotenl, hknoten2, 0); sprint (remark, "Alt.1 (% d)", LineNr); sprintf (NodeText, "Alt .1 (% d)", LineNr); uwgknotenC hknoten3 (CAUSE, NodeText, remark); insert Ihknoten2, hknoten3,0 ); sprintf (NodeText, "Alt. l (% d)", LineNr); uwgknotenC noden <J (OR, NodeText); insert (hknoten2, hknoten4, 0); posIFDFOR «sιze () - 1; buιld_Al_Part (Ξl, posIFDFOR, SLIF, SLORIG);

} break; case ELSE: sprintf (NodeText, "Verzweιgung_DF_Alt .2 (% d)", LineNr); uwgknotenC hknoten2 (AND, NodeText); insert (hknotenl, hknoten2, 0); sprintf (remark, "Alt.2 (% d)", LineNr); sprintf (NodeText, "Alt .2 (* d)", LineNr); uwgknotenC hknoten3 (CAUSE, NodeText, remark); insert (hnode2, hnode3, 0); sprintf (NodeText, "Alt.2 (% d)", LineNr); uwgknotenC hknoten4 (OR, NodeText); insert (hknoten2, hknoten4, 0); posIFDFORA2 = sizeO - 1; build_Al_Part (Sl, posIFDFORA2, SLIF, SLORIG);

} break; default: cout «" Ouch ¹ ' ¹ "« endl; return posIFDFOR;

void uwggraphC:: buιld_Al_Part (SliceC s Sl, int posIFDFOR, SliceC:: iterator SLIF, SliceC:: iterator SLNODE) (int posO = 0; int dummy = 0; int checkNr = 1; int checkPUse = 1; int helpNrl = 0; int helpNr2 = 0; with node number = 0; t node NR = 0; t node number 2 = 0; int LineNrO »0; int LineNrl = 0; char NodeTextO [128]; char remark O [1000];

NodeNo = SLNODE-> first. getNodeNumber ();

LineNrO = SLNODE-> fιrst.getLineNr (); sprintf (NodeTextO, "Op% d", nodeNoO);

// sprintf (remarkO, "Line% d", LineNrO); strcpy (Comment0, SLNODE-> fιrst.getCodeLιne ()); uwgknotenC hknotenO (CAUSE, NodeNo, NodeTextO, remarkO); posO = insert (hknotenO); verb deEcken (posIFDFOR, posO, 0);

SliceC:: Successor:: iterator BEGIN0 = SLNODE-> second.begιn ();

SliceC:: Successor:: iterator END0 = SLNODE-> second.end (); while (BEGINO! = END0) (lf (BEGIN0-> second == DFK) (helpNrl = BEGIN0-> first;

NodeNrl = Sl [helpNrl]. first. getNodeNumber ();

SLNODE = definelterator (Sl, nodesNrl); lf (nodeNrl <nodeNo) (

SliceC:: Successor:: iterator BEGIN1 = SLNODE-> second.begιn (); SliceC:: Successor:: iterator END1 = SLNODE-> second.end (); while (BEGIN1 '= END1) (lf (BEGINl-> second == KFK) (helpNr2 = BEGINl-> first; nodeNo2 =

Sl [helpNr2]. first. getNodeNumber ();

SliceC:: iterator HELPPUSE = defmelterator (Sl, NodeNo2); checkNr = checkUWGNode (nodeNo2); lf (SLIF-> fιrst.getKnotenNummer ()> NodeNo2)

(checkPUse checkPU- sesl (Sl, SLIF, HELPPUSE); else (checkPUse = checkPU- ses2 (Sl, SLIF, HELPPUSE);

} lf (NodeNo2! = SLIF-> first getNodeNumber ()) if (checkPUse == 0) (dummy = 1; HELPPUSE = fmdOutmostPUse (Sl, HELPPUSE); switch (HELPPUSE-

> first. getKFGNodeType ()) (case LC: buildInLoopTree (Sl, posIFDFOR, HELPPUSE, SLNODE); break; case IFC: ret = buιldInIfTree (Sl, HELPPUSE, SLNODE, posIFDFOR); break; default: cout «" Wrong way in AI '"« Endl;

) ice (lf (checkNr == 0) (dummy = 1; HELPPUSE = findOutmost-

PUse (Sl, HELPPUSE); switch (HELPPUSE-

> first. getKFGNodeType ()) (case LC: buildInLoopTree (Sl, posIFDFOR, HELPPUΞE, SLNODE) break; case IFC: ret = buildlnlf-

Tree (Ξl, HELPPUSE, SLNODE, posIFDFOR); break; default: cout «" Wrong

Path! "« Endl;

}

BEGIN1 ++;

} lf (dummy == 0) (

LineNrl = Sl [helpNrl]. first. getLineNrl); sprintf (NodeTextO, "Op% d", nodesNrl);

// sprintf (remarkO, "Line% d", LineNrl); strcpy (Bemer ungO, Sl [helpNrl] .first. etCodeLine ()); uwgknotenC hknotenl (CAUSE, nodesNrl, NodeTextO, remarkO); posl = insert (hknotenl); connect corners (posIFDFOR, posl, 0); buιld_Al_Part (Sl, posIFDFOR, SLIF, SLNODE); }

)

BEGIN0 ++; dummy = 0;

void uwggraphC:: buιld_IFKF_Part (SliceC S Sl, int posKFOR, SliceC:: iterator SLPUSE) (int posl = 0; int ret = 0; int dummy = 0; int checkNr = 1; int checkPUse = 1; int helpNrl = 0; int helpNr2 - 0; int NodeNo = 0; mt NodeNrl = 0; int NodeNo2 = 0; mt LineNrO = 0; int LineNrl = 0; char NodeText [128]; char notellOOO];

NodeNo = SLPUSE-> first. getNodeNumber (); LineNrO = SLPUSE-> ιrst.getLineNr (); sprintf (NodeText, "Op% d", nodeNo);

// sprintf (note, "Line% d", LineNrO); strcpy! remark, SLPUSE-> flrst. getCodeLine! )); uwgknotenC hknotenl (CAUSE, node number, node text, remark); posl = insert (hknotenl); connect corners (posKFOR, pos1,0);

SliceC:: Successor:: ιterator BEGIN0 = SLPUSE-> second.begιn (); SliceC:: Successor:: ιterator END0 = SLPUSE-> second.end (); while (BEGIN0 '= ENDO) {lf (BEGIN0-> second - »DFK) (helpNrl = BEGIN0-> fιrst;

NodeNrl = Sl [helpNrl]. first .getNodeNumber (); SliceC:: ιterator SLNODE = definelterator (Sl, nodesNrl); lf (nodeNrl <nodeNo) (

SliceC:: Successor:: iterator BEGIN1 = SLNODE-> second.begin (); SliceC:: Successor:: ιterator END1 = SLNODE-> second. endl); while (BEGIN1 '= END1) (lf (BEGINl-> second == KFK) (helpNr2 = BEGINl-> first; nodeNo2 = Sl [helpNr2]. first .getKnotenNummer I);

SliceC:: ιterator HELPPUSE = definelterator (Sl, nodeNo2); checkNr = checkUWGNode (nodeNo2); if ⁽ SLPUSE-> fιrst. getKnotenNummer!)> NodenNr2) (checkPUse = checkPU- sesl (Sl, SLPUSE, HELPPUSE); ise (checkPUse = checkPU- ses2 (Sl, SLPUSE, HELPPUSE); lf (nodeNo2 '= SLPUSE-> fιrst. getKknotenNumme ()) (if (checkPUse == 0) (dummy = 1; HELPPUSE = findOutmostPU- se (Sl, HELPPUSE); switch (HELPPUSE-

> first. getKFGNodeType! )) (case LC: buildInLoopTree (Sl, posKFOR, HELPPUSE, SLNODE); break; case IFC: ret = buildlnIfTreelSl,

HELPPUΞE, SLNODE, posKFOR); break; default: cout «" Wrong way in

AI! "« Endl; eise (lf (checkNr == 0) (dummy = 1; HELPPUSE = findOutmost-

PUse (Sl, HELPPUSE); switch (HELPPUSE-

> first. getKFGNodeType! )) (case LC: buildInLoopTree (Sl, posKFOR, HELPPUSE, SLNODE); break; case IFC: ret = buildlnlf- Tree (Sl, HELPPUSE, SLNODE, posKFOR); break; default: cout «" Wrong way '"« endl ;

BEGIN1 ++; l f (dummy == 0) (

LineNrl = Sl [helpNrl]. first. getLmeNr (); sprintf (NodeText, "Op% d", nodesNrl); // sprintf (note, "Line% d", LineNrl); strcpy) remark, Sl [helpNrl]. first. getCodeLine ()); uwgknotenC hknotenl (CAUSE, nodesNrl, NodeText, remark); posl = insert (hknotenl); connect corners (posKFOR, posl, 0); buιld_IFKF_Part (Sl, posKFOR, SLNODE);

BEGIN0 ++; dummy = 0;

void uwggraphC:: buιldInLoopTree (SliceC s Sl, int Posl, SliceC:: iterator SLPUSE, SliceC:: ιterator SLNODE) (mt posil = 0; int pos3 = 0; int posLOOPJCF = 0; int posOR_Dl = 0; t posOR_D2 - 0 ; t posANDJCF = 0; mt SliceNr = 0; int NodeNrD2 = 0; t node number = 0; t LineNr = 0;

NodeNo = SLPUSE-> first. getNodeNumber (); LineNr = SLPUSE-> fιrst.getLιneNr I); char NodeText [128]; char remark [1000]; sprintf (note, "loop (% d)", node number); strcpy (NodeText, SLPUSE-> fιrst. getCodeLine!)); uwgknotenC hknotenl (OR, NodeText, remark); posil = insert (hknotenl); connect corners (Posl, posil, 0); sprintf (NodeText, "Schlei fe_DF_Durchl .1 (% d)", LineNr); uwgknotenC hknoten2 (AND, NodeText); sprintf (NodeText, "Loop_DF_Durchl. + (% d)", LineNr); uwgknotenC hknoten3 (AND, NodeText); pos3 = insert (hknoten3); connect corners! posil, pos3,0); sprintf (NodeText, "Loop_KF (% d)", LineNr); uwgknotenC hknoten4 (OR, NodeText); insert (hknotenl, hknoten2, 0); insert (hknotenl, hknoten4, 0); posLOOPJCF = sizel) - 1; sprintf (note, "Durchl.l (% d)", LineNr); sprintf (NodeText, "Durchl .1 (% d)", LineNr); uwgknotenC hknoten5 (CAUSE, NodeText, remark); sprintf (NodeText, "Durchl .1 (% d)", LineNr); uwgknotenC hknoten6 (OR, NodeText); insert (hknoten2, hknoten5, 0); insert (hknoten2, hknoten6, 0); posOR_Dl = size!) - 1; sprintf (remark, "Durchl. + (* d)", LineNr); sprintf (NodeText, "Durchl. + (% d)", LineNr); uwgknotenC hknoten7 (CAUSE, NodeText, remark); sprintf (NodeText, "Durchl. + (% d)", LineNr); uwgknotenC hknotenδ (OR, NodeText); insert (hknoten3, hknoten "7, 0); posOR_D2 = insert (hknotenβ); connectEcken (pos3, posOR_D2,0); sprintf (NodeText," KF (% d) ", LineNr); uwgknotenC hknoten9 (AND, NodeText); insert (hknoten4, hknoten9, 0); insert (hknoten3, hknoten5, 0); posANDJCF = sizeO - 1; msert (hknoten9, hknoten5,0);

NodeNrD2 = buιldIn_LoopKF_ANDPart (Sl, posANDJCF, SLPUSE); buιldIn_LoopKF_ORPart (Sl, posLOOFJCF, SLPUSE, NodeNrD2);

// buιldIn_D2_Part (Sl, posOR_D2, SLPUSE, SLNODE, NodeNrD2); buιldIn_Dl_Part (Sl, posOR_Dl, SLPUSE, SLNODE, NodeNrD ₂ ); buιldIn_D2_Part (Sl, posOR_D2, SLPUSE, SLNODE, NodeNrD2);

void uwggraphC:: buιldIn_Dl_Part (SliceC S Sl, int posOR_Dl, SliceC:: iterator SLPUSE, Sli _¬ ceC:: ιterator SLNODE, int D2_RefNr) (int posl ■ = 0; int ret = 0; int nodeNrl = 0; int LineNrl = 0;

SliceC:: iterator ITERl = fmd_Dl_Node (Sl, SLPUSE, SLNODE); SliceC:: ιterator HELP = ITERl; swιtch (ITERl-> fιrst. getKFGNodeType!)) (case IFC: HELP = fιnd_Dl_Node (Sl, ITERl, SLNODE); ret = buildlnIfTreelSl, ITERl, HELP, posOR_Dl); break; case LC:

HELP = fιnd_Dl_Node (Ξl, ITERl, SLNODE); buildInLoopTree (Sl, posOR_Dl, ITERl, SLNODE); break; default: addAllDlNodes (Sl, ITERl, posOR_Dl, D2_Ref r); . SliceC:: ιterator uwggraphC:: fιnd_Dl_Node (SliceC S Sl, SliceC:: iterator SLPUSE, SliceC:: iterator SLNODE) (int helpNrl = 0; int helpNr2 = 0; mt dummyl = 0; int dummy∑ = 0; int nodeNoRet = 0; int NodeNoRetl = 0; int PUseNo = SLPUSE-> first getNodeNumber (); int PUseLevel = SLPUSE-> first.getLevel ();

SliceC :: iterator RETURNITER = SLNODE; NodeNoRetl = SLNODE-> first. getNodeNumber (); lf (NodeNoRetl - == (PUseNr + 1)) (

RETURNITER = definelterator (Sl, nodeNoRetl); stupid «1; dummy2 = 1;

}

SliceC:: successor :: iterator BEGIN1 = ΞLNODE-> second.beginl); SliceC:: Successor:: ιterator END1 = SLNODE-> second.end (); while ((BEGIN1! = END1) SS (dummyl! = 1)) (helpNrl = BEGINl-> fιrst; lf ((Sl [helpNrl) .first. getKotenNummer ()> PUseNr) SS (SlfhelpNrl] .first. getLevel () > = PUseLevel)) (lf (Sl [helpNrl]. First. EtLevel ()> PUseLevel) (NodeNoRetl = Sl [helpNrl]. First .getNodeNumber (); lf (NodeNoRetl == (PUseNr + 1)) {

RETURNITER = definelterator (Sl, nodeNoRetl); dummyl = 1; dummy2 = 1; }

SliceC:: Successor:: iterator BEGIN2 = Sl [helpNrl] .second.beginl);

SliceC:: Successor:: ιterator END2 = Sl (helpNrl] .second. End () while ((BEGIN ₂ '= END2) SS (dummy2! = 1)) (lf (BEGIN2-> second == KFK) (helpNr2 = BEGIN2->first; NodeNoRet = Sl [helpNr2]. First. GetNodeNumber (); if (NodeNoRet! = PUseNr) (RETURNITER = definelterator (Sl, NodeNoRet); dummyl = 1; dummy∑ = 1;}}

BEGIN2 ++; }} else (NodeNoRet = Sl [helpNrl]. first .getNodeNumber ();

RETURNITER = definelterator (Sl, nodeNoRet); dummyl = 1; } BEGIN1 ++;

) lf ((RETURNITER == SLNODE) SS (dummyl == 0)) {BEGIN1 = SLNODE-> second.beginl); while (BEGIN1 '= END1) (helpNrl = BEGINl-> fιrst;

NodeNoRet = Sl [helpNrl]. first .getNodeNumber (); SliceC:: iterator SLNODE = definelterator (Sl, nodeNoRet); RETURNITER = fιnd_Dl_Node (Sl, SLPUSE, SLNODE); BEGIN1 ++; )

} return RETURNITER; }

void uwggraphC:: buιldIn_D2_Part (SliceC S Sl, int posOR_D2, SliceC:: iterator SLPUSE, SliceC:: iterator SLNODE, with node numberD2) ( int helpNrl = 0; int helpNr2 = 0; int nodeNrl = 0; t LineNrl = 0; t NodeNoD2Ret - 0; int USEinD2KnotenNr ■ = 0; char note [1000]; char NodeTextl [128];

SliceC:: ιterator D2_NODE = definelteratorlSl, node number D2); NodeNrl = D2_NODE-> first. getKnotenNumber I); LineNrl - D2_N0DE-> fιrst.getLιneNr I); sprintf (NodeTextl, "Op% d", nodesNrl);

// sprintf (note, "Line% d", LineNrl); strcpy (remark, D2_N0DE-> first. getCodeLine!)); uwgknotenC hknotenl (CAUSE, nodesNrl, NodeTextl, remarkl); posl = insert (hknotenl); connectCorner (posOR_D2, posl, 0);

SliceC:: Successor:: ιterator BEGIN1 = D2_NODE-> second.begιn (); SliceC:: Successor:: iterator END1 = D2_NODE-> second.end (); while (BEGIN1 '= END1) (lf (BEGINl-> second == DFK) (helpNrl = BEGINl-> fιrst;

NodeNrl = Sl [helpNrl]. first .getNodeNumber (); LineNrl = Sl [helpNrl]. first .getLineNr (); sprintf (NodeTextl, "Op% d", nodesNrl); // sprintf (note, "Line% d", LineNrl); strcpy (remarkl, Sl (helpNrl]. first. getCodeLine ()); uwgknotenC hknoten2 (CAUSE, nodesNrl, NodeTextl, remarkl); pos2 = insert (hknoten2); connecting corners (posOR_D2, pos2,0);

SliceC:: Successor:: ιterator BEGIN2 = Sl [helpNrl] .second.beginl); SliceC:: Successor:: iterator END2 = Sl [helpNrl] .second. end (); while (BEGIN2! = END2) (helpNr2 = BEGIN2-> first; if ((BEGIN2-> second - = DFK) SS (Sl [helpNr2] .first. getKnotenNummer () '= nodeNoD2)) (// SliceC:: ιterator SLNODE1 = definelterator (Sl, nodesNrl);

// buιldIn_D2_Part (Sl, posOR, SLPUSE, SLNODE1, node number D2);

}

BEGIN2 ++;

} BEGIN1 ++;

}

SliceC:: ιterator USEmD2 = fmd_Dl_Node (Sl, SLPUSE, SLNODE); SliceC:: ιterator HELP = USEιnD2; if (USEιnD2-> fιrst. getLevel!)> SLPUSE-> fιrst. getLevel ()) (USEιnD2KnotNr = USEmD2-> fιrst. getKnotNumber (); nodeNoDD2Ret = fmdD2Node (Sl, USEιnD2); if (nodeNoDD2Ret == USEιnD2KnotNr) (switch (USEιnD2-> first. getKF)) (case. getKFGNode)

HELP = fιnd_Dl_Node (Sl, USEιnD2, SLNODE); // ret = buildlnIfTreelSl, UΞEιnD2, HELP, posOR); ret = buιldD2InIfTree (Ξl, USEιnD2, HELP, posOR_D2); break; case LC:

HELP = f ιnd_Dl_Node (Sl, USEιnD2, SLNODE); buildInLoopTree (Sl, posOR_D2, USEιnD2, SLNODE); break; default: cout «" Oops!! '"« endl; })

}

int uwggraphC:: fιndD2Node (SliceC S Sl, SliceC:: ιterator PUSE) (int dummy = 0; int helpNrl = 0; int helpNr2 = 0; int nodeNoReturn - PUSE-> first. getKnotNumber (); mt PUSEKnotNo = PUSE-> first .get node number I); SliceC:: Successor:: ιterator BEGIN1 = PUSE-> second.begιn (); SliceC:: Successor:: ιterator END1 = PUSE-> second. end (); while ((BEGIN1 '= END1) SS (dummy' = 1) 1 (lf (BEGINl-> second == DFK) {helpNrl = BEGINl->first; SliceC:: Successor:: ιterator BEGIN2 = Sl [helpNrl] .second.begin! ); SliceC:: Successor:: iterator END2 = Sl [helpNrl]. second. end (); while ((BEGIN2! = END2) SS (dummy! = 1)) {if (BEGIN2-> second == KFK) (helpNr2 = BEGIN2->fιrst; lf (Sl [helpNr2) .first. getKnotenNummer () - PUSEKno- tenNr) (

NodeNoReturn = Sl lhelpNr2]. first. getKnotenNumber I); dummy - 1;

}} BEGIN2 ++;

}

)

BEGIN1 ++; ) return nodeNoReturn;

int uwggraphC:: buildIn_LoopKF_ANDPart (SliceC S Sl, int posANDJCF, SliceC:: ιterator SLPUSE) t pos = 0; int helpNrl = 0; int helpNr2 = 0; int RefPUse = 0; int node number = O.mt line number = 0; t dummy = 0; int dummyl = 0; char remark [1000]; char NodeText [128); RefPUse = SLPUSE-> first. getNodeNumber ();

SliceC:: Successor:: ιterator BEGIN «SLPUSE-> second.begιn (); SliceC:: successor :: iterator END = SLPUSE-> second.end (); while ((BEGIN! = END) SS (dummyl! = 1)) (if (BEGIN-> second == DFK) (helpNrl = BEGIN-> first;

ΞliceC:: Successor:: iterator BEGIN2 = Sl [helpNrl] .second. beginl); ΞliceC:: Successor:: ιterator END2 = Sl [helpNrl] .second. end (); while ((BEGIN ₂ ! = END2) SS (dummy! = 1)) (if (BEGIN2-> second «« KFK) (helpNr2 = BEGIN2->first; lf (Sl [helpNr ₂ ] .first. getKnotenNummer () = = RefPUse) (NodeNo = Sl [helpNrl]. Firs .getNodeNumber (); LineNr = Sl [helpNrl]. First .getLineNr (); sprintf (NodeText, "Op% d", NodeNo); // sprintf (remark, " Line% d ", LineNr); strcpylMarkung, Sl [helpNrl]. First. GetCodeLine ()); uwgknotenC hknoten | CAUSE, node number, NodeText, remark); pos = insert (hknoten); connectEcken (posAND_KF, pos, 0 ); dummy = 1; dummyl = 1;

BEGIN2 ++;

}

BEGIN ++; return node number;

void uwggraphC:: buιldIn_LoopKF_ORPart (SliceC S Sl, t po≤LOOPJCF, ΞliceC:: iterator SLl, t nodeNoD2) {int posl = 0; int pos2 = 0; int helpNrl = 0; t helpNr2 = 0; int node number = 0; int nodeNrl = 0; int LineNr = 0; int LineNrl = 0; char NodeText [128]; char remark [1000];

NodeNo = SLl-> first. getKnotenNumber I); LineNr = SLl-> first .getLineNr I); sprintf (NodeText, "Op% d", node number); // sprintf (remark, "Line% d", LineNr); strcpyl remark, SLl-> first. getCodeLine! )); uwgknotenC hknotenl (CAUSE, NodeNo, NodeText, Comment); posl »insert (hknotenl); connect corners (posLOOPJCF, posl, 0);

SliceC:: successor :: iterator BEGIN = SLl-> second.begin (); SliceC:: Successor:: iterator END - SLl-> second.end (); while (BEGIN '= END) (lf (BEGIN-> second == DFK) (helpNrl = BEGIN-> fιrst;

NodeNrl = Sl [helpNrl]. first. getNodeNumber (); lf (nodeNrl '= nodeNoD2) (

LineNrl = Sl [helpNrl]. first. getLineNr I); sprintf (NodeText, "Op% d", nodesNrl);

// sprintf (note, "Line% d", ineNrl); strcpy (remark, SLl-> fιrst. getCodeLine ()); uwgknotenC hknotenl (CAUSE, nodesNrl, NodeText, remark); posl = insert (hknotenl); connect corners (posLOOPJCF, posl, 0); j

SliceC:: iterator NEXTNODE = definelterator (Sl, nodesNrl); SliceC:: Successor:: iterator BEGIN2 = NEXTNODE-> second.begιn (); ΞliceC:: successor:: iterator END2 = NEXTNODE-> second.end (); while (BEGIN2 '= END2) (lf (BEGIN2-> second == DFK) (helpNr2 = BEGIN2-> first; if (NEXTNODE-> first. getKknotenNummer!)' = nodeNoD2) (buιldIn_LoopKF_ORPart (Sl, posLOOPJCF, NEXTNODE, nodeNoD2 );

BEGIN2 ++;

BEGIN ++;

void uwggraphC:: addAllDlNodes (SliceC s Sl, SliceC:: iterator SLNODE, t posGatter, int D2_RefNr) ( int checkNr = 1; int helpNrl = 0; mt helpNr2 = 0; int SlιceNr2 = 0; int node number = 0; int nodeNrl = 0; int nodeNo2 = 0; int LineNrl = 0; int LineNrO = 0; char note [1000]; char NodeTextl [128];

NodeNo = SLNODE-> flrst .getNodeNumber (); LineNrO = SLNODE-> first. getLineNr (); sprintf (NodeTextl, "Op% d", nodeNo); // sprintf (remark, "Line% d", LineNrO); strcpy (remark, SLNODE-> fιrst. etCodeLine ()); uwgknotenC hknotenl (CAUSE, knotNo, NodeTextl, remarkl); posl = insert (hknotenl); connect corners (posGatter, posl, 0);

SliceC:. Successor:: ιterator BEGIN1 = SLNODE-> second. beginl); ΞliceC:: successor:: ιterator END1 = SLNODE-> second.end (); while (BEGIN1 '= END1) (lf (BEGINl-> second == DFK) (helpNrl = BEGINl-> first;

NodeNrl = Ξl [helpNrl]. firs .get node number I); SLNODE = definelterator (Ξl, nodeNrl); lf ((nodeNrl '= D2_RefNr) SS (nodeNrl' = nodeNo)) {ΞliceC:: successor:: iterator BEGIN2 = Ξl [helpNrl]. second.begin (); SliceC:: Successor:: ιterator END2 = Sl (helpNrl] .second. End (); hile (BEGIN2! = END2) (lf (BEGIN2-> second == KFK) {helpNr2 = BEGIN2->fιrst;

SlιceNr2 = Sl [helpNr2]. first .getNodeNumber ();

SliceC:: iterator HELPPUSE = definelteratorlSl,

SlιceNr2); checkNr = checkUWGNode (SlιceNr2); if (checkNr == 0) (ΞliceC:: iterator HELP1 = findOutmostPU- (Sl, HELPPUSE); switch (HELPl-> fιrst. getKFGNodeType!) 1 case LC: buildInLoopTree (Sl, posGatter,

HELPPUSE, SLNODE); break; case IFC: ret = buildlnlf-

Tree l Ξl, HELPPUSE, SLNODE, posGatter); break; default: cout «" Wrong way '"« endl; }

})

BEGIN2 ++; } if (checkNr == 1) (

LineNrl = Sl [helpNrl]. first. getLineNr O; sprintf (NodeTextl, "Op% d", nodesNrl);

// sprintf (note, "Line% d", LineNrl); strcpylMarketl, Sl [helpNrl]. first .getCodeLine! )); uwgknotenC hknoten2 (CAUSE, nodesNrl, NodeTextl, remarkl); posl = insert (hknoten2); connect corners (posGatter, posl, 0); addAllDlNodes (Sl, SLNODE, posGatter, D2 RefNr); }

}}

BEGIN1 ++; , 'mt uwggraphC:: buιldD2InIfTree (ΞliceC S Ξl, ΞliceC:: iterator SLIF, ΞliceC:: iterator SLORIG, int posl) (mt pos2 = 0; int posIFOR = 0; int posIFDFOR = 0; int posIFKFORA = 0; mt posIFDFOR = 0; char NodeText [128]; char remark [1000]; int NodeNo = SLIF-> first. GetNodeNumber (); int LineNr = SLIF-> first .getLineNr (); sprintf (NodeText, "Branching_D + (% d)" _» NodeNo); strcpy (remark, SLIF-> flrst. GetCodeLine ()); uwgknotenC hknotenl (OR, NodeText, remark); pos ₂ = insert (hknotenl); posIFOR = sizeO - 1; verbindenEcken (posl, pos2,0) ; sprintf (NodeText, "Verzweιgung_KF_D + (% d)", LineNr); uwgknotenC hknotenδ (OR, NodeText); posIFKFOR = insert (hknotenδ); verbindeEcken (pos2, posIFKFOR, 0); buιldD2_IFKF_PART (SL, posIF switch (ΞLORIG-> fιrst.getKknotenIdent ()) (case THEN: (sprintf (NodeText, "Verzweιgung_DF_Alt .1_D + (% d)", LineNr); uwgknotenC hknoten2 (AND, NodeTex); insert (hknotenl, hknintf2, 0); (Note ung, "Al .1_D + (% d)", LineNr); sprintf (NodeText, "Alt .1_D + I% d)", LineNr); uwgknotenC hknoten3 (CAUΞE, NodeText, remark); insert (hnode2, hnode3, 0); sprintf (NodeText, "Alt .1_D + (%)", LineNr); uwgknotenC hknoten4 (OR, NodeText); insert (hnode2, hnode, 0); posIFDFOR - sizeO - 1; buildD2_Al_Part (Sl, posIFDFOR, SLIF, SLORIG);

} break; case ELSE: sprintf (NodeText, "Verzweιgung_DF_Alt.2_D + (% d)", LineNr); uwgknotenC hknoten2 (AND, NodeText); insert (hknotenl, hknoten2.0); sprintf (remark, "Alt .2_D + (% d)", ineNrl; sprintf (NodeText, "AIt .2_D + (% d)", LineNr); uwgknotenC hknoten3 (CAUSE, NodeText, remark); insert (hknoten2, hknoten3, 0 ); sprintf (NodeText, "Alt .2_D + (% d)", LineNr); uwgknotenC hknoten ₄ (OR, NodeText); insert (hknoten2, hknoten4, 0); posIFDFORA2 = sizeO - 1; buildD2_Al_Part (Sl, posIFDFORA2, SLIF , SLORIG);

} break; default: cout «" Ouch '!' "« endl; return posIFDFOR;

void uwggraphC:: buιldD2_Al_Part (SliceC S Sl, int posIFDFOR_D2, SliceC:: iterator SLIF, SliceC:: iterator SLNODE) (~ mt pos0_Al = 0 int posl_Al = 0 int helpNrO = 0 int helpNrl = 0 int nodeNrO 0 int NodeNo2 = 0 int LineNrO = 0; int LineNrl = 0; char NodeTextO [128]; char RemarkO [1000]; NodeNoO = SLNODE-> first. GetNodeNumber ();

LineNrO - SLNODE-> first. getLineNr (); sprintf (NodeTextO, "Op% d", nodeNoO); // sprintf (remarkO, "Line% d", LineNrO); strcpy (remark0, ΞLNODE-> first. getCodeLine!)); uwgknotenC hknotenO (CAUΞE, NodeNrO, NodeTextO, remarkO); pos0_Al = insert (hknotenO); verbmdeEcken (posIFDFOR_D2, posO_Al, 0);

SliceC:: Successor:: ιterator BEGIN0 = SLNODE-> second.beginl); SliceC:: Successor:: ιterator END0 = SLNODE-> second.end (); while (BEGIN0! = END0) (helpNrO = BEGIN0-> first;

KnotNrl = Sl [helpNrO]. first. getNodeNumber (); if (nodeNrl> nodeNo) (

LineNrl = Sl [helpNrO]. first .getLineNr (); sprintf (NodeTextO, "Op% d", nodesNrl);

// sprintf (remarkO, "Line% d", LineNrl); strcpy (CommentO, Sl [helpNr0] .first .getCodeLine ()); uwgknotenC hknotenl (CAUSE, nodesNrl, NodeTextO, remarkO); posl_Al = insert (hknotenl); verbmdeEcken (posIFDFOR_D2, posl_Al, 0);

SliceC:: Successor:: ιterator BEGIN1 = Sl [helpNrO] .second.beginl); ΞliceC:: Successor:: ιterator END1 = Ξl [helpNrO] .second. endl); while (BEGIN1! = END1) (if (BEGINl-> second == DFK) (helpNrl = BEGINl-> first;

NodeNo2 = Sl [helpNrl). first .getNodeNumber (); if (nodeNrl '= nodeNo2) (

ΞliceC:: iterator SLNODE = definelterattoorrl (SSll, .KKnnootteennNNrr22)): buιldD2_Al_Part (Ξl, posIFDFOR_D2, SLIF,

SLNODE); BEGIN1 ++;

} BEGIN0 ++;

void uwggraphC:: buιldD2_IFKF_Part (ΞliceC S Sl, int posKFOR_D2, SliceC:: iterator ΞLPUSE) (int posO_D2 = 0; int posl_D2 = 0; int ret - 0; mt dummy = 0; int helpNrO = 0; int helpNrl = int helpNr2 - = int checkPUse = 0 mt checkNode = 0 int NodeNrO = 0 int NodeNrl = 0 int NodeNr2 = 0 int NodeNr3 = 0 int LineNrO = 0; int LineNrl = 0; char NodeTextO [128]; char CommentO (lOOO);

NodeNo = ΞLPUSE-> fιrst .getNodeNumber (); LineNrO = SLPUSE-> first. getLineNr (); sprintf (NodeTextO, "Op% d", nodeNoO); // sprintf (remarkO, "Line% d", LineNrO); strcpy (remarkO, SLPUSE-> fιrst. getCodeLine))); uwgknotenC hknotenO (CAUSE, NodeNo, NodeTextO, remarkO); posO_D2 = insert (hknotenO); connectCorner (posKFOR_D2, posO_D2, 0);

SliceC:: Successor:: ιterator BEGIN0 = SLPUΞE-> second.begιn (); ΞliceC:: successor:: iterator END0 = SLPUSE-> second.end (); while (BEGIN0 '= END0) (helpNrO = BEGIN0-> first;

NodeNrl = Sl (helpNrO]. First .getNodeNumber I); SliceC:: ιterator SLNODE = definelterator (Sl, nodesNrl); lf (NodeNrl> NodeNo) (

LineNrl = Ξl [helpNrO]. first. getLineNr (); sprintf (NodeTextO, "Op% d", nodesNrl);

// sprintf (remarkO, "Line% d", LineNrl); strcpy (NoteO, Ihl IhelpNrO]. first. getCodeLine ()); uwgknotenC hknotenl (CAUΞE, nodesNrl, NodeTextO, remarkO); posl_D2 = insert (hknotenl); connectCorner (posKFOR_D2, posl_D2, 0);

ΞliceC:: successor:: ιterator BEGIN1 = SLNODE-> second.begm ();

SliceC:: Successor:: ιterator END1 ΞLNODE-> second. end (); while (BEGIN1! = END1) {lf (BEGINl-> second «= DFK) (helpNrl = BEGINl-> fιrst;

Nodal number = Sl [helpNrl]. first. getNodeNumber O; lf (nodeNo2 '= nodeNrl) (

SliceC:: iterator SLNODE = defmelterator (Sl, nodeNo2);

ΞliceC:: Successor:: ιterator BEGIN2 =

Sl [helpNrl]. second.beginl);

ΞliceC:: successor:: ιterator END2 =

Sl [helpNrl] .second. end (); while (BEGIN2 '= END2) (lf (BEGIN2-> second == KFK) (helpNr2 = BEGIN2-> first; nodeNo3 =

Sl [helpNr2]. first .getNodeNumber ();

SliceC:: iterator HELPPUSE = definelterator (Sl, node number ₃ ); if (SLPUSE-> first. getKnotNum ()> NodeNo3) checkPUse = checkPU- sesl (Ξl, ΞLPUSE, HELPPUSE); else {checkPUse = checkPUSes2 (Sl, ΞLPUSE, HELPPUSE); checkNode = checkU-

WGNode I node number ₂ ); lf (checkNode == 0) {if (checkPUse == 0) (

// HELPPUSE = find-OutmostPUse (Ξl, HELPPUSE); switch (HELPPUSE-> first. getKFGNodeType ()) (case LC: buildInLoopTree (Sl, posKFOR_D ₂ , HELPPUΞE, ΞLNODE); dummy - 1; break; case IFC: ret - buildlnIfTreelSl, HELPPUSE, SLNODE, posKFOR D2); dummy = 1; break; default:

"Wrong way in AI!" «Endl; ice (

LineNrl =

Ξl [helpNr2]. first. getLineNr (); sprintf (NodeTextO, "Op% d", NodeNo2);

// sprintf (remarkO, "Line% d", LineNrl); strcpy! remarkO, l [helpNr2]. first .getCodeLine ()); uwgknotenC hknotenl (CAUSE, NodeNo2, NodeTextO, remarkO); posl D2 = insert (hknotenl); connect corners (posKFOR D2, posl D2,0);

BEGIN2 ++;

) BEGIN1 ++;

BEGIN0 ++;

SliceC:: iterator uwggraphC:: findOutmostPUse (SliceC s Sl, ΞliceC:: iterator ΞLPUΞE) (int dummy = 0; int helpNrl = 0; mt checkNr = 0; int nodeNrl = 0; SliceC :: iterator RETURN = SLPUSE;

SliceC:: Successor:: ιterator BEGIN1 = SLPUΞE-> second.beginl); ΞliceC:: Successor:: ιterator END1 = SLPUSE-> second.end (); while ÜBEGIN1! = END1) SS (dummy '= 1)) (lf (BEGINl-> second == KFK) (helpNrl = BEGINl-> first;

NodeNrl = Ξl [helpNrl]. first .getNodeNumber (); checkNr = checkUWGNode (nodesNrl); lf (checkNr == 0) (

ΞLPUSE = definelterator (Ξl, nodeNrl); RETURN = findOutmostPUse (Ξl, ΞLPUΞE); dummy = 1; else

RETURN = ΞLPUΞE; dummy = 1;

BEGINNING return RETURN;

int uwggraphC:: checkUWGNode (int SliceNr) (int dummy = 0; uwggraphC:: iterator ITER = beginl); while (ITER '= endO) (if (( ^» ITER) .first. getCauseNrl) == SliceNr) (dummy = 1;

) ITER ++;

} lf (dummy ■ == 1) return 1; else return 0; )

ΞliceC:: ιterator uwggraphC:: definelterator (ΞliceC S Ξl, mt SliceNr) (int dummy = 0;

SliceC:: iterator ITER = Sl.beginO; SliceC:: ιterator HELP = Sl.beginO; while ((ITER '= Sl.endO) SS (dummy! = 1)) (lf (( ^« ITER) .first.getKnotenNummer () == SliceNr) (HELP = ITER; dummy = 1;} ITER ++;

} return HELP; }

void S Ξl) ( ostream_ιterator <KFGLιstNodeC> POSITI target, "node \ n"); ostream_ιterator <KFGLιstNodeC> POSIT2 (Zιel, "successor:"); ostream_ιterator <GraphKanteC> KANTEIT (target, "\ n"); Target «" SLICE: "« endl «endl; for (int l = 0; l <Sl.sizeO; ++ ι) (target «Sl [ι]. first« "<";

SliceC:: Successor:: ιterator IT = Sl [l] .second. beginl); SliceC:: Successor:: ιterator ITEND = Sl [l] .second. end (); while (IT! = ITEND) (

Target «Ξl [( ^« IT) .first] .first «'' // corner« endl «" edge: "« ( ^« IT). second «''; // edge value

++ IT;

Target «"> \ n ";

"Include" uwgkante. H "D ffinclude <ιostream> D

D ostreamS Operator << (ostreamS os, const uwgkanteCS Node) | D os «Node.Number <<endl; return os; ffinclude "uwgknoten.h"

D ftmclude <iostream>

D

D ostreamS Operator «(ostreamS os, eonst uwgknotenCS Node) (

// os «node. Gatterldent «""« Node. CauseNr «""« Node. gate text «endl // return os; lf (Node.getNodeldentl) == EFFECT) (os «" %% EFFECT: \ "" «Node .gate remark« ^» \ ^» _: \ ^»» «Node. gatetext« "\", "« Node.Gatterldent «", , 10; "« endl; return os;) else lf (Node.getNodeldentl) == OR) (os «" %% OR: l: \ "" «Node. Gattertext <<" \ ": \" keme \ " , "« Node. Gatterldent «",, 10; "« endl; return os;} else lf (Node.getNodeldentl) == AND) (os «" %% AND: \ "" «Node. Gattertext« "\" : \ "none \", "« Node. Gatterldent «",, 10; "« endl; return os;} else lf (Node.getNodeldentl) == NOT) (os «" %% NOT: \ "" «Node . gattertext «" \ ": \" keιne \ "," «Node. Gatterldent« ",, 10;"«endl; return os;}

/ «Else if (Node.getNodeldentl) == CAUΞE) (os« "%% CAUSE: \""« Node. Gattertext «" \ ": \" keme \ "," «Node. Gatterldent« ",, 10; "« Endl; return os;} ^« / else lf (Node.getNodeldentl) == CAUSE) {os« "%% CAUSE: \""« Node. Gate remark «" \ ^» _: \ ^{» »} « Node. gattertext «" \ "," «Node. Gatterldent« ",, 10; "« Endl; return os;} ice (os «Node.Gatterldent« "" «Node. CauseNr« "" «Node. Attertext« endl; return os;}

} int uwgknotenC:: DummyNr = 1;

The following publications are cited in this document:

[1] N. Leveson, Safety Verification of ADA Programs using Software fault trees, IEEE Software, pages 48 to 59, July 1991

[2] Weiser M., Program Slicing, in: IEEE Transaction on Software Engineering, Vol. 10, No. 4, July 1984, pp. 352-357

[3] Liggesmeyer P., module test and module verification - state of the art, Mannheim, Vienna, Zurich: BI Wissenschaftsverlag 1990

[4] DIN 25424-1: fault tree analysis; Methods and symbols, September 1981

[5] DIN 25424-2: fault tree analysis; Manual calculation method for evaluating a fault tree, Berlin, Beuth Verlag GmbH, April 1990

Claims

claims

1. Method for determining an overall error description of at least part of a computer program by a computer,

In which at least the part of the computer program is stored,

In which a control flow description and a data flow description are determined for the part of the computer program,

In which program elements are selected from the part of the computer program,

In which an element error description is determined for each selected program element using a stored error description, which is assigned to a reference element, with which possible errors of the respective program element are described,

In which possible errors of the respective reference element are described with an error description of a reference element, and

• in which the overall error description is determined from the element error descriptions taking into account the control flow description and the data flow description.

2. The method of claim 1, wherein the control flow description is in the form of a control flow graph.

3. The method of claim 1 or 2, wherein the data flow description is in the form of a data flow graph.

4. The method according to any one of the preceding claims, • in which the error description is in the form of a stored error tree, • in which the element error description is determined as an element error tree, and

• in which the overall error description is determined as an overall error tree.

5. The method according to any one of the preceding claims, used for error analysis of the part of the computer program.

6. The method as claimed in one of the preceding claims, in which the overall error description is determined as an overall error tree,

• in which the overall fault tree is changed with regard to specifiable framework conditions.

7. The method according to claim 6, wherein the change is made by adding a supplementary fault tree.

8. Arrangement for determining an overall error description of at least part of a computer program, by a computer with a processor, which is set up in such a way that the following steps can be carried out:

At least the part of the computer program is stored, a control flow description and a data flow description are determined for the part of the computer program,

Program elements are selected from the part of the computer program,

• For each selected program element, using a stored error description, each one

Is assigned a reference element, an element error description is determined with which possible errors of the respective program element are described,

• An error description of a reference element describes possible errors of the respective reference element, and • The overall error description is determined from the element error descriptions taking into account the control flow description and the data flow description.

9. Arrangement according to claim 8, wherein the processor is set up such that the control flow description is in the form of a control flow graph.

10. The arrangement of claim 8 or 9, wherein the processor is set up such that the data flow description is in the form of a data flow graph.

11. Arrangement according to one of claims 8 to 10, wherein the processor is set up such that

The error description is in the form of a stored error tree,

• the element error description is determined as an element error tree, and • the overall error description is determined as an overall error tree.

12. Arrangement according to one of claims 8 to 11, used for error analysis of the part of the computer program.

13. Arrangement according to one of claims 8 to 12, wherein the processor is set up such that

• the overall error description is determined as an overall error tree, • the overall error tree is changed with regard to predefinable framework conditions.

14. Arrangement according to claim 13, wherein the processor is set up in such a way that the change is made by adding a supplementary fault tree.

15. A computer program product comprising a computer-readable storage medium on which a program is stored which, after it has been loaded into a memory of the computer, enables a computer to carry out the following steps for determining an overall error description of at least part of a computer program:

At least the part of the computer program is stored,

A control flow description and a data flow description are determined for the part of the computer program, program elements are selected from the part of the computer program,

For each selected program element, an element error description is determined using a stored error description, which is assigned to a reference element, with which possible errors of the respective program element are described.

16. Computer-readable storage medium, on which a program is stored, which enables a computer, after it has been loaded into a memory of the computer, to carry out the following steps for determining an overall error description of at least part of a computer program:

Program elements are selected from the part of the computer program,

Reference element is assigned, an element error Spelling is determined with which possible errors of the respective program element are described, possible errors of the respective reference element are described with an error description of a reference element, and the overall error description is determined from the element error descriptions taking into account the control flow description and the data flow description.