Discussion :

[darkwall_37]

Hello,

Je chercher le moyen, de la même manière que sprintf, d'avoir la possibilité d'insérer les valeurs de variables multiples dans une chaîne de caractères tel que par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
log_add( "header.h", "function.c", "T0 :: x = %zu > p_sz", x);

Je suis allé regarder le code de sprintf mais ça semble coton quand on commence à aller voir les autres fonctions appelées.

En gros, j'ai essayé de faire ceci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
char* test( const char* format, ...)
{
  va_list arg;
  int done;
  va_start (arg, format);
  char *s = NULL;
  done = __vsprintf_internal (s, -1, format, arg, 0);
  va_end (arg);
  return s;
}

Le truc c'est que le compilo ne trouve pas la définition__vsprintf_internal qui semble déclarée dans libioP.h qui malgré l'inclusion n'est pas trouvé également.
J'ai chopé le header en question mais le problème se cascade avec d'autres headers xD. Plutôt prévisible.

Une idée ou une autre façon pour m'en sortir plus simplement ?

Merci d'avance.

[Bktero]

Pourquoi recoder une fonction qui ferait le même travail ? Pourquoi ne pas utiliser snprintf() en interne ?

[darkwall_37]

Tout simplement parce que je ne vois pas comment je peux arriver à ceci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

log_add( "header.h", "function.c", "T0 :: x = %zu > p_sz, i = %d", x, i);

avec snprintf.

J'ai besoin que ma fonction ait pour forme ce prototype :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void log_add( const char* hea, const char* fun, const char* msg, ... );

Je veux bien utiliser snprintf mais je ne vois pas comment l'utiliser pour répondre à mon besoin dans ce cas.

[Bktero]

Quelle est la sortie attendue de ta fonction ? Tu peux donner un exemple d'utilisation ?

Perso, j'ai déjà fait un logger en C++ (lightweight sur embarqué) qui utilisait du snprintf() en interne, c'est pour que je propose d'aller dans cette direction si c'est possible

[Bousk]

Les fonctions de logging sont souvent des macros pour pouvoir avoir des variadic macro, embarquer des infos supplémentaires comme le nom du fichier, la ligne, ...

[darkwall_37]

Actuellement, j'ai ceci pour logger les erreurs ou tout du moins signaler un comportement suspect :

Je déclare une variable f_log en variable globale dans le main pour pouvoir l'exploiter. Je sais ce que vous pensez des variables globales, n'en dites pas plus =)

log.c

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
 
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include "log.h"
 
log_t* f_log;
 
static size_t str_length( const char* p )
{
    size_t sz = 0;
    if ( p )
        while ( *p != '\0' )
            p++, sz++;
 
    return sz;
}
 
static char* str_copy( const char* p )
{
    char* p_out = NULL;
    if ( p )
    {
        size_t p_sz = 0;
        if ( ( p_sz = str_length(p) ) > 0 )
        {
            if ( ( p_out = malloc( (p_sz+1)*sizeof(*p_out) ) ) )
            {
                size_t i;
                for ( i = 0 ; i< p_sz ; i++ )
                    p_out[i] = p[i];
 
                p_out[i] = '\0';
            }
        }
        else
        {
            if ( ( p_out = malloc( (p_sz+1)*sizeof(*p_out) ) ) )
                p_out[0] = '\0';
        }
    }
    return p_out;
}
 
log_t* log_create( void )
{
    log_t* p = NULL;
    if ( ( p = malloc( sizeof(*p) ) ) )
    {
        p->hea = NULL;
        p->fun = NULL;
        p->msg = NULL;
        p->sz = 0;
    }
    return p;
}
 
void log_destroy( log_t** p )
{
    if ( p )
    {
        if ( (*p)->hea && (*p)->fun && (*p)->msg )
        {
            for ( size_t i=0 ; i<(*p)->sz ; i++ )
            {
                if ( (*p)->hea[i] )
                    free( (*p)->hea[i] );
 
                if ( (*p)->fun[i] )
                    free( (*p)->fun[i] );
 
                if ( (*p)->msg[i] )
                    free( (*p)->msg[i] );
            }
            free( (*p)->hea );
            free( (*p)->fun );
            free( (*p)->msg );
        }
        free( (*p) );
    }
}
 
bool log_add( const char* hea, const char* fun, const char* msg )
{
    bool c = false;
    if ( hea && fun && msg )
    {
        log_t* a = NULL; //Testing pointer for the reallocation of f_log
        if ( f_log )
        {
            a = f_log; size_t sz_new = a->sz+1;
            char** b = NULL; //Testing pointer for reallocation of the string
            if ( ( b = realloc( (a->hea), sz_new*sizeof( *a ) ) ) )
            {
                a->hea = b;
                if ( ( a->hea[sz_new-1] = str_copy(hea) ) )
                {
                    if ( ( b = realloc( (a->fun), sz_new*sizeof( *a ) ) ) )
                    {
                        a->fun = b;
                        if ( ( a->fun[sz_new-1] = str_copy(fun) ) )
                        {
                            if ( ( b = realloc( (a->msg), sz_new*sizeof( *a ) ) ) )
                            {
                                a->msg = b;
                                if ( ( a->msg[sz_new-1] = str_copy(msg) ) )
                                {
                                    a->sz = sz_new;
                                    f_log = a;
                                    c = true;
                                }
                            }
                            else log_destroy(&a);
                        }
                        else log_destroy(&a);
                    }
                    else log_destroy(&a);
                }
                else log_destroy(&a);
            }
            else log_destroy(&a);
        }
        else log_destroy(&a);
    }
    return c;
}
 
void log_display( log_t* p )
{
    if ( p )
    {
        for ( size_t i=0 ; i<p->sz ; i++ )
            printf("\n%20s - %20s - %50s", p->hea[i], p->fun[i], p->msg[i]);
    }
}

log.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
#ifndef LOG_H
#define LOG_H
 
typedef struct
{
    char** hea;
    char** fun;
    char** msg;
    size_t sz;
}log_t;
 
extern log_t* f_log;
 
log_t* log_create  ( void );
void   log_destroy ( log_t** p );
void   log_display ( log_t* p );
bool   log_add     ( const char* hea, const char* fun, const char* msg );
 
#endif

Exemple d'utilisation dans une fonction :

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
 
i_2D_t* i_2D_create( size_t x, size_t** y  )
{
    i_2D_t* st = NULL;
    if ( ( st = malloc( sizeof( *st ) ) ) ) //T0
    {
        if ( x > 0 )
        {
            if ( ( st->da = i_2D_create_( x, y ) ) ) //T1
            {
                st->y = (*y);
                st->x =   x ;
                bool s0 = false; bool s1 = false;
                if ( !((s0 = sz_search_limit( st->y, x, &st->y_min, 0 )) && (s1 = sz_search_limit( st->y, x, &st->y_max, 1 ))) ) //T2
                {
                    if ( !s0 ) { log_add("ptr.h", "i_2D_create", "T2 :: s0 = false"); }
                    if ( !s1 ) { log_add("ptr.h", "i_2D_create", "T2 :: s1 = false"); }
                    i_2D_destroy( &st );
                }
            }
            else
            {
                log_add("ptr.h", "i_2D_create", "T1 :: st->da is NULL");
                i_2D_destroy( &st );
            }
        }
        else
        {
            st->da = NULL;
            st->y  = NULL;
            st->x  =    0;
            st->y_min = 0;
            st->y_max = 0;
        }
    }
    else log_add("ptr.h", "i_2D_create", "T0 :: st is NULL");
    return st;
}