Discussion :

[ternel]

Bonjour � tous.

Je me suis lanc� il y a peu dans la r�alisation d'un programme jouet.

Il s'agit d'un interpr�teur C++ de langages �tranges (dits �sot�riques).
Je m'int�resse aux langages dont les instructions sont cod�es par des caract�res.
Le c�l�bre brainf**k est un exemple, mais il y en a plein d'autres, tel que Path ou LNUSP.

Dans de nombreux cas, le pointeur d'instruction se d�place lin�airement, mais peut tourner sur certaines instructions:

$---\
    |
    |

Partant du $, le code pointeur rebondit sur le slash, comme la lumi�re sur un miroir.

Voici un code source possible (quoi qu'inutile...)

$  !/     !\   #
    ,      .
    \ ++++ /

Pour ex�cuter le script, je cr�e une matrice de caract�res, et je la parcoure.

Le probl�me, c'est qu'en g�n�ral, la densit� du code est tr�s basse, et qu'il ne sert pas � rien de stoquer les instructions vides

J'ai pens� � cr�er un graphe d'instructions.

Le probl�me est devenu subitement beaucoup plus complexe quand j'ai d�cid� de rendre l'interpr�teur g�n�rique en cr�ant des fichiers de langages. (voir la pi�ce jointe)

Certains languages ont une grille � une dimension, d'autres � 3 ou 4.
Certains ont des op�rateurs de rotation � 45 degr�s.

$---q
     \
      \

D'autres proposent des "pas de cot�s", qui d�placent le pointeur d'une case sur le c�t�, sans changer son d�placement.

$---v
    ----

J'ai essay� d'adapter mon graphe, mais je ne vois pas comment permettre tout cela.

En gros, j'ai besoin d'un it�rateur ayant pour fonctionnalit� un vecteur de d�placement, une position, le "case suivante" et le "avance jusqu'a la prochaine instruction"

Le tout dans une classe que j'imagine �tre templat�e par le nombre de dimension de la grille.

Quelqu'un a-t'il une proposition?

Voici mon (nouveau) d�but de code.

Code grid.hpp :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
template<typename VALUE, int DIMENSION>
class grid{
public:
	typedef std::array<int, DIMENSION> position_type;
	typedef VALUE value_type;
 
private:
	class Slot{
		typedef std::array<int, DIMENSION> position_type;
		position_type position;
	public:
		Slot(const position_type& place):position(place){}
		bool operator<(const Slot& other){
			for(int i=0;i!=DIMENSION;++i){
				if(position[i]!=other.position[i]) return position[i]<other.position[i];
			}
			return false;
		}
	};
 
	typedef std::map<Slot, VALUE> inner_type;
	inner_type cells;
 
public:
	grid();
	bool put(const position_type& slot, const value_type& value){
		return false;
	}
};

PS: voici deux sites pour les curieux sur les langages:
le magique 99 bottles of beer qui propose de nombreuses versions de l'affichage d'une comptine.
liste sur esolangs.org qui liste des langages souvent plus d�lirants les uns que les autres.

[Obsidian]

Hello,

Le probl�me, c'est qu'en g�n�ral, la densit� du code est tr�s basse, et qu'il ne sert pas � rien de stoquer les instructions vides

Si tu veux rentabiliser tes matrices creuses, je te conseille le whitespace. :-)

Le probl�me est devenu subitement beaucoup plus complexe quand j'ai d�cid� de rendre l'interpr�teur g�n�rique en cr�ant des fichiers de langages. (voir la pi�ce jointe)

Bon, je ne sais pas quel degr� de s�rieux apporter � ta requ�te mais dans tous les cas, il faut que tu fasses les choses dans l'ordre, l'une apr�s l'autre. Jette d�j� un �il, si ce n'est d�j� fait, � la th�orie des langages pour voir comment �crire des parsers et des compilateurs g�n�riques. M�me avec les langages classiques � une seule dimension, il y a d�j� de quoi faire et c'est quelque chose qui est tr�s utilis� en informatique.

Ensuite, je ne vois pas beaucoup l'int�r�t d'ajouter des dimensions au code comme tu le fait, pour deux raisons principales :

• Il s'agit toujours, dans les faits, de passer d'une instruction � une autre, et pas d'ex�cuter deux fils en parall�le. �a revient donc � faire des gotos d�guis�s, ce qui est mis en �vidence par ton graphe ;
• Une grille a plusieurs dimensions va forc�ment �tre creuse pour la bonne raison qu'il serait extr�mement long de la remplir. Avec trois dimensions, il faut n� fois le temps qu'il te faudrait pour en remplir une seule, soit par exemple un milliard d'instructions l� o� tu en aurais mis seulement mille ailleurs.

Par contre, je te conseille �galement de te pencher sur les automates � pile si ce n'est pas d�j� fait �galement : il s'agit d'un automate d'�tats fini ordinaire mais dont le diagramme des transitions d�pend de l'�l�ment au sommet d'une pile que tu remplis ou vide au fur et � mesure que tu parcours cet automate. �a ressemble donc � un � automate � �tages � et c'est assez proche des notions qui semblent flatter tes sens.

[ternel]

J'ai d�j� quelques connaissances en th�orie des langages, mes cours ne sont pas trop loin... Je vais r�fl�chir aux automates � piles, je n'y avais pas pens�.

Le probl�me auquel je me confronte est un d�fi personnel plus qu'autre chose.

La r�alisation de l'interpr�teur en tant que tel n'est pas un probl�me majeur. Il s'agit d'avoir deux it�rateurs bien fichus (pointeur d'instruction et pointeur m�moire) et une liste d'op�rateur, puis de r�p�ter "ip.suivant(); ip.eval(m�moire);" jusqu'� terminaison du programme

Le parseur est plus complexe dans mon cas, puisque j'ai des discriminations importantes selon les langages.

D'o� l'id�e d'une classe de langage pour param�trer le parseur cr��.

J'obtiendrais ainsi les classes suivantes:

• m�moire
• m�moire::iterateur
• langage
• operateur
• des impl�mentations d'operateurs (plus ou moins parametrables)
• programme
• programme<?>
• programme<?>::iterateur

Parmi les subtilit�s apparaissant avec les grilles d'instructions (comme dans PATH), il y a les possibilit�s de parcourir des s�quences d'instructions dans les deux sens ou de voir plusieurs s�quences partagent une ou plusieurs instructions.
exemple de partage

1  \/\/\/|
2  aaaaaa\
3  bbbbbb/
   \/\/\/

en entrant en 1 vers la droite, on a la s�quence abba abba abba abba abba abba, en ressortant en 1 vers la gauche
tandis qu'en commencant en 2 vers la droite on r�alise aaaaaa bbbbbb en sortant en 3 vers la gauche.


Cela dit, une grille creuse peut aussi servir dans d'autres contexte, tel que des jeux de plateaux.