Implémentation de MEMFILE

Bonjour,

Je cherche à optimiser un projet dont le coeur est construit sur une librairie qui travaille sur des fichiers intermédiaires.
Cette librairie procède en créant des fichiers temporaires à partir de données en mémoire, à les parser par ftell(), fseek(), fgets(), puis à les supprimer.

Pour optimiser, j'ai utilisé une librairie intéressante et qui réalise les même fonctions que ftell(), fseek() et fgets() mais en mémoire (cf. http://forum.tuts4you.com/index.php?showtopic=16238).

Mais hélas, cette librairie n'est pas complète. Je l'ai donc complété.
Voic le code

(A noter que je n'ai eu besoin que du mode "r" pour memopen(file, "r"), donc les autres modes ne sont pas implémentés).

Pouvez-vous me dire ce que vous en pensez et si vous voyez des erreurs ou des axes d'optimisation ?

Merci d'avances.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
#ifndef _MEMFILE_H_
#define _MEMFILE_H_
 
typedef struct MEMFILE MEMFILE;
 
MEMFILE *memopenbuf (const char *name, const char * dummy);
MEMFILE *memopen    (const char *name, const char * dummy);
void     memclose   (MEMFILE *handle);
size_t   memread    (void *buffer, size_t size, MEMFILE *handle);
char    *memgets    (void *buffer, int n, MEMFILE *handle);
int      memeof     (MEMFILE *handle);
void     memseek    (MEMFILE *handle, long offset, int origin);
long     memtell    (MEMFILE *handle);
int      memgetc    (MEMFILE *handle);
 
#endif /* _MEMFILE_H_ */

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "memfile.h"
 
struct MEMFILE {
    long  length;
    long  pos;
    void *data;
};
 
static MEMFILE *
memfile_init (size_t len)
{
    MEMFILE *memfile = NULL;
 
#ifdef DEBUG
    fprintf (stderr, "DEBUG: memfile_init()\n");
#endif
 
    memfile = (MEMFILE *) calloc (sizeof (MEMFILE), 1);
    if (! memfile)
    {
        perror ("memfile_init() : calloc");
        return NULL;
    }
 
    memfile-> length = len;
    memfile-> pos = 0;
    memfile-> data = calloc (len + 1, 1);
 
    return memfile;
}
 
MEMFILE *
memopenbuf (const char *name, const char * dummy)
{
    MEMFILE *memfile = NULL;
    size_t len = 0;
    char *data = NULL;
 
#ifdef DEBUG
    fprintf (stderr, "DEBUG: memopenbuf()\n");
#endif
 
    /* get length */
    len = strlen (name);
 
    /* initialize memfile */
    memfile = memfile_init (len);
    if (! memfile)
    {
        perror ("memopenbuf() : memfile_init");
        return NULL;
    }
 
    /* fill data */
    memcpy ((char *) memfile-> data, name, memfile-> length);
    data = (char *) memfile-> data + memfile-> length;
    *data = '\0';
 
    return memfile;
}
 
MEMFILE *
memopen (const char *name, const char * dummy)
{
    MEMFILE *memfile = NULL;
    size_t len = 0;
    char *data = NULL;
    FILE *fp = NULL;
 
#ifdef DEBUG
    fprintf (stderr, "DEBUG: memopen()\n");
#endif
 
    /* get length */
    fp = fopen (name, "rb");
    if (! fp)
    {
        perror ("memopen() : fopen");
        return NULL;
    }
    fseek (fp, 0, SEEK_END);
    len = ftell (fp);
 
    /* initialize memfile */
    memfile = memfile_init (len);
    if (! memfile)
    {
        perror ("memopen() : memfile_init");
        return NULL;
    }
 
    /* fill data */
    fseek (fp, 0, SEEK_SET);
    fread (memfile-> data, 1, memfile-> length, fp);
    data = (char *) memfile-> data + memfile-> length;
    *data = '\0';
    fclose (fp);
 
    return memfile;
}
 
void
memclose (MEMFILE *handle)
{
    MEMFILE *memfile = handle;
 
#ifdef DEBUG
    fprintf (stderr, "DEBUG: memclose()\n");
#endif
 
    free (memfile-> data);
    memfile-> data = NULL;
 
    free (memfile);
    memfile = NULL;
}
 
size_t
memread (void *buffer, size_t n, MEMFILE *handle)
{
    MEMFILE *memfile = handle;
    size_t nbread = n;
 
#ifdef DEBUG
    fprintf (stderr, "DEBUG: memread()\n");
#endif
 
    /* combien de caractères peut-on encore lire ? */
    if (memfile-> pos + (long) n >= memfile-> length)
        nbread = memfile-> length - memfile-> pos;
 
    memcpy (buffer, (char *) memfile-> data + memfile-> pos, nbread);
    memfile-> pos += nbread;
 
    return nbread;
}
 
char *
memgets (void *buffer, int size, MEMFILE *handle)
{
    MEMFILE *memfile = handle;
    char *data;
    int pos;
    int col;
 
#ifdef DEBUG
    fprintf (stderr, "DEBUG: memgets()\n");
#endif
 
    if (memfile-> pos >= memfile-> length)
    {
        printf ("memgets() : Fin de fichier\n");
        return NULL;
    }
 
    for (pos = memfile-> pos; pos < memfile-> length && pos < memfile-> pos + size; pos++)
    {
        data = (char *) memfile-> data + pos;
        col = pos - memfile-> pos;
#ifdef DEBUG
        printf ("col=%d, pos=%d, data[0]='%c' (%d)\n", col, pos, data[0], data[0]);
#endif
        if ('\n' == data[0])
            break;
    }
 
    memcpy (buffer, (char *) memfile-> data + memfile-> pos, pos + 1);
    data = buffer;
    data [pos + 1 - memfile-> pos] = '\0';
    memfile-> pos = pos + 1;
 
    return (char *) buffer;
}
 
int
memeof (MEMFILE *handle)
{
    MEMFILE *memfile = handle;
 
#ifdef DEBUG
    fprintf (stderr, "DEBUG: memeof()\n");
#endif
 
    if (memfile-> pos == memfile-> length)
        return EOF;
 
    return 0;
}
 
void
memseek (MEMFILE *handle, long offset, int origin)
{
    MEMFILE *memfile = handle;
 
#ifdef DEBUG
    fprintf (stderr, "DEBUG: memseek()\n");
#endif
 
    if (origin == SEEK_SET)
        memfile-> pos = offset;
    else
        if (origin == SEEK_CUR)
            memfile-> pos += offset;
        else
            if (origin == SEEK_END)
                memfile-> pos = memfile-> length + offset;
 
    if (memfile-> pos > memfile-> length)
        memfile-> pos = memfile-> length;
}
 
long
memtell (MEMFILE *handle)
{
    MEMFILE *memfile = handle;
 
#ifdef DEBUG
    fprintf (stderr, "DEBUG: memtell()\n");
#endif
 
    return memfile-> pos;
}
 
int
memgetc (MEMFILE *handle)
{
    MEMFILE *memfile = handle;
    char *data;
 
#ifdef DEBUG
    fprintf (stderr, "DEBUG: memgetc()\n");
#endif
 
    if (memfile-> pos >= memfile-> length)
        return EOF;
 
    data = (char *) memfile-> data + memfile-> pos;
 
    return data[0];
}

certaines fonctions ne mettent pas à jour le membre 'pos'...

Merci Vincent.
Je vais regarder.

Il y a aussi une erreur dans la fonction suivante que j'ai corrigé

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
char *
memgets (void *buffer, int size, MEMFILE *handle)
{
    MEMFILE *memfile = handle;
    char *data;
    int i;
    int len;
 
#ifdef DEBUG
    fprintf (stderr, "DEBUG: memgets()\n");
#endif
 
    if (memfile-> pos >= memfile-> length)
    {
 
#ifdef DEBUG
        printf ("DEBUG: memgets() - Fin de fichier\n");
#endif
 
        return NULL;
    }
 
    data = (char *) memfile-> data + memfile-> pos;
 
    for (i = 0; i < size && memfile-> pos + i < memfile-> length; i++)
    {
#ifdef DEBUG
        printf ("DEBUG: memgets() - col=%d, pos=%d, car='%c' (%d)\n", i, memfile-> pos + i, data[i], data[i]);
#endif
 
        if ('\n' == data[i])
            break;
    }
 
    len = i + 1;
    memcpy (buffer, data, len);
    data = buffer;
    data [len] = '\0';
    memfile-> pos += len;
 
    return (char *) buffer;
}