BrainFuck

Comme je suis de passage, autant poster quelques programmes.
Voilà un interpréteur brainfuck (pour ceux qui ne connaissent pas le langage: http://fr.wikipedia.org/wiki/Brainfuck )
Vous avez une garantie de marche de 50%, c'est possible qu'en plus de la lenteur, il plante  

J'ai ajouté des instructions: V pour afficher l'état de la mémoire.
Les espaces sont ignorés

Code:

:Input Str1
:{0→L1
:Ans→L2
:1→B
:For(A,1,length(Str1
:   sub(Str1,A,1
:   If Ans="+
:   Then
:         1+L1(B→L1(B
:   Else
:      If Ans="-
:      Then
:            L1(B)-1→L1(B
:      Else
:         If Ans=">
:         Then
:               B+1→B
:            If B>dim(L1
:               B→dim(L1
:         Else
:            If Ans="<
:            Then
:                  B-1→B
:            Else
:               If Ans=".
:               Then
:                     Pause L1(B
:               Else
:                  If Ans=",
:                  Then
:                        Input C
:                     C→L1(B
:                  Else
:                     If Ans="[
:                     Then
:                           A→L2(1+dim(L2
:                     Else
:                        If Ans="]
:                        Then
:                           If L1(B
:                              L2(dim(L2→A
:                        Else
:                           If Ans="V
:                           Then
:                                 Pause L1
:                           Else
:                              If Ans≠"
:                              Then
:                                    Disp "ERR: "+Ans+" IND:
:                                 Pause A
:                                 Menu("DELETE?","Y",0,"N",1
:                                 Lbl 0
:                                 " "+sub(Str1,1,A-1)+sub(Str1,A+1,length(Str1)-A→Str1
:                                 Lbl 1
:                                 Pause Str1
:                              End
:                           End
:                        End
:                     End
:                  End
:               End
:            End
:         End
:      End
:   End
:End

Gasp-euh   
je n'ai pas les skills pour tester, mais, ça me parait bien lourd...

Programmer en pur brainfuck est très difficile en soit... même pas de préprocesseur ni de routine.
Teste le avec le helloworld de wikipédia...

Cet interpréteur peut être allégé puisque les alternatives Else ne sont pas indispensables ici, mais cela nécessiterait alors de ne plus utiliser Ans pour le caractère.

ceci était faux:

EDIT : Ceci était tentant mais faux car il faut des chaines de caractères d'où erreur sur le A.

Argh rien qu'à voir ça j'aime pas ce langage

Heu... on obtiens une erreur argument sur le A en faisant ça non? //Edit: En effet une erreur type donnée plutôt.

Tu as raison il y a bien une erreur, mais de type de donnée. Il faut des chaînes de caractères. Dommage. Merci pour la bonne remarque.

Je ne connais pas du tout ce langage, et après un rapide tour sur Wikipedia, sa m'a découragé...

Mais il ne faut pas!
C'est très simple comme langage, il n'y a que 8 instructions    
Bon ok, ça devient lourd à programmer, le programme le plus long que j'ai fait faisait une multiplication...
Le Hello World ne marchera pas car je n'affiche que des nombres.
Il faudrait que je crée une table de caractères puis pour les afficher, utiliser un sub(.

L'absence de préprocesseur natif à ce langage me laisse perplexe mais je demeure intéressé.
J'ai écrit une lookuptable sans savoir comment y accéder plus tard. Utiliser l'interpréteur sans programme n'est pas gagné 
J'ai persévéré sans lookuptable et j'ai obtenu mes propres routines de copie et de produit.

Je commence à copier ce programme TI-Basic interpréteur pour tester mes routines de Brainfuck. Mais je découvre des défauts de conception. Je me décide donc à l'améliorer.

La taille de la table de données n'est pas affectée. Comme ça peut s'agrandir je peux l'admettre...
Le pointeur nul devrait être géré. Soit on interdira cela soit on insérera un terme.
Le pointeur excessif qui allonge la liste est intéressant. Retenons alors qu'il n'y a donc pas de wrapping (retour à l'autre extrémité).

L'instruction "[" doit réaliser un test à l'entrée dans la définition du langage mais tu ne l'as pas implémenté.
Je propose de corriger "[" avec une boucle dédiée à la recherche d'un "]" fermant ce "[" tout en tenant compte des boucles imbriquées. Je préfère cela à une exploitation de la boucle principale qui imposerait soit une alternative supplémentaire soit des conditions.
Enfin la table de pile de retour n'est jamais vidée, pas même lors d'une sortie de structure.
Par ailleurs j'envisage d'utiliser une variable pour conserver sa taille plutôt que de lire la fonction dim souvent.
Je propose de corriger "]" avec une condition pour vider la pile.

Si l'espace ajouté lors de la suppression de caractère non-sens sert à ne pas déplacer de code pour de la compatibilité avec les boucles, alors il faudra le placer au milieu en remplacement du caractère non-sens.
Si cet espace a un but d'éviter des chaines vides, alors c'est tout faux : les sous-chaînes sub() planteraient aussitôt qu'elles devraient être vides. Cela arriverait aux extrémités.
Il serait judicieux d'ajouter un caractère non-code tel qu'espace à chaque extrémité de la chaîne code juste après la saisie, et naturellement de remplacer les non-sens par espace lors de leur suppression. Ainsi les décalages de code et les chaines vides seront évités.
On peut modifier le pointeur initial si on ne veut pas lire le caractère ajouté en extrémité.

Par ailleurs les conventions du langage que j'ai lu stipulent que tout caractère non-sens est un commentaire, donc je négligerais bien cette fonctionnalité de remplacement des non-sens.

Je soulève à cette occasion une subtilité bien pratique du Brainfuck : si on enchaîne une quelconque boucle à une autre sans action entre les deux, la seconde n'est pas lue, donc on peut mettre n'importe quoi de commentaire à ce moment...

Dans cette première version sans alternative je retire la fonctionnalité de suppression des caractères non-sens.

Code:

:Input Str1
:{0→L1
:Ans→L2
 // :999→dim(L1
:1→B
:For(A,1,length(Str1
:   sub(Str1,A,1→Str2
:   If Str2="+
:      1+L1(B→L1(B
:   If Str2="-
:      L1(B)-1→L1(B
:   If Str2=">
:   Then
:      B+1→B
:      If B>dim(L1
:         B→dim(L1
:   End
:   If Str2="<
:   Then
:      B-1→B
:      If B<1
:      1→B
:   End
:   If Str2=".
:      Pause L1(B
:   If Str2=",
:   Then
:      Input C
:      C→L1(B
:   End
:   If Str2="[
:   Then
:      If L1(B
:      Then
:         A→L2(1+dim(L2
:      Else
:         1→C
:         While C
:            A+1→A
:            sub(Str1,A,1
:            C+(Ans="[")-(Ans="]")→C
:         End
:      End
:   End
:   If Str2="]
:   Then
:      If L1(B
:      Then
:         L2(dim(L2→A
:      Else
:         dim(L2)-1→dim(L2
:      End
:   End
:   If Str2="V
:      Pause L1
:End

Je n'ai pas le courage de revenir aux alternatives ou d'ajouter des conditions... Je montre juste les deux parties qui concerneront le remplacement des caractères non-sens.

Code:

Input Str1
" "+Str1+" "->Str1

Code:

:   If Str2≠" "  // et autres conditions, que ce ne soit pas du code notamment
:   Then
:      Disp "ERR: "+Str2+" IND:
:      Pause A
:      Menu("DELETE?","Y",0,"N",1
:      Lbl 0
:      sub(Str1,1,A-1)+" "+sub(Str1,A+1,length(Str1)-A→Str1
:      Lbl 1
:      Pause Str1
:   End

Et au final ma routine de produit de char marche et donc ce programme interpréteur aussi, youpi !

J'ai fait de grosses erreurs, très grosses (et beaucoup d'omissions)   
Je me demandais d'ailleurs pourquoi il plantait sur deux boucles while imbriquées... (Qui n'étaient pas des boucles while dans mon programme)

Spoiler:

Pour la suppression des caractères, j'avais pensé au cas ou la personne n'a pas appuyé sur la bonne touche et qu'elle ne s'en est pas rendue compte mais ça n'arrive pas souvent et ça se remarque, alors j'abandonne ce bout de code!

Est-ce que je peux reprendre ton code pour le mettre dans le premier post? (bien-sûr, je te citerai comme étant l'auteur)
J'ai modifié quelques caractères, même pas 10 octets, l'idée de wrapping me plaît beaucoup   , la méthode de recherche de fin de boucle aussi!

Code:

:Input Str1
:{0→L1
:Ans→L2
:1→B
:For(A,1,length(Str1
:   sub(Str1,A,1→Str2
:   If Str2="+
:      1+L1(B→L1(B
:   If Str2="-
:      L1(B)-1→L1(B
:   If Str2=">
:   Then
:      1+B(1-(B=999→B
:      If B>dim(L1
:         B→dim(L1
:   End
:   If Str2="<
:   Then
:      B-1→B
:      If not(B
:      dim(L1→B
:   End
:   If Str2=".
:      Pause L1(B
:   If Str2=",
:   Then
:      Input C
:      C→L1(B
:   End
:   If Str2="[
:   Then
:      If L1(B
:      Then
:         A→L2(1+dim(L2
:      Else
:         1→C
:         While C
:            A+1→A
:            sub(Str1,A,1
:            C+(Ans="[")-(Ans="]→C
:         End
:      End
:   End
:   If Str2="]
:   Then
:      If L1(B
:      Then
:         L2(dim(L2→A
:      Else
:         dim(L2)-1→dim(L2
:      End
:   End
:   If Str2="V
:      Pause L1
:End

LookUpTable est une table de données précalculées. Dans le cas concerné par mes précédents propos, il s'agissait donc de la table de multiplication. J'avais écrit un long code brainfuck pour affecter ces données à la mémoire. Puis je ne savais pas comment l'utiliser ensuite.

Je suis content de ces bonnes impressions.
Oui tu peux placer une version à jour dans le message initial. Garde sous la main (par exemple en spoiler) la première version.

J'ai repéré comme dernier changement les incréments du pointeur de données.
Tu poses donc un retour à 1 depuis 999, un retour à dim() depuis 1, et un allongement de la liste si on dépasse dim.
L'ensemble me paraît contradictoire : selon moi les seuils de retour s'il y en a devraient être les même dans les deux sens et être fixés.
Pour ce faire il faudrait affecter la taille à 999 lors d'un passage à zéro et aller à 999 plutôt que de revenir à dim().
D'autre part ces wrapping ne sont pas mentionnés dans les définitions que j'ai lu du langage. Je pense qu'imposer des limites est plus rigoureux que le wrapping.