Pr�processeur Ruby pour C++

Bonjour,

Actuellement je fait un pr�processeur C++ en Ruby.
L'int�ret ? C'est beaucoup plus simple et pratique � utiliser que le pr�processeur C++ normal, et puis Ruby est vraiment un langage tr�s agr�able pour faire des DSL. Si vous avez le temps, ce serait sympa de le tester et de me dire ce que vous en pensez, des fonctionnalit�s que vous aimeriez avoir, etc...
Ci dessous, quelques exemples pour illustrer l'int�ret de la b�te.

Quelques notes pr�liminaires :
Vous pouvez ins�rer du code Ruby � n'importe quel endroit du fichier avec les conventions suivantes :
<% code %> : Le code Ruby est interpr�t�.
<%= code %> : Le code Ruby est interpr�t� et son r�sultat est ins�r� en place.
% code : Si le premier caract�re de la ligne est %, toute la ligne sera interpr�t�e en Ruby.

Si vous avez un r�pertoire rppconf � la racine de votre projet, vous pouvez y ins�rer des fichiers en langage YAML (un langage simplissime et esth�tique pour s�rialiser des donn�es). Les donn�es du fichier seront ensuite accessibles n'importe o� dans votre source dans la variable <nom du fichier yaml>.!

Si vous avez un fichier rpphelpers.rb � la racine de votre projet, vous pouvez aussi y ins�rer des helpers (fonctions pratiques) qui vous permettent de garder un code Ruby propre et clair dans vos sources.

En Ruby, on dispose de "symboles", ce sont grossi�rement l'�quivalent de chaines de caract�res constantes. Un symbole se pr�fixe par deux points ":". Par rapport � des chaines de caract�res, l'int�ret c'est que les symboles sont des singletons.

Exemple 1:
Cr�er un fichier nomm� "project.yaml" dans le r�pertoire "rppconf", et mettre ceci dedans :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

--- :name: Ruby pre-processor example   :authors: - NewbiZ   :languages: - C++ - Ruby   :website: http://www.speednova.cc   :usage: Available arguments are listed below   :arguments: - :char: h :text: Display RCPP's help. - :char: v :text: Display RCPP's version number. - :char: d :text: Deprecated argument.   :version: 1.2

---

YAML est un langage qui fonctionne principalement sur le principe clef : valeur. Dans cet exemple nos clefs sont des symboles. On peut cr�er des listes en les pr�fixant par "-".
On dispose donc maintenant d'une variable "project" accessible partout dans nos sources, et contenant ces valeurs.

Cr�ons donc un fichier example1.rpp (notez l'extension) pour tester :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

%# Helper function displaying text while generating files (see rpphelpers.rb) % echo "Pre-processing \"example1.cpp\""   #include <cstdlib> #include <iostream>   int main (int argc, char const* argv[]) { std::cout << "This is " << "<%= project[:name] %>" << " version " << "<%= project[:version] %>" << " build date: " << "<%= Time.now.to_s %>" << std::endl << std::endl;   std::cout << "Visit us at " << "<%= project[:website] %>" << std::endl << std::endl;   std::cout << "<%= project[:usage] %>" << std::endl;   % project[:arguments].each do |argument| std::cout << "<%= argument[:char] %>" << " : " << "<%= argument[:text] %>" << std::endl; % end   return 0; }

---

Apr�s avoir execut� ./rppgen.rb, vous obtiendrez le fichier example1.cpp suivant :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

#include <cstdlib> #include <iostream>   int main (int argc, char const* argv[]) { std::cout << "This is " << "Ruby pre-processor example" << " version " << "1.2" << " build date: " << "Thu May 08 20:17:38 +0200 2008" << std::endl << std::endl;   std::cout << "Visit us at " << "http://www.speednova.cc" << std::endl << std::endl;   std::cout << "Available arguments are listed below" << std::endl;   std::cout << "h" << " : " << "Display RCPP's help." << std::endl; std::cout << "v" << " : " << "Display RCPP's version number." << std::endl; std::cout << "d" << " : " << "Deprecated argument." << std::endl;   return 0; }

---

Exemple 2:
Imaginez que vous vouliez cr�er un tableau contenant toutes les lettres de l'alphabet. C'est assez simple dynamiquement, mais statiquement c'est un cauchemard avec le pr�processeur C++. Voici ce que cel� donne avec RPP :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

// The old static way char alpha1[] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'}; // The RPP inline way char alpha2[] = {'<% $src << ('a'..'z').to_a.join("','") %>'}; // The RPP way using an helper function (see rpphelpers.rb) char alpha4[] = <%= c_array ('a'..'z') %>;   // The dynamic way for (int i=0; i<26; i++) std::cout << "letter " << lcase1[i] << std::endl;   // The RPP way % ('a'..'z').each do |c| std::cout << "letter " << '<%= c %>' << std::endl; % end

---

On profite des facilit�s des "range" de Ruby pour g�n�rer le tableau.

Vous obtenez exemple2.cpp :

Code:

---

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 31 32 33 34 35 36 37 38 39

// The old static way char alpha1[] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'}; // The RPP inline way char alpha2[] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'}; // The RPP way using an helper function (see rpphelpers.rb) char alpha4[] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};   // The dynamic way for (int i=0; i<26; i++) std::cout << "letter " << lcase1[i] << std::endl;   // The RPP way std::cout << "letter " << 'a' << std::endl; std::cout << "letter " << 'b' << std::endl; std::cout << "letter " << 'c' << std::endl; std::cout << "letter " << 'd' << std::endl; std::cout << "letter " << 'e' << std::endl; std::cout << "letter " << 'f' << std::endl; std::cout << "letter " << 'g' << std::endl; std::cout << "letter " << 'h' << std::endl; std::cout << "letter " << 'i' << std::endl; std::cout << "letter " << 'j' << std::endl; std::cout << "letter " << 'k' << std::endl; std::cout << "letter " << 'l' << std::endl; std::cout << "letter " << 'm' << std::endl; std::cout << "letter " << 'n' << std::endl; std::cout << "letter " << 'o' << std::endl; std::cout << "letter " << 'p' << std::endl; std::cout << "letter " << 'q' << std::endl; std::cout << "letter " << 'r' << std::endl; std::cout << "letter " << 's' << std::endl; std::cout << "letter " << 't' << std::endl; std::cout << "letter " << 'u' << std::endl; std::cout << "letter " << 'v' << std::endl; std::cout << "letter " << 'w' << std::endl; std::cout << "letter " << 'x' << std::endl; std::cout << "letter " << 'y' << std::endl; std::cout << "letter " << 'z' << std::endl;

---

Exemple 3:
Il arrive souvent qu'ait des classes � cr�er et qu'on se retrouve � retaper le m�me code pour les accesseurs, les classes � h�riter, etc... Voici un exemple de ce que cel� donne avec RPP :

Code:

---

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

class Displayable { std::string toString() const = 0; };   class Starship { private: % declare_fields :serialNumber => :int, :name => :string, :leftEngine => :Engine, :rightEngine => :Engine   public: % encapsulate :serialNumber => :int, :name => :string % getters :leftEngine => :Engine, :rightEngine => :Engine };   % classdef(:Warship, % :implements => [ :Starship, :Displayable ], % :fields => { :ammo => :int, :turret => :Weapon, :target => :Position }) {   public: string toString() const { std::cout << "ammo =" << get_ammo() << std::endl; std::cout << "turret=" << get_turret() << std::endl; std::cout << "target=" << get_target() << std::endl; }   % }

---

Ici on a cr�� (en quelques secondes) des helpers pour clarifier notre code.
"declare_fields" prend en param�tre une suite de noms d'attributs, suivis de leur type, et g�n�re leur d�claration.
"getters" g�n�re des fonctions de la forme get_<nom attribut> et
"setters" g�n�re des fonctions de la forme set_<nom_attribut>.
"encapsulate" g�n�re les getters et les setters en une seule fois.
On a d�j� �conomis� par mal de recopiage!

Pour encore plus de rapidit�, le dernier exemple est radical, le helper "classdef" prend en param�tre le nom de la classe, les noms des classes � impl�menter, et les attributs avec leurs types, et g�n�re directement la classe avec les getters et setters appropri�s. Comme on le voit dans l'exemple, vous pouvez tout de m�me rajouter ce que vous voulez dans le corps de la d�claration de la classe.

Voici ce que RPP a g�n�r� dans exemple3.cpp :

Code:

---

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 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95

class Displayable { std::string toString() const = 0; };   class Starship { private: Engine rightEngine; string name; int serialNumber; Engine leftEngine;   public:   void set_name( const string& value ) { name = value; }   void set_serialNumber( const int& value ) { serialNumber = value; }   const string& get_name() const { return name; }   const int& get_serialNumber() const { return serialNumber; }   const Engine& get_rightEngine() const { return rightEngine; }   const Engine& get_leftEngine() const { return leftEngine; } };   class Warship : public Starship, public Displayable { public: void set_turret( const Weapon& value ) { turret = value; }   void set_target( const Position& value ) { target = value; }   void set_ammo( const int& value ) { ammo = value; }   const Weapon& get_turret() const { return turret; }   const Position& get_target() const { return target; }   const int& get_ammo() const { return ammo; }   private: Weapon turret; Position target; int ammo;   public: string toString() const { std::cout << "ammo =" << get_ammo() << std::endl; std::cout << "turret=" << get_turret() << std::endl; std::cout << "target=" << get_target() << std::endl; }   };

---

On pourrait aussi imaginer g�n�rer une batterie de constructeurs avec classdef, ce serait tr�s rapide � faire.

Voil� pour la petite pr�sentation, si vous voulez tester, voici un package comprenant RPP (Ruby PreProcessor) + les codes des exemples + les helpers des exemples + le fichier YAML des exemples.

J'esp�re que certains trouveront ca utile :) Dans tous les cas n'h�sitez pas � poster vos avis, demandes, ...

Salut,

Je me dis que ce pourrait sans doute �tre int�ressant pour R�d qui cherchait justement comment faire pour afficher des informations � la compilation...

Je transmet l'adresse de cette discussion ;)

Un petit ajout pour montrer encore l'int�ret de la chose (issu d'une discussion avec Thelvyn).
Le but est d'obtenir une fonctionnalit� �quivalente � un is_base_of<Base,Derived> de boost. Voici ce que cel� donnerait avec RPP:

Dans rpphelpers.rb, rajouter la ligne suivante au d�but de la fonction "defclass" :

Code:

---

$classes[name] = options

---

Ainsi que la ligne suivante au d�but du fichier :

Code:

---

$classes = {}

---

Maintenant, � chaque fois que nous d�clarons une classe, celle-ci sera stock�e dans une variable globale $classes, avec ses m�tadonn�es, et sera accessible de partout!
Il ne reste donc plus qu'� rajouter les fonctions :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

def dump(name) # Existing class ? return if !$classes[name] # Recursive call for parents classes $classes[name][:implements].each { |c| dump c } if $classes[name][:implements] # Iterating through fields if $classes[name][:fields] then $classes[name][:fields].each_pair do |field_name,field_type| $src << %{std:cout << "#{name}.#{field_name} (#{field_type}) = " << #{field_name} << std::endl;\n} end end end   def is_base_of?(base, derived) $classes[derived][:implements].include?(base) or base==derived end

---

L'int�ret de la fonction "dump" est assez simple � comprendre, et profite du fait que l'on puisse dor�navant acc�der aux m�tadonn�es des classes (attributs, classes parentes...). Elle affiche le contenu de tous les champs (h�rit�s ou non) de la classe.

Faisons un petit essai de tout cel� :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

% classdef(:Warship, % :fields => { :ammo => :int, :turret => :Weapon, :target => :Position }) { // ... % }   % classdef(:Battleship, % :implements => [ :Warship ], % :fields => { :marines => :int, :firebats => :int, :medics => :int }) {   public: string toString() const { <% dump :Battleship %> std::cout << "Battleship inherits from Warship ?" << <%= is_base_of?(:Warship,:Battleship) %> << std::endl; }   % }

---

Et on obtient :

Code:

---

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 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93

class Warship { public: void set_turret( const Weapon& value ) { turret = value; }   void set_target( const Position& value ) { target = value; }   void set_ammo( const int& value ) { ammo = value; }   const Weapon& get_turret() const { return turret; }   const Position& get_target() const { return target; }   const int& get_ammo() const { return ammo; }   private: Weapon turret; Position target; int ammo; // ... };   class Battleship : public Warship { public: void set_firebats( const int& value ) { firebats = value; }   void set_medics( const int& value ) { medics = value; }   void set_marines( const int& value ) { marines = value; }   const int& get_firebats() const { return firebats; }   const int& get_medics() const { return medics; }   const int& get_marines() const { return marines; }   private: int firebats; int medics; int marines;   public: string toString() const { std:cout << "Warship.turret (Weapon) = " << turret << std::endl; std:cout << "Warship.target (Position) = " << target << std::endl; std:cout << "Warship.ammo (int) = " << ammo << std::endl; std:cout << "Battleship.firebats (int) = " << firebats << std::endl; std:cout << "Battleship.medics (int) = " << medics << std::endl; std:cout << "Battleship.marines (int) = " << marines << std::endl;   std::cout << "Battleship inherits from Warship ?" << true << std::endl; }   };

---

N'est-ce pas un peu de la triche ? Tu sais qu'une classe d�rive d'une autre uniquement parce que les deux classes ont �t� d�clar�es par un m�canisme sp�cifique et non standard. Si je voulais faire la m�me chose en C++, je ferais des macros qui enregistrent des cha�nes dans une map et utiliserais ces noms comme noms de classes.

Mais �a ne servirait � rien, car une des contraintes du C++ est de pouvoir mixer du code �crit par des personnes diff�rentes. Donc supposer qu'on peut/veut modifier le code de d�claration des deux classes est un peu irr�aliste.

Comment faire dans ton cas pour avoir un :

is_base_of?(:std::iostream,:std::ofstream)


Dit autrement, un pr�-processeur �crit dans un langage riche peut pr�senter de l'int�r�t pour moi, mais uniquement � condition qu'il soit non intrusif, et ne demande pas de modifier du code existant pour fournir des r�sultats corrects. Est-ce le cas de ce que tu proposes ?

Effectivement, c'est <le> gros probl�me du syst�me, et pour l'instant... je ne suis pas arriv� � des r�ponses r�ellement satisfaisantes.

Une solution serait de fournir un m�canisme simple de d�claration de classe (sans g�n�ration de code) au pr�processeur, pour qu'il connaisse les classes d�clar�es en pur C++. Quelquechose du type :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

class Foo { int n; }; // ... % classdecl :Foo, :fields => [ :n => :int ] % classdef :Bar, :implements => [ :Foo ] { // ... % }

---

Cette m�thode pourrait �tre coupl�e avec une batterie de d�finitions fournies de base pour la STL. (pour r�soudre ton exemple).

Alors bien sur, ce n'est pas parfaitement satisfaisant. Il semblerait que pour le moment la meilleure solution pour utiliser RPP, ce serait de l'utiliser � fond, et de mani�re exclusive. (comprendre, un projet avec peu de librairies non standards)

L'autre solution, ce serait d'int�grer � RPP une FSM basique de reconnaissance de la grammaire du C++, pour en extraire les d�finitions de classes.
C'est pas un travail �norme, et ca reste dans l'ordre du r�alisable. (Il existe de bons outils de g�n�ration de FSM en Ruby, et la grammaire du C++ est bien connue et document�e).

Derni�re solution, de loin la meilleure, mais aussi la plus couteuse en temps de d�veloppement :
Ruby est un langage <entre autres> sp�cialis� dans la cr�ation de DSL, notamment grace � d'�norme capacit�s de m�taprogrammation. On trouve par exemple de nombreuses impl�mentations de prolog sous forme de DSL en Ruby. Il pourrait �tre int�ressant d'�tudier la possibilit� d'en faire de m�me pour un sous-ensemble de C++: l'aspect purement d�claratif.

Toutes suggestions sont les bienvenues :)