fb9dc77b72a5700b16930454864f85a609c82d48
[scilab.git] / 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 }