IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C Discussion :

Implémentation de MEMFILE


Sujet :

C

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre éclairé Avatar de domiq44
    Homme Profil pro
    Inscrit en
    Novembre 2005
    Messages
    302
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Loire Atlantique (Pays de la Loire)

    Informations forums :
    Inscription : Novembre 2005
    Messages : 302
    Par défaut 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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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];
    }

  2. #2
    Rédacteur
    Avatar de Vincent Rogier
    Profil pro
    Inscrit en
    Juillet 2007
    Messages
    2 373
    Détails du profil
    Informations personnelles :
    Âge : 47
    Localisation : France

    Informations forums :
    Inscription : Juillet 2007
    Messages : 2 373
    Par défaut
    certaines fonctions ne mettent pas à jour le membre 'pos'...
    Vincent Rogier.

    Rubrique ORACLE : Accueil - Forum - Tutoriels - FAQ - Livres - Blog

    Vous voulez contribuer à la rubrique Oracle ? Contactez la rubrique !

    OCILIB (C Driver for Oracle)

    Librairie C Open Source multi-plateformes pour accéder et manipuler des bases de données Oracle

  3. #3
    Membre éclairé Avatar de domiq44
    Homme Profil pro
    Inscrit en
    Novembre 2005
    Messages
    302
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Loire Atlantique (Pays de la Loire)

    Informations forums :
    Inscription : Novembre 2005
    Messages : 302
    Par défaut
    Merci Vincent.
    Je vais regarder.

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

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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;
    }

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 12
    Dernier message: 01/07/2004, 11h03
  2. Réponses: 8
    Dernier message: 04/06/2004, 09h13
  3. Moteur physique : comment l'implémenter ?
    Par haypo dans le forum Algorithmes et structures de données
    Réponses: 15
    Dernier message: 17/12/2003, 12h56
  4. Réponses: 2
    Dernier message: 06/07/2002, 12h36
  5. Implémentation des fonctions mathématiques
    Par mat.M dans le forum Mathématiques
    Réponses: 9
    Dernier message: 17/06/2002, 16h19

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo