src/a_osloader.cc

   1 ///
   2 /// \file       a_osloader.cc
   3 ///             OS files parser (multi ALX files parser)
   4 ///
   5
   6 /*
   7     Copyright (C) 2010, Nicolas VIVIEN
   8     Copyright (C) 2005-2012, Net Direct Inc. (http://www.netdirect.ca/)
   9
  10     This program is free software; you can redistribute it and/or modify
  11     it under the terms of the GNU General Public License as published by
  12     the Free Software Foundation; either version 2 of the License, or
  13     (at your option) any later version.
  14
  15     This program is distributed in the hope that it will be useful,
  16     but WITHOUT ANY WARRANTY; without even the implied warranty of
  17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  18
  19     See the GNU General Public License in the COPYING file at the
  20     root directory of this project for more details.
  21 */
  22
  23 #include <iostream>
  24 #include <fstream>
  25 #include <algorithm>
  26
  27 #include <sys/types.h>
  28 #include <dirent.h>
  29 #include <errno.h>
  30
  31 #include "a_osloader.h"
  32 #include "a_alxparser.h"
  33 #include "vsmartptr.h"
  34 #include "error.h"
  35 #include "ios_state.h"
  36
  37
  38 namespace Barry {
  39
  40 namespace ALX {
  41
  42
  43 OSLoader::OSLoader(void)
  44 {
  45 }
  46
  47
  48 OSLoader::~OSLoader(void)
  49 {
  50 }
  51
  52
  53 void OSLoader::Load(const std::string& pathname)
  54 {
  55 #define ALX_FILE_EXT    ".alx"
  56
  57         int offset;
  58
  59         struct dirent *entry;
  60
  61         std::string alxfile;
  62         const std::string ext = ALX_FILE_EXT;
  63
  64         // At first, we have to read platform properties...
  65         alxfile = pathname + "/Platform.alx";
  66         LoadALXFile(alxfile, false);
  67
  68         // Then, we can read all ALX files
  69         // Wrap it in a smart pointer so exceptions are safe
  70         vLateSmartPtr<DIR, int (*)(DIR*)> path(&closedir);
  71         path.reset( opendir(pathname.c_str()) );
  72         if( path.get() == NULL )
  73                 throw Barry::ErrnoError("Could not opendir: " + pathname, errno);
  74
  75         while ((entry = readdir(path.get())) != NULL) {
  76                 alxfile = entry->d_name;
  77
  78                 if (alxfile.length() < ext.length())
  79                         continue;
  80
  81                 offset = alxfile.length() - ext.length();
  82
  83                 // Ignore all files except ".alx" files
  84                 if (alxfile.substr(offset, ext.length()) != ALX_FILE_EXT)
  85                         continue;
  86
  87                 LoadALXFile(pathname + "/" + alxfile, true);
  88         }
  89 }
  90
  91
  92 void OSLoader::LoadALXFile(const std::string& alxfile, const bool enable)
  93 {
  94         std::ifstream file(alxfile.c_str());
  95         if( !file )
  96                 throw Barry::Error("Cannot open ALX file: " + alxfile);
  97
  98         ALX::ALXParser parser(*this, file);
  99
 100         parser.Run(enable);
 101
 102         file.close();
 103 }
 104
 105
 106 void OSLoader::Dump(std::ostream &os) const
 107 {
 108         ios_format_state state(os);
 109
 110         os << "OS Properties :" << std::endl;
 111
 112         {
 113                 std::map<std::string, std::string>::const_iterator b = properties.begin(), e = properties.end();
 114
 115                 for (; b != e; b++) {
 116                         os << "  - " << (*b).first << " = " << (*b).second << std::endl;
 117                 }
 118         }
 119
 120         os << std::endl;
 121
 122         os << "SFI File :" << std::endl;
 123         os << "  " << sfifile << std::endl;
 124         os << std::endl;
 125
 126         os << "Applications :" << std::endl;
 127
 128         {
 129                 CODSectionList::const_iterator b = applications.begin(), e = applications.end();
 130
 131                 for (; b != e; b++) {
 132                         os << (**b) << std::endl;
 133                 }
 134         }
 135
 136         os << "Libraries :" << std::endl;
 137
 138         {
 139                 CODSectionList::const_iterator b = libraries.begin(), e = libraries.end();
 140
 141                 for (; b != e; b++) {
 142                         os << (**b) << std::endl;
 143                 }
 144         }
 145 }
 146
 147
 148 void OSLoader::AddProperties(const std::string& property, const std::string& value)
 149 {
 150         properties[property] = value;
 151
 152         if (property == "JVMLevel")
 153                 properties["Java"] = value;
 154 }
 155
 156
 157 void OSLoader::AddProperties(const xmlpp::SaxParser::AttributeList& attrs)
 158 {
 159         for (xmlpp::SaxParser::AttributeList::const_iterator iter = attrs.begin(); iter != attrs.end(); ++iter) {
 160                 std::string attribut(iter->name);
 161                 std::string value(iter->value);
 162
 163                 AddProperties(attribut, value);
 164         }
 165 }
 166
 167
 168 void OSLoader::SetSFIFile(const std::string& name)
 169 {
 170         sfifile = name;
 171 }
 172
 173
 174 bool OSLoader::IsSupported(const xmlpp::SaxParser::AttributeList& attrs)
 175 {
 176         if (properties.empty())
 177                 return false;
 178
 179         for (xmlpp::SaxParser::AttributeList::const_iterator iter = attrs.begin(); iter != attrs.end(); ++iter) {
 180                 std::string attribut(iter->name);
 181                 std::string value(iter->value);
 182
 183                 std::string s = properties[attribut];
 184
 185                 std::transform(value.begin(), value.end(), value.begin(), ::tolower);
 186                 std::transform(s.begin(), s.end(), s.begin(), ::tolower);
 187
 188                 if (value[0] == '~') {
 189                         value = value.substr(1, value.length()-1);
 190
 191                         if (s == value)
 192                                 return false;
 193                 }
 194                 else {
 195                         if (s != value)
 196                                 return false;
 197                 }
 198         }
 199
 200         return true;
 201 }
 202
 203
 204 void OSLoader::AddApplication(OSLoader::CODSectionPtr app)
 205 {
 206         applications.push_back(app);
 207 }
 208
 209
 210 void OSLoader::AddLibrary(OSLoader::CODSectionPtr lib)
 211 {
 212         libraries.push_back(lib);
 213 }
 214
 215
 216 } // namespace ALX
 217
 218 } // namespace Barry
 219