missing entries in array of string values - c

Question

I'm trying to create a const char array of strings used to identify some hardware channels. I then want to retrieve these entries by index to label outputs on a user console. Some of these channels are unassigned and labeled as such with a string "XX_UNASSIGNED_XX", so this value is repeated in the array.
When I try to sequentially display these values in my test code, I see that XX_UNASSIGNED_XX only appears once, and is subsequently skipped. I opened a memory trace in the embedded hardware, and sure enough, the memory only lists XX_UNASSIGNED_XX once, I'm assuming as a sort of optimization.
Is there a way to force the compiler to instead list out every entry in memory as is, duplicates and all? Or, is it possible that I don't need to do this, and the way I'm attempting to display the strings is incorrect or inefficient and could be improved?
I've played around with how I display the strings, and because it's ultimately a pointer array with each string a different length, I ultimately resulted in recording the length of each string, tracing the array with a pointer variable, then using snprintf to copy the string over to a temp string which I then display. Any attempt to print the values in the array directly kept resulting in anomalous behavior I couldn't seem to correct.
FYI The Display_printf command is simply a printf to the UART terminal with syntax as follows:
Display_printf(UART_handle,col_index, row_index, display_text))
#define ADC_COUNT (20)
const char* adcNamesArray[ADC_COUNT] = {
"KP_CUR_MON",
"A_CUR_MON",
"A_VOLT_MON",
"NEG_15_VOLT_MON",
"XX_UNASSIGNED_XX",
"FOCUS_CUR_MON",
"XX_UNASSIGNED_XX",
"XX_UNASSIGNED_XX",
"K_CUR_MON",
"XX_UNASSIGNED_XX",
"XX_UNASSIGNED_XX",
"XX_UNASSIGNED_XX",
"FOCUS_VOLT_MON",
"FARADAY_MON",
"MFC_MON",
"XX_UNASSIGNED_XX",
"POS_12_VOLT_MON",
"POS_24_VOLT_MON",
"POS_15_VOLT_MON",
"POS_5_VOLT_MON"
};
char str[20];
char* ptr = &adcNamesArray[0];
char* printPtr;
int nameLength;
for(int adc_index = 0; adc_index < ADC_COUNT; adc_index++) {
nameLength = 0;
while(*ptr == '\0') {
ptr += sizeof(char);
}
printPtr = ptr;
while(*ptr != '\0') {
ptr += sizeof(char);
nameLength++;
}
nameLength++;
char* str;
str = (char *)malloc((sizeof(char)*nameLength+1));
snprintf(str, nameLength, "%s", printPtr);
Display_printf(display,0,0,"ADC %d: %s", adc_index, str);
}
So, I expect all the XX_UNASSIGNED_XX entries to show up in order, but instead what I get is this:
ADC 0: KP_CUR_MON
ADC 1: A_CUR_MON
ADC 2: A_VOLT_MON
ADC 3: NEG_15_VOLT_MON
ADC 4: XX_UNASSIGNED_XX
ADC 5: FOCUS_CUR_MON
ADC 6: K_CUR_MON
ADC 7: FOCUS_VOLT_MON
ADC 8: FARADAY_MON
ADC 9: MFC_MON
ADC 10: POS_12_VOLT_MON
ADC 11: POS_24_VOLT_MON
ADC 12: POS_15_VOLT_MON
ADC 13: POS_5_VOLT_MON
ADC 14: ▒
ADC 15: #
ADC 16: ▒▒▒▒
ADC 17: #▒
ADC 18:
ADC 19:
A look at the memory dump gives this, which explains why XX_UNASSIGNED_XX doesn't show up multiple times.
0x0001C0D8 . . . . . . . 0 K P _ C U R _ M
0x0001C0E8 O N . . A _ C U R _ M O N . . .
0x0001C0F8 A _ V O L T _ M O N . . N E G _
0x0001C108 1 5 _ V O L T _ M O N . X X _ U
0x0001C118 N A S S I G N E D _ X X . . . .
0x0001C128 F O C U S _ C U R _ M O N . . .
0x0001C138 K _ C U R _ M O N . . . F O C U
0x0001C148 S _ V O L T _ M O N . . F A R A
0x0001C158 D A Y _ M O N . M F C _ M O N .
0x0001C168 P O S _ 1 2 _ V O L T _ M O N .
0x0001C178 P O S _ 2 4 _ V O L T _ M O N .
0x0001C188 P O S _ 1 5 _ V O L T _ M O N .
0x0001C198 P O S _ 5 _ V O L T _ M O N . .
0x0001C1A8 uartMSP432E4HWAttrs
0x0001C1A8 . . . # . . . . . . . . . . . .
0x0001C1B8 # . . . . . . . . . . . . . . .
Any help is appreciated.

Answer 1

You assume that the texts are contiguous in memory separated by one or more NUL characters. This assumption is wrong.
This declares an array of pointers to your texts:
const char* adcNamesArray[ADC_COUNT] = {
...
Just use that array and all of a sudden your code becomes much simpler and correct.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define ADC_COUNT (20)
int main(void)
{
const char* adcNamesArray[ADC_COUNT] = {
"KP_CUR_MON",
"A_CUR_MON",
"A_VOLT_MON",
"NEG_15_VOLT_MON",
"XX_UNASSIGNED_XX",
"FOCUS_CUR_MON",
"XX_UNASSIGNED_XX",
"XX_UNASSIGNED_XX",
"K_CUR_MON",
"XX_UNASSIGNED_XX",
"XX_UNASSIGNED_XX",
"XX_UNASSIGNED_XX",
"FOCUS_VOLT_MON",
"FARADAY_MON",
"MFC_MON",
"XX_UNASSIGNED_XX",
"POS_12_VOLT_MON",
"POS_24_VOLT_MON",
"POS_15_VOLT_MON",
"POS_5_VOLT_MON"
};
for (int adc_index = 0; adc_index < ADC_COUNT; adc_index++)
{
char *str = malloc(strlen(adcNamesArray[adc_index]) + 1);
strcpy(str, adcNamesArray[adc_index]);
printf("ADC %d: %s\n", adc_index, str);
}
}
If you don't have strcpy or strlen on your platform for whatever reason, you can implement them yourself, they are one-liners.
Some explanations:
sizeof char is 1 by definition, so you can drop it
the (char*) cast is not necessary with malloc, it's not wrong to put one, but there is zero benefit in doing so.