Cyclomatic Complexity Using Regex

Question

/ Cyclomatic Complexity Program               /
/          Program does not ignore comments in pattern /
/ Program looks for 1 pattern keywords then moves down a line for next search/
/ java.sun.com/j2se/1.4.2/docs/api/java/util/regex/Pattern.html     /                                   /
/ Using Java Regular Expression Class               /
import java.util.regex.Matcher;
import java.util.regex.Pattern;     
import java.io.*;
class Cyclomatic
          // uses the java i/o.*
          static BufferedReader keyboard = new BufferedReader(new InputStreamReader(System.in));
          protected String txtFileName;
          protected int count = + 1; // start count at one then no need to add 1 to count!
          private static BufferedReader reader; // Uses the java.io.*;
          public void Cyclomatic()
          try {
                    // open the file
                    System.out.println("------------------------------" );
                    System.out.println("CYCLOMATIC COMPLEXITY PROGRAM " );
                    System.out.println("------------------------------\n\n" );
                    System.out.println("Enter file name to be read: " );
                    // Create object to read textfile from keyboard
                    txtFileName = new String(keyboard.readLine());
                    System.out.println("\n \n");
                    // the buffered reader object
                    reader = new BufferedReader(new FileReader(txtFileName));
                    // Create a pattern object and split the key words using pipes |||
                    Pattern pattern = Pattern.compile("if|for|while|case|switch",Pattern.MULTILINE);
                    Matcher m = pattern.matcher(txtFileName);
                    boolean b = m.matches(); // return true if match found !
                    String line = null;
                    while((line = reader.readLine()) !=null)
                         m.reset(line);
                         if(m.find())
                              count = count +1;
                              System.out.println("KeyWord " + " found " + " start of line: " + m.start() + " ends at line: " m.end() " Keyword count = "+ count);
                    reader.close(); // close buffered reader!
                    if(count >10)
                         System.out.println("\n \nThis program according to McCabe has a COMPLEXITY OF: " + count +" \n");
                    else
                         System.out.println("\n \n This program is NOT COMPLEX \n \n");
               catch(IOException e)
                    System.out.println("Error : " + e.getMessage());
     // Run the thing!
     public static void main(String[]args)
          // Create object Complex
          Cyclomatic Complex = new Cyclomatic();
          Complex.Cyclomatic();
Does anyone have ideas as how to improve this program so that it can
ignore keywords inside comments, it finds the first keyword on a line
then jumps down to the next line to search. I know how to implement
this program using the Stream Tockenizer Class using the slashStar
comments, just interested in this alternative that I thought of. It works fine
when givin the following test file. Just want to iorn the few problems out.
Test File:
// SAVE AS A TEXT FILE AND OPEN WITH PROGRAM //
// Cyclomatic Complxity for this file is 17 //
1.     if
2. if
3.     while
4.     for
5.     if
6.     case
7.     case
8.     if
9.     switch
10.     for
11.     if
12.     while
13.     if
14.     if
no
     dont
     count
     this
15.     if
16.     for
Gives Correct CC for this layout.

Answer 1

Please use [code] tags when posting source code.
End-of-line comments are easy to handle, but the multiline varieties complicate the task quite a bit. They can span multiple lines, but they don't have to, and keywords can occur after the end of a multiline comment. Since you're reading the file line-by-line, you need to use a flag to handle comments that actually span multiple lines. For the rest, you've got capturing groups and the find(int) method:      // Pattern for keywords and the start of comments
      Pattern p1 = Pattern.compile("(/\\*)|(//)|(if|for|while|case|switch)");
      Matcher m1 = p1.matcher("");
      // Pattern for the end of multiline comments
      Pattern p2 = Pattern.compile("\\*/");
      Matcher m2 = p2.matcher("");
      boolean inComment = false;
      int lineNum = 0;
      String line = null;
      while ((line = reader.readLine()) != null)
        lineNum++;
        int startAt = 0;
        if (inComment)
          // In multiline comment; see if it ends in this line
          if (m2.reset(line).find())
            inComment = false;
            startAt = m2.end();
          else
            continue;
        m1.reset(line);
        while (m1.find(startAt))
          if (m1.start(1) != -1)
            // Start of multiline comment
            if (m2.reset(line).find(m1.end()))
              // If it ends in this line, we'll keep looking for keywords
              startAt = m2.end();
            else
              // ...otherwise, just set the flag
              inComment = true;
              break;
          else if (m1.start(2) != -1)
            // End-of-line comment
            break;
          else
            // It's a keyword
            count++;
            // If you aren't using Java 5, go back to the old way
            System.out.printf("Keyword found in line %2d at position %2d; Keyword count = %2d\n",
                              lineNum, m1.start(), count);
            // We only care about the first one
            break;
      }Here's the test data I used:1. if
2. if
3. while
4. don't count this // switch
5. for
6. if
7. don't count this /* case
8. for */ ...or this
9. case
10. /* yes count this */ case
11. if
12. switch
13. for
14. if
15. while
16. if
17. if
18. no
19. dont
20. count
21. this
22. if
23. for