+++ /dev/null
-/*
- sourcereader : Faust source file reader
-
- This component is in charge of mapping filenames to
- the list of faust definitions they contain.
-
-*/
-#include <iostream>
-#include <map>
-#include <list>
-#include <string>
-
-
-#include "sourcereader.hh"
-#include "enrobage.hh"
-#include "ppbox.hh"
-
-using namespace std;
-
-extern map<Tree, set<Tree> > gMetaDataSet;
-extern string gMasterDocument;
-extern vector<Tree> gDocVector;
-extern bool gLatexDocSwitch;
-
-/****************************************************************
- Parser variables
-*****************************************************************/
-
-
-int yyparse();
-
-extern int yyerr;
-extern int yydebug;
-extern FILE* yyin;
-extern int yylineno;
-extern const char * yyfilename;
-
-extern Tree gResult;
-extern Tree gResult2;
-
-
-
-
-/**
- * Checks an argument list for containing only
- * standard identifiers, no patterns and
- * is linear.
- * @param args the argument list to check
- * @return true if it contains only identifiers
- */
-
-static bool standardArgList(Tree args)
-{
- map<Tree,int> L;
- while (isList(args)) {
- if (!isBoxIdent(hd(args))) return false;
- if (++L[hd(args)] > 1) return false;
- args = tl(args);
- }
- return true;
-}
-
-
-static void printPatternError(Tree lhs1, Tree rhs1, Tree lhs2, Tree rhs2)
-{
- cerr << "ERROR : inconsistent number of parameters in pattern-matching rule: "
- << boxpp(reverse(lhs2)) << " => " << boxpp(rhs2) << ";"
- << " previous rule was: "
- << boxpp(reverse(lhs1)) << " => " << boxpp(rhs1) << ";"
- << endl;
-}
-
-Tree checkRulelist (Tree lr)
-{
- Tree lrules = lr;
- if (isNil(lrules)) { cerr << "ERROR : a case expression can't be empty" << endl; exit(1); }
- // first pattern used as a reference
- Tree lhs1 = hd(hd(lrules));
- Tree rhs1 = tl(hd(lrules));
- int npat = len(lhs1);
- lrules = tl(lrules);
- while (! isNil(lrules)) {
- Tree lhs2 = hd(hd(lrules));
- Tree rhs2 = tl(hd(lrules));
- if (npat != len(lhs2)) {
- printPatternError(lhs1,rhs1,lhs2,rhs2);
- exit(1);
- }
-
- lhs1 = lhs2;
- rhs1 = rhs2;
- lrules = tl(lrules);
- }
- return lr;
-}
-
-
-/**
- * Transforms a list of variants (arglist.body)
- * into an abstraction or a boxCase.
- * @param variants list of variants (arglist.body)
- * @return the corresponding box expression
- */
-static Tree makeDefinition(list<Tree>& variants)
-{
- if (variants.size() == 1) {
- Tree rhs = *(variants.begin());
- Tree args= hd(rhs);
- Tree body= tl(rhs);
-
- if (isNil(args)) {
- return body;
- } else if (standardArgList(args)) {
- return buildBoxAbstr(args, body);
- } else {
- return boxCase(cons(rhs,nil));
- }
- } else {
- list<Tree>::iterator p;
- Tree l = nil;
- Tree prev = *variants.begin();
- int npat = len(hd(prev));
- for (p=variants.begin(); p!=variants.end(); p++) {
- Tree cur = *p;
- if (npat != len(hd(cur))) {
- printPatternError(hd(prev), tl(prev), hd(cur), tl(cur));
- exit(1);
- }
- prev = cur;
- l = cons(*p,l);
- }
- return boxCase(l);
- }
-}
-
-
-
-/**
- * Formats a list of raw definitions represented by triplets
- * <name,arglist,body> into abstractions or pattern
- * matching rules when appropriate.
- *
- * @param rldef list of raw definitions in reverse order
- * @return the list of formatted definitions
- */
-Tree formatDefinitions(Tree rldef)
-{
- map<Tree,list<Tree> > dic;
- map<Tree,list<Tree> >::iterator p;
- Tree ldef2 = nil;
- Tree file;
-
- //cout << "Format definitions " << *rldef << endl;
- // collects the definitions in a dictionnary
- while (!isNil(rldef)) {
- Tree def = hd(rldef);
- rldef = tl(rldef);
- if (isImportFile(def, file)) {
- ldef2 = cons(def,ldef2);
- } else if (!isNil(def)) {
- //cout << " def : " << *def << endl;
- dic[hd(def)].push_front(tl(def));
- }
- }
-
- // produce the definitions
-
- for (p=dic.begin(); p!=dic.end(); p++) {
- ldef2 = cons (cons(p->first, makeDefinition(p->second)), ldef2);
- }
-
- //cout << "list of definitions : " << *ldef2 << endl;
- return ldef2;
-
-}
-
-
-/**
- * Parse a single faust source file. returns the list of
- * definitions it contains.
- *
- * @param fname the name of the file to parse
- * @return the list of definitions it contains
- */
-
-Tree SourceReader::parse(string fname)
-{
- string fullpath;
-
- yyerr = 0;
-
- yyfilename = fname.c_str();
- yyin = fopensearch(yyfilename, fullpath);
- if (yyin == NULL) {
- fprintf(stderr, "ERROR : Unable to open file %s \n", yyfilename);
- exit(1);
- }
-
- yylineno = 1;
- int r = yyparse();
- if (r) {
- fprintf(stderr, "Parse error : code = %d \n", r);
- }
- if (yyerr > 0) {
- //fprintf(stderr, "Erreur de parsing 2, count = %d \n", yyerr);
- exit(1);
- }
-
- // we have parsed a valid file
- fFilePathnames.push_back(fullpath);
- return gResult;
-}
-
-
-/**
- * Check if a file as been read and is in the "cache"
- *
- * @param fname the name of the file to check
- * @return true if the file is in the cache
- */
-
-bool SourceReader::cached(string fname)
-{
- return fFileCache.find(fname) != fFileCache.end();
-}
-
-
-/**
- * Return the list of definitions file contains. Cache the result.
- *
- * @param fname the name of the file to check
- * @return the list of definitions it contains
- */
-
-Tree SourceReader::getlist(string fname)
-{
- if (!cached(fname)) {
- fFileCache[fname] = parse(fname);
- }
- if (fFileCache[fname] == 0) exit(1);
- return fFileCache[fname];
-}
-
-
-/**
- * Return a vector of pathnames representing the list
- * of all the source files that have been required
- * to evaluate process (those in fFileCache)
- */
-
-vector<string> SourceReader::listSrcFiles()
-{
-// vector<string> srcfiles;
-
-// for (map<string, Tree>::const_iterator p = fFileCache.begin(); p != fFileCache.end(); p++) {
-// srcfiles.push_back(p->first);
-// }
-
-// return srcfiles;
- return fFilePathnames;
-}
-
-
-/**
- * Return the list of definitions where all imports have been expanded.
- *
- * @param ldef the list of definitions to expand
- * @return the expanded list of definitions
- */
-
-Tree SourceReader::expandlist(Tree ldef)
-{
- set<string> visited;
- return expandrec(ldef, visited, nil);
-}
-
-Tree SourceReader::expandrec(Tree ldef, set<string>& visited, Tree lresult)
-{
- for (;!isNil(ldef); ldef = tl(ldef)) {
- Tree d = hd(ldef);
- Tree fname;
- if (isNil(d)) {
- // skill null definitions produced by declarations
- } else if (isImportFile(d,fname)) {
- string f = tree2str(fname);
- //cerr << "import(" << f << ")" << endl;
-
- //string f = tree2str(fname);
- if (visited.find(f) == visited.end()) {
- visited.insert(f);
- //Tree l = getlist(f);
- lresult = expandrec(getlist(f), visited, lresult);
- }
-
- } else {
- lresult = cons(d, lresult);
- }
- }
- return lresult;
-}
-
-
-void declareMetadata(Tree key, Tree value)
-{
- if (gMasterDocument == yyfilename) {
- // inside master document, no prefix needed to declare metadata
- gMetaDataSet[key].insert(value);
- } else {
- string fkey(yyfilename);
- fkey += "/";
- fkey += tree2str(key);
- gMetaDataSet[tree(fkey.c_str())].insert(value);
- }
- //cout << "Master " << gMasterDocument << ", file " << yyfilename << " : declare " << *key << "," << *value << endl;
-}
-
-
-void declareDoc(Tree t)
-{
- //gLatexDocSwitch = true;
- gDocVector.push_back(t);
-}
projects / Faustine.git / blobdiff