正则表达式无法匹配开关案例模式

Question

W e need to parse a rule which may be include a switch case instruction.

As we considered to use Groovy to implement this parser within Java code, I wrote the code below in Groovy:

1. class RuleParser {
2. String functionRegex = /(frml[0-9]*)((\s*@[a-zA-Z0-9_]*\s*)?(,\s*@[a-zA-Z0-9_]*\s*)*)/
3. String variableRegex = /@[a-zA-Z0-9_]*/
4. String numberRegex = /\s+[0-9]+/
5. String switchRegex = /switch(\s*1\s*)((\s*|\n)case)+((\s*|\n)default)?/
6. String caseRegex = /case\s*1\s*:\s*1/
7. String defaultRegex = /default\s*:\s*1/
8. String conditionRegex = /1(>=|<=|>|<|==|!=)1/

9. testRule(String rule){
10.       try {
11.          rule.eachMatch(numberRegex){ match->
12.             rule=rule.replaceAll(match, ' 1');
13.          }
14.          rule.eachMatch(functionRegex){ match->
15.             rule=rule.replaceAll(match, '1');
16.          }
17.          rule.eachMatch(variableRegex){ match->
18.             rule=rule.replaceAll(match, '1');
19.          }
20.          rule.eachMatch(defaultRegex){ match->
21.             rule=rule.replaceAll(match, 'default');
22.          }
23.          rule.eachMatch(caseRegex){ match->
24.             rule=rule.replaceAll(match, 'case');
25.          }
26.          rule.eachMatch(switchRegex){ match->
27.             rule=rule.replaceAll(match, '1');
28.          }
29.          Eval.me(rule)
30.          println "run successfully"
31.       } catch (Exception e) {
32.          e.printStackTrace()
33.       }
34.    }
35. }

In first I just Wanna test the input rule to know if it is correct based on our structure, for example I considered the rule sample below to trace the code if it works properly:

switch(@prm43) 
case 12: @msg13
case 14: @msg32
default: @msg100

and it works until line 26, when it reach line 26 the rule is:

switch(1) 
case
case
default

Despite of the fact that it completely follow the pattern of switchRegex , but it doesn't have any change after line 28, why?

Answer 1

I'm sorry for not coming up with a straight answer for your question, but it seems a little unclear to me what you are trying to achieve. You eval the rule after you do some replacements, but your switch is not legal groovy (or java for that matter). switch needs to be followed by curly braces. Moreover, I would try to take advantage of groovy's DSL features instead of making a parser. If a parser is really what you need (missing information on motivation and context), then I would suggest using a combinator parser like jparsec:

https://github.com/jparsec/jparsec

It is extremely easy to describe grammars with jparsec, and it is very maintainable. In any case, using regexes for this seems like a problem looking like a nail because we have only a hammer.

Answer 2

As I research more about my problem, I test some other parser to evaluate the best way to parse my grammar. In first, as loteq recommended I went after examine jparsec in my project. But unfortunately I couldn't find enough information and a good reference to use that parser. So, I look for another parser to do my job on my specific grammar and I found antlr4. Then, I develop my grammar and save it in RuleExpr.g4 file to generate the lexer and parser file by antlr. the grammar is shown below:

grammar RuleExp;

start
    :   statement+
    ;

statement
    :   assignment
    |   message
    |   ifElseExp
    |   switchExp
    ;

ifElseExp
    :   'if' '(' relCnd ')' 'then' '{' start '}'
    |   'if' '(' relCnd ')' 'then' '{' start '}' elseExp
    ;

elseExp
    :   'else' ifElseExp
    |   'else' '{' start '}'
    ;

switchExp
    :   'switch' '(' relCnd ')' caseExp
    ;

caseExp
    :   'case' terminal ':' '{' start '}' caseExp
    |   dfltExpr
    ;

dfltExpr
    :   'default' ':' '{' start '}'
    ;

message
    :   '@msg'Digit+
    ;

assignment
    :   id '=' addStmt
    ;

relCnd
    :   relCnd  '>' logCnd
    |   relCnd  '<' logCnd
    |   relCnd  '>=' logCnd
    |   relCnd  '<=' logCnd
    |   relCnd  '==' logCnd
    |   relCnd  '!=' logCnd 
    |   logCnd
    ;

logCnd
    :   logCnd  'AND'   termCnd
    |   logCnd  'OR'    termCnd
    |   logCnd  'XOR'   termCnd
    |   'NOT'   termCnd
    |   termCnd
    ;

addStmt
    :   addStmt '+' mulStmt
    |   addStmt '-' mulStmt
    |   mulStmt
    ;


mulStmt
    :   mulStmt '*' terminal
    |   mulStmt '/' terminal
    |   mulStmt '^' terminal
    |   terminal
    ;

terminal
    :   '('addStmt')'
    |   id
    |   number
    ;

termCnd
    :   '('relCnd')'
    |   id
    |   number
    ;

id
    :   '@prmt'(Digit)+
    |   '@fild'(Digit)+
    |   '@infF'(Digit)+
    |   '@mthd'(Digit)+
    |   '@cmpnt'(Digit)+
    |   '@oprt'(Digit)+
    |   Letter(Letter|Digit)*
    ;

number
    :   Digit+ ('.' Digit+)?
    ;

Letter
    :   'a'..'z'
    |   'A'..'Z'
    |   '_'
    ;

Digit
    :   '0'..'9'
    ;

WS  :   [ \t\r\n]+  ->  skip 
    ;

After that I parse my sample code using the lexer and parser which generated by antlr

public void checkSyntax(String rule) {
      // TODO Auto-generated method stub
      try {
         CharStream stream=new ANTLRInputStream(decodeRule(rule));
         RuleExpLexer lexer=new RuleExpLexer(stream);
         CommonTokenStream tokens=new CommonTokenStream(lexer);
         RuleExpParser parser=new RuleExpParser(tokens);
         parser.start();
      } catch (Exception e) {
         // TODO: handle exception
         throw new ApplicationExceptions("uacRule is Wrong");
      }
   }