f174ca5762cbe873e0a5d64b02ed0d127564534a
[scilab.git] / scilab / modules / fileio / src / c / filesmanagement.c
1 /*
2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 * Copyright (C) 2007 - 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-en.txt
11 *
12 */
13 #include <string.h>
14 #include <stdlib.h>
15 #include "PATH_MAX.h"
16 #include "filesmanagement.h"
17 #include "core_math.h" /* Min Max */
18 #include "MALLOC.h"
19 #ifdef _MSC_VER
20 #include "strdup_windows.h"
21 #endif
22 #include "fullpath.h"
23 /*--------------------------------------------------------------------------*/
24 typedef struct
25 {
26     FILE *ftformat;
27     int ftswap; /* swap status for each file */
28     int ftmode; /* mode for each file */
29     int fttype; /* type (Fortran,C) for each file must be zero initialized */
30     char *ftname; /* name for each file */
31
32 } scilabfile;
33 /*--------------------------------------------------------------------------*/
34 static scilabfile *ScilabFileList = NULL;
35 static int CurFile = -1;
36 static int PreviousFile = -1;
37 static int CurrentMaxFiles = DEFAULT_MAX_FILES;
38 /*--------------------------------------------------------------------------*/
39 FILE *GetFileOpenedInScilab(int Id)
40 {
41     int fd1 = 0;
42
43     fd1 = (Id != -1) ?  Min(Max(Id, 0), GetMaximumFileOpenedInScilab() - 1) : CurFile ;
44
45     if ( fd1 != -1 )
46     {
47         return  ScilabFileList[fd1].ftformat;
48     }
49     return NULL;
50 }
51 /*--------------------------------------------------------------------------*/
52 int GetCurrentFileId(void)
53 {
54     return CurFile;
55 }
56 /*--------------------------------------------------------------------------*/
57 int GetPreviousFileId(void)
58 {
59     return PreviousFile;
60 }
61 /*--------------------------------------------------------------------------*/
62 void SetCurrentFileId(int Id)
63 {
64     if (Id == -1)
65     {
66         PreviousFile = -1;
67     }
68     else
69     {
70         PreviousFile = CurFile;
71     }
72
73     CurFile = Id;
74 }
75 /*--------------------------------------------------------------------------*/
76 void SetFileOpenedInScilab(int Id, FILE *fptr)
77 {
78     ScilabFileList[Id].ftformat = fptr;
79 }
80 /*--------------------------------------------------------------------------*/
81 int GetSwapStatus(int Id)
82 {
83     int fd1;
84     fd1 = (Id != -1) ?  Min(Max(Id, 0), GetMaximumFileOpenedInScilab() - 1) : GetCurrentFileId() ;
85     if ( fd1 != -1 )
86     {
87         return(ScilabFileList[fd1].ftswap);
88     }
89     return(0);
90 }
91 /*--------------------------------------------------------------------------*/
92 void SetSwapStatus(int Id, int newswap)
93 {
94     ScilabFileList[Id].ftswap =  newswap;
95 }
96 /*--------------------------------------------------------------------------*/
97 int GetMaximumFileOpenedInScilab(void)
98 {
99     return CurrentMaxFiles;
100 }
101 /*--------------------------------------------------------------------------*/
102 int GetFileModeOpenedInScilab(int Id)
103 {
104     return ScilabFileList[Id].ftmode;
105 }
106 /*--------------------------------------------------------------------------*/
107 void SetFileModeOpenedInScilab(int Id, int mode)
108 {
109     ScilabFileList[Id].ftmode = mode;
110 }
111 /*--------------------------------------------------------------------------*/
112 int GetFileTypeOpenedInScilab(int Id)
113 {
114     if ( (Id > 0) && (Id < GetMaximumFileOpenedInScilab()) )
115     {
116         return ScilabFileList[Id].fttype;
117     }
118     else
119     {
120         return 0;
121     }
122 }
123 /*--------------------------------------------------------------------------*/
124 char *GetFileTypeOpenedInScilabAsString(int Id)
125 {
126     char *ret = NULL;
127     switch (GetFileTypeOpenedInScilab(Id))
128     {
129         case 1:
130             ret = strdup("F");
131             break;
132         case 2:
133             ret = strdup("C");
134             break;
135         case 0:
136         default:
137             ret = strdup("Error");
138             break;
139     }
140     return ret;
141 }
142 /*--------------------------------------------------------------------------*/
143 void SetFileTypeOpenedInScilab(int Id, int Type)
144 {
145     ScilabFileList[Id].fttype = Type;
146 }
147 /*--------------------------------------------------------------------------*/
148 char* GetFileNameOpenedInScilab(int Id)
149 {
150     if (GetFileTypeOpenedInScilab(Id) == 1) // Fortran file
151     {
152         /* A exception for Id 5 and 6 */
153         /* no name */
154         if ((Id != 5) && (Id != 6))
155         {
156             return ScilabFileList[Id].ftname;
157         }
158     }
159     else
160     {
161         if (GetFileOpenedInScilab(Id) != NULL)
162         {
163             return ScilabFileList[Id].ftname;
164         }
165     }
166     return NULL;
167 }
168 /*--------------------------------------------------------------------------*/
169 BOOL SetFileNameOpenedInScilab(int Id, char *name)
170 {
171     BOOL bOK = FALSE;
172     char *ptrName = NULL;
173     char fullpath[PATH_MAX * 4];
174
175     /* A exception for Id 5 and 6 */
176     /* no filename */
177     if ( name[0] == '\0' )
178     {
179         ptrName = "";
180         bOK = TRUE;
181     }
182     else
183     {
184         if ( get_full_path( fullpath, name, PATH_MAX * 4 ) != NULL )
185         {
186             ptrName = strdup(fullpath);
187             if (ptrName)
188             {
189                 bOK = TRUE;
190             }
191         }
192         else
193         {
194             ptrName = strdup(name);
195             if (ptrName)
196             {
197                 bOK = TRUE;
198             }
199         }
200     }
201     ScilabFileList[Id].ftname = ptrName;
202     return bOK;
203 }
204 /*--------------------------------------------------------------------------*/
205 BOOL FreeFileNameOpenedInScilab(int Id)
206 {
207     char *ptr = ScilabFileList[Id].ftname;
208     if (ptr && ptr[0])
209     {
210         FREE(ptr);
211         ptr = NULL;
212         return TRUE;
213     }
214     return FALSE;
215 }
216 /*--------------------------------------------------------------------------*/
217 BOOL InitializeScilabFilesList(void)
218 {
219     if (!ScilabFileList)
220     {
221         CurrentMaxFiles = DEFAULT_MAX_FILES;
222         ScilabFileList = (scilabfile *) MALLOC(sizeof(scilabfile) * CurrentMaxFiles);
223
224         if (ScilabFileList)
225         {
226             int i = 0;
227             scilabfile initializedScilabFile;
228
229             initializedScilabFile.ftformat = NULL;
230             initializedScilabFile.ftmode = 0;
231             initializedScilabFile.ftname = NULL;
232             initializedScilabFile.ftswap = 0;
233             initializedScilabFile.fttype = 0;
234
235             for (i = 0; i < CurrentMaxFiles; i++)
236             {
237                 scilabfile *ptrScilabFile = &ScilabFileList[i];
238                 memcpy(ptrScilabFile, &initializedScilabFile, sizeof(scilabfile));
239             }
240             return TRUE;
241         }
242     }
243     return FALSE;
244 }
245 /*--------------------------------------------------------------------------*/
246 BOOL TerminateScilabFilesList(void)
247 {
248     if (ScilabFileList)
249     {
250         FREE(ScilabFileList);
251         ScilabFileList = NULL;
252         return TRUE;
253     }
254     return FALSE;
255 }
256 /*--------------------------------------------------------------------------*/
257 BOOL ExtendScilabFilesList(int NewSize)
258 {
259     if (ScilabFileList)
260     {
261         if (NewSize > CurrentMaxFiles)
262         {
263
264             scilabfile *ScilabFileListTmp = NULL;
265             ScilabFileListTmp = (scilabfile *)REALLOC(ScilabFileList, NewSize * sizeof(scilabfile));
266             if (ScilabFileListTmp)
267             {
268                 int i = 0;
269                 ScilabFileList = ScilabFileListTmp;
270                 for (i = CurrentMaxFiles; i < NewSize; i++)
271                 {
272                     ScilabFileList[i].ftformat = NULL;
273                     ScilabFileList[i].ftmode = 0;
274                     ScilabFileList[i].ftname = NULL;
275                     ScilabFileList[i].ftswap = 0;
276                     ScilabFileList[i].fttype = 0;
277                 }
278                 CurrentMaxFiles = NewSize;
279                 return TRUE;
280             }
281         }
282     }
283     return FALSE;
284 }
285 /*--------------------------------------------------------------------------*/
286 BOOL IsAlreadyOpenedInScilab(char *filename)
287 {
288     if (ScilabFileList)
289     {
290         char fullpath[PATH_MAX * 4];
291         int i = 0;
292
293         if ((strcmp(filename, "") == 0) || (filename == NULL))
294         {
295             return FALSE;
296         }
297
298         if ( get_full_path( fullpath, filename, PATH_MAX * 4 ) == NULL )
299         {
300             /* if we are a problem */
301             strcpy(fullpath, filename);
302         }
303
304         for (i = 0; i < CurrentMaxFiles; i++)
305         {
306             if ( (ScilabFileList[i].ftformat) && ScilabFileList[i].ftname)
307             {
308                 if (strcmp(ScilabFileList[i].ftname, fullpath) == 0)
309                 {
310                     return TRUE;
311                 }
312             }
313         }
314     }
315     return FALSE;
316 }
317 /*--------------------------------------------------------------------------*/
318 int GetIdFromFilename(char *filename)
319 {
320     if (ScilabFileList)
321     {
322         char fullpath[PATH_MAX * 4];
323         int i = 0;
324         if ( get_full_path( fullpath, filename, PATH_MAX * 4 ) == NULL )
325         {
326             /* if we are a problem */
327             strcpy(fullpath, filename);
328         }
329
330         for (i = 0; i < CurrentMaxFiles; i++)
331         {
332             if ( (ScilabFileList[i].ftformat) && ScilabFileList[i].ftname)
333             {
334                 if (strcmp(ScilabFileList[i].ftname, fullpath) == 0)
335                 {
336                     return i;
337                 }
338             }
339         }
340     }
341     return FILE_ID_NOT_DEFINED;
342 }
343 /*--------------------------------------------------------------------------*/
344 double *GetFilesIdUsed(int *sizeArrayReturned)
345 {
346     int i = 0, j = 0;
347     double* ArrayIdUsed = NULL;
348     *sizeArrayReturned = GetNumberOfIdsUsed();
349
350     ArrayIdUsed = (double*)MALLOC(sizeof(double) * (*sizeArrayReturned));
351     if (ArrayIdUsed == NULL)
352     {
353         *sizeArrayReturned = 0;
354         return NULL;
355     }
356
357     j = 0;
358     for (i = 0; i < GetMaximumFileOpenedInScilab(); i++)
359     {
360         if (GetFileTypeOpenedInScilab(i) != 0)
361         {
362             ArrayIdUsed[j] = (double)i;
363             j++;
364         }
365     }
366     return ArrayIdUsed;
367 }
368 /*--------------------------------------------------------------------------*/
369 double *GetSwapsUsed(int *sizeArrayReturned)
370 {
371     double *ArraySwapUsed = NULL;
372     int i = 0, j = 0;
373
374     *sizeArrayReturned = GetNumberOfIdsUsed();
375
376     ArraySwapUsed = (double*)MALLOC(sizeof(double) * (*sizeArrayReturned));
377     if (ArraySwapUsed == NULL)
378     {
379         *sizeArrayReturned = 0;
380         return NULL;
381     }
382
383     j = 0;
384     for (i = 0; i < GetMaximumFileOpenedInScilab(); i++)
385     {
386         if (GetFileTypeOpenedInScilab(i) != 0)
387         {
388             ArraySwapUsed[j] = (double)GetSwapStatus(i);
389             j++;
390         }
391     }
392     return ArraySwapUsed;
393 }
394 /*--------------------------------------------------------------------------*/
395 double *GetModesUsed(int *sizeArrayReturned)
396 {
397     double *ArrayModeUsed = NULL;
398     int i = 0, j = 0;
399
400     *sizeArrayReturned = GetNumberOfIdsUsed();
401
402     ArrayModeUsed = (double*)MALLOC(sizeof(double) * (*sizeArrayReturned));
403     if (ArrayModeUsed == NULL)
404     {
405         *sizeArrayReturned = 0;
406         return NULL;
407     }
408
409     j = 0;
410     for (i = 0; i < GetMaximumFileOpenedInScilab(); i++)
411     {
412         if (GetFileTypeOpenedInScilab(i) != 0)
413         {
414             ArrayModeUsed[j] = (double)GetFileModeOpenedInScilab(i);
415             j++;
416         }
417     }
418     return ArrayModeUsed;
419 }
420 /*--------------------------------------------------------------------------*/
421 int *GetTypesUsed(int *sizeArrayReturned)
422 {
423     int *ArrayTypeUsed = NULL;
424     int i = 0, j = 0;
425
426     *sizeArrayReturned = GetNumberOfIdsUsed();
427
428     ArrayTypeUsed = (int*)MALLOC(sizeof(int) * (*sizeArrayReturned));
429     if (ArrayTypeUsed == NULL)
430     {
431         *sizeArrayReturned = 0;
432         return NULL;
433     }
434
435     j = 0;
436     for (i = 0; i < GetMaximumFileOpenedInScilab(); i++)
437     {
438         if (GetFileTypeOpenedInScilab(i) != 0)
439         {
440             ArrayTypeUsed[j] = GetFileTypeOpenedInScilab(i);
441             j++;
442         }
443     }
444     return ArrayTypeUsed;
445 }
446 /*--------------------------------------------------------------------------*/
447 char **GetTypesUsedAsString(int *sizeArrayReturned)
448 {
449     char **ArrayTypeUsedAsString = NULL;
450     int i = 0, j = 0;
451
452     *sizeArrayReturned = GetNumberOfIdsUsed();
453
454     ArrayTypeUsedAsString = (char**)MALLOC(sizeof(char*) * (*sizeArrayReturned));
455     if (ArrayTypeUsedAsString == NULL)
456     {
457         *sizeArrayReturned = 0;
458         return NULL;
459     }
460
461     j = 0;
462     for (i = 0; i < GetMaximumFileOpenedInScilab(); i++)
463     {
464         if (GetFileTypeOpenedInScilab(i) != 0)
465         {
466             ArrayTypeUsedAsString[j] = GetFileTypeOpenedInScilabAsString(i);
467             j++;
468         }
469     }
470     return ArrayTypeUsedAsString;
471 }
472 /*--------------------------------------------------------------------------*/
473 char **GetFilenamesUsed(int *sizeArrayReturned)
474 {
475     char **FilenamesArray = NULL;
476     int i = 0, j = 0;
477
478     *sizeArrayReturned = GetNumberOfIdsUsed();
479
480     FilenamesArray = (char**)MALLOC(sizeof(char*) * (*sizeArrayReturned));
481     if (FilenamesArray == NULL)
482     {
483         *sizeArrayReturned = 0;
484         return NULL;
485     }
486
487     j = 0;
488     for (i = 0; i < GetMaximumFileOpenedInScilab(); i++)
489     {
490         if (GetFileTypeOpenedInScilab(i) != 0)
491         {
492             if (GetFileNameOpenedInScilab(i))
493             {
494                 FilenamesArray[j] = strdup(GetFileNameOpenedInScilab(i));
495             }
496             else
497             {
498                 FilenamesArray[j] = strdup("");
499             }
500             j++;
501         }
502     }
503     return FilenamesArray;
504 }
505 /*--------------------------------------------------------------------------*/
506 int GetNumberOfIdsUsed(void)
507 {
508     int i = 0;
509     int numberOfIds = 0;
510
511     for (i = 0; i < GetMaximumFileOpenedInScilab(); i++)
512     {
513         if (GetFileTypeOpenedInScilab(i) != 0)
514         {
515             numberOfIds++;
516         }
517     }
518     return numberOfIds;
519 }
520 /*--------------------------------------------------------------------------*/