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.
"the struct [element?] was formerly initialised with an address of a variable"
I presume you're talking about sPtr_obj->Adresse - yes?
If this is supposed to hold the address of a variable, why was it not properly defined as a pointer in the first place?!
The only reason why the language allows conversion from integers to pointers is for systems programming (embedded or when you write hardware drivers), i.e. when you need to access a hardware device at a specific location or when you need to locate variables dynamically at absolute locations.
Taking the address of a variable and convert to an integer and later converting the integer back to a pointer is something a program should hardly ever need. Most required address manipulation can be performed on the pointer. If you implement a memory manager, you might like to play with / and % (or more probably with >> and &) to figure out memory page and offset within memory page.
You can lead a horse to water, but you can't make him drink.
"You can lead a horse to water, but you can't make him drink."
Similarly:
"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'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
I presume you're talking about sPtr_obj->Adresse - yes? If this is supposed to hold the address of a variable, why was it not properly defined as a pointer in the first place?!
Because it does not really work to access a pointer address value inside a struct that is pointed to by a pointer. It should be something like
ptr_xdata = *(sPtr_obj->Adresse)
if Adresse wouldn't be an uint, but a pointer instead. We had severe problems in the past calming down the compiler when using such a way. The chance is 50:50 that it will work. Means, the compiler was unsure how to handle it.
Means, the compiler was unsure how to handle it.
That is a statement to print and put on the wall. The next time I get a compiler error, I will complain about insecure compilers. That is almost as funny as saying that the car stood still when the tree suddenly decided to run into it.
You can have any (!) level of pointer indirection (with or without any structs in the indirection chain) without any problems separating operations on the pointer value (the pointer) or on the referenced object. It all follows from the operator precedence rules.
"Because it does not really work to access a pointer address value (sic) inside a struct that is pointed to by a pointer"
Doesn't it?
If the struct element is correctly defined as a pointer, then there is no difference whether it is read via a direct access as
ptr_xdata = some_struct.some_pointer
or via a pointer as
ptr_xdata = struct_ptr->some_pointer
"We had severe problems in the past calming down the compiler when using such a way"
I very much suspect that all comes back to you not really understanding what's going on.
"chance is 50:50 that it will work"
The compiler will do exactly what you tell it to do - but, as mentioned earlier, if you cannot express what you want correctly, then the compiler cannot guess for you...
"the compiler was unsure how to handle it."
Again, the compiler does what you tell it - but, if you tell it rubbish, you will get rubbish as a result.
Hence the well-known programming term, GIGO = Garbage In; Garbage Out.
Because it does not really work to access a pointer address value inside a struct that is pointed to by a pointer.
It should work just fine as long as proper attention is paid to things like operator precedence. This functionality is well-defined and definitely not compiler-specific. If it does not work, then there is either a mistake in the C code or a bug in the compiler. The former is usually much more likely than the latter.
It should be something like
No. It shouldn't be something like X - this leads to bugs. The syntax for doing that is very clear and if you would not insist on ignoring how to work with pointers in C, you would probably know how to do it.
Have you read up on pointer-specific operators, especially the "Member access from pointer" operator, "->" ?
What is this supposed to do ?
1. Copy the value of the structure member Adresse to ptr_xdata ? 2. Copy the address of the structure member Adresse to ptr_xdata ? 3. Copy the contents of the memory address pointed to by the structure member Aresse to ptr_xdata ?
We had severe problems in the past calming down the compiler when using such a way.
The compiler should have absolutely no trouble parsing a trivial operation like that, provided it is fed with the correct code.
The chance is 50:50 that it will work.
Compilers don't roll dice. Provided that you didn't switch compilers somewhere in the middle, there should be no statistics involved. The code is either correct, or it is not.
The compiler will do exactly what you tell it to do - but, as mentioned earlier, if you cannot express what you want correctly, then the compiler cannot guess for you... "the compiler was unsure how to handle it." Often, a compiler will try to figure out what you ment and instead of an error issue a warning, which, in a way means "the compiler was unsure how to handle it.". Then, it is up to you to accept "unsure" or find the reason for the warning and remove it. Should you decide to accept 'unsure' please tell me and I will avoid buying any of your products.
I thought that in the OK it was "RIRO rubbish in, rubbish out" :)
"Means, the compiler was unsure how to handle it."
Assuming that you're running the C51 compiler on Windows on a PC using , the compiler will be consistent with its decisions.
As far as I am aware, the random computer is not in common usage.
You obviously use English as a method of communication - Haven't you noticed that it (like all languages) is based on mutual understanding.
If someone, unilaterally, opts to change the meaning of a word, then that person is obviously going to generate misunderstanding.
Why to you want that someone to be you?
Yes, I suppose it should be - but we are beset by far too many americanisms...
:-(
It shouldn't need saying yet another time, but apparently it does: No, that pointer is not of type uint. It's of type pointer-to-uint. A uint is not a pointer any more than a car is a driver's license. Staying in that image, you got a warning because you tried to put the car in your inside pocket. I'm just translating it from our language, Herr Broeker, to english. I don't know why the guys here are such nitpickers, but in german we say: Zeiger und Zeigertyp. Ein Zeiger, der auf eine uint-Variable zeigt, ist vom Typ uint. Und eine Zeigeradresse ist die Adresse, wo der Zeiger draufzeigt, und nicht seine eigene! Wie sollte man diese Adresse denn sonst nennen???
OK, in order to get this straight, folks: How do you call the adress the pointer points to? How do you call the value the pointer points to?
Assuming that you're running the C51 compiler on Windows on a PC using , the compiler will be consistent with its decisions. I agree the compiler is 'content' but I still maintain it is 'unsure'. i think we are haggling words rather that function.
Does a warning not mean "I have done the best I can and am 'content' with that, but it is possible I applied the wrong decision"
As an example: most often a simple non-prototyped functiaon will work just fine, but there is no guarantee that all non-prototyped functions will work. Thus the compiler, while being "content with its decision" (it has done what the documentation states it will) does declare "I am unsure" i.e. issues a warning.
One of my recurring 'faults' is forgetting to prototype a function and often I will run a debugging session with the warning existing and remove the warning at the next editing session.
I don't know why the guys here are such nitpickers,
Because most of the responders earn their income by writing programs in C.
How do you call the adress the pointer points to?
Value/content of the pointer.
How do you call the value the pointer points to?
Content of the memory address referenced by the pointer.
Did you read all the other postings on this thread yet ? If not, could you do so and comment on whether they make things clearer ? Could you also answer the questions I asked about the -> operator ? I assume that much of the confusion you experience stems from a misconception on what this operator does, and to confirm that I could use the answer to those questions. Sorry if they sound a bit textbook-ish, but if things are like I think they are, then an explanation of this operator would clear them up quite a bit.