fork(1) download
copy 
  1. /* file: dbg_macros.h */
  2. /*
  3. DBG_L0   exits
  4. DBG_L1   exits + calls
  5. DBG_L2   exits + calls + returns               (value)
  6. DBG_L3   exits + calls + returns               (address)
  7. DBG_L4   exits + calls + returns               (value + address)
  8. DBG_L5   exits + calls + returns + args        (value)
  9. DBG_L6   exits + calls + returns + args        (address)
  10. DBG_L7   exits + calls + returns + args        (value + address)
  11. DBG_L8   exits + calls + returns + args + vars (value)
  12. DBG_L9   exits + calls + returns + args + vars (address)
  13. DBG_LA   exits + calls + returns + args + vars (value + address)
  14. */
  15.  
  16.  
  17.  
  18. #ifndef _DBG_MACROS_H
  19.     #define _DBG_MACROS_H 1U
  20.  
  21.     #include <stdio.h>
  22.     #include <stdlib.h>
  23.  
  24.  
  25.  
  26.         #define __PRINT_HEADING( HEADING_STR,                                                            \
  27.                                  SPACE_NUM )                                                             \
  28.                     printf( "\t" HEADING_STR  "%" #SPACE_NUM "s" "file:      %s"               "\n"      \
  29.                             "\t" "          " "%" #SPACE_NUM "s" "function:  %s"               "\n",     \
  30.                             "",                                                                          \
  31.                             __FILE__,                                                                    \
  32.                             "",                                                                          \
  33.                             __FUNC__ )
  34.  
  35.         #define __PRINT_NAME( SPACE_NUM,                                                                 \
  36.                               NAME )                                                                     \
  37.                     printf( "\t" "          " "%" #SPACE_NUM "s" "name:      "   #NAME         "\n",     \
  38.                             "" )
  39.  
  40.         #define __PRINT_LINE( SPACE_NUM )                                                                \
  41.                     printf( "\t" "          " "%" #SPACE_NUM "s" "line:      %d"               "\n",     \
  42.                             "",                                                                          \
  43.                             __LINE__ )
  44.  
  45.         #if ( defined( DBG_L0 ) ||                                                                       \
  46.               defined( DBG_L1 ) ||                                                                       \
  47.               defined( DBG_L2 ) ||                                                                       \
  48.               defined( DBG_L4 ) ||                                                                       \
  49.               defined( DBG_L5 ) ||                                                                       \
  50.               defined( DBG_L7 ) ||                                                                       \
  51.               defined( DBG_L8 ) ||                                                                       \
  52.               defined( DBG_LA ) )
  53.             #define __PRINT_VALUE( SPACE_NUM,                                                            \
  54.                                    CONV_SPEC_STR,                                                        \
  55.                                    VALUE )                                                               \
  56.                         printf( "\t" "          " "%" #SPACE_NUM "s" "value:     %"  CONV_SPEC_STR "\n", \
  57.                                 "",                                                                      \
  58.                                 VALUE )
  59.         #else
  60.             #define __PRINT_VALUE( SPACE_NUM,                                                            \
  61.                                    CONV_SPEC_STR,                                                        \
  62.                                    VALUE )
  63.         #endif
  64.  
  65.         #if ( defined( DBG_L3 ) ||                                                                       \
  66.               defined( DBG_L4 ) ||                                                                       \
  67.               defined( DBG_L6 ) ||                                                                       \
  68.               defined( DBG_L7 ) ||                                                                       \
  69.               defined( DBG_L9 ) ||                                                                       \
  70.               defined( DBG_LA ) )
  71.             #define __PRINT_ADDRESS( SPACE_NUM,                                                          \
  72.                                      ADDRESS )                                                           \
  73.                         printf( "\t" "          " "%" #SPACE_NUM "s" "address:   %p"               "\n", \
  74.                                 "",                                                                      \
  75.                                 (void *)ADDRESS )
  76.         #else
  77.             #define __PRINT_ADDRESS( SPACE_NUM,                                                          \
  78.                                      ADDRESS )
  79.         #endif
  80.  
  81.         #if ( defined( DBG_L0 ) ||                                                                       \
  82.               defined( DBG_L1 ) ||                                                                       \
  83.               defined( DBG_L2 ) ||                                                                       \
  84.               defined( DBG_L3 ) ||                                                                       \
  85.               defined( DBG_L4 ) ||                                                                       \
  86.               defined( DBG_L5 ) ||                                                                       \
  87.               defined( DBG_L6 ) ||                                                                       \
  88.               defined( DBG_L7 ) ||                                                                       \
  89.               defined( DBG_L8 ) ||                                                                       \
  90.               defined( DBG_L9 ) ||                                                                       \
  91.               defined( DBG_LA ) )
  92.             #define SET_FUNC_NAME( FUNC )                                                                \
  93.                         const char *__FUNC__ = #FUNC
  94.         #else
  95.             #define SET_FUNC_NAME( FUNC )
  96.         #endif
  97.  
  98.         #if ( defined( DBG_L1 ) ||                                                                       \
  99.               defined( DBG_L2 ) ||                                                                       \
  100.               defined( DBG_L3 ) ||                                                                       \
  101.               defined( DBG_L4 ) ||                                                                       \
  102.               defined( DBG_L5 ) ||                                                                       \
  103.               defined( DBG_L6 ) ||                                                                       \
  104.               defined( DBG_L7 ) ||                                                                       \
  105.               defined( DBG_L8 ) ||                                                                       \
  106.               defined( DBG_L9 ) ||                                                                       \
  107.               defined( DBG_LA ) )
  108.             #define CALL_DUMP()                                                                          \
  109.                         __PRINT_HEADING( "[DBG|CALL]",                                                   \
  110.                                          1 )
  111.         #else
  112.             #define CALL_DUMP()
  113.         #endif
  114.  
  115.         #if ( defined( DBG_L5 ) ||                                                                       \
  116.               defined( DBG_L6 ) ||                                                                       \
  117.               defined( DBG_L7 ) ||                                                                       \
  118.               defined( DBG_L8 ) ||                                                                       \
  119.               defined( DBG_L9 ) ||                                                                       \
  120.               defined( DBG_LA ) )
  121.             #define ARG_DUMP( ARG,                                                                       \
  122.                               CONV_SPEC_STR )                                                            \
  123.                         do                                                                               \
  124.                         {                                                                                \
  125.                             __PRINT_HEADING( "[ DBG|ARG]",                                               \
  126.                                              2 );                                                        \
  127.                             __PRINT_NAME( 2,                                                             \
  128.                                           ARG );                                                         \
  129.                             __PRINT_VALUE( 2,                                                            \
  130.                                            CONV_SPEC_STR,                                                \
  131.                                            ARG );                                                        \
  132.                             __PRINT_ADDRESS( 2,                                                          \
  133.                                              &ARG );                                                     \
  134.                         } while ( 0 )
  135.  
  136.             #define PTRARG_DUMP( ARG,                                                                    \
  137.                                  CONV_SPEC_STR )                                                         \
  138.                         do                                                                               \
  139.                         {                                                                                \
  140.                             __PRINT_HEADING( "[ DBG|ARG]",                                               \
  141.                                              2 );                                                        \
  142.                             __PRINT_NAME( 2,                                                             \
  143.                                           ARG );                                                         \
  144.                             __PRINT_VALUE( 2,                                                            \
  145.                                            CONV_SPEC_STR,                                                \
  146.                                            *ARG );                                                       \
  147.                             __PRINT_ADDRESS( 2,                                                          \
  148.                                              ARG );                                                      \
  149.                         } while ( 0 )
  150.         #else
  151.             #define ARG_DUMP( ARG,                                                                       \
  152.                               CONV_SPEC_STR )
  153.  
  154.             #define PTRARG_DUMP( ARG,                                                                    \
  155.                                  CONV_SPEC_STR )
  156.         #endif
  157.  
  158.         #if ( defined( DBG_L8 ) ||                                                                       \
  159.               defined( DBG_L9 ) ||                                                                       \
  160.               defined( DBG_LA ) )
  161.             #define VAR_DUMP( VAR,                                                                       \
  162.                               CONV_SPEC_STR )                                                            \
  163.                         do                                                                               \
  164.                         {                                                                                \
  165.                             __PRINT_HEADING( "[ DBG|VAR]",                                               \
  166.                                              2 );                                                        \
  167.                             __PRINT_NAME( 2,                                                             \
  168.                                           VAR );                                                         \
  169.                             __PRINT_VALUE( 2,                                                            \
  170.                                            CONV_SPEC_STR,                                                \
  171.                                            VAR );                                                        \
  172.                             __PRINT_ADDRESS( 2,                                                          \
  173.                                              &VAR );                                                     \
  174.                         } while ( 0 )
  175.  
  176.             #define PTRVAR_DUMP( VAR,                                                                    \
  177.                                  CONV_SPEC_STR )                                                         \
  178.                         do                                                                               \
  179.                         {                                                                                \
  180.                             __PRINT_HEADING( "[ DBG|VAR]",                                               \
  181.                                              2 );                                                        \
  182.                             __PRINT_NAME( 2,                                                             \
  183.                                           VAR );                                                         \
  184.                             __PRINT_VALUE( 2,                                                            \
  185.                                            CONV_SPEC_STR,                                                \
  186.                                            *VAR );                                                       \
  187.                             __PRINT_ADDRESS( 2,                                                          \
  188.                                              VAR );                                                      \
  189.                         } while ( 0 )
  190.         #else
  191.             #define VAR_DUMP( VAR,                                                                       \
  192.                               CONV_SPEC_STR )
  193.  
  194.             #define PTRVAR_DUMP( VAR,                                                                    \
  195.                                  CONV_SPEC_STR )
  196.         #endif
  197.  
  198.         #if ( defined( DBG_L2 ) ||                                                                       \
  199.               defined( DBG_L3 ) ||                                                                       \
  200.               defined( DBG_L4 ) ||                                                                       \
  201.               defined( DBG_L5 ) ||                                                                       \
  202.               defined( DBG_L6 ) ||                                                                       \
  203.               defined( DBG_L7 ) ||                                                                       \
  204.               defined( DBG_L8 ) ||                                                                       \
  205.               defined( DBG_L9 ) ||                                                                       \
  206.               defined( DBG_LA ) )
  207.             #define RET_DUMP( RET,                                                                       \
  208.                               CONV_SPEC_STR )                                                            \
  209.                         do                                                                               \
  210.                         {                                                                                \
  211.                             __PRINT_HEADING( "[DBG|RET ]",                                               \
  212.                                              1 );                                                        \
  213.                             __PRINT_LINE( 1 );                                                           \
  214.                             __PRINT_VALUE( 1,                                                            \
  215.                                            CONV_SPEC_STR,                                                \
  216.                                            (RET) );                                                      \
  217.                             __PRINT_ADDRESS( 1,                                                          \
  218.                                              &(RET) );                                                   \
  219.                                                                                                          \
  220.                             return RET;                                                                  \
  221.                         } while ( 0 )
  222.  
  223.             #define PTRRET_DUMP( RET,                                                                    \
  224.                                  CONV_SPEC_STR )                                                         \
  225.                         do                                                                               \
  226.                         {                                                                                \
  227.                             __PRINT_HEADING( "[DBG|RET ]",                                               \
  228.                                              1 );                                                        \
  229.                             __PRINT_LINE( 1 );                                                           \
  230.                             __PRINT_VALUE( 1,                                                            \
  231.                                            CONV_SPEC_STR,                                                \
  232.                                            *(RET) );                                                     \
  233.                             __PRINT_ADDRESS( 1,                                                          \
  234.                                              (RET) );                                                    \
  235.                                                                                                          \
  236.                             return RET;                                                                  \
  237.                         } while ( 0 )
  238.         #else
  239.             #define RET_DUMP( RET,                                                                       \
  240.                               CONV_SPEC_STR )                                                            \
  241.                         return RET
  242.  
  243.             #define PTRRET_DUMP( RET,                                                                    \
  244.                                  CONV_SPEC_STR )                                                         \
  245.                         return RET
  246.         #endif
  247.  
  248.         #if ( defined( DBG_L0 ) ||                                                                       \
  249.               defined( DBG_L1 ) ||                                                                       \
  250.               defined( DBG_L2 ) ||                                                                       \
  251.               defined( DBG_L3 ) ||                                                                       \
  252.               defined( DBG_L4 ) ||                                                                       \
  253.               defined( DBG_L5 ) ||                                                                       \
  254.               defined( DBG_L6 ) ||                                                                       \
  255.               defined( DBG_L7 ) ||                                                                       \
  256.               defined( DBG_L8 ) ||                                                                       \
  257.               defined( DBG_L9 ) ||                                                                       \
  258.               defined( DBG_LA ) )
  259.             #define EXIT_DUMP( EXIT )                                                                    \
  260.                         do                                                                               \
  261.                         {                                                                                \
  262.                             __PRINT_HEADING( "[DBG|EXIT]",                                               \
  263.                                              1 );                                                        \
  264.                             __PRINT_LINE( 1 );                                                           \
  265.                             __PRINT_VALUE( 1,                                                            \
  266.                                            "d",                                                          \
  267.                                            (EXIT) );                                                     \
  268.                                                                                                          \
  269.                             exit( EXIT );                                                                \
  270.                         } while ( 0 )
  271.         #else
  272.             #define EXIT_DUMP( EXIT )                                                                    \
  273.                         exit( EXIT )
  274.         #endif
  275.  
  276. #endif
  277.  
  278.  
  279.  
  280. /* file: test.c */
  281. #define DBG_LA
  282.  
  283.  
  284.  
  285. int operations( int   a, 
  286.                 int   b, 
  287.                 int * mul )
  288. {
  289.     int add;
  290.  
  291.  
  292.     SET_FUNC_NAME( operations );
  293.     CALL_DUMP();
  294.     ARG_DUMP( a, "d" );
  295.     ARG_DUMP( b, "d" );
  296.     PTRARG_DUMP( mul, "d" );
  297.  
  298.     add = a + b;
  299.     *mul = a * b;
  300.  
  301.  
  302.     RET_DUMP( add, "d" );
  303. }
  304.  
  305.  
  306.  
  307. int main( void )
  308. {
  309.     int a;
  310.     int b;
  311.     int add;
  312.     int mul;
  313.  
  314.  
  315.     SET_FUNC_NAME( main );
  316.     CALL_DUMP();
  317.  
  318.     a = 3;
  319.     b = 2;
  320.     add = 0;
  321.     mul = 0;
  322.     add = operations(  a, 
  323.                    b, 
  324.                   &mul );
  325.  
  326.  
  327.     EXIT_DUMP( 0 );
  328. }
  329.  
Success #stdin #stdout 0.01s 1716KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Standard output is empty
https://ideone.com/OXWNH
language:
C99 (gcc 8.3)
created:
14 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!