mrmixer
Does anyone knows how Jonathan Blow's defer macro works ? Example of how he uses it at the end of this blog post.

1 2	auto name = filenames[i]; defer { gamelib_free_string(name); };

I found those two pages that show how to make defer macros, but I'm interested to know how Jonathan's curly braces syntax works.
http://the-witness.net/news/2012/11/scopeexit-in-c11/
http://www.gingerbill.org/article/defer-in-cpp.html

1
2
3
4
5
6
7
8

struct DEFER_TAG {};
template< class Func >
ScopeExit< Func > operator+( DEFER_TAG, Func&& func )
{
    return MakeScopeExit< Func >( std::forward< Func >( func ) );
}

#define defer auto STRING_JOIN2(scope_exit_, __LINE__) = DEFER_TAG() + [&]()

We support markdown, so you can do the usual triple-backtick. For example:

```c

#define ENTITY_STATE_LIST \
X(ENTITY_STATE_NONE) \
X(ENTITY_STATE_ENTER_MINE_AND_DIG_FOR_NUGGET) \
X(ENTITY_STATE_VISIT_BANK_AND_DEPOSIT_GOLD) \
X(ENTITY_STATE_GO_HOME_AND_SLEEP_TIL_RESTED) \
X(ENTITY_STATE_QUENCH_THIRST) \
X(ENTITY_STATE_EAT_STEW) \
X(ENTITY_STATE_WIFES_GLOBAL) \
X(ENTITY_STATE_DO_HOUSE_WORK) \
X(ENTITY_STATE_VISIT_BATHROOM) \
X(ENTITY_STATE_COOK_STEW) 

```

Your "defer" example looks more like "exception" handling than what I think of a defer statement. I expect a defer statement to allow me to keep the cleaning code next to the creation code. In your example it's the opposite that is happening.

I try to rewrite it just to experiment a bit with loop breaking which I never thought of using that way. I think it's a little bit more readable but still not something I find useful.

#define skipable while ( true )
#define skip_if_0( condition ) if ( !( condition ) ) break;
#define skip_if_not_0( condition ) if ( condition ) break;
#define no_skip( ) goto end
#define catch_if_0( condition ) if ( !( condition ) )
#define catch_if_not_0( condition ) if ( !( condition ) )
#define skipable_end( ) end:

void* alloc_test( void ) {
    
    void **result = 0;
    
    skipable {
        
        result = malloc( sizeof( result ) );
        skip_if_0( result );

        ( *result ) = malloc( 1024 );
        skip_if_0( *result );

        skip_if_0( do_some_other_tests( result ) );
        
        no_skip( );
    }
    
    catch_if_not_0( result ) {
        
        catch_if_not_0( *result ) {
            free( *result );
            *result = 0;
        }
        
        free( result );
        result = 0;
    }
    
    skipable_end( );
    
    return result;
}

In Ryan Fleury's articles about GUI they showed something that might look like a defer in C but I believe it can only do a single statement. It's useful when you need to have begin and end function calls.

#define concatenate( a, b ) a ## b

#define scope_start_end_2( start, end, count ) \
for ( u32 concatenate( scope_start_end_i_, count ) = ( start, 1 ); \
concatenate( scope_start_end_i_, count ) ; \
concatenate( scope_start_end_i_, count )--, end )
#define scope_start_end_1( start, end, count )  scope_start_end_2( start, end, count )
#define scope_start_end( start, end ) scope_start_end_1( ( start ), ( end ), __COUNTER__ )

void func( void ) {
    
    u8* buffer = 0;
    
    // Allocate at the start of the scope, free when exiting the scope.
    scope_start_end( buffer = malloc( 1024 ), free( buffer ) ) {
        buffer[ 0 ] = 1;
    }

}

A small trick I realized I could use a few days ago is to use compound literals with __VA_ARGS__ to create an array and get it's item count (only in C). Previously I was creating the array before calling the function which prevented me to pass the return value of the function "through" the macro.

#define array_count( array ) ( ( umm ) ( sizeof( array ) / sizeof( ( array )[ 0 ] ) ) )
#define equal_any( value, ... ) internal_equal_any( value, ( umm [] ) { __VA_ARGS__ }, array_count( ( umm [] ) { __VA_ARGS__ } ) )

stu b32 internal_equal_any( umm value, umm* array, umm count ) {
    
    b32 result = false;
    
    for ( umm i = 0; !result && i < count; i++ ) {
        result = ( array[ i ] == value );
    }
    
    return result;
}

if ( equal_any( some_var, flag_a, flag_b, flag_c, flag_w ) ) {
    // ...
}

I see ryan's thing as part of a more general (macro less!) idea, where instead of interpreting for as

for (init; loop condition; increment)

you interpret it as

for (init; before loop body expr; after loop body expr)

which can lead to some nice iterator type code like

for (IterState s = iter_begin(param); iter_next(&s);) {
    // s has some useful state here
}

and both the loop condition logic and the increment are done inside iter_next. And a lot of things look like iterators when you have an iterator hammer, e.g.

for (ScopedAlloc a = scoped_alloc(size); scoped_alloc_with(&a);) {

}

Sort of very bad defer in C.

• Requires to use "defer_scope";
• Requires non-deferred code to be in a "now" scope, unless it's the code after every defer scopes and every defer scopes contains a "continue" statement;
• Requires variables to be declared outside of the "now" scopes (if you want to use it after the now scope), which is really bad because if you just put the variable in the defer_scope without initializing it the compiler will complain about the potential use of non initialized variables, and if you initialized it, it will get re initialized before the defer scopes are executed. So you either need to declare them as static, or declare them outside the defer_scope. In every way it's annoying.
• If you exit the "defer_scope" using break, return, or goto the defers aren't executed;
• Uses multiple statements macros;
• Can't be nested;
• Use a loop and ifs so there is extra state/code;
• Potential variable name collisions;

It's most likely not worth it.

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

#define defer_scope for ( int first_time = 1, defer_count = 1, defer_id = 0; first_time || defer_count; first_time = 0, defer_id = 0, defer_count-- )
#define defer if ( first_time ) defer_count++; defer_id++; if ( !first_time && ( defer_id ) == defer_count )
#define now if ( first_time ) 

char* read_file( const char* file );

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

    char* mem = 0;    

    defer_scope {
                
        now {
            printf( "alloc\n" );
            mem = ( char* ) malloc( 1024 );
        }
        
        defer {
            printf( "free\n" );
            free( mem );
        }
        
        now {
            printf( "Some other stuff\n" );
        }
        
        defer {
            printf( "Should happen before free\n" );
        }
        
        now {
            printf( "If you add \"continue;\" before closing all defer scopes you don't need a now scope here.\n" );
        }
    }
    
    char* file = read_file( "main.c" );
    
    return 0;
}

char* read_file( const char* file ) {
    
    char* result = 0;
    FILE* f = 0;
    
    defer_scope {
        
        now {
            f = fopen( file, "rb" );
        }
        
        defer {
            fclose( f );
            continue;
        }
        
        fseek( f, 0, SEEK_END );
        size_t size = ftell( f );
        fseek( f, 0, SEEK_SET );
        
        result = ( char* ) malloc( size );
        fread( result, size, 1, f );
    }
    
    return result;
}