macro syntax induced error - c

Question

I the following code and a small little part of it didn't make sense because it was beyond the knowledge I have currently and I was wondering if someone could clear this little problem out for me
stack.h
#ifndef _STACK_H
#define _STACK_H
#include "lis1.h"
typedef List Stack ;
#define stack_init list_init
#define stack_destroy list_destroy
#define stack_size(stack) (stack)->size
#define stack_is_empty(stack) ((stack)->size==0)?1:0
int stack_push(Stack*stack,void*data);
int stack_pop(Stack*stack,void**data);
#endif
please note the #define stack_is_empty(stack) ((stack)->size==0)?1:0 carefully
and on compilation of the following program ,
#include<stdio.h>
#include"stack.h"
static char ams[5] = { 'h', 'e', 'l', 'l', 'o' };
void* data;
Stack stack;
char*ss;
void debug(int a)
{
printf(" debug %d \n", a);
}
int main()
{
stack_init(&stack, NULL);
debug(1);
int i;
for (i = 0; i < 5; i++)
{
stack_push(&stack, (void*) (&ams[i]));
};
debug(2);
while (printf("checker\n") && stack_is_empty(&stack) != 1)
{
printf("->");
printf("[%d ", stack_size(&stack));
stack_pop(&stack, &data);
printf("%c]", *((char*) data));
printf("--\n");
};
return 0;
}
I get this
debug 1 debug 2 checker
->[5 o]-- checker
->[4 l]-- checker
->[3 l]-- checker
->[2 e]-- checker
->[1 h]-- checker
segmentation fault
but if I change #define stack_is_empty(stack) ((stack)->size==0)?1:0
to #define stack_is_empty(stack) (((stack)->size==0)?1:0), there is no seg fault
My Query
My question why did the program work perfectly fine in the former case until the conditional spews a '1'..I seem to understand why the latter works.

Answer 1

In C, a macro is just substituted textually, with no regard to whether it produced the expression that you might expect.
Without the parentheses, your while loop condition expands to:
printf("checker\n")&&((&stack)->size==0)?1:0!=1
Which is interpreted as:
(printf("checker\n") && ((&stack)->size==0)) ? 1 : (0 != 1)
The printf thus becomes part of the condition for this ternary expression, but that's doesn't cause a problem, it returns the number of bytes printed which will be interpreted as true as long as it's non-zero. Then you perform an and with your actual condition, the part that checks the stack size. If the stack size is equal to zero, this returns 1, or true. If the stack size is not equal to zero, this returns the result of (0 != 1), which is always true. So this condition always returns a true value, and the while loop keeps going, even after it's run out of items on the stack.
When you add the parentheses, it's interpreted as you expected:
printf("checker\n") && ((((&stack)->size==0)) ? 1 : 0) != 1)
When writing macros that expand to an expression, you should always have a pair of parentheses around the result, to ensure that it is interpreted as a single expression, rather than operator precedence rules possibly causing the expression to be interpreted differently than you intended.
I should note that there is a lot of redundancy in this statement. You are checking the value of a boolean expression, (&stack)->size==0 to see if it is true, returning 1 if it is and 0 if not. But the == already returned a 1 if it was true and a 0 if not; there's no need for the ternary operator. Then you use != 1 to see if it's false. But how do you get false from a boolean expression? Simply use the not operator, !. You can skip the ternary operator and != 1 comparisons entirely:
#define stack_is_empty(stack) ((stack)->size==0)
while (!stack_is_empty(&stack)) {
// ...
}

Answer 2

Remember that C macros are just text replacement, NOT expression evaluations.
Using your umbra keyed stack_is_empty, your if condition becomes :
While (printf("checker\n") && ((&stack)->size)==0)?1:0!=1) {
Trouble is, the != operator has high precedence, so it effectively becomes :
While (printf("checker\n") && ((&stack)->size)==0)?1: (0!=1) ) {
Since 0 != 1, that while loop is going to keep going beyond the size of your stack.

Answer 3

After the macro substitution
printf("checker\n")&&stack_is_empty(&stack)!=1
becomes
printf("checker\n")&&((&stack)->size==0)?1:0!=1
because the ternary operator ?: has a fairly low precedence, this is equivalent to:
(printf("checker\n") && ((&stack)->size==0)) ? 1: (0 != 1)
Note that printf("checker\n") always returns a true value(because it returns how many characters it prints), so the check (&stack)->size==0) is never evaluated due to shortcut circuit.
Advice: always use enough parenthesis in macro definition.