dereferencing char pointer array

[syswizard]

newbie here (be gentle !)
I've got a call to a function that does some parsing. It supposedly returns a pointer to an array of char pointers. How does the calling program dereference the pointers to place the references into a character array ?

Here are the implementation details of the function:
char **foo(const char *inputString, const char *theDelims)
static char *Token[MAXSYMBOLS];
return Token

I've got these declarations in the calling program

char g_symbols[MAXSYMBOLS];
char **g_symbol;

and this call:

g_symbol = foo("xxxxx,yyyyy", ",")

Now what do I do to place the return result into g_symbols ?
TIA.

[Elysia]

If I get this right, you want to return an array of pointers to a function, and further, you want this function which takes the return to be able to modify the array (which is static)?
This sounds awfully complicated and some work-around issue.
Why not explain what you're trying to do?

[tabstop]

If the function returns char **bob, then *bob is a pointer to char. (If you want to/are supposed to interpret this as an array of char *, you can write "bob[0]" for *bob.) You can then strcpy that from bob[0] to g_symbols[0]. Increment index, lather, and repeat.

[Benzakhar]

One thing that doesn't seem to make sense is the following 2 declarations:

static char *Token[MAXSYMBOLS]; 
...
char g_symbols[MAXSYMBOLS];

As it appears to me you are using MAXSYMBOLS size for both (Amount of Tokens & Token size). Token is an array of pointers, and g_symbols is an array of char's which is likely to be a string. You might want a new size saying the maximum size of a token.

For example: you can have a maximum symbols of say 5 (maybe parsing a string 5 bits at a time). But a token could be a length of 6 which is more than 5. Now you will have a buffer overflow.

Similarly for large numbers: if you have MAXSYMBOLS as 200, memory will probably be wasted as token sizes would be ~20chars.

[xuftugulus]

static char *Token[MAXSYMBOLS]; 
...
char g_symbols[MAXSYMBOLS];

It looks like the function is returning a set of string starts that should be assigned differently to the g_symbols variable. In C a string, a true string is character array allocated either statically or dynamically to which we know the start and that at some point has a special character '\0' to mark it's end. When a function returns an array of string starts, based on a given true string, like in this example, it returns merely something equivalent to page-markers in a book. But someone who needs to study the things the page-markers show would go to get a printed copy of all the "marked" pages. Every Token[i] is the same as a page-marker.
g_symbol, is just a set of page-markers.
g_symbols, is an array of characters, or in other words a fixed width page.
To store the return value of foo() it would be necessary to get some blank pages and get a copy of the contents that the page-markers foo() returns indicate.
char g_symbols[MAXSYMBOLS], is not a good type to do that.
The best would be either:

char g_symbols[MAXSYMBOLS][MAXSYMBOLSIZE];
//or
char *g_symbols[MAX_SYMBOLS];

On the first one could get hard copies by saying using strcpy() with target every g_symbols[i] and source every g_symbol[i]. The problem is that if a g_symbol[i] has more length than our MAXSYMBOLSIZE constant, we would get overflow and corrupted data.
On the second, one could either malloc() every g_symbols[i] to the appropriate string length()+1 for the ending '\0'. or use a more elegant in my opinion call to strdup(), like:

// Case 1
...
strcpy(g_symbols[i], g_symbol[i]);   /* Buffer overflow danger */
...
// Case 2 solution 1
g_symbols[i] = malloc(strlen(g_symbol[i]) + 1);
strcpy(g_symbols[i], g_symbol[i]);    /* Ok, memory is enough and never fails */
...
// Case 2 solution 2, notice how much it looks like case 1.
g_symbols[i] = strdup(g_symbol[i]);   /* Guaranteed to work if we have memory */

So, it comes down that duplicating an array of string is as simple as to repeat a simple operation. The only things that needs to be correct to use this elegant and safe 99.99% of the time solution, is the type of an array of string starts, which is: char *str_array[N].
The memory allocation management is "handled" by strdup, and the programmer need release the pointers himself afterwards. That simple.

[syswizard]

wow, this group is sharp.
I want to especially thank xuftugulus as he really hit it "on the mark" and his explanation of "string starts" was just what I was looking for.

I've got a programming background, but it's always been "high-level" with either scripting languages, VB, or VBA. "C" has always mystified me, but I've got a current project that requires me to build a DLL "wrapper" from a bunch of C functions and libraries to be accessed from Excel.

[syswizard]

Unfortunately, nothing worked here.
The closest I came was getting the first string starter back.
I want a static approach as none of the strings will ever exceed 4 characters.

char **g_symbols[MAXSYMBOLS][5] // note: strings will be a max of 4 characters wide

**g_symbols = foo("xxxxx,yyyyy", ",") // only returned xxxxxx

returned my first token, but that was it.
Somehow, the declaration in the calling program is wrong.

I was reading about multidimensional arrays and wondering
if I need to use a pointer like this:
char (*ptr)[MAXSYMBOLS]

Under no circumstances show I need to use strcpy or strdup...
as the data is already there in the return value.
I just can't access it properly in the calling program.

Comment: when it comes to string handling, C's pretty weak.

[Elysia]

Comment: when it comes to string handling, C's pretty weak.

No, not really. It can be tricky, yes, but it isn't weak.

[tabstop]

Unfortunately, nothing worked here.
The closest I came was getting the first string starter back.
I want a static approach as none of the strings will ever exceed 4 characters.

char **g_symbols[MAXSYMBOLS][5] // note: strings will be a max of 4 characters wide

You've got to pick one: you can do either char **g_symbols or char g_symbols[MAXSYMBOLS][5]. You can't do both. (Well, you can, but it's not clear why or how.) It would appear you would want the latter.

What you had was a two-dimensional array of pointers to pointers to a character.

[syswizard]

Well guys, after more searching in this forum, I found the answer....
and it was so, SO simple:
// placed into the calling program:
char **g_symbols;
int i;
int g_SymbolCnt = 0;
g_symbols = foo("1234567,1234566", ",", &g_SymbolCnt);
for (i=0; i<g_SymbolCnt; i++)
printf("&#37;s", g_symbols[i]);

1) I modified "foo" to add the count of symbols returned.
2) no fancy malloc or crazy strdup or strcpy function calls needed
3) no exotic declarations of array or array of pointers needed

All of the "work" was done by "foo".
I tried to thank the author of "foo", but I am unable to "PM" anyone on this forum...
what's up with that ?
(Can anyone guess what "foo" really is ?)

[Elysia]

I suggest you use code tags, even for short code. It makes it easier to read.
PM is a privilege to those with a certain amount of posts, if I'm not mistaken. That's the way it is.
And you know, you could just pass a pointer to the function that acts as a buffer. The caller (main?) could call the function, passing in a char buffer, a local variable, to fill in the function. No malloc or exotic pointer syntax, and best of all, it's pretty standard to do that way.

[syswizard]

Thanks Elysia...what I discovered from this is that for C language help, all of the code is usually required before the best solution can be provided. Learned my lesson. This would not have taken nearly as long if I had shown more than the stubs and the prototypes, etc.
For the most part, Indirection and L-values are really driving me crazy.
I also learned that if the Compiler complains and even warns, I'll got something wrong.
I've got much more to go on this project.

[Elysia]

I also learned that if the Compiler complains and even warns, I'll got something wrong.

Now that's something I like to hear
You are absolutely right. You should never ignore warnings.