Thread: integer constant data types

Hi,

I have couple of basic questions about data types for integer constants in C.
In a fragment of code like the following:

Code:

long i = 10;

I want to confirm the processing of this simple assignment statement inside compiler. I will state my understanding first: compiler sees the integer constant 10, it is unsuffixed decimal so compiler checks if 10 can fit into the range: int->long->unsigned long (assuming ISO C90, not C99). 10 fits into int, so compiler allocate 4 bytes(assuming machine is 32-bit) to store 10 with type as int. This storage space for storing 10 might be a register or some place temporarily. Up to now is the processing of the integer constant 10. Then continue to the assignment, 10 is promoted from int to long because i is long, and assigned to i.

If the processing is like the above, my questions are:
1. What's the internal data type used by compiler (gcc or any) when dealing with such situation? Compiler must have an internal data type to store 10 when trying to figure out its data type (int, long, unsigned long). Is this data type the biggest one? For example, if the biggest uses 8 bytes, then when starting to process every integer constant, it is stored in this 8-byte data type. Then to check against int, if not fit, check against long, then unsigned long. If internal data type uses the biggest one, what if integer constant is too large to hold inside compiler?

2. What's the use of the data type of an integer constant?
I can only guess two points:
1) compiler assign storage to the constant according to its type. For example, the temporary storage for 10, its size is 4 bytes because the type of 10 is int.
2) when an integer constant is in an arithmetic operation, its type is used for type conversion among operands and to determine result type. For example, result for 10*10 is int and result for 10*10ul is unsigned long.
Is there any use I don't notice?

3. I searched the following example on the web:

Code:

on KEIL--51 (2 bytes for int, 4 bytes for long)
long totalsec;
totalsec =  60* 60 * 24 * 365;      //result is  0x3380, wrong
totalsec =  60ul* 60 * 24 * 365;  //result is  0x1E13380, correct

on KEIL_ARM  (4 bytes for int, 4 bytes for long)
long totalsec;
totalsec =  60* 60 * 24 * 365;      //result is 0x1E13380, correct
totalsec =  60ul* 60 * 24 * 365;  //result is 0x1E13380, correct

So on KEIL--51, the first example, int range is [-32768, +32767], 60*60*24 is 86400, which is already out of the range before multiplying 365. 86400 is truncated before multiplying 365 or is stored in the internal biggest data type and continue to multiply 365, the final result 31536000 is still stored in this internal data type. At last, it is converted to long. But if this way, the first example on KEIL--51 should be correct. So there must be truncation before assignment and no the internal biggest data type?

Actually I am quite confused with integer constant data type in C. I don't understand exactly its processing by compiler and why every code like

Code:

#define SECONDS_PER_YEAR (60*60*24*365)UL

has to have suffixes UL.
I really appreciate it if anyone can help me the correct and detailed way about the (integer) constant data type.

THANK you very much!!

The web example you found is not standard C code... Not sure what it is.

Your compiler's documentation should detail the sizes and ranges of your various types so your most accurate information will come from there.
If you want to be real picky about variable sizes (like me) you can include stdint.h, the best way to view it's contents is to open it in notepad or inside your IDE... but don't change anything!

And, you shouldn't really give a crap how the compiler decides what to do with a variable intializer like you've described. It's actually up to you as the programmer to select a data type large enough to hold the value. (10, for example, would even fit in a char type)

You should also know that it's not a constant unless you say it's a constant...

Code:

const int fraggle = 10;

And last of all the one nobody wants to hear... C has *absolutely no run time error checking*. It is 100% on you to write code that doesn't screw up.

if i understand your question, you are mixing up what happens at compile time with what happens at runtime. simplistically, a compiler has 2 phases : lexical scanner and parser. the lexical scanner picks out the tokens one by one and stores them internally without caring how it is used. the compiler lexical scanner will recognize the type of '10' and store it internally at compile time and as CommonTater says, it doesn't matter how. if the number was '1000000000000' the scanner will handle it differently or issue an error. at the point of reading the program text '10', it doesn't care anything about what you are doing with the value later on and that has nothing to do with runtime code. then when the compiler parser uses the grammar to parse the assignment statement it will figure out what promotions to use if any. none of this is happening at runtime. all at compile time. at run time all you will get is a single instruction store of a constant 10 into the your int variable.