自顶向下解析-Java

我被分配了一个项目来实现一个自顶向下的回溯解析器，用于任何在重写规则的RHS上只包含一个非终结符的语法（例如S->aaSb | aaSa | aSa）

到目前为止，我有三种方法，包括

main

，用于检查输入字符串的有效性

我的目标是，使用语法的

char[][]

数组，对照语法检查输入字符串中的每个字符，如果字符串包含在语法中，则返回

true

public class TDBP {
    public static void main(String[] args) {
        char[][] g = new char[][] 
            { {'a', 'a', 'S', 'b'}, 
              {'a', 'a', 'S', 'a'}, 
              {'a', 'S', 'a'}, 
              {'\0'} };

        SP(g);
    }
    public static void SP(char[][] g) {
        Scanner s = new Scanner(System.in);
        boolean again = true; int pn = 0;
        String test;

        while(again) {
            System.out.print("Next string? ");
            test = s.nextLine();

            if(S(pn, test, g))
                System.out.println("String is in the language");
            else
                System.out.println("String is not in the language");

            if(s.nextLine() == "\n") again = false;
        }

        s.close();
    }
    public static boolean S(int pn, String test, char[][] g) {
        char[] c = test.toCharArray();
        boolean exists = false;

        for(int i = pn; i < g.length; i++) {
            for(int j = 0; j < g[i].length; j++) {
                if(c[j] == 'S')
                    S(++pn, test, g);
                if(c[j] == g[i][j])
                    exists = true;
            }
        }

        return exists;
    }
}

公共类TDBP{
公共静态void main（字符串[]args）{
字符[][]g=新字符[][]
{{'a'，'a'，'S'，'b'}，
{'a'，'a'，'S'，'a'}，
{'a'，'S'，'a'}，
{'\0'} };
SP（g）；
}
公共静态无效SP（字符[][]g）{
扫描仪s=新的扫描仪（System.in）；
布尔值=真；int pn=0；
串试验；
同时（再次）{
System.out.print（“下一个字符串？”）；
test=s.nextLine（）；
if（S（pn，测试，g））
System.out.println（“字符串在语言中”）；
其他的
System.out.println（“字符串不在语言中”）；
如果（s.nextLine（）==“\n”）再次=false；
}
s、 close（）；
}
公共静态布尔S（int-pn，字符串测试，字符[][]g）{
char[]c=test.toCharArray（）；
布尔存在=假；
对于（int i=pn；i

在我的算法中，

pn

是一个整数，用于跟踪我当前查看的语法中的哪个生成，并确保我不会扫描同一语法两次（例如，上述语法中的

pn

为1对应于

aaSa

）。另外，我还有

\0

表示空字符串

我是否正确解析字符串

---

谢谢大家!

我对我的CS类有些生疏：但是下面的代码对我很有用：

public static boolean fullCheck(char[] toTest, char[][] g) {
    int val = checkOnAll(0, toTest, g);

    if (val == toTest.length) {
        return true;
    }
    return false;
}

public static int checkOnAll(int charPos, char[] toTest, char[][] g) {
    for(int i = 0; i < g.length; i++) {
        int val = checkOne(charPos, toTest, g[i], g);
        if (val != -1) {
            return val;
        }
    }
    return -1;
}

//also needs length checks
public static int checkOne(int charPos, char[] toTest, char[] rule, char[][] rules) {
    for(int j = 0; j < rule.length; j++) {
        if (charPos >= toTest.length) {
            return -1;
        }
        if(rule[j] == 'S') {
            int value = checkOnAll(charPos, toTest, rules);
            if (value == -1) {
                return -1;
            } else {
                charPos = value - 1;
            }
        } else if (toTest[charPos] != rule[j]) {
            return -1;
        }
        charPos++;
    }
    return charPos;
}

（长度检查时“\0”给了我麻烦，上面的更改是最简单的解决方案）

我在您的代码中发现了一些问题，尽管我不能完全确定我自己的代码是否没有bug，但我想我还是要与大家分享一下： 1.当S在递归中返回“false”时，该值被忽略。 2.“pn”应该被限制为知道我们在哪个测试字符上，而不是规则字符上。 3.即使返回的值为true，也必须确保检查了整个测试字符串，而不仅仅是其中的一部分。我没看见你那样做。 4.如果您有一条很长的规则，但输入很短，则可能会出现数组越界异常，因为您从不查看测试字符串的长度

我用各种输入尝试了我自己的代码，我有一种感觉，我可能错过了一些东西，但我找不到它。如果您发现问题，请告诉我：）

---

祝你好运。

使用递归下降自上而下解析可以更容易地解决这个问题

假设你的语法是

S->aaSb | aaSa | aSa |#其中#表示空字符串

在左因子分解之后，它将是

S  -> aS' | #
S' -> aSS" | Sa
S" -> b | a

然后在单独的方法中定义每个规则，并递归调用，如下所示

对于第一条规则：S->aS'|#

对于第二条规则：S'->aSS“| Sa

像这样定义第三个函数。（注意，我必须通过引用传递）

有关更多详细信息，您可以参考任何自上而下的解析教程。您也可以参考其中一个

---

希望这会有所帮助。

问题需要改进，您遇到了什么问题？我检查字符串中每个字符有效性的方法是否正确？测试然后编辑您的问题以获得更多信息specific@Delfini您的方法不正确。您的程序提供的输出字符串使用的是aaba语言，但不能为从给定的语法中派生。那么，对于如何修复我的方法，有什么建议吗？

S  -> aS' | #
S' -> aSS" | Sa
S" -> b | a

function S(char[] input, int &i) {
     if(input[i]=='a') {
       i++;
       return S1(input, i);
      } 
      return true;   //For empty string
}

function s1(char[] input, int &i) {
    if(input[i]=='a') {
       i++;
       S(input, i);
       return S2(input, i);
    } else {
       S(input, i);
       if(input[i]=='a') {
          return true;
       } else {
          return false;
       }
    }
}