È possibile definire una macro simile a una funzione con un corpo variabile?

Question

Ho osservato lo GCC docs per la definizione dei macro e sembra che ciò che voglio non sia possibile, ma immagino che se lo fosse, qualcuno qui lo saprebbe.

Quello che voglio fare è definire questa macro:

synchronized(x) { 
    do_thing(); 
} 

che si espande a:

{ 
    pthread_mutex_lock(&x); 
    do_thing(); 
    pthread_mutex_unlock(&x); 
} 

In C++ ho potuto solo fare un oggetto SynchronizedBlock che ottiene il blocco nel suo costruttore e sblocca nel distruttore, ma non ho idea di come farlo in C.

Mi rendo conto che potrei usare un puntatore di funzione nel modulo synchronized(x, &myfunction);, ma il mio l'obiettivo è far sì che un codice C assomigli il più possibile a Java. E sì, so che questo è malvagio.

Answer 1

EDIT: Modificato nella versione di nategoose

#define synchronized(lock) \ 
for (pthread_mutex_t * i_#lock = &lock; i_#lock; \ 
    i_#lock = NULL, pthread_mutex_unlock(i_#lock)) \ 
    for (pthread_mutex_lock(i_#lock); i_#lock; i_#lock = NULL) 

E lo si può usare come questo:

synchronized(x) { 
    do_thing(x); 
} 

o anche senza bretelle

synchronized(x) 
    do_thing(); 

Answer 2

Ecco un inizio, ma potrebbe essere necessario modificarlo:

#define synchronized(lock, func, args...) do { \ 
    pthread_mutex_lock(&(lock)); \ 
    func(##args); \ 
    pthread_mutex_unlock(&(lock)); \ 
} while (0) 

Usa come questo (purtroppo, non la sintassi simile a Java si voleva):

synchronized(x, do_thing, arg1, arg2); 

Answer 3

Questa è stata la migliore che si avvicinò con:

#define synchronized(x, things) \ 
     do { \ 
      pthread_mutex_t * _lp = &(x); \ 
      pthread_mutex_lock(_lp);  \ 
      (things);      \ 
      pthread_mutex_unlock(_lp); \ 
     } while (0) 

... 

     synchronized(x,(
          printf("hey buddy\n"), 
          a += b, 
          printf("bye buddy\n") 
         )); 

Si noti che è necessario utilizzare l'operatore virgola usato raramente e ci sono restrizioni a quale codice può vivere all'interno dell'elenco di codici di sincronizzazione (non proprio java).

Answer 4

Domanda molto interessante!

Ho guardato le altre risposte e mi è piaciuto quello con for. Ho un miglioramento, se posso! GCC 4.3 introduce la macro COUNTER, che possiamo usare per generare nomi di variabili univoci.

#define CONCAT(X, Y) X##__##Y 
#define CONCATWRAP(X, Y) CONCAT(X, Y) 
#define UNIQUE_COUNTER(prefix) CONCATWRAP(prefix, __COUNTER__) 

#define DO_MUTEX(m, counter) char counter; \ 
for (counter = 1, lock(m); counter == 1; --counter, unlock(m)) 

#define mutex(m) DO_MUTEX(m, UNIQUE_COUNTER(m)) 

Usando le macro, questo codice ...

mutex(my_mutex) { 
    foo(); 
} 

... si espanderà per ...

char my_mutex__0; 
for (my_mutex__0 = 1, lock(my_mutex); my_mutex__0 == 1; --my_mutex__0, unlock(m)) { 
    foo(); 
} 

Con my_mutex__n a partire dal 0 e generando un nuovo nome ogni tempo è usato! È possibile utilizzare la stessa tecnica per creare corpi di codice simili a monitor, con un nome univoco ma sconosciuto per il mutex.