#define USING(alloc, free, action) \
    if (alloc)                     \
    {                              \
        action;                    \
        free;                      \
    }

typedef struct
{
    int dummy;
    // etc.
} base_rec_t;

typedef struct
{
    base_rec_t base;

    char    *url;
    char    *tag;
    char    *last_mod;
    wchar_t *tmp_name;
    
} record_t;

record_t *alloc_record(size_t url_len, size_t tag_len, size_t lm_len, size_t tmp_len)
{
    record_t *r;

    USING(r = malloc(sizeof(*r)), free(r),
    {
        memset(r, 0, sizeof(*r));

        USING(r->url      = malloc(url_len), free(r->url),
        USING(r->tag      = malloc(tag_len), free(r->tag),
        USING(r->last_mod = malloc(lm_len),  free(r->last_mod),
        USING(r->tmp_name = malloc(tmp_len), free(r->tmp_name),
        {
            /* OK */
            return r;
        }
    }
    )))));

    /* OOPS */
    return 0;
}

int copy_file(char *src_name, char *dst_name)
{
    FILE *src;
    FILE *dst;
    void *buf;
    size_t sz;
    int result = 0;

    const int B_SIZE = 4096;

    USING(src = fopen(src_name, "rb"), fclose(src),
    USING(dst = fopen(dst_name, "wb"), fclose(dst),
    USING(buf = malloc(B_SIZE), free(buf),
    {
        result = 1;

        while (sz = fread(buf, 1, B_SIZE, src))
        {
            if (fwrite(buf, 1, sz, dst) != sz)
            {
                result = 0;
                break;
            }
        }
    }
    )));

    return result;
}

d:\projects\dummy\csource.c(75) : warning C4002: too many actual parameters for macro 'USING'
d:\projects\dummy\csource.c(79) : fatal error C1075: end of file found before the left brace '{' at 'd:\projects\dummy\csource.c(52)' was matched

int
hexfs_open(const char            *path,
           struct fuse_file_info *fi)
{
    HFS_FILE_DATA_T *fd = NULL;
    FILE            *f = NULL;
    int             e = 0;

    HFS_LOG1("hexfs_open: Enter. Open %s.", path);

    RA(        f = fopen(path, "rb"),      NULL, e, fclose(f),
    RA(       fd = malloc(sizeof(*fd)),    NULL, e, free(fd),
    RA( fd->line = malloc(LINE_WIDTH),     NULL, e, free(fd->line),
    RA(fd->bytes = malloc(BYTES_PER_LINE), NULL, e, free(fd->bytes),
    {
        fd->n_line = -1;
        fd->f = f;
        fd->err_no = 0;

        fi->fh = (intptr_t)fd;

        HFS_LOG("hexfs_open: Exit.");
        return 0;
    }
    ))));

    HFS_LOG("hexfs_open: Exit with fail.");
    return -e;
}

R>

AD>Здесь нас спасет простой по своей сути вариант Владека

Автор: Владек
Дата: 14.01.06

, за что ему отдельное спасибо

AD>#define USING(alloc, free, action) \
AD>    if (alloc)                     \
AD>    {                              \
AD>        action;                    \
AD>        free;                      \
AD>    }
AD>

#include <cstdio>
#include <stdexcept>
#include <boost\shared_ptr.hpp>

void copy_file(char *src_name, char *dst_name)
{
    const int buf_size = 4096;

    typedef boost::shared_ptr<void> Memory;
    typedef boost::shared_ptr<FILE> File;

    File src(fopen(src_name, "rb"), fclose);
    File dst(fopen(dst_name, "wb"), fclose);
    Memory buf(malloc(buf_size), free);

    while (size_t sz = fread(buf.get(), 1, buf_size, src.get()))
        if (fwrite(buf.get(), 1, sz, dst.get()) != sz)
            throw std::runtime_error("File write error");                
}

RA( fd->line = malloc(LINE_WIDTH), NULL, free(fd->line),
RA( f = fopen(path, "rb"), NULL, fclose(f),

RA_MALLOC( fd->line, LINE_WIDTH,
RA_FOPEN( f, path, "rb",

AD>#define USING(alloc, free, action) \
AD>    if (alloc)                     \
AD>    {                              \
AD>        action;                    \
AD>        free;                      \
AD>    }
AD>

#define EAT(x)
#define EXEC(x) x
#define GET1(x) EXEC(x) EAT
#define GET22(x) EXEC(x)
#define GET2(x) GET22
#define USING(alloc_free, ...)     \
    if (EXEC(GET1 alloc_free))     \
    {                              \
        __VA_ARGS__;               \
        EXEC(GET2 alloc_free);     \
    }

    USING((p = malloc(1))(free(p)), printf("%p\n", p));