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.