butting two arrays

I thought you could do that with the compiler. I think checking "Keep variables in order" in the C51 dialog or ORDER on the C51 command line should do it. Of course you'd then need to define the three arrays in order in a C file, .e.g.

SomeType arrA[SOME_SIZE];
SomeType arrB[SOME_OTHER_SIZE];
SomeType arrC[SOME_DIFF_SIZE];

Or you could define the arrays within a struct, thus guaranteeing their order.

Not sure what (if any) impact this may have on access efficiency - but I'm quite sure that you're fully capable of investigating that for yourself, if it's an issue! ;-)

The struct is a good idea but C does not guarantee that there won't be pad bytes added. In this case though I think the pad bytes wouldn't matter.

"C does not guarantee that there won't be pad bytes added"

This is true; however, in this specific case, I don't think that Keil C51 ever adds padding bytes (there would be no reason to do so on an 8-bit processor).

Generally, I think most compilers have an option to prevent the addition of padding bytes?

True, on an 8-bit machine without alignment considerations I'd agree with you. I just like to raise portability issues so we all remember what C guarantees. Yes most compilers offer some #pragma pack or __attribute__((packed)) option.

Further thoughts:

1. Could you use a union, so that you're actually getting the compiler to some "overlaying?"

2. Or something like this:

U8 b[SIZE_A];
{
   U8 a[SIZE_B];
   // get data into a[]
   :

   // format data from a[] into b[]
   :
}
{
   U8 c[SIZE_C];
   // reformat data from b[] into c[]
   :
}

I've assumed that your process is a[] --> b[] --> c[], so that the data in a[] is no longer required when you start processing b[] into c[] - but I could be wrong there?
A receives compressed data which is uncompressed to b for fast upload to C. B may contain several data blocks one of which is uploaded to c every 3 seconds. Since the operation following data -> a ->b always require a refresh of c overflow is not a problem if it occor into c; however some input data is added to b rather than replacing it, so b must be preserved at all times.

"...b must be preserved at all times."

My suggestion has b[] outside both blocks, so it would be preserved (only a[] and c[] would be overlayed)

Does this work for you?

Gave up and made it in assembler, not too big a deal since these 3 buffers/arrays is the only XDATA used.

Thanks for the suggestions

Erik