Java中语法解析器的正则表达式

Question

I need a regular expression for a Java syntax parser that matches my programming language syntax that look like this:

Variable1={1,2,3}
Variable2=Variable1+{4,5,6}+{}*{2}
Variable3=(Variable2+{1})*Variable1
?Variable3 
?{1,2,3}
?Variable3+{1,2,3}

Expression assignments to variables contain "=" and evaluations start with a "?" sign. Inside parenthesis, you can define a new expression, but the new expression can contain parenthesis again, so it's like a recursive regular assignment, which is not possible in this way:

String IdPattern = "[a-zA-Z][a-zA-Z0-9]*";            
String SePattern ="\\{"+"([0-9]*)(\\,[0-9]+)*"+"\\}";  


// Problem at next line:
   String CoPattern  = "\\(" + ExPattern + "\\)";   
// CoPattern depends on 
// Expattern, which depends on TePattern, 
// which depends on FaPattern, which depends on CoPattern again.

String FaPattern= "("+IdPattern+"|"+SePattern+"|"+CoPattern+")";              
String TePattern = FaPattern + "("+ "\\*"+ FaPattern+ ")*" ;   
String ExPattern= "" + TePattern + "(" + "\\+"+ TePattern+")*";  


String AsPattern =  "("+IdPattern+"="+ExPattern+")";  
String PriPattern = "(\\?"+ExPattern +")";                     
String StaPattern = "("+AsPattern+"|"+PriPattern+")";    
String Pro = StaPattern+"$";       
System.out.println("Input=((({20}+{1,2,3})))".matches(Pro));

The problem here is that CoPattern, depends on ExPattern, which depends on FaPattern, which depends on CoPattern itself again. So how do I make this work?

Answer 1

Inside parenthesis, you can define a new expression, but the new expression can contain parenthesis again, so it's like a recursive regular assignment, which is not possible:

You figured it yourself: it doesn't seem to work.

Thus the simple answer is: regular expressions are an insufficient tool here. You should very much look into building a real parser instead.

Not only because of the hard conceptual limitations, see here for example. But because: building a parser is more than matching input. One key element of a compiler/parsers is to give feedback on invalid input. A regular expression gives you a binary "matches" vs "does not match" answer. But as programmer, you wan't to be told "your input is invalid, and most likely, one problem is a missing bracket over here and an invalid identifier over there ".

So even if you somehow get that approach to work for you, it will give you only a binary answer. And: a "proof of concept" isn't the same as having a reasonable, robust foundation to build on.

It is your project, your "new language". You should understand any part of the tooling around it. Coming from there, "I have seen that super complicated regex that supposedly solves my problem, can someone adapt that to my needs" ... is clearly not a good starting point.

Regular expressions are a very helpful and import tool, but they need to be used with care. My personal rule of thumb: when your regex is so complicated that you need other people to explain it to you, even write it down for you ... then consider not using a regex. Because you are probably out of your league. And you will be the one who has to maintain that code.