scilab/modules/slint/sci_gateway/cpp/sci_slint.cpp

   1 /*
   2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  * Copyright (C) 2006 - INRIA - Antoine ELIAS
   4  *
   5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
   6  *
   7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
   8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
   9  * This file was originally licensed under the terms of the CeCILL v2.1,
  10  * and continues to be available under such terms.
  11  * For more information, see the COPYING file which you should have received
  12  * along with this program.
  13  *
  14  */
  15
  16 #include <iostream>
  17 #include <string>
  18
  19 #include "SLint.hxx"
  20 #include "output/SLintScilabResult.hxx"
  21 #include "output/SLintXmlResult.hxx"
  22 #include "output/cnes/CNESXmlResult.hxx"
  23 #include "output/cnes/CNESCsvResult.hxx"
  24 #include "config/cnes/ToolConfiguration.hxx"
  25 #include "config/XMLConfig.hxx"
  26
  27 #include "struct.hxx"
  28 #include "string.hxx"
  29 #include "slint_gw.hxx"
  30
  31 extern "C"
  32 {
  33 #include "Scierror.h"
  34 #include "localization.h"
  35 }
  36
  37 /**
  38  * slint(String[a,b] files, String[1,c] conf, String[1,1] out)
  39  * slint(String[a,b] files, String[1,1] out)                   : default conf is etc/slint.xml
  40  * slint(String[a,b] files)                                    : default conf is etc/slint.xml & out is outputstream
  41  * slint(String[a,b] files, bool[1,1] printResult)             : default conf is etc/slint.xml
  42  * slint(String[a,b] files, String[1,c] conf, bool[1,1] printResult)
  43  */
  44
  45 /*--------------------------------------------------------------------------*/
  46 types::Function::ReturnValue sci_slint(types::typed_list & in, int _iRetCount, types::typed_list & out)
  47 {
  48     slint::SLintResult * results = nullptr;
  49     bool printResults = false;
  50     const int size = (int)in.size();
  51     types::String * conf = nullptr;
  52     types::String * outFile = nullptr;
  53
  54     if (size == 0 || size >= 4)
  55     {
  56         Scierror(999, _("%s: Wrong number of input arguments: at least %d expected.\n"), "slint", 1);
  57         return types::Function::Error;
  58     }
  59
  60     if (!in[0]->isString())
  61     {
  62         Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), "slint", 1);
  63         return types::Function::Error;
  64     }
  65
  66     switch (size)
  67     {
  68         case 1:
  69         {
  70             printResults = true;
  71             break;
  72         }
  73         case 2:
  74         {
  75             if (in[1]->isBool())
  76             {
  77                 if (in[1]->getAs<types::Bool>()->getSize() == 1)
  78                 {
  79                     printResults = in[1]->getAs<types::Bool>()->get(0) == 0 ? false : true;
  80                 }
  81                 else
  82                 {
  83                     Scierror(999, _("%s: Wrong type for input argument #%d: A single boolean expected.\n"), "slint", 2);
  84                     return types::Function::Error;
  85                 }
  86             }
  87             else if (in[1]->isString())
  88             {
  89                 outFile = in[1]->getAs<types::String>();
  90             }
  91             else
  92             {
  93                 Scierror(999, _("%s: Wrong type for input argument #%d: A string or a boolean expected.\n"), "slint", 2);
  94                 return types::Function::Error;
  95             }
  96             break;
  97         }
  98         case 3:
  99         {
 100             if (in[2]->isBool())
 101             {
 102                 if (in[2]->getAs<types::Bool>()->getSize() == 1)
 103                 {
 104                     printResults = in[2]->getAs<types::Bool>()->get(0) == 0 ? false : true;
 105                 }
 106                 else
 107                 {
 108                     Scierror(999, _("%s: Wrong type for input argument #%d: A single boolean expected.\n"), "slint", 3);
 109                     return types::Function::Error;
 110                 }
 111             }
 112             else if (in[2]->isString())
 113             {
 114                 outFile = in[2]->getAs<types::String>();
 115             }
 116             else
 117             {
 118                 Scierror(999, _("%s: Wrong type for input argument #%d: A string or a boolean expected.\n"), "slint", 3);
 119                 return types::Function::Error;
 120             }
 121
 122             if (!in[1]->isString())
 123             {
 124                 Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), "slint", 3);
 125                 return types::Function::Error;
 126             }
 127             conf = in[1]->getAs<types::String>();
 128             break;
 129         }
 130     }
 131
 132     try
 133     {
 134         slint::SLintOptions options;
 135         if (conf)
 136         {
 137             if (conf->getSize() == 1)
 138             {
 139                 slint::XMLConfig::getOptions(conf->get(0), options);
 140             }
 141             else
 142             {
 143                 slint::XMLConfig::getOptions(*conf, options);
 144             }
 145         }
 146         else
 147         {
 148             slint::XMLConfig::getOptions(L"SCI/modules/slint/etc/slint.xml", options);
 149         }
 150
 151         if (outFile)
 152         {
 153             if (conf && conf->getSize() >= 2 && (std::wstring(conf->get(0)) == L"cnes"))
 154             {
 155                 const slint::CNES::ToolConfiguration tc = slint::CNES::ToolConfiguration::createFromXml(conf->get(1));
 156                 const std::wstring out(outFile->get(0));
 157                 const std::size_t pos = out.find_last_of(L'.');
 158                 if (pos != std::string::npos && out.substr(pos) == L".csv")
 159                 {
 160                     results = new slint::CNES::CNESCsvResult(tc, conf, options.getId(), outFile->get(0));
 161                 }
 162                 else
 163                 {
 164                     results = new slint::CNES::CNESXmlResult(tc, conf, options.getId(), outFile->get(0));
 165                 }
 166             }
 167             else
 168             {
 169                 results = new slint::SLintXmlResult(outFile->get(0));
 170             }
 171         }
 172         else
 173         {
 174             if (printResults)
 175             {
 176                 results = new slint::SLintScilabResult();
 177             }
 178             else
 179             {
 180                 results = new slint::SLintScilabOut();
 181             }
 182         }
 183
 184         slint::SLint slint(options, *results);
 185         slint.setFiles(in[0]->getAs<types::String>());
 186         slint.check();
 187         results->finalize();
 188
 189         if (!outFile && !printResults)
 190         {
 191             out.emplace_back(static_cast<slint::SLintScilabOut *>(results)->getStruct());
 192         }
 193     }
 194     catch (slint::PCREException & e)
 195     {
 196         delete results;
 197         Scierror(999, _("%s: %s\n"), "slint", e.what(), 1);
 198         return types::Function::Error;
 199     }
 200     catch (slint::FileException & e)
 201     {
 202         delete results;
 203         Scierror(999, _("%s: %s\n"), "slint", e.what(), 1);
 204         return types::Function::Error;
 205     }
 206     catch (slint::SLintXMLException & e)
 207     {
 208         delete results;
 209         Scierror(999, _("%s: %s\n"), "slint", e.what(), 1);
 210         return types::Function::Error;
 211     }
 212
 213     delete results;
 214
 215     return types::Function::OK;
 216 }