Merge remote-tracking branch 'origin/master' into windows
[scilab.git] / scilab / modules / helptools / sci_gateway / cpp / sci_buildDoc.cpp
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2008 - INRIA - Sylvestre LEDRU
4  *  Copyright (C) 2011 - Scilab Enterprises - Sylvestre LEDRU
5  *
6  * Copyright (C) 2012 - 2016 - Scilab Enterprises
7  *
8  * This file is hereby licensed under the terms of the GNU GPL v2.0,
9  * pursuant to article 5.3.4 of the CeCILL v.2.1.
10  * This file was originally licensed under the terms of the CeCILL v2.1,
11  * and continues to be available under such terms.
12  * For more information, see the COPYING file which you should have received
13  * along with this program.
14  *
15  */
16 /*--------------------------------------------------------------------------*/
17 #include "SciDocMain.hxx"
18 #include "GiwsException.hxx"
19 #include "BuildDocObject.hxx"
20
21 extern "C"
22 {
23     /*--------------------------------------------------------------------------*/
24 #include <string.h>
25 #include "api_scilab.h"
26 #include "gw_helptools.h"
27 #include "Scierror.h"
28 #include "sci_path.h"
29 #include "localization.h"
30 #include "setgetlanguage.h"
31 #include "getScilabJavaVM.h"
32 #include "sci_malloc.h"
33 #ifdef _MSC_VER
34 #include "ConvertSlash.h"
35 #endif
36     /*--------------------------------------------------------------------------*/
37 #define PATHTOCSS "/modules/helptools/css/javahelp.css"
38 #define PATHTOBUILDDOC "/modules/helptools/build/doc/scilab_%s_help/"
39 #define PATHTOMASTERXML "/modules/helptools/master_%s_help.xml"
40 #define DEFAULTEXPORT "JH"
41 #ifdef _MSC_VER
42     static void __slashToAntislash(std::string * in)
43     {
44         size_t found = in->rfind("/");
45
46         while (found != std::string::npos)
47         {
48             in->replace(found, 1, "\\");
49             found = in->rfind("/");
50         }
51     }
52 #endif
53     /*--------------------------------------------------------------------------*/
54     int sci_buildDoc(char *fname, void* pvApiCtx)
55     {
56         std::string exportFormat;
57         std::string SciPath; /* Scilab path */
58         std::string masterXML; /* Which file contains all the doc stuff */
59         std::string masterXMLTMP;
60         std::string outputDirectory;    /* Working directory */
61         std::string outputDirectoryTMP;
62         std::string language;
63         std::string styleSheet; /* the CSS */
64         char * fileToExec = NULL;
65         char * temp;
66         SciErr sciErr;
67         int *piAddr = NULL;
68         int iRet = 0;
69
70         CheckRhs(0, 4);
71         CheckLhs(1, 1);
72
73         temp = getSCI();
74         SciPath = std::string(temp);
75         free(temp);
76         styleSheet = SciPath + PATHTOCSS;
77
78         if (Rhs < 1)
79         {
80             exportFormat = DEFAULTEXPORT;
81         }
82         else
83         {
84             char* pstData = NULL;
85             sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
86
87             if (sciErr.iErr)
88             {
89                 printError(&sciErr, 0);
90                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
91                 return 0;
92             }
93
94             if (!isStringType(pvApiCtx, piAddr))
95             {
96                 Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 1);
97                 return 0;
98                 // Wrong type string
99             }
100
101             iRet = getAllocatedSingleString(pvApiCtx, piAddr, &pstData);
102             if (iRet)
103             {
104                 freeAllocatedSingleString(pstData);
105                 return iRet;
106             }
107             exportFormat = std::string(pstData);
108             freeAllocatedSingleString(pstData);
109
110
111         }
112
113         if (Rhs < 3)            /* Language not provided */
114         {
115             language = getlanguage();
116         }
117         else
118         {
119             char* pstData = NULL;
120             sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr);
121
122             if (sciErr.iErr)
123             {
124                 printError(&sciErr, 0);
125                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
126                 return 0;
127             }
128
129             if (!isStringType(pvApiCtx, piAddr))
130             {
131                 Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 3);
132                 return 0;
133                 // Wrong type string
134             }
135
136             if (!isScalar(pvApiCtx, piAddr))
137             {
138                 language = getlanguage();
139             }
140             else
141             {
142                 iRet = getAllocatedSingleString(pvApiCtx, piAddr, &pstData);
143                 if (iRet)
144                 {
145                     freeAllocatedSingleString(pstData);
146                     return iRet;
147                 }
148                 language = std::string(pstData);
149                 freeAllocatedSingleString(pstData);
150
151             }
152
153         }
154
155         if (Rhs < 2)
156         {
157             /* Update the path with the localization */
158             masterXMLTMP = std::string("/modules/helptools/master_") + language + std::string("_help.xml");
159             masterXML = SciPath + masterXMLTMP;
160         }
161         else
162         {
163             char* pstData = NULL;
164             sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);
165
166             if (sciErr.iErr)
167             {
168                 printError(&sciErr, 0);
169                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
170                 return 0;
171             }
172             if (!isStringType(pvApiCtx, piAddr))
173             {
174                 Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 2);
175                 return 0;
176                 // Wrong type string
177             }
178
179             iRet = getAllocatedSingleString(pvApiCtx, piAddr, &pstData);
180             if (iRet)
181             {
182                 freeAllocatedSingleString(pstData);
183                 return iRet;
184             }
185             masterXML = std::string(pstData);
186             freeAllocatedSingleString(pstData);
187         }
188
189         if (Rhs == 4)
190         {
191             char* pstData = NULL;
192             sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr);
193
194             if (sciErr.iErr)
195             {
196                 printError(&sciErr, 0);
197                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
198                 return 0;
199             }
200             if (!isStringType(pvApiCtx, piAddr))
201             {
202                 Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 4);
203                 return 0;
204                 // Wrong type string
205             }
206
207             iRet = getAllocatedSingleString(pvApiCtx, piAddr, &pstData);
208             if (iRet)
209             {
210                 freeAllocatedSingleString(pstData);
211                 return iRet;
212             }
213             outputDirectory = std::string(pstData) + "/scilab_" + language + "_help/";
214             freeAllocatedSingleString(pstData);
215
216         }
217         else                    /* Scilab help */
218         {
219             /* Update the path with the localization */
220             if (exportFormat != "jar-only")
221             {
222                 outputDirectoryTMP = "/modules/helptools/" + exportFormat + "/scilab_" + language + "_help/";
223             }
224             else
225             {
226                 outputDirectoryTMP = "/modules/helptools/javaHelp/scilab_" + language + "_help/";
227             }
228
229             outputDirectory = SciPath + outputDirectoryTMP;
230         }
231
232 #ifdef _MSC_VER
233         __slashToAntislash(&outputDirectory);
234         __slashToAntislash(&styleSheet);
235         __slashToAntislash(&masterXML);
236 #endif
237
238         try
239         {
240             org_scilab_modules_helptools::SciDocMain * doc = new org_scilab_modules_helptools::SciDocMain(getScilabJavaVM());
241
242             if (doc->setOutputDirectory((char *)outputDirectory.c_str()))
243             {
244                 doc->setWorkingLanguage((char *)language.c_str());
245                 doc->setExportFormat((char *)exportFormat.c_str());
246                 doc->setIsToolbox(Rhs == 4);
247                 fileToExec = doc->process((char *)masterXML.c_str(), (char *)styleSheet.c_str());
248             }
249             else
250             {
251                 Scierror(999, _("%s: Could find or create the working directory %s.\n"), fname, outputDirectory.c_str());
252                 return FALSE;
253             }
254             if (doc != NULL)
255             {
256                 delete doc;
257             }
258         }
259         catch (GiwsException::JniException ex)
260         {
261             Scierror(999, _("%s: Error while building documentation: %s.\n"), fname, ex.getJavaDescription().c_str());
262             Scierror(999, _("%s: Execution Java stack: %s.\n"), fname, ex.getJavaStackTrace().c_str());
263             Scierror(999,
264                      _
265                      ("If Scilab is started in a chroot, you might want to try to set the two environment variables: SCI_DISABLE_TK=1 SCI_JAVA_ENABLE_HEADLESS=1\n"));
266             return FALSE;
267         }
268
269         if (fileToExec)
270         {
271             createMatrixOfString(pvApiCtx, Rhs + 1, 1, 1, &fileToExec);
272             delete [] fileToExec;
273         }
274         else
275         {
276             createEmptyMatrix(pvApiCtx, Rhs + 1);
277         }
278
279         LhsVar(1) = Rhs + 1;
280         PutLhsVar();
281
282         return 0;
283     }
284     /*--------------------------------------------------------------------------*/
285 }