[Axe] Interpréteurs dit "Brainf*ck"

Bonjour à tous j'aimerais avoir un peu plus d’éclaircissement pour savoir de quelle manière faire un interpréteur dit "Brainf*ck":

• Comment ouvrir un programme de la calculatrice et copier tout le code dans une variable de type string ?
  
• De quelle manière lire chaque caractère de cette string en allant vers l'avant de la continuité ?
  

Merci de vos conseils !

#Axenntio

Le sdk indique comment sont formatés les programmes, réfères-y toi plutôt que je dise n'importe quoi. Il y a une entête ave le nom et autres, et je crois un pied.
Copier le contenu se fait juste en prenant tous les octets de la partie utile, je crois, car ce sont des tokens.
Déclarer à la VAT une chaine et la créer avec son entête, puis écrire à l'intérieur les tokens du programme.

A voir s'il y a des fonctions d'Axe utiles ou des romcalls à commander par hexa.
Matrefeytontias a déjà écrit des codes hexa qui accèdent aux programmes par leurs noms. Par contre la VAT, il la pirate dans son programme ZHide.

Lire les tokens, cela se fait avec une boucle mais il faut se méfier des tokens longs qui demandent des tests.
Encore une fois il doit y avoir des romcalls, mais surtout des instructions Axe.

EDIT: Si tu veux seulement copier les données, contente toi de parcourir le programme octet par octet, en copiant chacun là où tu le veux. ("Lire" n'est pas très précis comme demande)

En espérant te faire avancer, mais les spécialistes seront plus précis.

Merci beaucoup pour cette réponse ma fois fort constructive !
Je me lance dans mes recherche mais si d'autres personnes ont d'autres choses qui puissent me faire avancer, je suis preneur !

*Comment ouvrir un programme de la calculatrice et copier tout le code dans une variable de type string ?

Et bien c'est assez simple, il faut recupere l'adresse du programme stocke dans la VAT pour cela consulte notre tutoriels sur le sdz tu y arriveras facilement

*De quelle manière lire chaque caractère de cette string en allant vers l'avant de la continuité ?

et bien enfaite tu n'en auras meme pas besoin car du coups tu auras une adresse avec la taille du programme donc tu fait une boucle de la taille du programme et tu lis chacun de ses octets.

Merci beaucoup pour ces réponse Sachiix par contre tu m'en vois navré mais je n'arrive pas à accéder au tutoriel du SDZ.
Et de quelle manière je lis chaque octets ? avec Data( ?

le sdz bug en ce moment... non aucune commande a utiliser tu fais :

FFFF→A

et la en gros tu pourra lire tout les octets avant ou après l'adresse FFFF grace a des crochet

L'adresse FFFF... heu c'est de l'hexa non ?
parce que je vois pas ce que signifie "avant ou après l'adresse FFFF"

bah la mémoire en gros ca ressemble a ca :
[] [] [] [] [] [] [] [] [] [].......

chaque case est représente par une adresse, je simplifie énormément car c'est plus complique en realite, donc je disais que chaque case est une adresse et donc l'adresse FFFF c'est la FFFFeme case en gros.

Donc en gros si je veux le 2ème octet, je dois faire
[2]→A ?
pour la str0 ?
str0[2]->str1 ?

Effectivement, si le but est seulement de copier, on peut le faire octet par octet, sans se préoccuper de ce qu'ils représentent. (pas de soucis de token long ou pas)

Je suis pas axeux alors je peux me tromper facilement, mais les étapes seront plutôt :
- recherche avec inData du nom du programme, afin d'obtenir un pointeur à une bonne adresse : inData(je_sais_plus_quoi)->Pic1
- accéder à l'octet d'indice I : {Pic1+I}
- le stocker là où pointe Pic2 : {Pic1+I}->{Pic2+I}
- contrôler I avec une boucle

EDIT: mon charabia ci-dessus correspond tout-à-fait au message suivant de sachiix69

autre méthode qui complique (j'ai édité pour mettre en spoiler)

Spoiler:

Encore une chose : le token de retour à la ligne risque de poser des problèmes dans les chaines.

Mais vous vous compliquez la vie pour rien :

un programme est dans la VAT donc même si il est archivé tu peut le lire (les donnée ne sont pas dans la vat attention ! ) donc il faut suivre ce schema :
ATTENTION ! la VAT se lit a l'envers !

-récupérer le nom du programme
-le chercher dans la vat
-trouver son adresse et sa taille
-enregistrer l'adresse dans un pointeur ( une variable c'est bien )
pour cela tu fais : adresse→A ou l'adresse n'est pas entre crochet
-et tu lis les donnés octets par octets

voila donc c'est tout c'est assez simple mais certes déroutant.

OK j'ai commencer par faire
GetCalc("prgmBRAINF")->P
Disp P

j'obtiens bien le programme dans le pointeur P
mais là, les + sont des p, les > des fleches montrant le haut,...
Est-ce à cause de la VAT qui se lit à l'envers ?

Je n'ai pas testé mais oui il me semble bien. Lit les octets a l'envers et dit nous. Mais dans tout les cas je crois que ce sont des tokens a lire.

comment je pourrais lire les octets à l"envers ? avec un "-" devant ?

Quand tu pointes un octet avec une variable et un offset (la position de référence), il suffit en effet de soustraire la variable au lieu de l'ajoûter. Ou bien utiliser une variable décrémentée négative.

La VAT (Symbol Table dans le sdk) se lit à l'envers mais pas les variables.
Mais l'essentiel de la gestion des variables se fait avec des romcalls comme ChkFindSym ou CreateStrng.

Alors j'ai testee deux trois truc pour qu'on soit fixer :

-n'utilise pas getcalc ca ne sert absolument a rien et ca cree des confusion, extrait directement le programme ( dont le nom est taper par l'utilisateur ) directement de la vat donc de la memoire de la calculatrice.
-une fois arriver ici tiu auras fait le plus gros et il te resteras juste a lire les octets en faisant :
{adresse trouvee} pour le premiere token; {adresse trouvee -1} pour le deuxieme...

Getcalc ne permet pas de faire ce qu'on veut...

@Sachiix69 merci j'ai bien ri

@Linkakro tout ce que tu dis est vrai (à part qu'il faut une variable pour parcourir la VAT, c'est que des constantes) mais je crois que tu l'embrouilles un peu avec l'ASM, on parle d'Axe là

@Axenntio j'ai fait un interpréteur brainf*ck, donc je peux t'éclairer :

Le principe, c'est que tu as un programme (appelons-le prgmBRAIN) remplis uniquement de 8 caractères équivalents à 8 fonctions :

• > : décaler le pointeur sur l'octet suivant
  
• < : décaler le pointeur sur l'octet précédent
  
• + : incrémenter l'octet pointé
  
• - : décrémenter l'octet pointé
  
• [ : enregistrer le program counter, c'est à dire l'endroit où on se situe dans l'exécution du programme
  
• ] : restaurer le program counter et retourner au [ précédent si l'octet pointé est nul (égal à 0). Note que dans tous les cas il faut enlever le PC de la pile d'enregistrement (selon comment tu gères ça)
  
• . : afficher le contenu de l'octet pointé comme un caractère ASCII
  
• , : attendre un input d'un caractère et le stocker dans l'octet pointé

La plupart de ces commandes s'implémentent pépèrement, tu devrais pas avoir trop de mal. Tu risques quand même d'avoir du mal avec les crochets, donc hésite pas à demander si t'as des problèmes.

Aussi, une routine utile si tu veux demander le nom du programme à interpréter :

Code:

:.ASKPRGM
:
:.Demande un programme à interpréter
:.On choisira le programme depuis le menu [prgm]
:
:Buff(9)→Str1
:Fill(Str1,9,0
:
:ClrHome
:Disp "Open:"
:input→A
:
:If {A-2}r>8                // en fait, input renvoie un pointeur sur un programme temporaire, donc on peut voir sa taille avec {pointeur - 2}r
:Copy(A,Str1,8
:Else
:Copy(A,Str1,{A-2}r)
:End
:
:GetCalc(Str1)→A

Et après l'exécution de ce code, A est un pointeur sur le programme demandé. Si tu as des questions sur comment ça marche (ou des questions tout court ) demande toujours

EDIT : ah oui, petite précision pour sachiix69 : toi tu voulais accéder au programme via la VAT. C'est extrêmement compliqué et totalement inutile puisque c'est exactement ce que fais GetCalc(). Tu lui donnes un nom de programme, il cherche ce nom de programme dans la VAT et te renvoie les octets 4 et 5 de l'entrée, c'est à dire un pointeur sur ses données. C'est n'importe quoi quand tu dis qu'il faut parcourir un programme à l'envers. La VAT est ce qui s'appelle une liste chaînée, c'est une liste qui ne se parcours qu'à l'envers. Depuis quand les programmes tu les parcours à l'envers ?

De retour à @Axenntio, pour parcourir ton programme à la recherche de tes tokens, c'est très simple, voici un peu de pseudocode :

Code:

programCounter = 0

tant_que programCounter < programSize
{
  opcode = prendreOctet(programmeCourant, programCounter)
 
  si opcode == '<'
  {
    ...
  }
  // tester chaque commande ici

  programCounter = programCounter + 1
}

C'est la base de tout parser, interpréteur et compilateur.

EDIT 2 (oui je pense à plein de trucs rahlàlà) : le token "retour de ligne" a pour code hexa $3F. La meilleure solution pour pas être gêné par lui est de le tester comme une commande et si on tombe dessus, de ne rien faire. Comme ça le parser ira naturellement à la commande suivante.

Mais getcalc ne permet pas d'aller a un programme dont le nom a été rentré par l'utilisateur... donc c'est plus pratique pour toi mais moins pratique pour l'utilisateur...