Thread: passing data

In the first place, don't use "void *" everywhere. That defeats the purpose of prototype checking. It doesn't matter what type of RAM object it is, you may _always_ define it as atleast an "unsigned char *".

Secondly, don't pass large things by value, pass their address. Much faster program operation. Safer.

Thirdly, if you have something you want to verify, run a 32-bit CRC on the object and pass that value along with it's address. The receiving algorithm can run a CRC check again and compare its result with the caller's.

Lastly, you're interested in checking integrity of passed data, yet the first few lines of your code (see main()) fail to even check whether or not the "buffer" RAMblock was successfully allocated... gotta get used to performing that little check with every allocation.

good luck.

Thanks!
Would you please show me how to pass the address instead of passing value? Sorry, I don't understand your third thing, would you explain it a little bit more? Thank!

passing by address .v. value
---------------------------------------

Let's first understand that everything resides in memory (RAM). RAM is just consecutive bytes. Every byte resides at a specific position in RAM-- from the first byte to the last byte. That position is that byte's "address".

When you pass arguments to a function, compilers allow you to pass (generally speaking) the item either by value-- which is to say it copies the whole variable's contents onto the stack and expects the called function to work with that, or by address-- which means you just pass the address of the first byte of the variable's contents.

Let's say you have a structure:

Code:

typedef struct
   {
   char   name[50];                     /* customer name */
   long   hairs;                             /* hairs on head */
   int      fingtoes;                       /* number of fingers & toes */
   }custRec;

Now, if we count the size of each field, and the alignment padding the compiler adds to align each field, that structure is 58 bytes in length.

If you pass the structure by value, you pass 58 bytes of data onto the stack-- which is slow to do (in computer time).

Code:

custRec   myRecord;

/* stuff info into myRecord */

ProcessCustomer(myRecord);                 /* <-- pass by value */

However, if you pass the address of the structure's first byte instead, it's much faster, because only 4 bytes need stored on the stack (in other words, a "long word"). Like so:

Code:

ProcessCustomer(&myRecord);

It's operationally faster, more stable because you're doing less stackwork and data manipulation.


Don't Be a Niller
---------------------
In your main(), you perform an allocation, but never check to see if that allocation was valid-- how do you know malloc() handed you a RAMblock? Maybe it didn't-- here's how to tell:

Code:

int main (void)
   {
   char     *buffer;

   buffer = 0L;                           /* Nill/Null the variable to known state */
   buffer = (char*)malloc(sizeof(CFIXED)*4096);

   if(buffer)                                /* <-- need to ALWAYS check */
      {
      CallFunction(BBT,&buffer);
      CallFunction(AAT,&buffer);
      }
   else
      ErrHandler("OUT OF MEMORY");     /* terminate gracefully */
   }

See? The above checks to see if the allocation worked. If not, we display an error (that's called exiting "gracefully").