Bug fixed in preprocessor for new primitives.
[Faustine.git] / interpretor / preprocessor / faust-0.9.47mr3 / compiler / parser / enrobage.cpp
1 /************************************************************************
2 ************************************************************************
3 FAUST compiler
4 Copyright (C) 2003-2004 GRAME, Centre National de Creation Musicale
5 ---------------------------------------------------------------------
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 ************************************************************************
20 ************************************************************************/
21
22
23
24 #include "enrobage.hh"
25 #include <vector>
26 #include <string>
27 #include <limits.h>
28 #include <stdlib.h>
29 #include "compatibility.hh"
30 #include <climits>
31
32 extern string gFaustSuperSuperDirectory;
33 extern string gFaustSuperDirectory;
34 extern string gFaustDirectory;
35 extern string gMasterDirectory;
36 extern string gClassName;
37
38 //----------------------------------------------------------------
39
40
41 /**
42 * Returns true is a line is blank (contains only white caracters)
43 */
44 static bool isBlank(const string& s) {
45 for (size_t i=0; i<s.size(); i++) {
46 if (s[i] != ' ' && s[i] != '\t') return false;
47 }
48 return true;
49 }
50
51
52 /**
53 * Replace every occurrence of oldstr by newstr inside str. str is modified
54 * and returned as reference for convenience
55 */
56 static string& replaceOccurences(string& str, const string& oldstr, const string& newstr)
57 {
58 string::size_type l1 = oldstr.length();
59 string::size_type l2 = newstr.length();
60
61 string::size_type pos = str.find(oldstr);
62 while ( pos != string::npos) {
63 str.replace(pos, l1, newstr);
64 pos = str.find(oldstr, pos + l2);
65 }
66 return str;
67 }
68
69
70 /**
71 * Used when copying architecture files to replace default mydsp
72 * class name with the user specified one
73 */
74 static string& replaceClassName(string& str)
75 {
76 return replaceOccurences(str, "mydsp", gClassName);
77 }
78
79
80 /**
81 * Copy or remove license header. Architecture files can contain a header specifying
82 * the license. If this header contains an exception tag (for example "FAUST COMPILER EXCEPTION")
83 * it is an indication for the compiler to remove the license header from the resulting code.
84 * A header is the first non blank line that begins a comment.
85 */
86 void streamCopyLicense(istream& src, ostream& dst, const string& exceptiontag)
87 {
88 string s;
89 vector<string> H;
90
91 // skip blank lines
92 while (getline(src,s) && isBlank(s)) dst << s << endl;
93
94 // first non blank should start a comment
95 if (s.find("/*")==string::npos) { dst << s << endl; return; }
96
97 // copy the header into H
98 bool remove = false;
99 H.push_back(s);
100
101 while (getline(src,s) && s.find("*/")==string::npos) {
102 H.push_back(s);
103 if (s.find(exceptiontag) != string::npos) remove=true;
104 }
105
106 // copy the header unless explicitely granted to remove it
107 if (!remove) {
108 // copy the header
109 for (unsigned int i=0; i<H.size(); i++) {
110 dst << H[i] << endl;
111 }
112 dst << s << endl;
113 }
114 }
115
116
117 /**
118 * Copy src to dst until specific line.
119 */
120 void streamCopyUntil(istream& src, ostream& dst, const string& until)
121 {
122 string s;
123 while ( getline(src,s) && (s != until) ) dst << replaceClassName(s) << endl;
124 }
125
126 /**
127 * Copy src to dst.
128 */
129 void streamCopy(istream& src, ostream& dst)
130 {
131 string s;
132 while ( getline(src,s)) dst << replaceClassName(s) << endl;
133 }
134
135 /**
136 * Copy src to dst until end
137 */
138 void streamCopyUntilEnd(istream& src, ostream& dst)
139 {
140 string s;
141 while ( getline(src,s) ) dst << replaceClassName(s) << endl;
142 }
143
144
145 /**
146 * Try to open an architecture file searching in various directories
147 */
148 ifstream* open_arch_stream(const char* filename)
149 {
150 char buffer[FAUST_PATH_MAX];
151 char* old = getcwd (buffer, FAUST_PATH_MAX);
152 int err;
153
154 {
155 ifstream* f = new ifstream();
156 f->open(filename, ifstream::in); if (f->is_open()) return f; else delete f;
157 }
158 char *envpath = getenv("FAUST_LIB_PATH");
159 if (envpath!=NULL) {
160 if (chdir(envpath)==0) {
161 ifstream* f = new ifstream();
162 f->open(filename, ifstream::in);
163 if (f->is_open()) return f; else delete f;
164 }
165 }
166 err = chdir(old);
167 if ( (chdir(gFaustDirectory.c_str())==0) && (chdir("architecture")==0) ) {
168 //cout << "enrobage.cpp : 'architecture' directory found in gFaustDirectory" << endl;
169 ifstream* f = new ifstream();
170 f->open(filename, ifstream::in);
171 if (f->good()) return f; else delete f;
172 }
173 err = chdir(old);
174 if ((chdir(gFaustSuperDirectory.c_str())==0) && (chdir("architecture")==0) ) {
175 //cout << "enrobage.cpp : 'architecture' directory found in gFaustSuperDirectory" << endl;
176 ifstream* f = new ifstream();
177 f->open(filename, ifstream::in);
178 if (f->good()) return f; else delete f;
179 }
180 err = chdir(old);
181 if ((chdir(gFaustSuperSuperDirectory.c_str())==0) && (chdir("architecture")==0) ) {
182 //cout << "enrobage.cpp : 'architecture' directory found in gFaustSuperSuperDirectory" << endl;
183 ifstream* f = new ifstream();
184 f->open(filename, ifstream::in);
185 if (f->good()) return f; else delete f;
186 }
187
188 /* Faustine directories (Karim Barkati 09/2013) */
189
190 #ifdef INSTALL_PREFIX
191 err = chdir(old);
192 if (chdir(INSTALL_PREFIX "/lib/faustine")==0) {
193 ifstream* f = new ifstream();
194 f->open(filename);
195 if (f->good()) return f; else delete f;
196 }
197 #endif
198 err = chdir(old);
199 if (chdir("/usr/local/lib/faustine")==0) {
200 ifstream* f = new ifstream();
201 f->open(filename);
202 if (f->good()) return f; else delete f;
203 }
204 err = chdir(old);
205 if (chdir("/usr/lib/faustine")==0) {
206 ifstream* f = new ifstream();
207 f->open(filename);
208 if (f->good()) return f; else delete f;
209 }
210
211 /* End of Faustine directories */
212
213
214 #ifdef INSTALL_PREFIX
215 err = chdir(old);
216 if (chdir(INSTALL_PREFIX "/lib/faust")==0) {
217 ifstream* f = new ifstream();
218 f->open(filename);
219 if (f->good()) return f; else delete f;
220 }
221 #endif
222 err = chdir(old);
223 if (chdir("/usr/local/lib/faust")==0) {
224 ifstream* f = new ifstream();
225 f->open(filename);
226 if (f->good()) return f; else delete f;
227 }
228 err = chdir(old);
229 if (chdir("/usr/lib/faust")==0) {
230 ifstream* f = new ifstream();
231 f->open(filename);
232 if (f->good()) return f; else delete f;
233 }
234
235 return 0;
236 }
237
238
239
240 /*---------------------------------------------*/
241
242 /**
243 * Check if a file exists.
244 * @return true if the file exist, false otherwise
245 */
246
247 bool check_file(const char* filename)
248 {
249 FILE* f = fopen(filename, "r");
250
251 if (f == NULL) {
252 fprintf(stderr, "faust: "); perror(filename);
253 } else {
254 fclose(f);
255 }
256 return f != NULL;
257 }
258
259
260 /**
261 * Try to open the file '<dir>/<filename>'. If it succeed, it stores the full pathname
262 * of the file into <fullpath>
263 */
264 static FILE* fopenat(string& fullpath, const char* dir, const char* filename)
265 {
266 int err;
267 char olddirbuffer[FAUST_PATH_MAX];
268 char newdirbuffer[FAUST_PATH_MAX];
269
270 char* olddir = getcwd (olddirbuffer, FAUST_PATH_MAX);
271
272 if (chdir(dir) == 0) {
273 FILE* f = fopen(filename, "r");
274 fullpath = getcwd (newdirbuffer, FAUST_PATH_MAX);
275 fullpath += '/';
276 fullpath += filename;
277 err = chdir(olddir);
278 return f;
279 }
280 err = chdir(olddir);
281 return 0;
282 }
283
284 /**
285 * Try to open the file '<dir>/<filename>'. If it succeed, it stores the full pathname
286 * of the file into <fullpath>
287 */
288 static FILE* fopenat(string& fullpath, const string& dir, const char* filename)
289 {
290 return fopenat(fullpath, dir.c_str(), filename);
291 }
292
293 /**
294 * Try to open the file '<dir>/<path>/<filename>'. If it succeed, it stores the full pathname
295 * of the file into <fullpath>
296 */
297 static FILE* fopenat(string& fullpath, const string& dir, const char* path, const char* filename)
298 {
299 int err;
300 char olddirbuffer[FAUST_PATH_MAX];
301 char newdirbuffer[FAUST_PATH_MAX];
302
303 char* olddir = getcwd (olddirbuffer, FAUST_PATH_MAX);
304 if (chdir(dir.c_str()) == 0) {
305 if (chdir(path) == 0) {
306 FILE* f = fopen(filename, "r");
307 fullpath = getcwd (newdirbuffer, FAUST_PATH_MAX);
308 fullpath += '/';
309 fullpath += filename;
310 err = chdir(olddir);
311 return f;
312 }
313 }
314 err = chdir(olddir);
315 return 0;
316 }
317
318
319
320 /**
321 * Test absolute pathname.
322 */
323 static bool isAbsolutePathname(const string& filename)
324 {
325 //test windows absolute pathname "x:xxxxxx"
326 if (filename.size()>1 && filename[1] == ':') return true;
327
328 // test unix absolute pathname "/xxxxxx"
329 if (filename.size()>0 && filename[0] == '/') return true;
330
331 return false;
332 }
333
334
335 /**
336 * Build a full pathname of <filename>.
337 * <fullpath> = <currentdir>/<filename>
338 */
339 static void buildFullPathname(string& fullpath, const char* filename)
340 {
341 char old[FAUST_PATH_MAX];
342
343 if (isAbsolutePathname(filename)) {
344 fullpath = filename;
345 } else {
346 fullpath = getcwd (old, FAUST_PATH_MAX);
347 fullpath += '/';
348 fullpath += filename;
349 }
350 }
351
352 /**
353 * Try to open the file <filename> searching in various directories. If succesful
354 * place its full pathname in the string <fullpath>
355 */
356
357 #ifdef WIN32
358 FILE* fopensearch(const char* filename, string& fullpath)
359 {
360 FILE* f;
361 char* envpath;
362
363 if ((f = fopen(filename, "r"))) {
364 buildFullPathname(fullpath, filename);
365 return f;
366 }
367 if ((f = fopenat(fullpath, gMasterDirectory, filename))) {
368 return f;
369 }
370 if ((envpath = getenv("FAUST_LIB_PATH")) && (f = fopenat(fullpath, envpath, filename))) {
371 return f;
372 }
373 if ((f = fopenat(fullpath, gFaustDirectory, "architecture", filename))) {
374 return f;
375 }
376 if ((f = fopenat(fullpath, gFaustSuperDirectory, "architecture", filename))) {
377 return f;
378 }
379 if ((f = fopenat(fullpath, gFaustSuperSuperDirectory, "architecture", filename))) {
380 return f;
381 }
382 return 0;
383 }
384 #else
385 FILE* fopensearch(const char* filename, string& fullpath)
386 {
387 FILE* f;
388 char* envpath;
389
390 if ((f = fopen(filename, "r"))) {
391 buildFullPathname(fullpath, filename);
392 return f;
393 }
394 if ((f = fopenat(fullpath, gMasterDirectory, filename))) {
395 return f;
396 }
397 if ((envpath = getenv("FAUST_LIB_PATH")) && (f = fopenat(fullpath, envpath, filename))) {
398 return f;
399 }
400 if ((f = fopenat(fullpath, gFaustDirectory, "architecture", filename))) {
401 return f;
402 }
403 if ((f = fopenat(fullpath, gFaustSuperDirectory, "architecture", filename))) {
404 return f;
405 }
406 if ((f = fopenat(fullpath, gFaustSuperSuperDirectory, "architecture", filename))) {
407 return f;
408 }
409
410 /* Faustine directories (Haisheng WANG 09/2013) */
411
412 #ifdef INSTALL_PREFIX
413 if ((f = fopenat(fullpath, INSTALL_PREFIX "/lib/faustine", filename))) {
414 return f;
415 }
416 #endif
417 if ((f = fopenat(fullpath, "/usr/local/lib/faustine", filename))) {
418 return f;
419 }
420 if ((f = fopenat(fullpath, "/usr/lib/faustine", filename))) {
421 return f;
422 }
423
424 /* End of Faustine directories */
425
426 #ifdef INSTALL_PREFIX
427 if ((f = fopenat(fullpath, INSTALL_PREFIX "/lib/faust", filename))) {
428 return f;
429 }
430 #endif
431 if ((f = fopenat(fullpath, "/usr/local/lib/faust", filename))) {
432 return f;
433 }
434 if ((f = fopenat(fullpath, "/usr/lib/faust", filename))) {
435 return f;
436 }
437 return 0;
438 }
439 #endif
440
441
442 /**
443 * filebasename returns the basename of a path.
444 * (adapted by kb from basename.c)
445 *
446 * @param[in] The path to parse.
447 * @return The last component of the given path.
448 */
449 #ifndef DIR_SEPARATOR
450 #define DIR_SEPARATOR '/'
451 #endif
452
453 #ifdef WIN32
454 #define HAVE_DOS_BASED_FILE_SYSTEM
455 #ifndef DIR_SEPARATOR_2
456 #define DIR_SEPARATOR_2 '\\'
457 #endif
458 #endif
459
460 /* Define IS_DIR_SEPARATOR. */
461 #ifndef DIR_SEPARATOR_2
462 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
463 #else /* DIR_SEPARATOR_2 */
464 # define IS_DIR_SEPARATOR(ch) \
465 (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
466 #endif /* DIR_SEPARATOR_2 */
467
468
469 /**
470 * returns a pointer on the basename part of name
471 */
472 const char* filebasename(const char* name)
473 {
474 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
475 /* Skip over the disk name in MSDOS pathnames. */
476 if (isalpha(name[0]) && name[1] == ':')
477 name += 2;
478 #endif
479
480 const char* base;
481 for (base = name; *name; name++)
482 {
483 if (IS_DIR_SEPARATOR (*name))
484 {
485 base = name + 1;
486 }
487 }
488 return base;
489 }
490
491
492 /**
493 * returns a string containing the dirname of name
494 * If no dirname, returns "."
495 */
496 string filedirname(const string& name)
497 {
498 const char* base = filebasename(name.c_str());
499 const unsigned int size = base-name.c_str();
500 string dirname;
501
502 if (size==0) {
503 dirname += '.';
504
505 } else if (size==1) {
506 dirname += name[0];
507
508 } else {
509 for (unsigned int i=0; i<size-1; i++) {
510 dirname += name[i];
511 }
512 }
513 return dirname;
514 }