monitor/src/config/Parser.cpp

   1 /**
   2         Aesalon, a tool to visualize a program's behaviour at run-time.
   3         Copyright (C) 2010, Aesalon Development Team.
   4
   5         Aesalon is distributed under the terms of the GNU GPLv3. For more
   6         licensing information, see the file LICENSE included with the distribution.
   7
   8         @file monitor/src/config/Parser.cpp
   9
  10 */
  11
  12 #include <iostream>  // for debugging
  13 #include <sstream>
  14 #include <fstream>
  15 #include <string>
  16 #include <cctype>
  17
  18 #include "config/Parser.h"
  19 #include "common/ParsingException.h"
  20 #include "common/StreamAsString.h"
  21 #include "config/ConcreteVault.h"
  22
  23 namespace Monitor {
  24 namespace Config {
  25
  26 void Parser::parse(ConcreteVault *vault, const std::string &configFile) {
  27         std::string currentModule;
  28
  29         openFile(configFile);
  30
  31         for(;;) {
  32                 TokenType tokenType;
  33                 std::string token = nextToken(tokenType);
  34                 if(tokenType == END_OF_FILE) break;
  35
  36                 //std::cout << '"' << token << '"' << " of type " << nameOf(tokenType) << std::endl;
  37
  38                 if(tokenType == WORD && token == "include") {
  39                         Parser().parse(vault, expectNextToken(QUOTED_WORD));
  40                         expectNextSymbol(";");
  41                 }
  42                 else if(tokenType == WORD && token == "module") {
  43                         currentModule = expectNextToken(WORD);
  44                         expectNextSymbol("{");
  45                 }
  46                 else if(tokenType == SYMBOL && token == "}") {
  47                         if(currentModule != "") {
  48                                 currentModule = "";
  49                         }
  50                         else throw Common::ParsingException("Extra \"}\"");
  51                 }
  52                 else if(tokenType == WORD && token == "use") {
  53                         /*std::cout << "Parser: Using module \"" << expectNextToken(WORD) << "\"\n";*/
  54                         vault->set("LD_PRELOAD", expectNextToken(WORD));
  55                         expectNextSymbol(";");
  56                 }
  57                 else if(tokenType == WORD) {
  58                         std::string op = expectNextToken(SYMBOL);
  59
  60                         if(op == "=") vault->clear(token);
  61
  62                         do {
  63                                 TokenType nextType;
  64                                 std::string next = nextToken(nextType);
  65
  66                                 //if(nextType == SYMBOL && next == ";") break;
  67
  68                                 if(nextType == WORD || nextType == QUOTED_WORD) {
  69                                         if(currentModule != "") vault->set(
  70                                                 Common::StreamAsString() << currentModule << ":" << token, next);
  71
  72                                         else vault->set(token, next);
  73
  74                                         std::cout << "Set \"" << currentModule << "::" << token << "\" to \""
  75                                                 << next << "\" with operator " << op << std::endl;
  76                                 }
  77                                 else throw Common::ParsingException("Invalid RHS");
  78
  79                                 std::string sym = expectNextToken(SYMBOL);
  80                                 if(sym == ";") break;
  81                                 else if(sym == ",") {}
  82                                 else {
  83                                         throw Common::ParsingException(Common::StreamAsString()
  84                                                 << "Expected \",\" or \";\", got \"" << sym << "\"");
  85                                 }
  86                         } while(true);
  87                 }
  88                 else {
  89                         throw Common::ParsingException(Common::StreamAsString()
  90                                 << "Syntax error at token \"" << token << "\"");
  91                 }
  92                 //std::cout << "\"" << token << "\"\n";
  93         }
  94
  95         closeFile();
  96 }
  97
  98 void Parser::openFile(const std::string &configFile) {
  99         m_stream = new std::ifstream(configFile.c_str());
 100         if(!m_stream->is_open()) {
 101                 std::cout << "Error opening config file \"" << configFile << "\"\n";
 102         }
 103 }
 104
 105 std::string Parser::nextToken(TokenType &type) {
 106         std::ifstream &stream = *m_stream;
 107
 108         skipWhitespace();
 109
 110         if(stream.eof()) {
 111                 type = END_OF_FILE;
 112                 return "";
 113         }
 114
 115         if(stream.peek() == '#') {
 116                 std::string line;
 117                 std::getline(stream, line);
 118                 return nextToken(type);
 119         }
 120         else if(stream.peek() == '"') {
 121                 stream.get();  // skip "
 122
 123                 std::string word;
 124                 while(stream.peek() != '"') {
 125                         word += stream.get();
 126                 }
 127
 128                 stream.get();  // skip "
 129
 130                 type = QUOTED_WORD;
 131             return word;
 132         }
 133         else if(std::isalnum(stream.peek())) {
 134                 std::string word;
 135                 while(std::isalnum(stream.peek())) {
 136                         word += stream.get();
 137                 }
 138
 139                 type = WORD;
 140             return word;
 141         }
 142         else if(stream.peek() == '+') {
 143                 stream.get();  // skip '+'
 144                 if(stream.peek() == '=') {
 145                         stream.get();  // skip '='
 146                         type = SYMBOL;
 147                         return "+=";
 148                 }
 149
 150                 std::string rest;
 151                 stream >> rest;
 152
 153                 throw Common::ParsingException(Common::StreamAsString()
 154                         << "Unrecognized token: \"+" << rest << "\"");
 155         }
 156         else {
 157                 std::string token;
 158                 token += stream.get();
 159
 160                 type = SYMBOL;
 161                 return token;
 162         }
 163 }
 164
 165 std::string Parser::expectNextToken(TokenType expected) {
 166         TokenType actual;
 167         std::string token = nextToken(actual);
 168
 169         if(actual != expected) {
 170                 throw Common::ParsingException(Common::StreamAsString()
 171                         << "Expected " << nameOf(expected) << " token, found " << nameOf(actual)
 172                         << " token: \"" << token << "\"");
 173         }
 174
 175         return token;
 176 }
 177
 178 void Parser::expectNextSymbol(const std::string &symbol) {
 179         std::string s = expectNextToken(SYMBOL);
 180         if(symbol != s) {
 181                 throw Common::ParsingException(Common::StreamAsString()
 182                         << "Expected token \"" << symbol << "\", got \"" << s << "\"");
 183         }
 184 }
 185
 186 void Parser::skipWhitespace() {
 187         std::ifstream &stream = *m_stream;
 188
 189         while(!stream.fail() && std::isspace(stream.peek())) {
 190                 stream.get();
 191         }
 192 }
 193
 194 void Parser::closeFile() {
 195         delete m_stream;
 196         m_stream = NULL;
 197 }
 198
 199 const char *Parser::nameOf(TokenType type) const {
 200         static const char *name[] = {
 201                 "WORD",
 202                 "QUOTED_WORD",
 203                 "SYMBOL",
 204                 "END_OF_FILE"
 205         };
 206
 207         return name[type];
 208 }
 209
 210 } // namespace Config
 211 } // namespace Monitor