Acho que o seu problema mesmo é ter perdido a prática com Lisp. Clisp
na verdade é apenas uma implementação de Common Lisp (CL), que é uma
linguagem muito robusta - tem muitas funções, acredito que tenha bem
mais do que você precisa para traduzir o seu programa, mesmo porque
mulisp é minimalista. Fazendo um pouco de pesquisa me leva a acreditar
que mulisp mesmo é um Lisp que implementa várias funções de Common
Lisp, mas ainda não havia o padrão ANSI Common Lisp.
Olhando o seu código meio por cima, me parece que o problema é apenas
uma questão de sintaxe. Por exemplo, isto:
(DEFUN P-LIVRE (x FORMULA y A)
((OR (CASA FORMULA '(QS y A))
(CASA FORMULA '(EX y A)))
(SETQ A (THIRD FORMULA))
(SETQ y (SECOND FORMULA))
(AND (NEQ x y) (P-LIVRE x A)))
((OR (CASA FORMULA '(A eq B))
(CASA FORMULA '(A ent B))
(CASA FORMULA '(A e B))
(CASA FORMULA '(A ou B)))
(OR (P-LIVRE x (CAR FORMULA)) (P-LIVRE x (CADDR FORMULA))))
((OR (CASA FORMULA '(nf A))
(CASA FORMULA '(co A))
(CASA FORMULA '(n A)))
(P-LIVRE x (CADR FORMULA)))
((MEMBER x FORMULA) 'T))
Não faz nenhum sentido em CL. Acredito que a tradução deste pedaço de
código seria apenas colocar um cond ao redor do corpo da função:
(DEFUN P-LIVRE (x FORMULA y A)
(cond
((OR (CASA FORMULA '(QS y A))
(CASA FORMULA '(EX y A)))
(SETQ A (THIRD FORMULA))
(SETQ y (SECOND FORMULA))
(AND (NEQ x y) (P-LIVRE x A)))
((OR (CASA FORMULA '(A eq B))
(CASA FORMULA '(A ent B))
(CASA FORMULA '(A e B))
(CASA FORMULA '(A ou B)))
(OR (P-LIVRE x (CAR FORMULA)) (P-LIVRE x (CADDR FORMULA))))
((OR (CASA FORMULA '(nf A))
(CASA FORMULA '(co A))
(CASA FORMULA '(n A)))
(P-LIVRE x (CADR FORMULA)))
((MEMBER x FORMULA) 'T))))
Tanto faz se cond é escrito em maiúsculas ou minúsculas, porque CL é
insensitivo à maiúsculas. Por outro lado, este loop
(LOOP
((NULL PILHA) 'raiz-insatisfativel)
((EQL (PROCESSE NO) 'satisfativel) 'raiz-satisfativel)
(SETQ PILHA (APPEND (GET NO 'FILHOS) (CDR PILHA)))
(PRINT PILHA)
(SETQ NO (CAR PILHA))
)
pode ser traduzido em algo usando do
(do ((pilha pilha (append (get no 'filhos) (cdr pilha)))
(no (car pilha)))
((null pilha )'raiz-insatisfativel)
(if (eql (processe no) 'satisfativel)
(return 'raiz-satisfativel))
ou, se você não se importar com legibilidade, ou que o código fique
"da maneira correta", mas quiser apenas traduzir tudo de maneira
prática, pode fazer assim:
(loop do
(cond
((NULL PILHA) (return 'raiz-insatisfativel))
((EQL (PROCESSE NO) 'satisfativel) (return 'raiz-
satisfativel)))
(SETQ PILHA (APPEND (GET NO 'FILHOS) (CDR PILHA)))
(PRINT PILHA)
(SETQ NO (CAR PILHA))
)
Outro problema são as variáveis. Elas não estão declaradas. Por
exemplo, naquele loop acima você chama (setq pilha alguma-coisa), mas
pilha não está declarada como uma variável local (usando let) nem
global (usando defvar). Talvez seu programa funcione se você deixar
assim mesmo, provavelmente o Clisp vai tratar a variável pilha como se
fosse global, mas isso em geral não é uma boa prática, e talvez não
funcione em outras implementações de CL.
Agora, acredito que esta seja a dica mais valiosa: vá traduzindo e
testando função por função, a começar pelas mais básicas. Não queira
traduzir tudo de uma só vez. Acho que o mais difícil vai ser achar
essas funções mais básicas e ir testando elas. Qualquer dificuldade,
estamos sempre por aqui :-)
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"Lisp-br" group.
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to
[email protected]
For more options, visit this group at
http://groups.google.com/group/lisp-br?hl=en
-~----------~----~----~----~------~----~------~--~---
