fcecdb4d26dde6816df70b2f2d2a6fd6621d515d
[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             wchar_t* l = getlanguage();
116             temp = wide_string_to_UTF8(l);
117             language = std::string(temp);
118             FREE(temp);
119             free(l);
120         }
121         else
122         {
123             char* pstData = NULL;
124             sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr);
125
126             if (sciErr.iErr)
127             {
128                 printError(&sciErr, 0);
129                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
130                 return 0;
131             }
132
133             if (!isStringType(pvApiCtx, piAddr))
134             {
135                 Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 3);
136                 return 0;
137                 // Wrong type string
138             }
139
140             if (!isScalar(pvApiCtx, piAddr))
141             {
142                 wchar_t* pwstLang = getlanguage();
143                 temp = wide_string_to_UTF8(pwstLang);
144                 language = std::string(temp);
145                 FREE(temp);
146                 free(pwstLang);
147             }
148             else
149             {
150                 iRet = getAllocatedSingleString(pvApiCtx, piAddr, &pstData);
151                 if (iRet)
152                 {
153                     freeAllocatedSingleString(pstData);
154                     return iRet;
155                 }
156                 language = std::string(pstData);
157                 freeAllocatedSingleString(pstData);
158
159             }
160
161         }
162
163         if (Rhs < 2)
164         {
165             /* Update the path with the localization */
166             masterXMLTMP = std::string("/modules/helptools/master_") + language + std::string("_help.xml");
167             masterXML = SciPath + masterXMLTMP;
168         }
169         else
170         {
171             char* pstData = NULL;
172             sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);
173
174             if (sciErr.iErr)
175             {
176                 printError(&sciErr, 0);
177                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
178                 return 0;
179             }
180             if (!isStringType(pvApiCtx, piAddr))
181             {
182                 Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 2);
183                 return 0;
184                 // Wrong type string
185             }
186
187
188             iRet = getAllocatedSingleString(pvApiCtx, piAddr, &pstData);
189             if (iRet)
190             {
191                 freeAllocatedSingleString(pstData);
192                 return iRet;
193             }
194             masterXML = std::string(pstData);
195             freeAllocatedSingleString(pstData);
196         }
197
198         if (Rhs == 4)
199         {
200             char* pstData = NULL;
201             sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr);
202
203             if (sciErr.iErr)
204             {
205                 printError(&sciErr, 0);
206                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
207                 return 0;
208             }
209             if (!isStringType(pvApiCtx, piAddr))
210             {
211                 Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 4);
212                 return 0;
213                 // Wrong type string
214             }
215
216             iRet = getAllocatedSingleString(pvApiCtx, piAddr, &pstData);
217             if (iRet)
218             {
219                 freeAllocatedSingleString(pstData);
220                 return iRet;
221             }
222             outputDirectory = std::string(pstData) + std::string("/scilab_") + language + std::string("_help/");
223             freeAllocatedSingleString(pstData);
224
225         }
226         else                    /* Scilab help */
227         {
228             /* Update the path with the localization */
229             if (exportFormat != "jar-only")
230             {
231                 outputDirectoryTMP =
232                     std::string("/modules/helptools/") + std::string(exportFormat) + std::string("/scilab_") + language + std::string("_help/");
233             }
234             else
235             {
236                 outputDirectoryTMP =
237                     std::string("/modules/helptools/") + std::string("javaHelp") + std::string("/scilab_") + language + std::string("_help/");
238             }
239
240             outputDirectory = SciPath + outputDirectoryTMP;
241         }
242
243 #ifdef _MSC_VER
244         __slashToAntislash(&outputDirectory);
245         __slashToAntislash(&styleSheet);
246         __slashToAntislash(&masterXML);
247 #endif
248
249         try
250         {
251             org_scilab_modules_helptools::SciDocMain * doc = new org_scilab_modules_helptools::SciDocMain(getScilabJavaVM());
252
253             if (doc->setOutputDirectory((char *)outputDirectory.c_str()))
254             {
255                 doc->setWorkingLanguage((char *)language.c_str());
256                 doc->setExportFormat((char *)exportFormat.c_str());
257                 doc->setIsToolbox(Rhs == 4);
258                 fileToExec = doc->process((char *)masterXML.c_str(), (char *)styleSheet.c_str());
259             }
260             else
261             {
262                 Scierror(999, _("%s: Could find or create the working directory %s.\n"), fname, outputDirectory.c_str());
263                 return FALSE;
264             }
265             if (doc != NULL)
266             {
267                 delete doc;
268             }
269         }
270         catch (GiwsException::JniException ex)
271         {
272             Scierror(999, _("%s: Error while building documentation: %s.\n"), fname, ex.getJavaDescription().c_str());
273             Scierror(999, _("%s: Execution Java stack: %s.\n"), fname, ex.getJavaStackTrace().c_str());
274             Scierror(999,
275                      _
276                      ("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"));
277             return FALSE;
278         }
279
280         if (fileToExec)
281         {
282             createMatrixOfString(pvApiCtx, Rhs + 1, 1, 1, &fileToExec);
283             delete [] fileToExec;
284         }
285         else
286         {
287             createEmptyMatrix(pvApiCtx, Rhs + 1);
288         }
289
290         LhsVar(1) = Rhs + 1;
291         PutLhsVar();
292
293         return 0;
294     }
295     /*--------------------------------------------------------------------------*/
296 }