Problème de compilation avec bibliothèque personelle

Bonsoir,
j'ai entrepris la création d'une petite bibliothèque personnelle contenant actuellement deux fonctions et une classe.

Voici mes fichiers :

t_lib.h :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
// Bibliothèque personelle. Contient différentes classes et fonctions
// utiles.
 
#ifndef _T_LIB_
#define _T_LIB_
 
#include <iostream>
#include <sstream>
#include <fstream>
#include <list>
 
#include "t_functions.h"
#include "t_file.h"
 
#endif

t_file.h :

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
 
#ifndef _T_FILE_
#define _T_FILE_
 
class t_file {
   std::list<char>            m_l_content;
   std::list<char>::iterator  m_icursor;
   std::list<char>::iterator  m_ocursor;
   std::string                m_s_path_file;
public:
   // Constructeurs
   t_file();
   t_file(std::string path_file);
 
   // Destructeur
   ~t_file();
 
   // Accesseurs
   std::string get_path_file() const { return m_s_path_file; }
 
   // Mutateurs
   void  set_path_file(std::string s_path_file) {
      m_s_path_file = s_path_file;
   }
 
   // Méthodes
   bool load();
   bool write();
   void view();
   // Action(s) en lecture
   bool is_bloc(std::string name);
   bool is_value(std::string bloc, std::string value);
   std::string get_value(std::string bloc_name, std::string value_name);
   std::string* get_avalue(std::string bloc_name, std::string value_name);
   // Action(s) en écriture
   bool set_bloc(std::string bloc);
   bool update_bloc(std::string abloc, std::string nbloc);
   bool remove_bloc(std::string bloc);
   bool set_value(std::string bloc, std::string value, std::string vvalue);
   bool remove_value(std::string bloc, std::string value);
   bool update_value(std::string bloc, std::string value, std::string vvalue);
};
 
#endif

t_file.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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
 
// Classe t_file :
// Gestion de fichiers standardisés
 
#include <iostream>
#include <fstream>
#include <list>
#include "t_file.h"
 
 
// Constructeur(s)
t_file::t_file() {
   m_s_path_file.clear();
   m_icursor = m_ocursor = m_l_content.begin();
}
 
t_file::t_file(std::string path_file) {
   m_s_path_file = path_file;
   m_icursor = m_ocursor = m_l_content.begin();
}
 
 
// Destructeur
t_file::~t_file() {
   write();
   m_l_content.clear();
}
 
// Charge le fichier dans une liste de char
bool t_file::load() {
   char carac;
   std::ifstream file;
   file.open(m_s_path_file.c_str(), std::ios::in);
 
   if(!file.is_open()) {
      return false;
   }
 
   while(file.get(carac)) {
      m_l_content.push_back(carac);
   }
 
   file.close();
 
   return true;
}
 
// Affiche le contenu du fichier
void t_file::view() {
   std::cout << "\n" << m_s_path_file << "\n======" << std::endl;
   m_icursor = m_l_content.begin();
   while(m_icursor != m_l_content.end()) {
      std::cout << *m_icursor;
      m_icursor++;
   }
   std::cout << "\n======" << std::endl;
}
 
// Ecrit la liste de char dans le fichier
bool t_file::write() {
   std::ofstream file;
   file.open(m_s_path_file.c_str(), std::ios::out | std::ios::trunc);
 
   if(!file.is_open()) {
      return false;
   }
 
   m_ocursor = m_l_content.begin();
   while(m_ocursor != m_l_content.end()) {
      file.put(*m_ocursor);
      m_ocursor++;
   }
 
   file.close();
 
   return true;
}
 
// Vérifie l'existence du bloc spécifié
bool t_file::is_bloc(std::string name) {
   std::string s_string;
 
   m_icursor = m_l_content.begin();
   while(m_icursor != m_l_content.end()) {
      // On récupère le nom du bloc
      if(*m_icursor == '[') {
         s_string.clear();
         while(*m_icursor != ']') {
            if(*m_icursor != '[') {
               s_string += *m_icursor;
            }
            m_icursor++;
         }
         m_icursor++;
      }
      // On compare ce nom au nom spécifié par l'utilisateur
      if(s_string.compare(name) == 0) {
         return true;
      }
      m_icursor++;
   }
 
   return false;
}
 
// Vérifie l'existence de la valeur spécifiée dans le bloc spécifié
bool t_file::is_value(std::string bloc, std::string value) {
   std::string s_string;
   s_string.clear();
 
   if(!is_bloc(bloc)) {
      return false;
   }
 
   // On regarde dans le bloc jusqu'à voir la fin du fichier ou le début 
   // d'un nouveau bloc
   while(m_icursor != m_l_content.end() && *m_icursor != '[') {
      // Tant qu'on regarde le nom de la valeur, on la récupère
      if(*m_icursor != '\n' && *m_icursor != '=') {
         s_string += *m_icursor;
      }
      // On compare ensuite la valeur trouvée à celle spécifiée
      if(s_string.compare(value) == 0) {
         return true;
      }
      // On saute la ligne
      if(*m_icursor == '=') {
         s_string.clear();
         while(*m_icursor != ';') {
            m_icursor++;
         }
      }
      m_icursor++;
   }
 
   return false;
}
 
// Récupère la valeur de la valeur spcifiée dans le bloc spécifié
std::string t_file::get_value(std::string bloc_name, std::string value_name) {
   std::string s_string;
   s_string.clear();
 
   if(!is_value(bloc_name, value_name)) {
      return s_string;
   }
 
   while(*m_icursor != '=') {
      m_icursor++;
   }
 
   while(*m_icursor != ';' && *m_icursor != '\n' 
         && m_icursor != m_l_content.end()) {
      if(*m_icursor != '=') {
         s_string += *m_icursor;
      }
      m_icursor++;
   }
 
   return s_string;
}
 
// Récupère un tableau de str de la valeur du bloc spécifié
std::string* t_file::get_avalue(std::string bloc_name, std::string value_name){
   int nb_value = 0;
   std::list<char>::iterator cursor;
   int i = 0;
   std::string *a_s_string;
 
   if(!is_value(bloc_name, value_name)) {
      return NULL;
   }
 
   while(*m_icursor != '=') {
      m_icursor++;
   }
 
   m_icursor++;
   cursor = m_icursor;
 
   while(*m_icursor != ';' && *m_icursor != '\n' 
         && m_icursor != m_l_content.end()) {
      if(*m_icursor == '|') {
         nb_value++;
      }
      m_icursor++;
   }
 
   a_s_string = new std::string[nb_value + 2];
   m_icursor = cursor;
 
   while(*m_icursor != ';' && *m_icursor != '\n' 
         && m_icursor != m_l_content.end()) {
      if(*m_icursor != '|') {
         a_s_string[i] += *m_icursor;
      }
      else {
         i++;
      }
      m_icursor++;
   }
 
   a_s_string[i + 1] += "END";
 
   return a_s_string;
}
 
// Ajoute le bloc spécifié dans la liste
bool t_file::set_bloc(std::string bloc) {
   int i = 0;
   const char *s_string = bloc.c_str();
   // Si le bloc existe déjà
   if(is_bloc(bloc)) {
      return false;
   }
 
   // Sinon, on ajoute le bloc à la fin du fichier
   m_l_content.push_back('\n');
   m_l_content.push_back('[');
   while(s_string[i] != '\0') {
      m_l_content.push_back(s_string[i]);
      i++;
   }
   m_l_content.push_back(']');
 
   if(write()) {
      return true;
   }
 
   return false;
}
 
// Change le nom du bloc spécifié
bool t_file::update_bloc(std::string abloc, std::string nbloc) {
   const char* new_bloc = nbloc.c_str();
   int i = 0;
 
   if(!is_bloc(abloc)) {
      return false;
   }
 
   // On se place au début de la ligne
   while(*m_icursor != '[') {
      m_icursor--;
   }
 
   // On efface la ligne
   while(*m_icursor != '\n') {
      m_icursor = m_l_content.erase(m_icursor);
   }
 
   // On réécri la ligne avec la valeur spécifiée
   m_l_content.insert(m_icursor, '[');
   while(new_bloc[i] != '\0') {
      m_l_content.insert(m_icursor, new_bloc[i]);
      i++;
   }
   m_l_content.insert(m_icursor, ']');
 
   if(write()) {
      return true;
   }
 
   return false;
}
 
// Supprime le bloc
bool t_file::remove_bloc(std::string bloc) {
   if(!is_bloc(bloc)) {
      return false;
   }
 
   // On se place au début du bloc
   while(*m_icursor != '[') {
      m_icursor--;
   }
 
   // On supprime tout son contenu
   do {
      m_icursor = m_l_content.erase(m_icursor);
   } while(*m_icursor != '[' && m_icursor != m_l_content.end());
 
   if(write()) {
      return true;
   }
 
   return false;
}
 
// Ajoute la valeur spécifié dans le bloc spécifié de la liste
bool t_file::set_value(std::string bloc, std::string value, 
                        std::string vvalue) {
   int i = 0;
   const char* s_value = value.c_str();
   const char* s_vvalue = vvalue.c_str();
   std::list<char>::iterator cursor;
 
   // On vérifie que le bloc spécifié existe
   if(!is_bloc(bloc)) {
      if(!set_bloc(bloc)) {
         return false;
      }
   }
 
   cursor = m_icursor;
 
   // On vérifie que la valeur spécifié n'existe pas
   if(is_value(bloc, value)) {
      return false;
   }
 
   m_icursor = cursor;
 
   // On se place à la fin du bloc
   while(*m_icursor != '[' && m_icursor != m_l_content.end()) {
      m_icursor++;
   }
 
   // On écrit la nouvelle valeur
   m_l_content.insert(m_icursor, '\n');
   while(s_value[i] != '\0') {
      m_l_content.insert(m_icursor, s_value[i]);
      i++;
   }
   m_l_content.insert(m_icursor, '=');
   i = 0;
   while(s_vvalue[i] != '\0') {
      m_l_content.insert(m_icursor, s_vvalue[i]);
      i++;
   }
   m_l_content.insert(m_icursor, ';');
 
   if(write()) {
      return true;
   }
 
   return false;
}
 
// Supprime la valeur du bloc spécifié
bool t_file::remove_value(std::string bloc, std::string value) {
 
   // On vérifie que la valeur spécifié existe
   if(!is_value(bloc, value)) {
      return false;
   }
 
   // On se place au début de la ligne
   while(*m_icursor != '\n') {
      m_icursor--;
   }
 
   // On efface la ligne
   do {
      m_icursor = m_l_content.erase(m_icursor);
   } while(*m_icursor != '\n' && m_icursor != m_l_content.end());
 
   if(write()) {
      return true;
   }
 
   return false;
}
 
// Met à jour la valeur du bloc spécifié
bool t_file::update_value(std::string bloc, std::string value, 
                            std::string vvalue) {
   if(!remove_value(bloc, value)) {
      return false;
   }
 
   m_icursor = m_l_content.erase(m_icursor);
 
   if(!set_value(bloc, value, vvalue)) {
      return false;
   }
 
   return true;
}

t_functions.h

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
 
// Contient les prototypes des fonctions de la bibliothèque
// Note : une fonction template doit être déclarée dans le fichier d'en-tête
 
#ifndef _T_FUNCTIONS_
#define _T_FUNCTIONS_
 
// Fonctions templates :
// -------------------------
// Convertit une chaine de caractère en nombre
template <typename T>
T t_str_to_nb(const char* s_string) {
   std::istringstream flux(s_string);
   T number;
 
   if(flux >> number) {
      return number;
   }
 
   return NULL;
}
 
// Convertit un nombre en chaine de caractère
template <typename T>
const char* t_nb_to_str(T number) {
   std::stringstream flux;
   std::string s_string;
   s_string.clear();  
 
   flux << number;
   flux >> s_string;
   return s_string.c_str();
}
 
// Prototypes :
// -------------------------
 
#endif

t_functions.cpp :

Code:

1
2
3
4
 
#include <iostream>
#include <sstream>
#include "t_functions.h"

Makefile :

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
 
#Makefile libt
 
#Paths
DSRC=src
DOBJ=obj
DINC=inc
DLIB=lib
 
#Compiler flags
CXXFLAGS=-W -Wall -I$(DINC)
LDFLAGS=
 
#Archiver flags
ARFLAGS=-cvq
 
#Commands
CPP=g++ -c $(CXXFLAGS)
AR=ar $(ARFLAGS)
 
#Project list
OBJS=	\
$(DOBJ)/t_lib.o	\
$(DOBJ)/t_functions.o	\
$(DOBJ)/t_file.o
 
all: libt
 
#créé la bibliothèque
libt: t_functions.o t_file.o
	$(AR) $(DLIB)/libtim.a $(DOBJ)/*.o
 
t_functions.o:
	$(CPP) $(CFLAGS) $(DSRC)/t_functions.cpp -o $(DOBJ)/t_functions.o
 
t_file.o:
	$(CPP) $(CFLAGS) $(DSRC)/t_file.cpp -o $(DOBJ)/t_file.o
 
clean: 
	rm -f $(DOBJ)/*.o
 
clobber: clean
	rm -f $(DLIB)/*.*

Je teste ma bibliothèque en créant un simple fichier main.cpp destiné à justement tester cette bibliothèque :

Code:

1
2
3
4
5
6
7
8
 
#include "t_lib.h"
 
int main(void) {
	t_file file;
 
	return 0;
}

Je compile celui-ci avec cette ligne de commande :

Code:

1
2
 
g++ -W -Wall main.cpp -Iinc -Llib -ltim -o test

Et voilà l'erreur que j'obtiens :

Code:

1
2
3
 
/usr/bin/ld: 1: Syntax error: newline unexpected
collect2: ld returned 2 exit status

J'imagine que cela viens du fait que mes fichiers sources ne sont pas aptes à êtres intégrés en bibliothèque, mais je ne peux absolument pas en être certain... De plus, google est très vague quand je lui propose mon erreur de compilation.

Merci pour votre aide !