Hello!
I have uVision that compiles fine with the C51 v7.03 compiler and the related package, but not complete with the 8.06. I used two different Keil installations. All files are in the same folder.
In the 8.06 I get linker errors like "object does not fit in to pdata page" and "0080H". This looks like the compiler was thinking the PDATA was only 128 bytes, but it is set to 256 bytes in the startup.a51. Any clue what's different in the newer Keil package?
Also there is a warning in 8.06 (which does not show in 7.03) "converting non-pointer to pointer" on this
ptr_xdata = sPtr_obj->Adresse;
while the vars are set like this:
uchar uc_set_obj( uchar pdata *ptr_Set) { uchar i; uchar xdata *ptr_xdata; struct stOBJADR code *sPtr_obj; sPtr_obj=&Obj[*ptr_Set]; . . . ptr_xdata = sPtr_obj->Adresse; }
The struct stOBJADR has a member "uint Adresse;"
I can see no wrong use of the pointers. I just want to be sure that the warning does not affect the code to not work correctly.
"You can lead a boy to college, but you can't make him think." - Elbert Hubbard. "you can lead a boy to college, but you can not make him do his homework instead of posting "please send schematic and code" in a forum"
Erik
Unfortunately, this forum doesn't support pictures, so we'll have to make do with "ASCII-Art" - but here goes.
Consider the following definitions
typedef unsigned int uint; // In C51, this occupies 2 bytes (16 bits) uint my_uint; // A variable of type uint uint *my_ptr; // A pointer to type uint uint **my_ptr_ptr; // A pointer to a pointer to type uint
Assuming that pointers are also 16 bits, these could result in a memory layout looking something like this:
Address: 100 101 102 103 104 105 106 ...+------+------+------+------+------+------+... Memory: | | | | ...+------+------+------+------+------+------+... Name: my_uint my_ptr my_ptr_ptr
You can see that: The address of my_uint is 100; The address of my_ptr is 102; The address of my_ptr_ptr is 104.
Now let's assign some values:
my_uint = 986; // Assign the value 986 to the variable my_ptr = &my_uint; // Assign the address of my_uint to my_ptr my_ptr_ptr = &my_ptr // Assign the address of the pointer to my_ptr_ptr
This would result in the following values being stored in memory:
Address: 100 101 102 103 104 105 106 ...+------+------+------+------+------+------+... Memory: | 986 | 100 | 102 | ...+------+------+------+------+------+------+... Name: my_uint my_ptr my_ptr_ptr
Now you can see that: The address of my_uint is still 100, and the value of (ie, the value stored in) my_uint is 986; The address of my_ptr is still 102, and the value of (ie, the value stored in) my_ptr is 100; The address of my_ptr_ptr is still 104, and the value of (ie, the value stored in) my_ptr_ptr 102.
Thus it should now be clear that the address of a pointer has nothing to do with the value of a pointer.
"Assuming that pointers are also 16 bits..."
Note that, in general this assumption is not true for Keil C51.
In Keil C51, an unqualified pointer definition (as shown) would give a Generic Pointer - which occupies three bytes. See: http://www.keil.com/support/man/docs/c51/c51_le_genptrs.htm
Therefore, with Keil C51, the diagram should be more like:
X:100 101 102 103 104 105 106 107 108 ...+------+------+------+------+------+------+------+------+... | 986 | X:100 | X:102 | ...+------+------+------+------+------+------+------+------+... my_uint my_ptr my_ptr_ptr
Mr OP,
When I get confused with things like pointers, typecasts and functions, I always add brackets.
But ... take note of the following text from the C infrequently asked questions:
"In the old days, when Microsoft first invented C, the syntax for calling functions involved more parentheses; this was after their market research indicated that most C programmers would be coming from a Lisp environment. Later, when Kernighan took over the language design (right after AT&T bought Microsoft's language technology), he decided to eliminate the parentheses, but the old form is still allowed."
Additional brackets (parentheses) would be of no help at all in this situation, I'm afraid.
Yes. I believe the OP thinks that the "->" operator returns a pointer to the member, when it actually references the member itself ...
"Additional brackets (parentheses) would be of no help at all in this situation, I'm afraid."
Trouble is, looks like nothing helps him anyway!
Not even your nice explicit diagrammed examples!
Perhaps if a native German speaker could translate & explain his German quotation, that might throw some light...
I did, and it doesn't.
So his terminology has exactly the same flaw when expressed in German?
ie, it's a fundamental flaw, not just a problem with the translation into English?
Absolutely. Nothing was lost in translation.