Java RegEx loop referencing pattern

Question

I want to learn how to use regular expressions in Java and found the following tasks: Write a class to check whetever a given input string is a valid arithmetic term based on these criteria in BNF-form:

term = [Vz]summand|[Vz]summand addOp term
summand = factor | factor mulOp summand
factor = number | '('term')'
number = digit | digit number
digit = '0'|'1'|...|'9'
vz = '+'|'-'
addOp = '+'|'-'
mulOp = '*'|'/'

Using these rules, I wrote some patterns, resembling the different types:

static Pattern vz = Pattern.compile("[+-]");
static Pattern addOp = Pattern.compile("[+-]");
static Pattern multOp = Pattern.compile("[*/]");
static Pattern digit= Pattern.compile("[0-9]");
static Pattern number = Pattern.compile(digit.pattern()+"+");
static Pattern factor = Pattern.compile(number.pattern()+"|("+term.pattern()+")");
static Pattern summand = Pattern.compile(factor.pattern()+"|"+factor.pattern()+ multOp.pattern()+"\n");
static Pattern term = Pattern.compile(vz.pattern()+"?"+summand.pattern()+"|"
        +vz.pattern()+"?"+summand.pattern()+addOp.pattern()+"\n");

And you already see my problem: I reference term in the definiton of factor without having it defined first. Unfortunately I can not switch it around in any way. So my question is:

Is there a possibility to reference a pattern in such a way? Or any other to reference a pattern and defining it later on?

This is a nearly impossible task. Your grammar defines a language that can have balanced parentheses to any depth. This cannot be handled by regex. (Put another way, your grammar is context-free but not regular.) Get rid of the production `factor = '('term')' and you might have a chance. — Ted Hopp
– Ted Hopp, Commented Dec 9, 2012 at 22:03

Martin Ender · Accepted Answer · 2012-12-09 22:39:40Z

The problem is, BNF defines a context-free grammar (which describes languages more complex than those described by regular expressions). You will have to come up with a different approach than just using the BNF rules as regex patterns straight away.

In particular, correct nesting of parentheses is not regular. Some regex engines support (non-regular) features that allow for matching of these, but the regexes often become very long and unmaintainable. And I'm not sure right now if Java has any of these features (PCRE and .NET do, for instance).

If you want to solve the task at hand, you will have to write a parse manually. If you want to learn regular expressions, you will have to either do it in another language or look for a different task. However, here is a great source to improve your regex skills.

For the fun of it (and to show you why regular expressions are not the right tool for this, even if the engine supports the necessary features), here is the regular expression that corresponds to the above BNF (except for the Vz rule, for some odd reason I could not get it to work):

^(((\d+|[(](?1)[)])|(?3)[*\/](?2))|(?2)[+-](?1))$

The (?n) recursively try to match the nth subpattern (which are counted by opening parentheses from left to right).

It does not work in PHP, but I believe their PCRE implementation has some backtracking issues when using recursion. An online PCRE tester seemed to treat some example input correctly. Here it is in free-spacing mode (x) with some annotations:

^
(                # term (?1)
  (              # summand (?2)
    (            # factor (?3)
      \d+        # number
    |
      [(](?1)[)] # (term)
    )            # end of factor
  |
    (?3)[*/](?2) # factor mulOp summand
  )              # end of summand
|
  (?2)[+-](?1)   # summand addOp term
)                # end of term
$

Thank you m.buettner for the explanation, this explains why I was unable to find an answer to my question online.

Collectives™ on Stack Overflow

Java RegEx loop referencing pattern

1 Answer 1

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related