124e199b9b9559205b9c8b0c85dbf7d9b4d8478a
[scilab.git] / scilab / modules / fileio / sci_gateway / c / sci_mgetl.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2006 - INRIA - Allan CORNET
4  * Copyright (C) 2010 - DIGITEO - Allan CORNET
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 "gw_fileio.h"
15 #include "localization.h"
16 #include "Scierror.h"
17 #include "api_scilab.h"
18 #include "mgetl.h"
19 #include "mopen.h"
20 #include "mclose.h"
21 #include "expandPathVariable.h"
22 #include "filesmanagement.h"
23 #include "freeArrayOfString.h"
24 #include "BOOL.h"
25 /*--------------------------------------------------------------------------*/
26 int sci_mgetl(char *fname, unsigned long fname_len)
27 {
28     SciErr sciErr;
29     int *piAddressVarOne = NULL;
30     int numberOfLinesToRead = -1;
31
32     char **wcReadStrings = NULL;
33     int numberOfLinesRead = 0;
34     int fileDescriptor = 0;
35     int iErrorMgetl = 0;
36     BOOL bCloseFile = FALSE;
37
38     Rhs = Max(0, Rhs);
39
40     CheckRhs(1, 2);
41     CheckLhs(1, 1);
42
43
44     if (Rhs == 2)
45     {
46         int *piAddressVarTwo = NULL;
47
48         sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
49         if (sciErr.iErr)
50         {
51             printError(&sciErr, 0);
52             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
53             return 0;
54         }
55
56         if ( isDoubleType(pvApiCtx, piAddressVarTwo) )
57         {
58             double dValue = 0.;
59             if (!isScalar(pvApiCtx, piAddressVarTwo))
60             {
61                 Scierror(999, _("%s: Wrong size for input argument #%d: Integer expected.\n"), fname, 2);
62                 return 0;
63             }
64
65             if ( getScalarDouble(pvApiCtx, piAddressVarTwo, &dValue) == 0)
66             {
67                 numberOfLinesToRead = (int)dValue;
68             }
69             else
70             {
71                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
72                 return 0;
73             }
74         }
75         else
76         {
77             Scierror(999, _("%s: Wrong type for input argument #%d: Integer expected.\n"), fname, 2);
78             return 0;
79         }
80     }
81
82     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
83     if (sciErr.iErr)
84     {
85         printError(&sciErr, 0);
86         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
87         return 0;
88     }
89
90     if (isStringType(pvApiCtx, piAddressVarOne) == FALSE &&  isDoubleType(pvApiCtx, piAddressVarOne) == FALSE)
91     {
92         Scierror(999, _("%s: Wrong type for input argument #%d: String or logical unit expected.\n"), fname, 1);
93         return 0;
94     }
95
96     if (!isScalar(pvApiCtx, piAddressVarOne))
97     {
98         Scierror(999, _("%s: Wrong size for input argument #%d: String or logical unit expected.\n"), fname, 1);
99         return 0;
100     }
101
102     if (isStringType(pvApiCtx, piAddressVarOne))
103     {
104         char *fileName = NULL;
105         char *expandedFileName = NULL;
106         if (getAllocatedSingleString(pvApiCtx, piAddressVarOne, &fileName))
107         {
108             if (fileName)
109             {
110                 freeAllocatedSingleString(fileName);
111             }
112
113             Scierror(999, _("%s: Memory allocation error.\n"), fname);
114             return 0;
115         }
116
117         expandedFileName = expandPathVariable(fileName);
118         freeAllocatedSingleString(fileName);
119
120         if (IsAlreadyOpenedInScilab(expandedFileName))
121         {
122             int fd = GetIdFromFilename(expandedFileName);
123             fileDescriptor = fd;
124             FREE(expandedFileName);
125             bCloseFile = FALSE;
126         }
127         else
128         {
129 #define READ_ONLY_TEXT_MODE "rt"
130             int fd = 0;
131             int f_swap = 0;
132             double res = 0.0;
133             int ierr = 0;
134
135             C2F(mopen)(&fd, expandedFileName, READ_ONLY_TEXT_MODE, &f_swap, &res, &ierr);
136             bCloseFile = TRUE;
137
138             switch (ierr)
139             {
140                 case MOPEN_NO_ERROR:
141                     fileDescriptor = fd;
142                     FREE(expandedFileName);
143                     break;
144                 case MOPEN_NO_MORE_LOGICAL_UNIT:
145                 {
146                     Scierror(66, _("%s: Too many files opened!\n"), fname);
147                     FREE(expandedFileName);
148                     return 0;
149                 }
150                 break;
151                 case MOPEN_CAN_NOT_OPEN_FILE:
152                 {
153                     Scierror(999, _("%s: Cannot open file %s.\n"), fname, expandedFileName);
154                     FREE(expandedFileName);
155                     return 0;
156                 }
157                 break;
158                 case MOPEN_NO_MORE_MEMORY:
159                 {
160                     FREE(expandedFileName);
161                     Scierror(999, _("%s: No more memory.\n"), fname);
162                     return 0;
163                 }
164                 break;
165                 case MOPEN_INVALID_FILENAME:
166                 {
167                     Scierror(999, _("%s: invalid filename %s.\n"), fname, expandedFileName);
168                     FREE(expandedFileName);
169                     return 0;
170                 }
171                 break;
172                 case MOPEN_INVALID_STATUS:
173                 default:
174                 {
175                     FREE(expandedFileName);
176                     Scierror(999, _("%s: invalid status.\n"), fname);
177                     return 0;
178                 }
179                 break;
180             }
181         }
182     }
183     else /* double */
184     {
185         double dValue = 0.;
186         FILE *fd = NULL;
187
188         if (getScalarDouble(pvApiCtx, piAddressVarOne, &dValue) )
189         {
190             Scierror(999, _("%s: Memory allocation error.\n"), fname);
191             return 0;
192         }
193
194         fileDescriptor = (int)dValue;
195         if ((fileDescriptor == STDIN_ID) || (fileDescriptor == STDOUT_ID))
196         {
197             SciError(244);
198             return 0;
199         }
200
201         fd = GetFileOpenedInScilab(fileDescriptor);
202         if (fd == NULL)
203         {
204             Scierror(245, _("%s: No input file associated to logical unit %d.\n"), fname, fileDescriptor);
205             return 0;
206         }
207     }
208
209     wcReadStrings = mgetl(fileDescriptor, numberOfLinesToRead, &numberOfLinesRead, &iErrorMgetl);
210
211     if (bCloseFile)
212     {
213         double dErrClose = 0.;
214         C2F(mclose)(&fileDescriptor, &dErrClose);
215     }
216
217     switch (iErrorMgetl)
218     {
219         case MGETL_NO_ERROR:
220         {
221             if (numberOfLinesRead == 0)
222             {
223                 if (createEmptyMatrix(pvApiCtx, Rhs + 1))
224                 {
225                     freeArrayOfString(wcReadStrings, numberOfLinesRead);
226                     Scierror(999, _("%s: Memory allocation error.\n"), fname);
227                     return 0;
228                 }
229             }
230             else
231             {
232                 sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, numberOfLinesRead, 1, wcReadStrings);
233                 if (sciErr.iErr)
234                 {
235                     freeArrayOfString(wcReadStrings, numberOfLinesRead);
236                     printError(&sciErr, 0);
237                     Scierror(17, _("%s: Memory allocation error.\n"), fname);
238                     return 0;
239                 }
240             }
241
242             freeArrayOfString(wcReadStrings, numberOfLinesRead);
243         }
244         break;
245
246         case MGETL_EOF:
247         {
248             if (numberOfLinesRead == 0)
249             {
250                 if (createEmptyMatrix(pvApiCtx, Rhs + 1))
251                 {
252                     freeArrayOfString(wcReadStrings, numberOfLinesRead);
253                     Scierror(999, _("%s: Memory allocation error.\n"), fname);
254                     return 0;
255                 }
256             }
257             else
258             {
259                 sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, numberOfLinesRead, 1, wcReadStrings);
260                 if (sciErr.iErr)
261                 {
262                     freeArrayOfString(wcReadStrings, numberOfLinesRead);
263                     printError(&sciErr, 0);
264                     Scierror(17, _("%s: Memory allocation error.\n"), fname);
265                     return 0;
266                 }
267             }
268
269             freeArrayOfString(wcReadStrings, numberOfLinesRead);
270         }
271         break;
272
273         case MGETL_MEMORY_ALLOCATION_ERROR:
274         {
275             freeArrayOfString(wcReadStrings, numberOfLinesRead);
276             Scierror(999, _("%s: Memory allocation error.\n"), fname);
277             return 0;
278         }
279         break;
280
281         case MGETL_ERROR:
282         {
283             freeArrayOfString(wcReadStrings, numberOfLinesRead);
284             Scierror(999, _("%s: error.\n"), fname);
285             return 0;
286         }
287         break;
288     }
289
290     LhsVar(1) = Rhs + 1;
291     PutLhsVar();
292
293     return 0;
294 }
295 /*--------------------------------------------------------------------------*/