Displaying result of Macro evaluation

Of course I can crunch it all by hand but it would be nice to see what the preprocessor evaluates this to.

No. It would be anything but nice. Because the preprocessor does nothing like the kind of "evaluation" you appear to expect. It just replasces text by other text. In particular, it performs none of the math in those lines.

To see what the preprocessor actually makes of your code, you should just run it through the preprocessor and look --- every C compiler worth having offers a way to do that. It's an exercise worth doing every once in a while, and sometimes it's an absolutely necessary test to understand why something you tried to do with the preprocessor just didn't work.

You'll have to modify your example, though, because as is, the preprocessor will compile it to effectively nothing at all. But if you finish it with an invocation of the final macro, you will get something like this:

(unsigned char) ((((double)(v)) - 1.8 + (double)(0.5)*(double)(( 2.4 - 1.8)/(double)255))/(double)(( 2.4 - 1.8)/(double)255))

Of course I can crunch it all by hand but it would be nice to see what the preprocessor evaluates this to.

No. It would be anything but nice. Because the preprocessor does nothing like the kind of "evaluation" you appear to expect. It just replasces text by other text. In particular, it performs none of the math in those lines.

To see what the preprocessor actually makes of your code, you should just run it through the preprocessor and look --- every C compiler worth having offers a way to do that. It's an exercise worth doing every once in a while, and sometimes it's an absolutely necessary test to understand why something you tried to do with the preprocessor just didn't work.

You'll have to modify your example, though, because as is, the preprocessor will compile it to effectively nothing at all. But if you finish it with an invocation of the final macro, you will get something like this:

(unsigned char) ((((double)(v)) - 1.8 + (double)(0.5)*(double)(( 2.4 - 1.8)/(double)255))/(double)(( 2.4 - 1.8)/(double)255))

Thanks for the response. I realize how the macro is expanded however I am pretty sure that the constant expression that it results in is evaluated and the result is what is replaced. For example it will not try to actually compute floating point calculation at run time. It will not link in floating point libs etc.

#define FOO(bar) (unsigned char)((double)(bar)*0.75)

void someFunc(void){ unsigned char a; .... a=FOO(100); ....
}

At compile time, FOO(100); will be replaced with the constant 75 and the line in the function will be a=75; In the same way as if you write a= (1<<5); this doesn't result in several left shift operations being generated. It results at compile time to be 32; Maybe this is done as an optimizing step by the C-compiler and not the preprocessor but I have used other tools that will show the what the final value substituted is. Maybe there is no such feature in the C51 toolset.
I have historically found it to be a useful thing to have available.

As already noted, the Prepocessot just does text substitution - it does not evaluate anything.

Most toolsets have an option to view the preprocessor output; for Keil C51, it is PREPRINT:
http://www.keil.com/support/man/docs/c51/c51_preprint.htm

See also: http://www.keil.com/support/man/docs/uv4/uv4_dg_listing.htm

But it is the Compiler - not the preprocessor - which evaluates (or may evaluate) constant expressions.

AFAIK, The only way to see what the Compiler has done is to look at the generated assembly:

http://www.keil.com/support/man/docs/c51/c51_code.htm
http://www.keil.com/support/man/docs/c51/c51_cm_lstfile.htm

As already noted, the Prepocessot just does text substitution - it does not evaluate anything.

Do you think that statement is 100% accurate?

Consider:

#include <stdio.h>

void main(void)
{
#if (1+1)==2
  printf("(1+1)==2 : Accuracy of advice is important!\n");
#else
  printf("(1+1)!=2 : Accuracy of advice is not important!\n");
#endif
}

Which text do you think will be printed?

OK, "the Macro pocessor just does text substitution - it does not evaluate anything"

Macro pocessor

Not a good day for accuracy.

It's a fair cop!

It is.

The Keil C51 Manual calls it, "Constant Folding":

http://www.keil.com/support/man/docs/c51/c51_optimize.htm

is quite simple
WORD temp_variable = AXX*BYY/CCC;

and have a pek in the debugger, then remove temp_variable

Erik