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