src/xlat-i/xi-main.C

   1 #include "sdag/constructs/Constructs.h"
   2 #include "xi-symbol.h"
   3 #include "xi-util.h"
   4 #include <cstdio>
   5 #include <cstdlib>
   6 #include <fstream>
   7 #include <iostream>
   8 #include <list>
   9 #include <string>
  10 #include <vector>
  11
  12 using std::cout;
  13 using std::endl;
  14
  15 extern FILE* yyin;
  16 extern void yyrestart(FILE* input_file);
  17 extern int yyparse(void);
  18 extern void yyerror(const char*);
  19 extern int yylex(void);
  20 extern void scan_string(const char*);
  21
  22 extern xi::AstChildren<xi::Module>* modlist;
  23 extern xi::rwentry rwtable[];
  24
  25 using namespace xi;
  26 #include "xi-grammar.tab.h"
  27
  28 namespace xi {
  29
  30 std::vector<std::string> inputBuffer;
  31
  32 int fortranMode, internalMode;
  33 const char* cur_file;
  34
  35 char *fname, *origFile;
  36
  37 void ReservedWord(int token, int fCol, int lCol) {
  38   char text[300];
  39   const char* word = 0;
  40   for (int i = 0; rwtable[i].tok != 0; ++i) {
  41     if (rwtable[i].tok == token) {
  42       word = rwtable[i].res;
  43       break;
  44     }
  45   }
  46   sprintf(text, "Reserved word '%s' used as an identifier", word);
  47   xi::pretty_msg("error", text, fCol, lCol);
  48   yyerror(text);
  49 }
  50
  51 /******************* Macro defines ****************/
  52 class MacroDefinition {
  53  private:
  54   char* key;
  55   char* val;
  56
  57  public:
  58   MacroDefinition() : key(NULL), val(NULL) {}
  59   MacroDefinition(char* k, char* v) : key(k), val(v) {}
  60   explicit MacroDefinition(char* str) {
  61     // split by '='
  62     char* equal = strchr(str, '=');
  63     if (equal) {
  64       *equal = 0;
  65       key = str;
  66       val = equal + 1;
  67     } else {
  68       key = str;
  69       val = const_cast<char*>("");
  70     }
  71   }
  72   char* match(const char* k) {
  73     if (!strcmp(k, key)) {
  74       return val;
  75     } else {
  76       return NULL;
  77     }
  78   }
  79 };
  80
  81 static std::list<MacroDefinition*> macros;
  82
  83 int macroDefined(const char* str, int istrue) {
  84   std::list<MacroDefinition*>::iterator def;
  85   for (def = macros.begin(); def != macros.end(); ++def) {
  86     char* val = (*def)->match(str);
  87     if (val) {
  88       if (!istrue) {
  89         return 1;
  90       } else {
  91         return atoi(val);
  92       }
  93     }
  94   }
  95   return 0;
  96 }
  97
  98 // input: name
  99 // output: basename (pointer somewhere inside name)
 100 //         scope (null if name is unscoped, newly allocated string otherwise)
 101 void splitScopedName(const char* name, const char** scope, const char** basename) {
 102   const char* scopeEnd = strrchr(name, ':');
 103   if (!scopeEnd) {
 104     *scope = NULL;
 105     *basename = name;
 106     return;
 107   }
 108   *basename = scopeEnd + 1;
 109   int len = scopeEnd - name + 1; /* valid characters to copy */
 110   char* tmp = new char[len + 1];
 111   strncpy(tmp, name, len);
 112   tmp[len] = 0; /* gotta null-terminate C string */
 113   *scope = tmp;
 114 }
 115
 116 /*
 117 FILE *openFile(char *interfacefile) {
 118   if (interfacefile == NULL) {
 119     cur_file = "STDIN";
 120     return stdin;
 121   } else {
 122     cur_file = interfacefile;
 123     FILE *fp = fopen(interfacefile, "r");
 124     if (fp == NULL) {
 125       cout << "ERROR : could not open " << interfacefile << endl;
 126       exit(1);
 127     }
 128     return fp;
 129   }
 130   return NULL;
 131 }
 132
 133 ModuleList *Parse(char *interfacefile)
 134 {
 135   cur_file=interfacefile;
 136   FILE * fp = fopen (interfacefile, "r") ;
 137   if (fp) {
 138     yyin = fp ;
 139     if(yyparse())
 140       exit(1);
 141     fclose(fp) ;
 142   } else {
 143     cout << "ERROR : could not open " << interfacefile << endl ;
 144   }
 145   return modlist;
 146 }
 147 */
 148
 149 std::string readFile(const char* interfaceFile) {
 150   // istream::operator== was introduced in C++11.
 151   // It seems the usual workaround to multiplex cin/ifstream is to use pointers.
 152   std::istream* in;
 153   std::string buffer;
 154   if (interfaceFile) {
 155     cur_file = interfaceFile;
 156     in = new std::ifstream(interfaceFile);
 157     if(in->fail()) {
 158       cout << "Error: failed to open input file '" << interfaceFile << "'." << endl;
 159       exit(1);
 160     }
 161   } else {
 162     cur_file = (origFile != NULL) ? origFile : "STDIN";
 163     in = &std::cin;
 164   }
 165
 166   std::string line;
 167   while (std::getline(*in, line)) {
 168     buffer += line + "\n";
 169     inputBuffer.push_back(line);
 170   }
 171
 172   if (interfaceFile) delete in;
 173
 174   return buffer;
 175 }
 176
 177 AstChildren<Module>* Parse(std::string& str) {
 178   modlist = NULL;
 179   scan_string(str.c_str());
 180   if (yyparse()) exit(1);
 181   if (num_errors > 0) exit(1);
 182   return modlist;
 183 }
 184
 185 int count_tokens(std::string& str) {
 186   scan_string(str.c_str());
 187   int count = 0;
 188   while (yylex()) count++;
 189   return count;
 190 }
 191
 192 void abortxi(char* name) {
 193   cout << "Usage : " << name << " [-ansi|-f90|-intrinsic|-M]  module.ci" << endl;
 194   exit(1);
 195 }
 196
 197 }  // namespace xi
 198
 199 using namespace xi;
 200
 201 int processAst(AstChildren<Module>* m, const bool chareNames, const bool dependsMode,
 202                const int fortranMode_, const int internalMode_, char* fname_,
 203                char* origFile_) {
 204   // set globals based on input params
 205   fortranMode = fortranMode_;
 206   internalMode = internalMode_;
 207   origFile = origFile_;
 208   fname = fname_;
 209
 210   if (!m) return 0;
 211   m->preprocess();
 212   m->check();
 213   if (num_errors != 0) exit(1);
 214
 215   if (chareNames) {
 216     m->printChareNames();
 217     return 0;
 218   }
 219
 220   if (dependsMode) {
 221     std::string ciFileBaseName;
 222     if (fname != NULL) {
 223       ciFileBaseName = fname;
 224     } else if (origFile != NULL) {
 225       ciFileBaseName = origFile;
 226     } else {
 227       abortxi(fname);
 228     }
 229     size_t loc = ciFileBaseName.rfind('/');
 230     if (loc != std::string::npos) ciFileBaseName = ciFileBaseName.substr(loc + 1);
 231     m->recurse(ciFileBaseName.c_str(), &Module::genDepend);
 232   } else {
 233     m->recursev(&Module::generate);
 234   }
 235
 236   return 0;
 237 }
 238
 239 int main(int argc, char* argv[]) {
 240   origFile = NULL;
 241   fname = NULL;
 242   int fortranMode = 0;
 243   int internalMode = 0;
 244   bool dependsMode = false;
 245   bool countTokens = false;
 246   bool chareNames = false;
 247
 248   for (int i = 1; i < argc; i++) {
 249     if (*argv[i] == '-') {
 250       if (strcmp(argv[i], "-ansi") == 0) {
 251       } else if (strcmp(argv[i], "-f90") == 0)
 252         fortranMode = 1;
 253       else if (strcmp(argv[i], "-intrinsic") == 0)
 254         internalMode = 1;
 255       else if (strncmp(argv[i], "-D", 2) == 0)
 256         macros.push_back(new MacroDefinition(argv[i] + 2));
 257       else if (strncmp(argv[i], "-M", 2) == 0)
 258         dependsMode = true;
 259       else if (strcmp(argv[i], "-count-tokens") == 0)
 260         countTokens = true;
 261       else if (strcmp(argv[i], "-chare-names") == 0)
 262         chareNames = true;
 263       else if (strcmp(argv[i], "-orig-file") == 0)
 264         origFile = argv[++i];
 265       else
 266         abortxi(argv[0]);
 267     } else {
 268       fname = argv[i];
 269     }
 270   }
 271   // if (fname==NULL) abortxi(argv[0]);
 272   std::string buffer = readFile(fname);
 273   sanitizeComments(buffer);
 274   sanitizeStrings(buffer);
 275
 276   if (countTokens) {
 277     cout << count_tokens(buffer) << endl;
 278     return 0;
 279   }
 280
 281   AstChildren<Module>* m = Parse(buffer);
 282   return processAst(m, chareNames, dependsMode, fortranMode, internalMode, fname,
 283                     origFile);
 284 }