如何编写上下文无关文法？

Question

I have two classes here.

The CFG class takes a string array in its constructor that defines the context-free grammar. The SampleTest class is being used to test the CFG class by inputting the grammar (C) into the class, then inputting a string by the user, and seeing if that string can be generated by the context-free grammar.

The problem I'm running into is a stack overflow (obviously). I'm assuming that I just created a never-ending recursive function.

Could someone take a look at the processData() function, and help me out figure out how to correctly configure it. I'm basically using recursion to take generate all possibilities for strings that the CFG can create, then returning true if one of those possibilities being generated matches the user's input (inString). Oh, and the wkString parameter is simply the string being generated by the grammar through each recursive iteration.

public class SampleTest {
  public static void main(String[] args) {
    // Language: strings that contain 0+ b's, followed by 2+ a's,
    // followed by 1 b, and ending with 2+ a's.
    String[] C = { "S=>bS", "S=>aaT", "T=>aT", "T=>bU", "U=>Ua", "U=>aa" };
    String inString, startWkString;
    boolean accept1;
    CFG CFG1 = new CFG(C);
    if (args.length >= 1) {
      // Input string is command line parameter
      inString = args[0];
      char[] startNonTerm = new char[1];
      startNonTerm[0] = CFG1.getStartNT();
      startWkString = new String(startNonTerm);
      accept1 = CFG1.processData(inString, startWkString);
      System.out.println(" Accept String? " + accept1);
    }
  } // end main
} // end class


public class CFG {

  private String[] code;
  private char startNT;

  CFG(String[] c) {
    this.code = c;
    setStartNT(c[0].charAt(0));
  }

  void setStartNT(char startNT) {
    this.startNT = startNT;
  }

  char getStartNT() {
    return this.startNT;
  }

  boolean processData(String inString, String wkString) {
    if (inString.equals(wkString)) {
      return true;
    } else if (wkString.length() > inString.length()) {
      return false;
    }

    // search for non-terminal in the working string
    boolean containsNT = false;
    for (int i = 0; i < wkString.length(); i++) {
      // if one of the characters in the working string is a non-terminal
      if (Character.isUpperCase(wkString.charAt(i))) {
        // mark containsNT as true, and exit the for loop
        containsNT = true;
        break;
      }
    }
    // if there isn't a non-terminal in the working string
    if (containsNT == false) {
      return false;
    }

    // for each production rule
    for (int i = 0; i < this.code.length; i++) {
      // for each character on the RHS of the production rule
      for (int j = 0; j <= this.code[i].length() - 3; j++) {
        if (Character.isUpperCase(this.code[i].charAt(j))) {
          // make substitution for non-terminal, creating a new working string
          String newWk = wkString.replaceFirst(Character.toString(this.code[i].charAt(0)), this.code[i].substring(3));
          if (processData(inString, newWk) == true) {
            return true;
          }
        }

      }
    } // end for loop
    return false;
  } // end processData
} // end class

Answer 1

Your grammar contains a left-recursive rule

U=>Ua

Recursive-descent parsers can't handle left-recursion, as you've just discovered.

You have two options: Alter your grammar to not be left-recursive anymore, or use a parsing algorithm that can handle it, such as LR1. In your case, U is matching "at least two a characters", so we can just move the recursion to the right.

U=>aU

and everything will be fine. This isn't always possible to do in such a nice way, but in your case, avoiding left-recursion is the easy solution.

Answer 2

You don't need this for loop: "for (int j = 0; j <= this.code[i].length() - 3; j++)". jus create a var to hold the Capital letter in the nonterminal search you did above. Then do your outer for loop followed by if there is a production rule in String[] that starts with that found Non-terminal, do your substitution and recursion.