Re: regexp(ing) Backus-Naurish expressions ...

From:

Leif Roar Moldskred <leifm@dimnakorr.com>

Newsgroups:

comp.lang.java.programmer

Date:

Sat, 09 Mar 2013 23:33:31 -0600

Message-ID:

<kvOdnR7MkYC2hqHMnZ2dnUVZ8gGdnZ2d@giganews.com>

qwertmonkey@syberianoutpost.ru wrote:

I think one possible way to do that is via a regexp, which should match all
the options included in the test array aISAr
~
One of the problems I am having is that if you enter as options say [true|t],
the matcher would match just the "t" of "true" and I want for "true" to be
actually matched another one is that, say, " true ", should be matched, as well
as "false [ nix |mac| windows ] line.separator" ...
~
Any ideas you would share?

When working with regular expressions you should always remember that
you don't need to do everything in a single expression. There's no law
against splitting things up into sub-expressions or using "boring old
code" for parts of the match.

You should also bear in mind that some parsing tasks are just not
suited to regular expressions and if the regular expression starts
getting complicated you should consider if the task might be solved
more easily with another approach.

Here, assuming I've understood the problem right, I might do something
as below (I'm not on my development computer, so note that this has
not been checked for errors):

  Set<String> VALID_FIRST_WORDS = toSet( "true", "false", "t", "f" );
  String WORD = "(\\w+)";
  String BRACKETED_WORD = "(\\[([^]])+\\])";
  Pattern LINE_MATCH = Pattern.compile( WORD + "\\s*" +
    BRACKETED_WORD + "?\\s+" + WORD + "?" );

  boolean validLine( String inputLine ) {
    String line = inputLine.toLowerCase().trim();
    Matcher matcher = LINE_MATCH.matcher( line );
    if( matcher.matches() ) {
      String firstWord = matcher.group(1);
      // Not .group(2) as that would include the brackets.
      String bracketedWord = matcher.group(3).trim();
      String lastWord = matcher.group(4);

      return firstValid( firstWord ) &&
             bracketedValid( firstWord, bracketedWord ) &&
             lastValid( firstWord, bracketedWorld, lastWord );
    }
    return false;
  }

  boolean firstValid( String firstWord ) {
    // Alternatively, use a HashSet
    switch( firstWord ) {
      case "true" : /* Fall through */
      case "t" : /* Fall through */
      case "false" : /* Fall through */
      case "f" : return true;
      default : return false;
    }
  }

  // This is assuming the valid values of the bracketed
  // expression depends on what the first word was
  Map<String, Set<String>> LEGAL_BRACKETED = ...;

  boolean bracketedValid( String firstWord, String bracketed ) {
    if( bracketed == null ) {
      return true;
    }

    Set<String> legalBracketed = LEGAL_BRACKETED.get( firstWord );

    return legalBracketed != null &&
           legalBracketed.contains( bracketed );
  }

  boolean lastValid( String first, String bracketed, String last ) {
    if( bracketed == null && last == null ) {
      return true;
    }

    // Implementation depends on the particulars of when certain
    // last words are valid and when not.
    ...
  }


--
Leif Roar Moldskred