Determine positions in array at compile-time in c - c

Question

Is there a way to determine a position within a const array at compile-time in c? Here's an example of what I'm trying to do:
const unsigned char DATA[] = {
// Part 1
// hundreds or thousands of values
// Part 2
// compiler records this position in the array in PART2
// hundreds or thousands of values
// Part 3
// compiler records this position in the array in PART3
// hundreds or thousands of values
// ...
};
const unsigned int PART_IDX [] = {
// index to Part 1
0,
// index to Part 2
PART2,
// index to Part 3
PART3,
// ...
};
I could calculate the indexes at run-time, but would rather have them already done, since the array is constant. I could make a program that analyzes the source code, counts the number of elements in each part, and inserts the data in PART_IDX, but I would really like to have the compiler do this at compile-time. That way if data gets inserted or deleted, or parts get added or removed, the compiler still generates correct code. Does someone know how I could do this? Thanks!
Edit:
To clarify, using a example with actual data:
const unsigned char DATA[] = {
// Part 1
0, 1, 2, 3, 4,
// Part 2
// compiler records this position in the array in PART2 (should be 5)
10, 11, 12, 13, 14, 15, 16,
// Part 3
// compiler records this position in the array in PART3 (should be 12)
20, 21, 22
};
const unsigned int PART_IDX [] = {
// index to Part 1
0,
// index to Part 2
PART2, // should be 5, points to 10 in the array
// index to Part 3
PART3, // should be 12, points to 20 in the array
};
Question is, what can I put in place of the lines that start with // compiler records this position ... to get the compiler to record the appropriate values in PART2 and PART3?

Answer 1

Rather than trying to kludge C to do something it was not meant to do, a better and common method is to prepare data for a C program by writing a program that prepares the data. That is, write some other program that counts the data in the parts and writes the C code necessary to initialize both DATA and PART_IDX.
Another option is:
Put all the data each part in a separate “.h” file, such as files “part1.h”, “part2.h”, “part3.h”.
To initialize DATA, include all of those header files in its initializer list.
To calculate the indices for the parts, use sizeof to calculate the numbers of elements in proxy arrays containing the preceding parts.
Example:
“part1.h” contains 10, 11, 12,.
“part2.h“ contains 20, 21,.
“part3.h” contains 30, 31, 32, 33,.
The C file is:
const unsigned char DATA[] =
{
#include "part1.h"
#include "part2.h"
#include "part3.h"
};
const unsigned int PART_IDX [] =
{
0,
sizeof (const unsigned char []) {
#include "part1.h"
} / sizeof (const unsigned char),
sizeof (const unsigned char []) {
#include "part1.h"
#include "part2.h"
} / sizeof (const unsigned char),
};
#include <stdio.h>
int main(void)
{
for (int i = 0; i < 3; ++i)
printf("Part %d begins at index %d with value %d.\n",
i, PART_IDX[i], DATA[PART_IDX[i]]);
}

Answer 2

Is there a way to determine a position within a const array at compile-time in c?
Yes. Remember that C source files can be generated, and improve your build automation accordingly (e.g. edit your Makefile).
So just generate the second part (e.g. with some awk or Guile script on Linux, or your own simple meta-program coded in C -or some scripting language- that output portions of generated C code). Play with preprocessor tricks. See this answer for inspiration.
You could, assuming you use GCC as your C compiler, also consider writing your ad-hoc GCC plugin, but in your particular case it is not worth the effort.
BTW, my Bismon program uses such meta-programming tricks. And GCC itself has dozens of ad-hoc code generators.
If you generate some complex enough C code, I recommend keeping internally some kind of AST of it.