Analisador Sintático que aceite uma determinada gramática

Programação Java
#1

Pessoal preciso fazer um analisador sintático pra seguinte gramatica.
S -> SS* | SS+ | a | vazio

meu código aceita a gramática mas estou com problemas em validar a cadeia de acordo com as restrições.

estou lendo de um arquivo texto chamado cadeia que contem a seguinte string

a aa* aa+ aa* a+
o meu problema é pegar a segunda string do txt e jogar em outra variavel auxiliar no caso proxlookahead mas manter meu lookahead no corrente…pra poder fazer as comparações.

[code]import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.StringTokenizer;

public class LerStrings {

String token;
String lookahead;
String antlookahead;
String proxlookahead;
StringTokenizer st = null;


public LerStrings() throws FileNotFoundException, IOException {
    BufferedReader arq = new BufferedReader(new FileReader("cadeia.txt"));
    token = arq.readLine(); //leio a linha toda e jogo na string 
    st = new StringTokenizer(token);
    this.lookahead = st.nextToken(); //pego a primeira palavra
    System.out.println(lookahead);// imprimi primeira palavra só pra ter certeza
   }

void match(String t) {
    if (this.lookahead.equals(t)) { //se palavra for igual a string t
        antlookahead = this.lookahead; //guardo palavra atual numa string auxiliar
        lookahead = nextTerminal(); // pego proxima palavra
     //   this.proxlookahead = nextTerminal();
        System.out.println(this.lookahead); //imprimo pra ver se pegou mesmo proxima palavra
        System.out.println(antlookahead);//imprimo pra ver se guardou palavra anterior
        //System.out.println(proxlookahead);
    } else {
        System.out.println("Erro de Sintaxe");
    }
}

void s() {
    if (this.lookahead.equals("a")) {//testo se palavra atual é igual e se for...
        //verificar se tem caracteres antes, caso seja ultimo da cadeia não validar!
        //se for o primeiro e tiver mais "as" na cadeia tbm não validar!
        if ((this.antlookahead.equals(" "))||(this.antlookahead.equals("aa*"))||(this.antlookahead.equals("a*"))||(this.antlookahead.equals("aa+"))||(this.antlookahead.equals("a+"))){

//&&(this.proxlookahead.equals(“aa*”))||(this.proxlookahead.equals(“aa+”))||(this.proxlookahead.equals(“a*”))||(this.proxlookahead.equals(“a+”))) {
System.out.println(“Erro de Sintaxe, cadeia não válida!”);
} else { //então se for único, validar!
match(“a”);//joga a pra string t da função match
}
} else if (this.lookahead.equals(“aa*”)) {//senão se palavra for igual…
if (this.antlookahead.equals(“a”)){ //testar se não tem nenhum a sozinho antes ou depois
System.out.println(“Erro de Sintaxe”);
}else{ //validar senaum tiver a sozinho antes ou depois
match(“aa*”);
s();
}
} else if (this.lookahead.equals(“aa+”)) {//senão se palavra for igual…
if (this.antlookahead.equals(“a”)){ //testar se não tem nenhum a sozinho antes ou depois
System.out.println(“Erro de Sintaxe, cadeia não é válida!”);
}else{ //validar senaum tiver a sozinho antes ou depois
match(“aa+”);
s();
}
} else if (this.lookahead.equals(“a+”)) {//senão se palavra for igual…
if ((this.antlookahead.equals(“aa*”))||(this.antlookahead.equals(“aa+”))){ //testar se tem aa* ou aa+ antes e validar
match(“a+”);
s();
}else{ //senão erro de sintaxe
System.out.println(“Erro de Sintaxe, cadeia não é válida!”);
}
} else {
System.out.println(“Erro de Sintaxe, cadeia não é válida!”);
}
}

public String nextTerminal() {
    return st.nextToken(); 
  
}

}[/code]

#2