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