¿Qué significa "hacer {...} mientras (0)" hacer exactamente en el código kernel?

Question

duplicados posibles:
What’s the use of do while(0) when we define a macro?
Why are there sometimes meaningless do/while and if/else statements in C/C++ macros?
C multi-line macro: do/while(0) vs scope block

que he visto una gran cantidad de usos de este tipo, previamente pensé que el programador querían salir de un bloque de codificar fácilmente ¿Por qué necesitamos un bucle do {...} mientras (0) aquí? ¿Estamos tratando de decirle algo al compilador?

Por ejemplo, en el kernel de Linux 2.6.25, include/asm-IA64/system.h

/* 
* - clearing psr.i is implicitly serialized (visible by next insn) 
* - setting psr.i requires data serialization 
* - we need a stop-bit before reading PSR because we sometimes 
* write a floating-point register right before reading the PSR 
* and that writes to PSR.mfl 
*/ 
#define __local_irq_save(x)   \ 
do {     \ 
    ia64_stop();    \ 
    (x) = ia64_getreg(_IA64_REG_PSR); \ 
    ia64_stop();    \ 
    ia64_rsm(IA64_PSR_I);   \ 
} while (0) 

Answer 1

parece que está allí sólo por alcance. Es similar a:

if (true) 
{ 
    // Do stuff. 
} 

edición

no veo que en su ejemplo, pero es posible que uno de los llamadas de función es en realidad una macro, en cuyo caso hay una diferencia clave entre do/while (0) y if (true), que es que el primero permite continue y break.

Answer 2

Se usa siempre en macros, por lo que se requiere un punto y coma después de una llamada, al igual que cuando se llama a una función normal.

En su ejemplo, usted tiene que escribir

__local_irq_save(1); 

mientras

__local_irq_save(1) 

daría lugar a un error sobre un punto y coma que falta. Esto no sucedería si el do while no estuviera allí. Si se tratara de un scoping, bastaría con un simple par de llaves.

Answer 3

Se permite que aparezca el código aquí:

if(a) __local_irq_save(x); else ...; 

// -> if(a) do { .. } while(0); else ...; 

si simplemente utilizan un { .. } que obtendría

if(a) { ... }; else ...; 

La persona no pertenece a ningún if más, porque el punto y coma haría sea ​​el siguiente enunciado y separe el else del anterior if. Se produciría un error de compilación.

Answer 4

El propósito de do{ ... } while(0) constructo es a su vez un grupo de instrucciones en una declaración de solo compuesto que puede ser terminada con un ;. Verá, en lenguaje C, el constructo do/while tiene una propiedad extraña e inusual: aunque "funciona" como una declaración compuesta, espera un ; al final. Ningún otro constructo compuesto en C tiene esta propiedad.

Debido a esta propiedad, puede utilizar do/while a escribir macros de múltiples instrucciones, que se pueden utilizar con seguridad como funciones "normales" sin preocuparse de lo que hay dentro de la macro, como en el siguiente ejemplo

if (/* some condition */) 
    __local_irq_save(x); /* <- we can safely put `;` here */ 
else 
    /* whatever */; 

Answer 5

El la respuesta ya ha sido dada (entonces la macro fuerza un ; cuando se llama), pero otro uso de este tipo de enunciado que he visto: permite que break se llame en cualquier parte del "bucle", terminando anticipadamente si es necesario. Esencialmente un "goto" que tus compañeros programadores no te matarían.

do { 
    int i = do_something(); 
    if(i == 0) { break; } // Skips the remainder of the logic 
    do_something_else(); 
} while(0); 

Tenga en cuenta que esto todavía es bastante confuso, por lo que no recomiendo su uso.

Answer 6

Hace uso de la macro actuar como una declaración real o llamada a la función.

una declaración es bien { expression-list } o expression; de manera que plantea un problema para definir comandos que necesitan más de una expresión, ya que si se utiliza { } continuación, se producirá un error de sintaxis si la persona que llama de la macro añade bastante razonable un ; antes un otro

if(whatever) 
    f(x); 
else 
    f(y); 

Si f() es una sola macro comunicado, bien, pero lo que si se trata de una macro y algo complicado? Usted termina con if(...) { s1; s2; }; else ... y eso no funciona.

De modo que el autor de la macro tiene que convertirla en una función real, envolver la construcción en una sola declaración o usar una extensión gnu.

El patrón do .. while(0) es el enfoque de "envolver la construcción".