Commenter automatiquement une ligne en fonction d'une variable préprocesseur

Version imprimable

08/03/2007, 16h47
Rodrigue

Commenter automatiquement une ligne en fonction d'une variable préprocesseur
Bonjour,

A votre avis, est-il possible de commenter automatiquement une ligne du style:

Code:

Log(DEBUG) << ...

en fonction d'une variable préprocesseur:
Code:

1 2 3 #ifndef _DEBUG #define Log(DEBUG) // #endif
Bien sûr ici ça ne fonctionnera pas car // va être interpréter par le compilateur comme un début de commentaire... Vous voyez ce que je veux faire?

Un grand merci d'avance!

Tout depend de ce que fais ta ligne a commenté, mais pour ce genre de choses, une macro me semble bien adaptée

Par exemple une macro qui fait un printf :
Code:

1 2 3 4 5 6 #ifdef DEBUG_FLAG #define DEBUGOUTPUT(A) printf("%d",A); //definition de la macro DEBUG OUTPUT #else #define DEBUGOUTPUT(A) //on remplace les DEBUGOUTPUT par...du vide ! #endif

08/03/2007, 20h35
Rodrigue

Salut Ksempac,

Le problème c'est que dans le define, le // va être interprêté par le compilateur comme un compilateur donc va être éliminé...
08/03/2007, 20h49
Ksempac
Le // n'est la que pour commenter ce que j'ai ecrit. Le code sans commentaires est :
Code:

1 2 3 4 5 6 #ifdef DEBUG_FLAG #define DEBUGOUTPUT(A) printf("%d",A); #else #define DEBUGOUTPUT(A) #endif
;)
08/03/2007, 21h46
nikko34
deux avis:

- les macros c'est le mal, au pire fait un
Code:

1 2 3 4 5 6 7 #define DEBUG //... #ifdef DEBUG //code de debug #endif
si vraiment tu tiens à le définir à la compilation...

- pour un code professionel:

le débug, ça peut être important, quand ce sera en production tu en auras peut être besoin sans pouvoir tout recompiler. Dans ce cas là il vaut mieux pouvoir le définir à l'éxécution ( dans la ligne de commande par exemple, ou fichier de configuration ou autre...)
08/03/2007, 22h25
Ksempac
C'est vrai que les macros c'est dangereux. Mais je pense que la premiere solution que tu proposes n'est pas vraiment adaptée : Si la ligne qu'il veut supprimer apparait regulierement dans son code (ce qui semble etre le cas car on dirait un systeme de traces/log) il faut ecrire partout des :
Code:

1 2 3 4 #ifdef DEBUG // code de debug #endif
Ceci est assez lourd.

Avec la Macro tu n'as pas ce probleme. L'important est de bien nommé la Macro pour que le fait que c'est une macro saute aux yeux de suite et qu'il n'y ait pas de confusion (typiquement avec un nom en majuscules du genre DEBUGMONFICHIER(A)).

En ce qui concerne la définition "à la volée" durant l'exécution, c'est sur que c'est une très bonne idée, mais il faut voir si ca correspond a ces besoins.
08/03/2007, 23h49
nikko34

si son debug doit apparaître de nombreuses fois dans le code, de manière permanente, ce devrait être la fonction de log qui décide si elle doit afficher ou pas le message, et non un choix à la compilation.

Je ne sais pas si c'est très clair ce que je dis :)

Comme on est sur le forum C++, on va dire non aux macros :P Ce serait sur le forum C...
09/03/2007, 02h23
nicroman
Dans l'absolu je suis d'accord avec nikko... si c'est pour logger des informations, alors le code devrait resembler à ça:
Code:

1 2 3 if (log.isDebugEnabled()) log.debug(.....);
Si c'est pour executer des choses différentes... alors oui, le define est la seule solution...

Sous Visual par exemple:
Code:

1 2 3 4 5 6 #ifdef _DEBUG #define DEBUG_ONLY(...) __VA__ARGS__ #else #define DEBUG_ONLY(...) #endif
Tout ce qui sera dedans sera utilisé tel quel quand _DEBUG est défini, et n'existera pas sinon.

Mais attention... avoir un code différent entre debug et release ne veut dire qu'une chose: tu auras des bugs qui n'apparaitront qu'en mode release ! :D
09/03/2007, 11h21
Médinoc
Citation:

Envoyé par Rodrigue

Salut Ksempac,

Le problème c'est que dans le define, le // va être interprêté par le compilateur comme un compilateur donc va être éliminé...

Encore que, je suis tombé sur un drôle de hack dans Visual, pas plus tard qu'hier:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #if UNEMACRO #define UNEAUTREMACRO /##/ #else #define UNEAUTREMACRO #endif //... { //... UNEAUTREMACRO UneInstruction(); //... } //...
Je me demande si gcc accepte un truc du genre, mais puisqu'il existe une option "keep comments" dans le préprocesseur de gcc, il y a fort à penser que ça marche aussi...

Edit: Sous Visual, pas moyen de le faire marcher avec des commentaires C : J'ai beau tenter diverses combinaisons, la macro de fin n'est jamais remplacée...

Edit2: Réussi!
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #if UNEMACRO #define MACROA /##* #define MACROB #else #define MACROA #define MACROB /##* #endif void TestMacro(void) { puts("A"); MACROA puts("B"); MACROB */ puts("C"); }
Je teste sous GCC à présent...

Edit3: Échec sous gcc:

Citation:

Envoyé par cpp, gcc version 3.4.6 20060404 (Red Hat 3.4.6-3)

pasting "/" and "/" does not give a valid preprocessing token

Et on se retrouve avec un espace entre les deux caractères, que ce soit pour les commentaires C++ ou les commentaires C...
09/03/2007, 19h46
Rodrigue

Magnifique Médinoc! Je viens d'essayer sur un exemple simple et le coup du /##/ (qu'au passage je connaissais pas et dont je ne trouve aucune documentation à ce sujet) a l'air de fonctionner parfaitement :)

Lundi, j'essaye ça au bureau. Merci à tous!
09/03/2007, 20h14
Médinoc

Enfin, comme l'ont montré mes tests, c'est totalement non-portable (à moins que gcc 4 accepte ce hack) et à mon avis, non-standard...

Concernant les log, j'ai écrit une classe similaire avec des macros faisant ce que tu veux il me semble (enfin il est ard ... donc j'ai peut-etre compris de travers) En tout cas si ca peut t'aider, voici mon fichier :

.hpp

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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
#ifndef LOGGER_HPP
#define LOGGER_HPP 
 
    // Output Type (Flags)
    #define LOG_FILE      0x00000001
    #define LOG_SCREEN    0x00000002
    #define LOG_CONSOLE   0x00000004
    #define LOG_ALL       LOG_FILE | LOG_SCREEN | LOG_CONSOLE
 
    // Msg Type (1 = Log / 0 = Don't)
    #define LOG_OK 1
    #define LOG_WARNING 1
    #define LOG_ERROR 1 
    #define LOG_MISC 1
 
    // 0 -> __FUNCTION__ macro supported ; 1 -> Define your own macro .
    #if 0
        #define __FUNCTION__ "__FUNCION__ isn't available"
    #endif
 
    // The actual logging macro.
    #define Log(flag,type) Logger<type == 1>(#type,flag,__FILE__,__FUNCTION__,__LINE__)
 
    #include <sstream>
    #include <iostream>
    #include <fstream>
	#include <boost/algorithm/string/replace.hpp>
 
    // Template, general declaration
    template<bool DoLog> class Logger;
 
    // Template version, if we actually want to log something .
    template<> class Logger<true>
    {
        public :
 
			Logger(const char * Type,unsigned const char Flag,const char * File,const char * Function,unsigned int Line)
			: m_Type(Type)       ,
			m_Flag(Flag)         ,
			m_File(File)         ,
			m_Function(Function) ,
			m_Line(Line)         {}
 
			~Logger()
			{
				if ( m_Flag & LOG_FILE )
				{
					boost::algorithm::replace_all(m_Function,"<","&lt;");
					boost::algorithm::replace_all(m_Function,">;","&gt");
 
					m_FileStream << "<EventLog>" << "\n" ; 
					m_FileStream << "<Type>" << m_Type << "</Type>" << "\n" ;
					m_FileStream << "<File>" << m_File << "</File>" << "\n" ;
					m_FileStream << "<Line>" << m_Line << "</Line>" << "\n" ;
					m_FileStream << "<Function>" << m_Function << "</Function>" << "\n" ; 
					m_FileStream << "<Msg>"  << m_Msg.str()  << "</Msg>" << "\n" ;
					m_FileStream << "</EventLog>" << "\n" << "\n" << std::flush ;
				}
				if ( m_Flag & LOG_SCREEN ) 
				{ /* TODO */ }
				if ( m_Flag & LOG_CONSOLE )
				{ /* TODO */ } 
			}
 
			static void Init()
			{ 
				m_FileStream << "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>" << "\n" ;
				m_FileStream << "<?xml-stylesheet type=\"text/xsl\" href=\"Log.txt\" ?>" << "\n" ;
				m_FileStream << "<RuntimeLog>" << "\n" << "\n" ;
				m_FileStream << "<LogHeader>" << "\n" ;
				/* TODO : Find what i need in the LogHeader . */
				m_FileStream << "</LogHeader>" << "\n" << "\n" << std::flush ;
			}
 
			static void Close()
			{ 
				m_FileStream << "</RuntimeLog>" << std::flush ;
				m_FileStream.close();
			}
 
			template<typename T> Logger & operator << (T const & Msg) { m_Msg << Msg; return * this; }
 
        private:
 
			std::stringstream m_Msg;
 
			unsigned const char m_Flag ;
 
			const char * m_File ;
 
			const int m_Line ;
 
			const char * m_Type ;
 
			std::string m_Function ;
 
			static std::ofstream m_FileStream ;
    };
 
    // Template version, if we do NOT want to log .
    template<> class Logger<false>
    {
        public :
 
			Logger(const char * Type,unsigned const char Flag,const char * File,const char * Function,unsigned int Line){}
 
			template<typename T> Logger & operator << (T const & Msg) { return * this; }
 
    };
 
#endif

.cpp

Code:

1
2
3
4
5
 
#include <Tools/Logger.hpp>
 
// Static menber initialisation .
std::ofstream Logger<true>::m_FileStream("Log/Log.xml") ;

Sinon j'en parle dans un de mes anciens post sur ce forum, si tu ne le trouve pas, je le rechererai , bonne chance.