dudas sobre programación y #pragma

[JuanjoPic]

Hola compañeros, me gustaria que me ayudaran a entender un codigo y acerca de #pragma.

Este es el codigo:

Código: C

1. else{
2.         while (!(IFG2&UCA0TXIFG));      
3.         UCA0TXBUF = c[i];              
4.         }

Lo que esta dentro del while (!(IFG2&UCA0TXIFG)), según yo mientras se mantenga el valor de  !(IFG2&UCA0TXIFG) (por ejemplo diera como resultado 0x00) estará dentro del while, pero si el resultado cambia saldrá del while (por ejemplo, IFG2 cambiara y diera como resultado 0x01)....¿Es correcto lo que he dicho?
(puede que sea facil  lo que pregunto pero trate de hacer lo mismo en el DEV C++ y la lógica que expuse no se cumple (incluso sale del while). Esto es lo que hice en el DEV C++

Código: C

1. #include <stdio.h>
2. #include <stdlib.h>
3.  
4. void main(void) {
5.         int a, b;
6.         a = 10;
7.         b = 12;
8.        
9.         while(!(a&b)){
10.                 printf("estoy dentro del while\n");
11.                
12.         }
13.         printf("no estoy en el while");
14.        
15. }

Trate de "recrear" pero con unas variables fijas, y como resultado tengo es que salgo del while...la consola me dice "no estoy en el while"...y no debiera ya que siempre se mantiene el resultado !(a&b)...deberia decirme "estoy dentro del while)).

Lo otro es acerca de la directiva #pragma. Investigue acerca de ella y note que no es un estándar para todos los compiladores y C, son "etiquetas" que realizan "tareas" especificas para cada compilador.
¿Es asi o no?

Cualquier ayuda me sera de utilidad.

Saludos!!

[KILLERJC]

Creo que el problema que tenes es que no estas entendiendo lo que se intenta realizar.

El & ( AND ) es un operadot bit-wise ( o bit a bit ). Primero entendamos que es cada cosa

IFG2 & UCA0TXIFG

IFG2 Es el registro Interrupt Flag Register 2, el cual es de 8 bits, pero solo 4 tienen un significado.
UCA0TXIFG es el flag de interrupcion ( uno de los bits de IFG2 ) de la UART. Esto en realidad es un numero y potencia de 2.

Lo que se suele hacer es que IFG2 devuelva los 8 bits, es decir todo el registro, mientras que UCA0TXIFG sea una "mascara". Me explico con un ejemplo.

Tengos los siguientes valores:

IFG2 = 0b0000 1011
UCA0TXIFG = 0b0000 0010

Al hacerle la AND queda asi:

0000 1011
0000 0010
-------------
0000 0010

Es decir mi "mascara" solo deja pasar el bit de mi interes.

Eso me da un numero que es 2. Pero C, el unico numero que considera "falso" es el 0, todo lo demas es considerado "Verdadero". Asi que si de IFG2 mi bit de interes era 0, el resultado de la AND es 0, sino es numero distinto de 0.
Hay una cosa mas que decirte, la mascara suele ser un numero constante, mientras que el IFG2 es el puntero al registro

Entonces... Suupongamos que el flag esta en 0, para entender el codigo. Si lo reemplazamos queda asi:

Código: C

1. else{
2.         while (!(0));      
3.         UCA0TXBUF = c[i];              
4.         }

Ahora el operador !, es un operador LOGICO, es decir solo se maneja con Verdadero o Falso. Por lo tanto primero va a pasar el numero 0 a un booleano, como anticipe antes es un "Falso", Y el operador lo va a cambiar a "Verdadero". Por lo tanto el queda asi:

Código: C

1. else{
2.         while (true);      
3.         UCA0TXBUF = c[i];              
4.         }

Y se mantendria en ese while. Esto se repite continuamente, hasta que el flag esta activo ( termino de transmitir ), dejando al resultado de la AND en un 2. Eso es un "Verdadero" y el !, lo convierte en "Falso".

En resumen. Se mantiene encerrado hasta que se activa el flag.
Ahora revisemos tu ejemplo en tu PC

a = 10 = 0000 1010
b = 12 = 0000 1100
a&b =     0000 1000

Por lo tanto es, luego de negarlo es "Falso" y sale del while ahi nomas. Para probar, podrias hacerlo cambiando los valores de b, y dandole los valores 0x1, 0x2, 0x4 y 0x8
Vas a notar que si dejas a con un valor de 10, para cuando valga 0x2 y 0x8 nunca va a salir del while.

Lo otro es acerca de la directiva #pragma. Investigue acerca de ella y note que no es un estándar para todos los compiladores y C, son "etiquetas" que realizan "tareas" especificas para cada compilador.
¿Es asi o no?

la directiva de preprocesamiento PRAGMA pertenece al ANSI C

#pragma keyword options

Y puede ser usado para modificar el comportamiento del compilador. La diferencia es que no todos poseen los mismos keyword, estos si son dedicados a cada compilador. Muy pocas veces lo vi usado aparte de los FUSES, solo para eliminar algun warning que da el compilador (que lo omita).

[Geo]

Trate de "recrear" pero con unas variables fijas, y como resultado tengo es que salgo del while...la consola me dice "no estoy en el while"...y no debiera ya que siempre se mantiene el resultado !(a&b)...deberia decirme "estoy dentro del while)).

Como mencionó KILLERJC y como puedes ver aquí: http://c.conclase.net/curso/index.php?cap=004c#Op_logicos
el operador ! devolverá verdadero cuando la expresión que evalúa es 0, por lo que el código del ciclo while en tu ejemplo solo se ejecutará si la expresión a & b evalúa a 0, en el caso de los valores que colocas, no es así, por ello sales del ciclo de inmediato.

Lo otro es acerca de la directiva #pragma. Investigue acerca de ella y note que no es un estándar para todos los compiladores y C, son "etiquetas" que realizan "tareas" especificas para cada compilador.
¿Es asi o no?

La directiva #pragma si es parte del estándar, no las diferentes implementaciones. Una que he usado bastante es #pragma once: https://es.wikipedia.org/wiki/Pragma_once