Second Iteration: Detection of Classes and Methods

Definition of Examples

We make three passes. First, we work with anAbstract Class, then with a concreteClassand after that we look at an interface that we map to anAbstract Class. In the end, we put it all together.

First Pass: Abstract Class

A problem is the definition of an abstract Method because it is quite different than that of a concrete

Method. In this pass we take an abstractClassand specify an example of an abstractMethodin this file: javax/xml/soap/SOAPConnection.java

That example gives us the following grammar:

Class ::= "abstract" "class" <IDENTIFIER> ’name’ not_known*

"{" ( Class_not_known | Method )* "}" ; Method ::= "abstract" <IDENTIFIER> ("[" "]")? <IDENTIFIER> ’name’

"(" not_known* ")" not_known* ";" ; Class_not_known ::= common_not_known | "(" Class_not_known* ")" | ";" ;

Second Pass: Concrete Class

We do the same as for theAbstract Classbefore for a concreteClass. We choose the following file: java/jms/TopicRequestor.java

In this file we make an example for theClassitself and two of itsMethods. One of them is a constructor. We get the following grammar from these examples:

Class ::= "class" <IDENTIFIER> ’name’ not_known*

"{" ( Class_not_known | Method )* "}" ; Method ::= "public" <IDENTIFIER> ("[" "]")? <IDENTIFIER> ’name’ "("

not_known* ")" not_known* "{" Method_not_known* "}" | "public" <IDENTIFIER> ’name’ "(" not_known* ")"

not_known* "{" Method_not_known* "}" ; Class_not_known ::= common_not_known | "(" Class_not_known* ")" ;

As we can see in the definitions of aMethodwe specified “public” as a keyword. So, we run into prob- lems because we do not detectAttributesuntil now. If there is anAttributewith the visibility “public” parsing fails. With this grammar we cannot detect any Method with the visibility “private” or “pro- tected”. If we give an example of a private Method we can hardly parse any file because our parser breaks whenever it finds a privateAttribute.

Third Pass: Interface

We take the same interface as in the first iteration and specify one (abstract)Methodin the already defined (abstract)Class. This leads to the following grammar:

Class ::= "interface" <IDENTIFIER> ’name’ not_known*

"{" ( Class_not_known | Method )* "}" ; Method ::= <IDENTIFIER> ’name’ "(" not_known* ")" not_known* ";" ;

Class_not_known ::= common_not_known | ";" ;

As we see in this grammar we ignore the semicolon in the context of aClass. Otherwise we cannot parse any file that contains an Attributedefinition. Such a definition contains a semicolon, too. Our parser complains about that token if we do not ignore it. Nevertheless we detectMethodsbased on the brackets together with a semicolon.

Results

First Pass: Abstract Class

When we parse all files with the parser generated based on the grammar for this pass we get the results shown in Table 4.4. We recognize only abstract Methodswith this parser. We cannot detect concrete

Methodsthat are defined in those abstractClasses.

Number of Model Classes 12

Number of Abstract Classes 12

Total Number Of Methods 64

Total Number of Attributes 0

Table 4.4: System overview in MOOSE after import of abstract classes and methods (Java - second iteration).

Second Pass: Concrete Class

In Table 4.5 we see the results from this run.

Number of Model Classes 83

Number of Abstract Classes 0

Total Number Of Methods 295

Total Number of Attributes 0

4.1. JBOSS J2EE PACKAGE 29

Third Pass: Interface

With the parser based on the grammar for the third pass we detect all of the 221 interfaces defined in the jboss-j2ee package. In Table 4.6 we see the system overview after the import of that model in MOOSE.

Number of Model Classes 221

Number of Abstract Classes 221

Total Number Of Methods 1289

Total Number of Attributes 0

Table 4.6: System overview in MOOSE after import of interfaces (Java - second iteration). All Three Passes Together

We cannot merge the grammars of the three passes together because of two things:

• The grammar becomes ambiguous. That means we cannot produce a useful parser anymore. We discuss this problem in Section 5.2.1.

• We could detect wrong elements with the merged grammar. Section 5.2.3 contains an explication of that problem.

Nevertheless we can use all of the three parsers in parallel. The result of that run is shown in Table 4.7.

Number of Model Classes 316

Number of Abstract Classes 233

Total Number Of Methods 1648

Total Number of Attributes 0

Table 4.7: System overview in MOOSE after import (Java - second iteration).

Problems

There are still the same two files as in the first iteration that we cannot parse. So, we cannot detect anything in these files. There are the following definitions ofMethods:

• javax/security/jacc/EJBMethodPermission.java: This Class has a total of ten

Methods. Three of them are constructors.

• javax/security/jacc/URLPattern.java: Here are fourMethodscontaining one con- structor.

There are different kinds of problems in the other files we cannot parse:

• There are definitions ofAttributesthat contain keywords that we use for specifyingMethods. • There areLanguageConstructsin contexts where we do not expect them. For example oneClass

contains the following source code:

static {

ALL_HTTP_METHODS.add("GET"); ...

There is no example that can be matched to that construct. So, our parser does not expect that there can be curly brackets and fails to parse that file. We discuss that problem in Section 5.2.4.

• There are too many different definitions ofMethodsused in one singleClass. This could be solved by providing more examples.

Comparison with a Precise Model

Table 4.8 shows the comparison between a precise model and our model. As we can see our model includes all of the 233Abstract Classes. This is the combination of the 221 interfaces and the 12Abstract Classes. We can parse 83 of the remaining 133Classestogether with theirMethods. Altogether, we can say that our model at the end of this iteration contains a little more than85 percentof all elements we wanted to detect.

Precise Model Our Model

Number of Model Classes 366 316

Number of Abstract Classes 233 233

Total Number Of Methods 1887 1648

Table 4.8: Comparison between a precise model and our model (Java - second iteration).