66b6f22d74e4e30c3f1d2eece6308bba4f890eb4
[Faustine.git] / interpretor / faust-0.9.47mr3 / compiler / parser / sourcereader.cpp
1 /*
2 sourcereader : Faust source file reader
3
4 This component is in charge of mapping filenames to
5 the list of faust definitions they contain.
6
7 */
8 #include <iostream>
9 #include <map>
10 #include <list>
11 #include <string>
12
13
14 #include "sourcereader.hh"
15 #include "enrobage.hh"
16 #include "ppbox.hh"
17
18 using namespace std;
19
20 extern map<Tree, set<Tree> > gMetaDataSet;
21 extern string gMasterDocument;
22 extern vector<Tree> gDocVector;
23 extern bool gLatexDocSwitch;
24
25 /****************************************************************
26 Parser variables
27 *****************************************************************/
28
29
30 int yyparse();
31
32 extern int yyerr;
33 extern int yydebug;
34 extern FILE* yyin;
35 extern int yylineno;
36 extern const char * yyfilename;
37
38 extern Tree gResult;
39 extern Tree gResult2;
40
41
42
43
44 /**
45 * Checks an argument list for containing only
46 * standard identifiers, no patterns and
47 * is linear.
48 * @param args the argument list to check
49 * @return true if it contains only identifiers
50 */
51
52 static bool standardArgList(Tree args)
53 {
54 map<Tree,int> L;
55 while (isList(args)) {
56 if (!isBoxIdent(hd(args))) return false;
57 if (++L[hd(args)] > 1) return false;
58 args = tl(args);
59 }
60 return true;
61 }
62
63
64 static void printPatternError(Tree lhs1, Tree rhs1, Tree lhs2, Tree rhs2)
65 {
66 cerr << "ERROR : inconsistent number of parameters in pattern-matching rule: "
67 << boxpp(reverse(lhs2)) << " => " << boxpp(rhs2) << ";"
68 << " previous rule was: "
69 << boxpp(reverse(lhs1)) << " => " << boxpp(rhs1) << ";"
70 << endl;
71 }
72
73 Tree checkRulelist (Tree lr)
74 {
75 Tree lrules = lr;
76 if (isNil(lrules)) { cerr << "ERROR : a case expression can't be empty" << endl; exit(1); }
77 // first pattern used as a reference
78 Tree lhs1 = hd(hd(lrules));
79 Tree rhs1 = tl(hd(lrules));
80 int npat = len(lhs1);
81 lrules = tl(lrules);
82 while (! isNil(lrules)) {
83 Tree lhs2 = hd(hd(lrules));
84 Tree rhs2 = tl(hd(lrules));
85 if (npat != len(lhs2)) {
86 printPatternError(lhs1,rhs1,lhs2,rhs2);
87 exit(1);
88 }
89
90 lhs1 = lhs2;
91 rhs1 = rhs2;
92 lrules = tl(lrules);
93 }
94 return lr;
95 }
96
97
98 /**
99 * Transforms a list of variants (arglist.body)
100 * into an abstraction or a boxCase.
101 * @param variants list of variants (arglist.body)
102 * @return the corresponding box expression
103 */
104 static Tree makeDefinition(list<Tree>& variants)
105 {
106 if (variants.size() == 1) {
107 Tree rhs = *(variants.begin());
108 Tree args= hd(rhs);
109 Tree body= tl(rhs);
110
111 if (isNil(args)) {
112 return body;
113 } else if (standardArgList(args)) {
114 return buildBoxAbstr(args, body);
115 } else {
116 return boxCase(cons(rhs,nil));
117 }
118 } else {
119 list<Tree>::iterator p;
120 Tree l = nil;
121 Tree prev = *variants.begin();
122 int npat = len(hd(prev));
123 for (p=variants.begin(); p!=variants.end(); p++) {
124 Tree cur = *p;
125 if (npat != len(hd(cur))) {
126 printPatternError(hd(prev), tl(prev), hd(cur), tl(cur));
127 exit(1);
128 }
129 prev = cur;
130 l = cons(*p,l);
131 }
132 return boxCase(l);
133 }
134 }
135
136
137
138 /**
139 * Formats a list of raw definitions represented by triplets
140 * <name,arglist,body> into abstractions or pattern
141 * matching rules when appropriate.
142 *
143 * @param rldef list of raw definitions in reverse order
144 * @return the list of formatted definitions
145 */
146 Tree formatDefinitions(Tree rldef)
147 {
148 map<Tree,list<Tree> > dic;
149 map<Tree,list<Tree> >::iterator p;
150 Tree ldef2 = nil;
151 Tree file;
152
153 //cout << "Format definitions " << *rldef << endl;
154 // collects the definitions in a dictionnary
155 while (!isNil(rldef)) {
156 Tree def = hd(rldef);
157 rldef = tl(rldef);
158 if (isImportFile(def, file)) {
159 ldef2 = cons(def,ldef2);
160 } else if (!isNil(def)) {
161 //cout << " def : " << *def << endl;
162 dic[hd(def)].push_front(tl(def));
163 }
164 }
165
166 // produce the definitions
167
168 for (p=dic.begin(); p!=dic.end(); p++) {
169 ldef2 = cons (cons(p->first, makeDefinition(p->second)), ldef2);
170 }
171
172 //cout << "list of definitions : " << *ldef2 << endl;
173 return ldef2;
174
175 }
176
177
178 /**
179 * Parse a single faust source file. returns the list of
180 * definitions it contains.
181 *
182 * @param fname the name of the file to parse
183 * @return the list of definitions it contains
184 */
185
186 Tree SourceReader::parse(string fname)
187 {
188 string fullpath;
189
190 yyerr = 0;
191
192 yyfilename = fname.c_str();
193 yyin = fopensearch(yyfilename, fullpath);
194 if (yyin == NULL) {
195 fprintf(stderr, "ERROR : Unable to open file %s \n", yyfilename);
196 exit(1);
197 }
198
199 yylineno = 1;
200 int r = yyparse();
201 if (r) {
202 fprintf(stderr, "Parse error : code = %d \n", r);
203 }
204 if (yyerr > 0) {
205 //fprintf(stderr, "Erreur de parsing 2, count = %d \n", yyerr);
206 exit(1);
207 }
208
209 // we have parsed a valid file
210 fFilePathnames.push_back(fullpath);
211 return gResult;
212 }
213
214
215 /**
216 * Check if a file as been read and is in the "cache"
217 *
218 * @param fname the name of the file to check
219 * @return true if the file is in the cache
220 */
221
222 bool SourceReader::cached(string fname)
223 {
224 return fFileCache.find(fname) != fFileCache.end();
225 }
226
227
228 /**
229 * Return the list of definitions file contains. Cache the result.
230 *
231 * @param fname the name of the file to check
232 * @return the list of definitions it contains
233 */
234
235 Tree SourceReader::getlist(string fname)
236 {
237 if (!cached(fname)) {
238 fFileCache[fname] = parse(fname);
239 }
240 if (fFileCache[fname] == 0) exit(1);
241 return fFileCache[fname];
242 }
243
244
245 /**
246 * Return a vector of pathnames representing the list
247 * of all the source files that have been required
248 * to evaluate process (those in fFileCache)
249 */
250
251 vector<string> SourceReader::listSrcFiles()
252 {
253 // vector<string> srcfiles;
254
255 // for (map<string, Tree>::const_iterator p = fFileCache.begin(); p != fFileCache.end(); p++) {
256 // srcfiles.push_back(p->first);
257 // }
258
259 // return srcfiles;
260 return fFilePathnames;
261 }
262
263
264 /**
265 * Return the list of definitions where all imports have been expanded.
266 *
267 * @param ldef the list of definitions to expand
268 * @return the expanded list of definitions
269 */
270
271 Tree SourceReader::expandlist(Tree ldef)
272 {
273 set<string> visited;
274 return expandrec(ldef, visited, nil);
275 }
276
277 Tree SourceReader::expandrec(Tree ldef, set<string>& visited, Tree lresult)
278 {
279 for (;!isNil(ldef); ldef = tl(ldef)) {
280 Tree d = hd(ldef);
281 Tree fname;
282 if (isNil(d)) {
283 // skill null definitions produced by declarations
284 } else if (isImportFile(d,fname)) {
285 string f = tree2str(fname);
286 //cerr << "import(" << f << ")" << endl;
287
288 //string f = tree2str(fname);
289 if (visited.find(f) == visited.end()) {
290 visited.insert(f);
291 //Tree l = getlist(f);
292 lresult = expandrec(getlist(f), visited, lresult);
293 }
294
295 } else {
296 lresult = cons(d, lresult);
297 }
298 }
299 return lresult;
300 }
301
302
303 void declareMetadata(Tree key, Tree value)
304 {
305 if (gMasterDocument == yyfilename) {
306 // inside master document, no prefix needed to declare metadata
307 gMetaDataSet[key].insert(value);
308 } else {
309 string fkey(yyfilename);
310 fkey += "/";
311 fkey += tree2str(key);
312 gMetaDataSet[tree(fkey.c_str())].insert(value);
313 }
314 //cout << "Master " << gMasterDocument << ", file " << yyfilename << " : declare " << *key << "," << *value << endl;
315 }
316
317
318 void declareDoc(Tree t)
319 {
320 //gLatexDocSwitch = true;
321 gDocVector.push_back(t);
322 }