Home / Questions / 45937
Accepted
Ivan Botero
Asked: 2020-01-26 06:22:45 +0800 CST 2020-01-26 06:22:45 +0800 CST

Using the __LINE__ macro - C

  • 772

Cheers!

I am making a function in C that allows obtaining a more detailed record of what happens in the program, something similar to a debug , but trying to summarize things for the programmer.

I found the documentation of the CPP Preprocessor (GNU/Linux) and there they indicated the different macros and constants that can be used in our program so that functions can also be used and these macros can be used there .

Thanks to this, carry out the following program:

#include <stdio.h>
#include <stdlib.h>

/* Dump para variables */
#define dump(variable) {   \
    printf("La variable '%s' ocupa %d bytes\n", #variable, sizeof(variable)); \
}

/* Dump para funciones */
#define dumpf(){ \
    printf("Se llama a funcion %s()\n", __FUNCTION__); \
}

void funcion(int argumento){
    dumpf();
    printf("%d\n", argumento + argumento);
}

void sumar(int a, int b){
    dumpf();
    printf("%d + %d = %d\n", a, b, (a+b));
}

int main(int argc, char *argv[]){

    /* Variables */
    int variableINT   = 45;
    char variableCHAR = 'A';
    char *variablePTR = "Hola Mundo";

    /* Debug de Variables*/
    dump(variableINT);
    dump(variableCHAR);
    dump(variablePTR);

    /* Debug de Funcion*/
    funcion(10);
    sumar(5, 5);

   return EXIT_SUCCESS;
}

This program allows us to know the weight in bytes of a variable thanks to the dump() function , it also allows us to know which function we are calling through the dumpf() function .

Up to this point, the output of the console program is:

The variable 'variableINT' occupies 4 bytes

The variable 'variableCHAR' occupies 1 bytes

The variable 'variablePTR' occupies 4 bytes

function is called function()

twenty

Sum() function is called

5 + 5 = 10

After that, to make our "debug" a little more readable and easier to understand , I wanted to add something that would indicate the line where the function call was being made, so I made the following modification in the function dumpf( ) :

/* Dump para funciones */
#define dumpf(){ \
    printf("Se llama a funcion %s() en la linea %d\n", __FUNCTION__, __LINE__); \
}

I added the LINE macro , which in theory indicates the line where the instruction is being executed.

But the result that the program throws is:

function function() is called on line 15

twenty

function add() is called on line 20

In other words, it is indicating the line where the function was originally called within each of the function() and add() functions , it does not indicate the line where the function was actually called, which are actually lines 37 and 38.

How would it be possible to obtain the line in which the function call was made? Are there any drawbacks to the LINE macro when it is included in a function? Since the Preprocessor is supposed to replace these values ​​before doing the compilation.

I thank you in advance for your help.

c

2 Answers

  1. Best Answer

    What you are looking for is a macro that tells you that the function has been called from line X and that will not work if you call the macro from the function itself... Think that the message is being generated at compile time ... the compiler at that point doesn't know where you're going to call the function from.

    To achieve what you want you should call the macro before calling the function (or adapt the macro so that it is able to call the function)... in any case it is not very practical:

    // "hack" para convertir el nombre de un parametro en una cadena
#define ___TOSTRING(x) #x
#define TOSTRING(x) ___TOSTRING(x)

#define dumpf(FUNC) \
    printf("Se llama a funcion %s() en la linea %d\n", TOSTRING(FUNC), __LINE__); \
    FUNC

int main(int argc, char *argv[]){

    /* Variables */
    int variableINT   = 45;
    char variableCHAR = 'A';
    char *variablePTR = "Hola Mundo";

    /* Debug de Variables*/
    dump(variableINT);
    dump(variableCHAR);
    dump(variablePTR);

    /* Debug de Funcion*/
    dumpf(funcion)(10);
    dumpf(sumar)(5, 5);

   return EXIT_SUCCESS;
}

    And the result would be:

    La variable 'variableINT' ocupa 4 bytes
La variable 'variableCHAR' ocupa 1 bytes
La variable 'variablePTR' ocupa 4 bytes
Se llama a funcion funcion() en la linea 37
20
Se llama a funcion sumar() en la linea 38
5 + 5 = 10

    If you are interested in having the execution traces, perhaps you should consider learning to use the code debugger... in programs as small as the one you show, it does not make much sense to include a trace system.

    • 5

  2. How would it be possible to obtain the line in which the function call was made?

    No way. The information you're looking for is the stack trace which is determined at runtime while macros like __LINE__and __FUNCTION__are tokens that the pre-processor translates into literals just before compiling.

    That is, the macro __LINE__written on line 100 will be translated by the literal 100 before compiling. The only way would be passing each function a parameter indicating the call point:

    void funcion(int argumento, int linea){
    printf("%d\nllamada en %d\n", argumento + argumento, linea);
}

void sumar(int a, int b, int linea){
    printf("%d + %d = %d\nllamada en %d\n", a, b, (a+b), linea);
}

/*09*/int main(void)
/*10*/{
/*11*/    funcion(1, __LINE__);
/*12*/    sumar(3, 2, __LINE__);
/*13*/    return 0;
/*14*/}

    The call to funcion(1, __LINE__)will be translated by the pre-processor to funcion(1, 11)while it sumar(3, 2, __LINE__)will be translated to sumar(3, 2, 12).

    Maybe you are thinking that it is enough for you and you can use default parameters... but it would not work:

    /*01*/void funcion(int argumento, int linea = __LINE__){
/*02*/    printf("%d\nllamada en %d\n", argumento + argumento, linea);
/*03*/}
/*04*/
/*05*/void sumar(int a, int b, int linea = __LINE__){
/*06*/    printf("%d + %d = %d\nllamada en %d\n", a, b, (a+b), linea);
/*07*/}

int main(void)
{
    funcion(1);
    sumar(3, 2);
    return 0;
}

    The previous code, when passing through the pre-processor, would look like:

    /*01*/void funcion(int argumento, int linea = 1){
/*02*/    printf("%d\nllamada en %d\n", argumento + argumento, linea);
/*03*/}
/*04*/
/*05*/void sumar(int a, int b, int linea = 5){
/*06*/    printf("%d + %d = %d\nllamada en %d\n", a, b, (a+b), linea);
/*07*/}

    So the output of the program would be:

    1
llamada en 1
3 + 2 = 5
llamada en 5

    Which you already know is false, since the functions were called on lines 11 and 12.

    Conclusion.

    Check your compiler's documentation to see if you can access the stack trace during program execution.

    • 1