Java 并行解释器；“树人”；程序设计语言未按预期运行

是臭名昭著的Brainf***编程语言的变体，它不是在磁带上运行，而是在向下无限的二叉树上运行。对于编程难题和代码栈交换，我正在尝试为它编写一个并行解释器，它最终将输出语言中所有语法上有效、停止的程序，不包括那些需要输入和产生输出的程序

出于某种原因，它似乎也省略了所有小于5个字符的非空程序，同时也包括一些语法明显无效的程序。当然，在我开始打高尔夫球之前，这些都是需要解决的问题

以下是它的来源：

import java.util.*;

public class I{
    static class NODE{
        public NODE l=null,r=null;
        public byte v=0;
    }
    static class PROGRAM extends Stack<NODE>{
        public int i=0;
        public char[]s;
        public boolean h=false;
    }
    static void step(PROGRAM t){
        if(t.i>=t.s.length){
            t.h=true;return ;
        }
        char c=t.s[t.i];
        if(c=='<'){if(t.peek().l==null)t.peek().l=new NODE();t.push(t.peek().l);}
        if(c=='>'){if(t.peek().r==null)t.peek().r=new NODE();t.push(t.peek().r);}
        if(c=='^')t.pop();
        if(c=='+')t.peek().v++;
        if(c=='-')t.peek().v--;
        if(c=='['&&t.i==0){
            int i=1;
            while(i>0){
                t.i++;
                if(t.s[t.i]==']')i--;
                if(t.s[t.i]=='[')i++;
            }
            return;
        }
        if(c==']'&&t.i!=0){
            int i=1;
            while(i>0){
                t.i--;
                if(t.s[t.i]==']')i++;
                if(t.s[t.i]=='[')i--;
            }
            return ;
        }
        t.i++;
    }
    static char[]n(char[]a){
        String b="<^>+-[]";
        for(int i=a.length-1;i>=0;i--){
            int j=b.indexOf(a[i]);
            if(j<6){a[i]=b.charAt(j+1);return a;}
            a[i]='<';
        }
        char[]c=Arrays.copyOf(a,a.length+1);
        c[a.length]='<';
        return c;
    }
    public static void main(String[]a){
        List<PROGRAM>programs=new ArrayList<PROGRAM>();
        char[]c={};
        while(true){
            PROGRAM t=new PROGRAM();
            t.s=c;
            if(isBalanced(c))programs.add(t);
            c=n(c);
            for(PROGRAM u:programs){
                try{step(u);if(u.h){programs.remove(u);System.out.println(String.valueOf(u.s));break ;}}catch(Exception e){
                    programs.remove(u);break ;
                }
            }
        }
    }
    static boolean isBalanced(char[]c) {
        int i=0;
        for(char d:c){
            if(d=='[')i++;
            if(d==']')i--;
            if(i<0)return false;
        }
        return i==0;
    }
}

import java.util.*；
公共一级{
静态类节点{
公共节点l=null，r=null；
公共字节v=0；
}
静态类程序扩展堆栈{
公共整数i=0；
公共字符[]s；
公共布尔h=false；
}
静态无效步骤（程序t）{
如果（t.i>=t.s.长度）{
t、 h=真；返回；
}
字符c=t.s[t.i]；
if（c=''）{if（t.peek（）.r==null）t.peek（）.r=new NODE（）；t.push（t.peek（）.r）；}
如果（c=='^'）t.pop（）；
如果（c='+'）t.peek（）.v++；
如果（c='-'）t.peek（）.v--；
如果（c='['&&t.i==0）{
int i=1；
而（i>0）{
t、 i++；
如果（t.s[t.i]=']'）i--；
如果（t.s[t.i]='['）i++；
}
回来
}
如果（c==']'&&t.i！=0）{
int i=1；
而（i>0）{
t、 我--；
如果（t.s[t.i]=']'）i++；
如果（t.s[t.i]='['）i--；
}
回来
}
t、 i++；
}
静态字符[]n（字符[]a）{
字符串b=“+-[]”；
对于（int i=a.length-1；i>=0；i--）{
int j=b.indexOf（a[i]）；
如果（jLeave the question as is，它可能对其他用户也有帮助。
用该语言输出所有语法上有效、停止的程序。
这是一项不确定的任务，它无法在这个宇宙的生命周期内解决/完成。很抱歉，您在开始之前就失败了。我们的想法是一次生成一个可能的程序被解释的图灵完整语言中的，并在这样做时，用parralel解释语法上有效的。然后，在它们停止时将它们打印到输出中，不包括触发异常的程序。每个有效的、完全停止的程序最终将在输出中出现一次，尽管可能需要任意长的时间是时候让它出现了。是的，我知道它永远不会真正结束。