src/config/Parser.cpp

   1 /** Aesalon, a tool to visualize program behaviour in real time.
   2         Copyright (C) 2009-2011, Aesalon development team.
   3
   4         Aesalon is distributed under the terms of the GNU GPLv3. See
   5         the included file LICENSE for more information.
   6
   7         @file src/config/Parser.cpp
   8 */
   9
  10 #include <cstring>
  11 #include <cstdlib>
  12 #include <libgen.h>
  13 #include <dirent.h>
  14 #include <sys/stat.h>
  15
  16 #include "config/Parser.h"
  17 #include "util/StreamAsString.h"
  18 #include "util/MessageSystem.h"
  19 #include "Config.h"
  20
  21 namespace Config {
  22
  23 void Parser::parse(Vault *vault, const std::string &configFile) {
  24         std::string currentModule;
  25
  26         openFile(configFile);
  27
  28         if(!m_stream->is_open()) return;
  29
  30         for(;;) {
  31                 TokenType tokenType;
  32                 std::string token = nextToken(tokenType);
  33                 if(tokenType == END_OF_FILE) break;
  34
  35                 //std::cout << '"' << token << '"' << " of type " << nameOf(tokenType) << std::endl;
  36
  37                 if(tokenType == WORD && token == "include") {
  38                         Parser().parse(vault, expectNextToken(QUOTED_WORD));
  39                         expectNextSymbol(";");
  40                 }
  41                 else if(tokenType == WORD && token == "module") {
  42                         currentModule = expectNextToken(WORD);
  43                         expectNextSymbol("{");
  44                 }
  45                 else if(tokenType == WORD && token == "search") {
  46                         char *dirpath = strdup(configFile.c_str());
  47                         dirpath = dirname(dirpath);
  48
  49                         std::string dirname = expectNextToken(QUOTED_WORD);
  50
  51                         if(dirname[0] != '/' && dirname[0] != '~') {
  52                                 dirname = Util::StreamAsString() << dirpath << "/" << dirname;
  53                         }
  54
  55                         Parser().parseDirectory(vault, dirname);
  56
  57                         expectNextSymbol(";");
  58                         std::free(dirpath);
  59                 }
  60                 else if(tokenType == SYMBOL && token == "}") {
  61                         if(currentModule != "") {
  62                                 currentModule = "";
  63                         }
  64                         else Message(Fatal, "Extra \"}\" in config file.");
  65                 }
  66                 else if(tokenType == WORD && token == "use") {
  67                         /*std::cout << "Parser: Using module \"" << expectNextToken(WORD) << "\"\n";*/
  68                         std::string moduleName = expectNextToken(WORD);
  69
  70                         vault->set("::modules", moduleName);
  71
  72                         expectNextSymbol(";");
  73                 }
  74                 else if(tokenType == WORD) {
  75                         std::string op = expectNextToken(SYMBOL);
  76
  77                         if(op == "=") vault->clear(token);
  78
  79                         do {
  80                                 TokenType nextType;
  81                                 std::string next = nextToken(nextType);
  82
  83                                 //if(nextType == SYMBOL && next == ";") break;
  84
  85                                 if(nextType == WORD || nextType == QUOTED_WORD) {
  86                                         if(currentModule != "") vault->set(
  87                                                 Util::StreamAsString() << currentModule << ":" << token, next);
  88
  89                                         else vault->set(token, next);
  90
  91                                         /*std::cout << "Set \"" << currentModule << "::" << token << "\" to \""
  92                                                 << next << "\" with operator " << op << std::endl;*/
  93                                 }
  94                                 else Message(Fatal, "Invalid RHS");
  95
  96                                 std::string sym = expectNextToken(SYMBOL);
  97                                 if(sym == ";") break;
  98                                 else if(sym == ",") {}
  99                                 else {
 100                                         Message(Fatal, "Expected \",\" or \";\", got \"" << sym << "\"");
 101                                 }
 102                         } while(true);
 103                 }
 104                 else {
 105                         Message(Fatal, "Syntax error at token \"" << token << "\"");
 106                 }
 107                 //std::cout << "\"" << token << "\"\n";
 108         }
 109
 110         closeFile();
 111 }
 112
 113 void Parser::parseDirectory(Vault *vault, const std::string &directory) {
 114         DIR *dir = opendir(directory.c_str());
 115         if(dir == NULL) return;
 116
 117         vault->clear("::directory");
 118         vault->set("::directory", directory);
 119
 120         struct dirent *dent;
 121
 122         while((dent = readdir(dir)) != NULL) {
 123                 if(!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..")) continue;
 124                 std::string possible = directory + "/";
 125                 possible += dent->d_name;
 126
 127                 struct stat s;
 128                 if(stat(possible.c_str(), &s) != 0) {
 129                         /* Cannot stat file, probably don't have access permissions. */
 130                         continue;
 131                 }
 132
 133                 possible += "/";
 134
 135                 if(S_ISDIR(s.st_mode)) {
 136                         parse(vault, possible + AesalonModuleConfigFileName);
 137                         std::string path = dent->d_name;
 138                         path += ":root";
 139                         vault->clear(path);
 140                         vault->set(path, possible);
 141                 }
 142         }
 143
 144         closedir(dir);
 145 }
 146
 147 void Parser::openFile(const std::string &configFile) {
 148         m_stream = new std::ifstream(configFile.c_str());
 149 }
 150
 151 std::string Parser::nextToken(TokenType &type) {
 152         std::ifstream &stream = *m_stream;
 153
 154         skipWhitespace();
 155
 156         if(stream.eof()) {
 157                 type = END_OF_FILE;
 158                 return "";
 159         }
 160
 161         if(stream.peek() == '#') {
 162                 std::string line;
 163                 std::getline(stream, line);
 164                 return nextToken(type);
 165         }
 166         else if(stream.peek() == '"') {
 167                 stream.get();  // skip "
 168
 169                 std::string word;
 170                 while(stream.peek() != '"') {
 171                         word += stream.get();
 172                 }
 173
 174                 stream.get();  // skip "
 175
 176                 type = QUOTED_WORD;
 177             return word;
 178         }
 179         else if(std::isalnum(stream.peek())) {
 180                 std::string word;
 181                 while(std::isalnum(stream.peek())) {
 182                         word += stream.get();
 183                 }
 184
 185                 type = WORD;
 186             return word;
 187         }
 188         else if(stream.peek() == '+') {
 189                 stream.get();  // skip '+'
 190                 if(stream.peek() == '=') {
 191                         stream.get();  // skip '='
 192                         type = SYMBOL;
 193                         return "+=";
 194                 }
 195
 196                 std::string rest;
 197                 stream >> rest;
 198
 199                 Message(Fatal, "Unrecognized token: \"+" << rest << "\"");
 200                 return ""; // Never reached.
 201         }
 202         else {
 203                 std::string token;
 204                 token += stream.get();
 205
 206                 type = SYMBOL;
 207                 return token;
 208         }
 209 }
 210
 211 std::string Parser::expectNextToken(TokenType expected) {
 212         TokenType actual;
 213         std::string token = nextToken(actual);
 214
 215         if(actual != expected) {
 216                 Message(Fatal,
 217                         "Expected " << nameOf(expected) << " token, found " << nameOf(actual)
 218                         << " token: \"" << token << "\"");
 219         }
 220
 221         return token;
 222 }
 223
 224 void Parser::expectNextSymbol(const std::string &symbol) {
 225         std::string s = expectNextToken(SYMBOL);
 226         if(symbol != s) {
 227                 Message(Fatal, "Expected token \"" << symbol << "\", got \"" << s << "\"");
 228         }
 229 }
 230
 231 void Parser::skipWhitespace() {
 232         std::ifstream &stream = *m_stream;
 233
 234         while(!stream.fail() && std::isspace(stream.peek())) {
 235                 stream.get();
 236         }
 237 }
 238
 239 void Parser::closeFile() {
 240         delete m_stream;
 241         m_stream = NULL;
 242 }
 243
 244 const char *Parser::nameOf(TokenType type) const {
 245         static const char *name[] = {
 246                 "WORD",
 247                 "QUOTED_WORD",
 248                 "SYMBOL",
 249                 "END_OF_FILE"
 250         };
 251
 252         return name[type];
 253 }
 254
 255 } // namespace Config