0

I'm trying to use a regular expression to parse a file by extracting certain pieces of text. The regular expressions I need to use are not supported by the standard java.util.regex packages (since I need to match nested constructs, such as nested {} brackets and other similar things), so I decided to try JRegex, which claims to fully handle Perl 5.6 regex syntax. However, I ran into a problem when trying to use this package with a recursive regex to match the nested {} brackets:

Pattern p = new Pattern("(\\{(?:(?1)*|[^{}]*)+\\}|\\w+)");  // jregex.Pattern

Exception in thread "main" jregex.PatternSyntaxException: wrong char after "(?": 1

The analogous regex /(\{(?:(?1)*|[^{}]+)+\}|\w+)/sg works as expected in Perl, however. So, my next idea was to find a way to parse the file in Perl and then pass the results to Java (preferably in the form of a string array or something similar), and my question is: what is the best way to do that in this case? Or, is there another simpler alternative that I am overlooking?

arshajii
  • 127,459
  • 24
  • 238
  • 287
  • 1
    It claims to support full feature of Perl regex, but I don't see recursive regex in its documentation. – nhahtdh Mar 09 '13 at 13:03
  • 1
    Perl 5.6 didn't support recursive regexes. You could achieve the same effect with its embedded-code feature, but actual recursive regexes (using `(?R)` , `(?1)`, etc.) didn't arrive until Perl 5.10. JRegex does not support recursive patterns. – Alan Moore Mar 09 '13 at 15:47

3 Answers3

3

JRegex does not seem to support recursive matching, so I suggest you just use java.util.regex and set a limit upon the number of levels of nesting.

For example, to allow up to fifty levels of nesting, with an 'unlimited' number of bracket pairs on each level (except the deepest), you could use

// Set the maximum number of nested levels required.
int max = 50;
String regex = "(?R)";

while (--max > 0) {
    regex = regex.replace("(?R)", "(?>\\{(?:[^{}]*+|(?R))+\\})");
}

// Ensure no (?R) in the final and deepest replacement.
regex = regex.replace("(?R)", "\\{[^{}]*+\\}") + "|\\w+";

String str = " {{}{}} {abc} {{de}{fg}} hij {1{2{3{4{5{6{7{8{9{10{11{12{13{14{15{16{17{18{19{20{21{22{23{24{25{26{27{28{29{30{31{32{33{34{35{36{37{38{39{40{41{42{43{44{45{46{47{48{49{50}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}} {end}";
Matcher m = Pattern.compile(regex).matcher(str);

while (m.find()) {
    System.out.println(m.group());
}

/*
 {{}{}}
 {abc}
 {{de}{fg}}
 hij
 {1{2{3{4{5{6{7{8{9{10{11{12{13{14{15{16{17{18{19{20{21{22{23{24{25{26{27{28{29{30{31{32{33{34{35{36{37{38{39{40{41{42{43{44{45{46{47{48{49{50}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}
 {end}
*/

The above builds a regular expression by taking one that could be used if recursive matching was supported (?>\\{(?:[^{}]*+|(?R))+\\}) and repeatedly substituting the (?R) for the whole pattern.

Because there are many nested quantifiers in the expression that is created, atomic grouping (?>) and the possessive quantifier + are used to limit backtracking and ensure that the regex fails fast if it cannot find a match. Although the regex may be long, it will be efficient.

If you don't want or are unable to set a limit on the nesting, or if the idea of a lengthy regex is worrying, you could parse the nested brackets by simply iterating over the file text and tracking the number of opening and closing brackets, for example

List<String> list = new ArrayList<String>();
int strLen = str.length();

for (int i = 0; i < strLen; i++) {
    char c = str.charAt(i);

    if (c == '{') {
        int b = 1;
        StringBuilder sb = new StringBuilder("{");

        while (b > 0 && i < strLen - 1) {
            sb.append( c = str.charAt(++i) );

            if (c == '}') b--;
            else if (c == '{') b++;
        }
        list.add(sb.toString());
    }
}

for (String s : list) { System.out.println(s); }

That seems like a lot less trouble than interacting with Perl, but see answers such as How should I call a Perl Script in Java? if that is what you want to do.

Community
  • 1
  • 1
MikeM
  • 13,156
  • 2
  • 34
  • 47
1

The best way is to tokenize the input and send it through a token-stream to your parser then parse it top-down/bottm-up depending on your needs. Regex is not always helpful in parsing nested structures.

The JLex utility is based upon the Lex lexical analyzer generator model. JLex takes a specification file similar to that accepted by Lex, then creates a Java source file for the corresponding lexical analyzer.

Have a look on JLex as it may help you generating lexical analyzer for your case out of very simple code.

dlock
  • 9,447
  • 9
  • 47
  • 67
  • Again, that is not true for recursive "regex". Possibility wise, it can parse nested structure well, if the language supports the feature. Whether it is recommended or not, it is debatable. – nhahtdh Mar 09 '13 at 13:08
  • I can see he is trying to spot a string that belongs to a language that is __NOT__ regular but context-free which takes us to the fact that it needs a grammar to generate it and push down automata to recognize it. It can be done using regular expressions, but it will be very cumbersome. Moreover, I would like to see someone writing a compiler using only regex one day , that may prove your point. – dlock Mar 09 '13 at 13:12
  • This is a case simple enough to work with regex. Not talking about compiling, only checks whether the input is a valid program, the specs are usually complex, with extra constraints in addition to the BNF grammar that make regex, if possible at all, an unmaintainable solution. (I only talk about possibility, not whether regex should be used or not). – nhahtdh Mar 09 '13 at 13:23
  • It's indeed possible. But the OP asked about the best way to do it, that's why my answer regarded the better solution. – dlock Mar 09 '13 at 14:12
0

Regex can't really handle nested delimiters. I've approached this in the past by using a regex to find the delimiters and then using a simple Finite State Machine to parse the resulting array.

Peter Wooster
  • 6,009
  • 2
  • 27
  • 39
  • 1
    Recursive "regex" can handle nested delimiters, so it can do bracket matching problem, which theoretical regex can't do. – nhahtdh Mar 09 '13 at 13:05
  • Yes, this is why I had to resort to the specialized JRegex package (although it didn't work in this case). – arshajii Mar 09 '13 at 13:06
  • The regex and FSM solution is quite easy to implement. The other simple choice is to use Lex. It does mean learning yet another language. You might want to learn YACC while your at it if you go that route. Very handy for building a compiler in a hurry. – Peter Wooster Mar 09 '13 at 13:19