Thread: Its killing me! Allocating memory in software!

Doesn't work like that though:

* WM_INIT is added to the queue.
Unit1: does its thing
Unit2: does its thing
Unit3: puts WM_DRIVEATTACHED in your application's queue
Once WM_DRIVEATTACHED is in the queue, the function returns so that WM_INIT can continue down the line! The pointer to the data for WM_DRIVEATTACHED is now gone.
Unit4: does its thing with the init
Unit5: does its thing with the init
etc...
WM_INIT is removed from the queue. It's pointer data is freed.
WM_DRIVEATTCHED is the next message in the queue.
Unit1: tries to do it's thing. Unfortunately, there is no data any more

A bit more insight:

* Create an object for INIT
* Unit1
* Unit2
* Unit3
*** Responds to INIT by finding attached drives
*** Finds drive C -- creates a drive object to be passed to other units later
*** Finds drive D -- creates a drive object to be passed to other units later
*** Finds a bunch of other drives...
*** Adds them all to the queue, pointers to the data and all.
*** Returns from it's processing function -- freeing the pointers
* Unit4
* Unit5

INIT message has made it through the line. It's processing is done -- freeing it's pointer.

Now the next message comes up with drive C as the object. However, the pointer is now invalid because the pointer was freed.

Colin,

I'm a bit out of touch with this stuff and current programming environments. To me, it seems the problem is that you are working with local variables that are destroyed as you leave the procedure.

The static modifier on a variable declaration tells the compiler to make a variable stay around until next time a procedure is called instead of releasing it on exit.

I would approach this by keeping a linked list in global memory of the queue data.

If you google linked list, you should find some example code. Each entry in the list will be a struct and contain a pointer to the previous and the next entry. The first entry has previous = NULL and the last entry has next = NULL so you can test for the first and last entries. I would maintian global pointers to firstrecord and lastrecord. An empty list would have NULL values for both of these. You probably need a initialize_list() and empty_list() functions called at the beginning and end of your program.


Now I might be way off here about your probelm, but hopefully, I have given some ideas to think about.

EDIT: You would also have procedures/methods to AddEntry(), ProcessEntry() and DeleteEntry(). Ideally all wrapped up in a classs so it is robust and contained. So when you add to the queue you call AddEntry() and when you have processed it with ProcessEntry(), call DeleteEntry()

Originally Posted by rodweb

Colin,

I'm a bit out of touch with this stuff and current programming environments. To me, it seems the problem is that you are working with local variables that are destroyed as you leave the procedure.

The static modifier on a variable declaration tells the compiler to make a variable stay around until next time a procedure is called instead of releasing it on exit.

I would approach this by keeping a linked list in global memory of the queue data.

If you google linked list, you should find some example code. Each entry in the list will be a struct and contain a pointer to the previous and the next entry. The first entry has previous = NULL and the last entry has next = NULL so you can test for the first and last entries. I would maintian global pointers to firstrecord and lastrecord. An empty list would have NULL values for both of these. You probably need a initialize_list() and empty_list() functions called at the beginning and end of your program.


Now I might be way off here about your probelm, but hopefully, I have given some ideas to think about.

EDIT: You would also have procedures/methods to AddEntry(), ProcessEntry() and DeleteEntry(). Ideally all wrapped up in a classs so it is robust and contained. So when you add to the queue you call AddEntry() and when you have processed it with ProcessEntry(), call DeleteEntry()

Ill look around at the static modifier, thanks.

I did take a programming class this year at school, and we did a lot of very complex work with structures such as linked lists. I know what you mean, but it doesn't help my case in any way. I can store pointers in a queue no problem, I can't keep the data.

I was using local variables.

My code would be something like this (for example):

Code:

Function
- Create object
- Add it to queue
- Free Object

Queue
- TRY TO copy memory **
- Dispatch the message
- Check if queue is empty

My individual functions have to be able to free the memory they use. Im trying to copy it right now using Move, but that's not working either. How the hell can I queue memory!!!