ryzom/tools/stats_scan/char_scan_script.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 //-----------------------------------------------------------------------------
  18 // includes
  19 //-----------------------------------------------------------------------------
  20
  21 #include "nel/misc/variable.h"
  22 #include "nel/misc/path.h"
  23 #include "game_share/file_description_container.h"
  24 #include "game_share/utils.h"
  25 #include "char_scan_script.h"
  26
  27
  28 //-----------------------------------------------------------------------------
  29 // Namespaces
  30 //-----------------------------------------------------------------------------
  31
  32 using namespace std;
  33 using namespace NLMISC;
  34
  35
  36 //-----------------------------------------------------------------------------
  37 // Variables
  38 //-----------------------------------------------------------------------------
  39
  40 CVariable<string>       ScriptDirectory("variables", "ScriptDirectory", "Directory containing script files", string("./"), 0, true);
  41 CVariable<string>       OutputDirectory("variables", "OutputDirectory", "Directory containing output files", string("./"), 0, true);
  42
  43
  44 //-------------------------------------------------------------------------------------------------
  45 // methods CCharScanScript
  46 //-------------------------------------------------------------------------------------------------
  47
  48 bool CCharScanScript::addScriptFile(const std::string& fileName)
  49 {
  50         std::string fullFileName=NLMISC::CPath::standardizePath(ScriptDirectory)+fileName;
  51
  52         // make sure the file exists
  53         if (!NLMISC::CFile::fileExists(fullFileName))
  54         {
  55                 nlwarning("script file not found: %s",fullFileName.c_str());
  56                 return false;
  57         }
  58
  59         // make sure the file hasn't already been included previously
  60         for (uint32 i=0;i<_ScriptFiles.size();++i)
  61         {
  62                 if (_ScriptFiles[i].getFileName()==fullFileName)
  63                 {
  64                         nlwarning("attempt to include script file '%s' more than once",fullFileName.c_str());
  65                         return true;
  66                 }
  67         }
  68
  69         // add & parse the new file
  70         return vectAppend(_ScriptFiles).parseFile(fullFileName);
  71 }
  72
  73 void CCharScanScript::applyToJob(CCharacterScanJob& job)
  74 {
  75         // iterate backwards over the script files in order to apply the most important files last
  76         for (uint32 i=(uint32)_ScriptFiles.size();i--;)
  77         {
  78                 _ScriptFiles[i].applyToJob(job);
  79         }
  80 }
  81
  82 //-------------------------------------------------------------------------------------------------
  83 // methods CCharScanScriptFile
  84 //-------------------------------------------------------------------------------------------------
  85
  86 bool CCharScanScriptFile::parseFile(const std::string& fileName, CCharScanScript* container)
  87 {
  88         _FileName= fileName;
  89
  90         // read the content of the input file
  91         bool result;
  92         NLMISC::CSString fileContent;
  93         result=fileContent.readFromFile(fileName);
  94         if (result==false)
  95         {
  96                 nlwarning("Failed to read script file: %s",fileName.c_str());
  97                 return false;
  98         }
  99
 100         // split the file into lines and execute them one by one
 101         NLMISC::CVectorSString lines;
 102         fileContent.splitLines(lines);
 103         for (uint32 i=0;i<lines.size();++i)
 104         {
 105                 // strip comments and leading and trailing blanks
 106                 CSString theLine= lines[i].replace("//","\xff").splitTo('\xff').strip();
 107                 if (theLine.empty())
 108                         continue;
 109
 110                 CCharScanScriptCommandRegistry::getInstance()->execute(*this,theLine,container);
 111         }
 112         return true;
 113 }
 114
 115 bool CCharScanScriptFile::applyToJob(CCharacterScanJob& job)
 116 {
 117         bool result=true;
 118
 119         // apply the file names
 120         CFileDescriptionContainer fdc;
 121         for (uint32 i=0;i<_InputFiles.size();++i)
 122         {
 123                 fdc.addFileSpec(_InputFiles[i]);
 124         }
 125         job.addFiles(fdc);
 126
 127         // apply the filters
 128         for (uint32 i=0;i<_Filters.size();++i)
 129         {
 130                 ICharFilter* filter= CCharFilterFactory::getInstance()->build(_Filters[i]);
 131                 if (filter==NULL)
 132                 {
 133                         nlwarning("Failed to build filter description from line: %s",_Filters[i].c_str());
 134                         result=false;
 135                         continue;
 136                 }
 137                 job.addFilter(filter);
 138         }
 139
 140         // apply the info extractors
 141         for (uint32 i=0;i<_InfoExtractors.size();++i)
 142         {
 143                 ICharInfoExtractor* infoExtractor= CCharInfoExtractorFactory::getInstance()->build(_InfoExtractors[i]);
 144                 if (infoExtractor==NULL)
 145                 {
 146                         nlwarning("Failed to build filter description from line: %s",_InfoExtractors[i].c_str());
 147                         result=false;
 148                         continue;
 149                 }
 150                 job.addInfoExtractor(infoExtractor);
 151         }
 152
 153         // apply the output path
 154         job.setOutputPath(_OutputPath);
 155
 156         return result;
 157 }
 158
 159 const std::string& CCharScanScriptFile::getFileName() const
 160 {
 161         return _FileName;
 162 }
 163
 164 const std::string& CCharScanScriptFile::getDescription() const
 165 {
 166         return _Description;
 167 }
 168
 169 bool CCharScanScriptFile::setDescription(const std::string& description)
 170 {
 171         _Description= description;
 172         return true;
 173 }
 174
 175 bool CCharScanScriptFile::setOutputPath(const std::string& path)
 176 {
 177         _OutputPath= path;
 178         return true;
 179 }
 180
 181 bool CCharScanScriptFile::addFilter(const std::string& rawArgs)
 182 {
 183         _Filters.push_back(rawArgs);
 184         return true;
 185 }
 186
 187 bool CCharScanScriptFile::addInfoExtractor(const std::string& rawArgs)
 188 {
 189         _InfoExtractors.push_back(rawArgs);
 190         return true;
 191 }
 192
 193 bool CCharScanScriptFile::addInputFiles(const std::string& rawArgs)
 194 {
 195         _InputFiles.push_back(rawArgs);
 196         return true;
 197 }
 198
 199
 200 //-------------------------------------------------------------------------------------------------
 201 // methods CCharScanScriptCommandRegistry
 202 //-------------------------------------------------------------------------------------------------
 203
 204 CCharScanScriptCommandRegistry* CCharScanScriptCommandRegistry::getInstance()
 205 {
 206         static CCharScanScriptCommandRegistry* ptr=NULL;
 207         if (ptr==NULL)
 208                 ptr= new CCharScanScriptCommandRegistry;
 209         return ptr;
 210 }
 211
 212 void CCharScanScriptCommandRegistry::registerScriptCommand(NLMISC::CSmartPtr<ICharScanScriptCommand> scriptCommand)
 213 {
 214         // ensure that we don't have a name conflict with an existing script command
 215         for (uint32 i=0;i<_ScriptCommands.size();++i)
 216         {
 217                 nlassert(scriptCommand->getName()!=_ScriptCommands[i]->getName());
 218         }
 219
 220         // add the new script command
 221         _ScriptCommands.push_back(scriptCommand);
 222 }
 223
 224 void CCharScanScriptCommandRegistry::displayScriptCommands(NLMISC::CLog* log)
 225 {
 226         uint32 longestName=4;
 227
 228         // iterate over the script commands to determine the length of the longest name
 229         for (uint32 i=0;i<_ScriptCommands.size();++i)
 230         {
 231                 std::string s= _ScriptCommands[i]->getName();
 232                 if (s.size()>longestName)
 233                         longestName=(uint32)s.size();
 234         }
 235
 236         // iterate over the script commands displaying names and description
 237         for (uint32 i=0;i<_ScriptCommands.size();++i)
 238         {
 239                 log->displayNL("%-*s  %s",longestName,_ScriptCommands[i]->getName(),_ScriptCommands[i]->getDescription());
 240         }
 241 }
 242
 243 bool CCharScanScriptCommandRegistry::execute(CCharScanScriptFile& scriptFile,const CSString& commandLine,CCharScanScript* container)
 244 {
 245         // split the command line into its constituent parts
 246         CSString theCommand= commandLine.firstWordConst();
 247         CSString theRawArgs= commandLine.tailFromFirstWord().strip();
 248         CVectorSString theArgs;
 249         theRawArgs.splitByOneOfSeparators(" \t",theArgs,false,false,false,false,true);
 250
 251         // try to locate and execute the given command
 252         for (uint32 i=0;i<_ScriptCommands.size();++i)
 253         {
 254                 if (theCommand==_ScriptCommands[i]->getName())
 255                 {
 256                         return _ScriptCommands[i]->execute(scriptFile,theArgs,theRawArgs,commandLine,container);
 257                 }
 258         }
 259
 260         // we failed to find the command so bomb
 261         nlwarning("Unknown script command '%s' in line: %s",theCommand.c_str(),commandLine.c_str());
 262         return false;
 263 }
 264
 265
 266 //-----------------------------------------------------------------------------
 267 // CHAR_SCAN_SCRIPT_COMMAND: instances
 268 //-----------------------------------------------------------------------------
 269
 270 CHAR_SCAN_SCRIPT_COMMAND(description,"<description>","Set the description phrase for the script - displayed by the listScripts command")
 271 {
 272         if (rawArgs.strip().empty())
 273                 return false;
 274
 275         return scriptFile.setDescription(rawArgs);
 276 }
 277
 278 CHAR_SCAN_SCRIPT_COMMAND(include,"<include_file_name>","Include another script file")
 279 {
 280         if (args.size()!=1)
 281                 return false;
 282
 283         if (container==NULL)
 284                 return true;
 285
 286         return container->addScriptFile(args[0]);
 287 }
 288
 289 CHAR_SCAN_SCRIPT_COMMAND(inputFiles,"[<path>/]<file_spec>","Add a set of files to be parsed")
 290 {
 291         if (rawArgs.strip().empty())
 292                 return false;
 293
 294         return scriptFile.addInputFiles(rawArgs);
 295 }
 296
 297 CHAR_SCAN_SCRIPT_COMMAND(filter,"<name> [<args>]","Add a filter to limit the set criteria to determine which files' content to reflect in output")
 298 {
 299         if (rawArgs.strip().empty())
 300                 return false;
 301
 302         return scriptFile.addFilter(rawArgs);
 303 }
 304
 305 CHAR_SCAN_SCRIPT_COMMAND(infoExtactor,"<name> [<args>]","Add an info extractor")
 306 {
 307         if (rawArgs.strip().empty())
 308                 return false;
 309
 310         return scriptFile.addInfoExtractor(rawArgs);
 311 }
 312
 313 CHAR_SCAN_SCRIPT_COMMAND(outputPath,"<path>","Set the directory to which the output will be written")
 314 {
 315         if (args.size()!=1)
 316                 return false;
 317
 318         return scriptFile.setOutputPath(args[0]);
 319 }
 320
 321
 322 //-----------------------------------------------------------------------------