O que seu professor parece querer é que vc. escreva um interpretador BASIC.
Um interpretador é um programa que lê instruções e as executa à medida que as lê. Isto é diferente, de um compilador, que transforma as instruções contidas no código-fonte em outro conjunto, normalmente mais simples, que será executado diretamente pela CPU ou por um outro interpretador, mas não as executa.
Para implementar um interpretador vc. precisa, antes de mais nada, de uma definição da liguagem a interpretar. No seu caso, a linguagem pode ser definida como uma seqüência de linhas, cada uma composta de um número seguido por uma sentença.
No caso do BASIC em particular, uma linha recebida que comece com um número não será executada imediatamente, mas armazenada para execução posterior. A execução em si começa ao se receber um comando “run”, que processa as instruções previamente armazenadas. Durante a execução, o programa terá associado um contexto, no qual “vivem” as variáveis que forem utilizadas. Como cada variável é identificada por um nome, a estrutura natural para armazená-las é um mapa. Como o acesso é sempre feito pela chave primária, que é o nome da variável, uma implementação como o HashMap é uma boa alternativa.
Já para o programa, há dois tipos de acesso: direto para uma linha (um “goto”, pex) e seqüencial (próxima instrução). Como normalmente há mais acessos sequenciais do que diretos, deve-se procurar uma estrutura que favoreça o primeiro tipo de acesso. Assim, sugiro algo como o TreeMap para armazenar o programa em si.
Juntando estas peças podemos conceber um esqueleto de programa mais ou menos assim (pseudo-código):
TreeMap<Integer,Comando> programa = new TreeMap<Integer,Comando>();
Map<String,Object> variaveis = new Map<String,Object>;
while( (linha = le_linha_do_arquivo) != EOF ) {
Comando cmd = faz_parse_da_linha(linha);
if ( cmd.getLinha() >= 0 ) {
// Armazena o comando para execução posterior
programa.put(cmd.getLinha(),cmd);
}
else {
// Comando para execução imediata
cmd.executa(programa,variaveis);
}
}
Bem, agora ainda restam alguns problemas a resolver, presumivelmente menores
- Interpretar uma linha individual e retornar um objeto Comando (no seu caso dá para implementar um bacalhau usando expressões regulares)
- Implementar cada comando da linguagem
Destes vou avançar um pouco apenas em um caso particularmente interessante: o comando “run”. A implementação deste comando é que justifica a passagem do programa como um dos argumentos do método “executa”. O pseudo-código do run ficaria assim:
Iterator<Map.Entry<Integer,Comando>> programIterator = programa.entrySet().iterator();
while(programIterator.hasNext() ) {
Map.Entry<Integer,Comando> entry = programIterator.next();
Integer linhaAtual = entry.getKey();
Comando cmd = entry.getValue();
Integer proximaLinha = cmd.executa(programa,variaveis);
if ( proximaLinha != null ) {
SortedMap<Integer,Comando> sub = programa.tailMap(proximaLinha);
programIterator = sub.entrySet().iterator();
}
}
Este “miolo” do run implementa a execução sequencial, bem como permite que os comandos individuais alterem o fluxo de execução, bastando para isto retornar o número da linha específica a ser executada na sequência, o que torna trivial a implementação do IF e GOTO.
Atenção: Neste modelo não há suporte para subrotinas, variáveis locais nem comandos “multi-linha”.
Bem, espero ter ajudado de alguma maneira. Se vc. optar por procurar um código pronto, tudo bem. Mas acho que este tipo de exercício (escrever um interpretador) é daqueles que vc. deve fazer ao menos uma vez na vida. Por mais porco que saia o código, o que vc. irá aprender no processo já valerá a pena e, quem sabe, lhe fará refletir um pouco sobre o que está atrás da execução de um programa.
Boa sorte com o exercício !