fix crash at startup
[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  *  This file must be used under the terms of the CeCILL.
7  *  This source file is licensed as described in the file COPYING, which
8  *  you should have received as part of this distribution.  The terms
9  *  are also available at
10  *  http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
11  *
12  */
13 /*--------------------------------------------------------------------------*/
14 #include "SciDocMain.hxx"
15 #include "GiwsException.hxx"
16 #include "BuildDocObject.hxx"
17
18 extern "C"
19 {
20     /*--------------------------------------------------------------------------*/
21 #include <string.h>
22 #include "api_scilab.h"
23 #include "gw_helptools.h"
24 #include "Scierror.h"
25 #include "sci_path.h"
26 #include "localization.h"
27 #include "setgetlanguage.h"
28 #include "getScilabJavaVM.h"
29 #include "sci_malloc.h"
30 #ifdef _MSC_VER
31 #include "ConvertSlash.h"
32 #endif
33     /*--------------------------------------------------------------------------*/
34 #define PATHTOCSS "/modules/helptools/css/javahelp.css"
35 #define PATHTOBUILDDOC "/modules/helptools/build/doc/scilab_%s_help/"
36 #define PATHTOMASTERXML "/modules/helptools/master_%s_help.xml"
37 #define DEFAULTEXPORT "JH"
38 #ifdef _MSC_VER
39     static void __slashToAntislash(std::string * in)
40     {
41         size_t found = in->rfind("/");
42
43         while (found != std::string::npos)
44         {
45             in->replace(found, 1, "\\");
46             found = in->rfind("/");
47         }
48     }
49 #endif
50     /*--------------------------------------------------------------------------*/
51     int sci_buildDoc(char *fname, void* pvApiCtx)
52     {
53         std::string exportFormat;
54         std::string SciPath = getSCI(); /* Scilab path */
55         std::string masterXML; /* Which file contains all the doc stuff */
56         std::string masterXMLTMP;
57         std::string outputDirectory;    /* Working directory */
58         std::string outputDirectoryTMP;
59         std::string language;
60         std::string styleSheet; /* the CSS */
61         char * fileToExec = NULL;
62         SciErr sciErr;
63         int *piAddr = NULL;
64         int iRet = 0;
65
66         CheckRhs(0, 4);
67         CheckLhs(1, 1);
68
69         styleSheet = SciPath + PATHTOCSS;
70
71         if (Rhs < 1)
72         {
73             exportFormat = DEFAULTEXPORT;
74         }
75         else
76         {
77             char* pstData = NULL;
78             sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
79
80             if (sciErr.iErr)
81             {
82                 printError(&sciErr, 0);
83                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
84                 return 0;
85             }
86
87             if (!isStringType(pvApiCtx, piAddr))
88             {
89                 Scierror(999, _("%s: Wrong type for input argument #%d: Single string expected.\n"), fname, 1);
90                 return 0;
91                 // Wrong type string
92             }
93
94             iRet = getAllocatedSingleString(pvApiCtx, piAddr, &pstData);
95             if (iRet)
96             {
97                 freeAllocatedSingleString(pstData);
98                 return iRet;
99             }
100             exportFormat = std::string(pstData);
101             freeAllocatedSingleString(pstData);
102
103
104         }
105
106         if (Rhs < 3)            /* Language not provided */
107         {
108             wchar_t* l = getlanguage();
109             language = wide_string_to_UTF8(l);
110             free(l);
111         }
112         else
113         {
114             char* pstData = NULL;
115             sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr);
116
117             if (sciErr.iErr)
118             {
119                 printError(&sciErr, 0);
120                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
121                 return 0;
122             }
123
124             if (!isStringType(pvApiCtx, piAddr))
125             {
126                 Scierror(999, _("%s: Wrong type for input argument #%d: Single string expected.\n"), fname, 3);
127                 return 0;
128                 // Wrong type string
129             }
130
131             if (!isScalar(pvApiCtx, piAddr))
132             {
133                 wchar_t* pwstLang = getlanguage();
134                 language = wide_string_to_UTF8(pwstLang);
135                 free(pwstLang);
136             }
137             else
138             {
139                 iRet = getAllocatedSingleString(pvApiCtx, piAddr, &pstData);
140                 if (iRet)
141                 {
142                     freeAllocatedSingleString(pstData);
143                     return iRet;
144                 }
145                 language = std::string(pstData);
146                 freeAllocatedSingleString(pstData);
147
148             }
149
150         }
151
152         if (Rhs < 2)
153         {
154             /* Update the path with the localization */
155             masterXMLTMP = std::string("/modules/helptools/master_") + language + std::string("_help.xml");
156             masterXML = SciPath + masterXMLTMP;
157         }
158         else
159         {
160             char* pstData = NULL;
161             sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);
162
163             if (sciErr.iErr)
164             {
165                 printError(&sciErr, 0);
166                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
167                 return 0;
168             }
169             if (!isStringType(pvApiCtx, piAddr))
170             {
171                 Scierror(999, _("%s: Wrong type for input argument #%d: Single string expected.\n"), fname, 2);
172                 return 0;
173                 // Wrong type string
174             }
175
176
177             iRet = getAllocatedSingleString(pvApiCtx, piAddr, &pstData);
178             if (iRet)
179             {
180                 freeAllocatedSingleString(pstData);
181                 return iRet;
182             }
183             masterXML = std::string(pstData);
184             freeAllocatedSingleString(pstData);
185         }
186
187         if (Rhs == 4)
188         {
189             char* pstData = NULL;
190             sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr);
191
192             if (sciErr.iErr)
193             {
194                 printError(&sciErr, 0);
195                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
196                 return 0;
197             }
198             if (!isStringType(pvApiCtx, piAddr))
199             {
200                 Scierror(999, _("%s: Wrong type for input argument #%d: Single string expected.\n"), fname, 4);
201                 return 0;
202                 // Wrong type string
203             }
204
205             iRet = getAllocatedSingleString(pvApiCtx, piAddr, &pstData);
206             if (iRet)
207             {
208                 freeAllocatedSingleString(pstData);
209                 return iRet;
210             }
211             outputDirectory = std::string(pstData) + std::string("/scilab_") + language + std::string("_help/");
212             freeAllocatedSingleString(pstData);
213
214         }
215         else                    /* Scilab help */
216         {
217             /* Update the path with the localization */
218             if (exportFormat != "jar-only")
219             {
220                 outputDirectoryTMP =
221                     std::string("/modules/helptools/") + std::string(exportFormat) + std::string("/scilab_") + language + std::string("_help/");
222             }
223             else
224             {
225                 outputDirectoryTMP =
226                     std::string("/modules/helptools/") + std::string("javaHelp") + std::string("/scilab_") + language + std::string("_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 }