Formatting a string based on Input and predefined values - c

Question

I have 26 values's that i am considering as Special Symbol and are as with special delimeter "$" the value's can be from $A to $Z.
Same time i have a predefined template as:
I have $A,$B,$C.....
Now i am allowing user to input a string that can contain a special symbol and the values of those example:
Input - $ACar $BBike $CTruck.
Then my output should be : *I have Car,Bike,Truck... *
As now all special symbol has been replaced by its values.
Note 1.if $A Car $A Bike is the input value then it should take $A as Car rest should be discarted.
If input string doesn't contain any special symbol the there should be no change in output and output will be
I have $A,$B,$C.....
3.if input start as i am a men $A glass then till $A all values should be discarted.
Which approach should i follow to make this possible?
I am thinking to do strstr on the input string and compare those with my special symbol and store the position of Special Symbol in a list and then as per the position i am thinking to take the values but i don't think it will work for me.

Answer 1

Processing is simplified by using a dynamic string.
like this
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
typedef struct dstr {
size_t size;
size_t capacity;
char *str;
} Dstr;//dynamic string
Dstr *dstr_make(void){
Dstr *s;
s = (Dstr*)malloc(sizeof(Dstr));
s->size = 0;
s->capacity=16;
s->str=(char*)realloc(NULL, sizeof(char)*(s->capacity += 16));
return s;
}
void dstr_addchar(Dstr *ds, const char ch){
ds->str[ds->size] = ch;
if(++ds->size == ds->capacity)
ds->str=(char*)realloc(ds->str, sizeof(char)*(ds->capacity += 16));
}
void dstr_addstr(Dstr *ds, const char *s){
while(*s) dstr_addchar(ds, *s++);
//dstr_addchar(ds, '\0');
}
void dstr_free(Dstr *ds){
free(ds->str);
free(ds);
}
void dic_entry(char *dic[26], const char *source){
char *p, *backup, ch;
p = backup = strdup(source);
for(;NULL!=(p=strtok(p, " \t\n"));p=NULL){
if(*p == '$' && isupper(ch=*(p+1))){
if(dic[ch -'A'] == NULL)
dic[ch -'A'] = strdup(p+2);
}
}
free(backup);
}
void dic_clear(char *dic[26]){
int i;
for(i=0;i<26;++i){
if(dic[i]){
free(dic[i]);
dic[i] = NULL;
}
}
}
int main(void){
const char *template = "I have $A,$B,$C.";
char *dic[26] = { 0 };
char buff[1024];
const char *cp;
Dstr *ds = dstr_make();
printf("input special value setting: ");
fgets(buff, sizeof(buff), stdin);
dic_entry(dic, buff);
for(cp=template;*cp;++cp){
if(*cp == '$'){
char ch;
if(isupper(ch=*(cp+1)) && dic[ch - 'A']!=NULL){
dstr_addstr(ds, dic[ch - 'A']);
++cp;
} else {
dstr_addchar(ds, *cp);
}
} else {
dstr_addchar(ds, *cp);
}
}
dstr_addchar(ds, '\0');
printf("result:%s\n", ds->str);
dic_clear(dic);
dstr_free(ds);
return 0;
}
/* DEMO
>a
input special value setting: $ACar $BBike $CTruck
result:I have Car,Bike,Truck.
>a
input special value setting: $BBike
result:I have $A,Bike,$C.
*/

Answer 2

What you're describing is called a Macro Processor or Macro Expander.
You can store your symbol table in an array indexed by the input char.
char *symtab[256] = {0};
Since the symbol names are single-letters, you can use strchr to find the first '$' and check if the next char is a letter (isupper()).
For the actual replacement, it will require some delicate memory management unless you just use really big buffers and make sure to only feed it small data.
If symtab['A'] == "Car" then you can loc = strstr(line, "$A"). Then loc-line is the length of the prefix part, 2 is the length of the symbol name being deleted, strlen("Car") is the length of the replacement, and strlen(loc+2) is the length of the suffix part. So the new string size should be
char *result = malloc( (loc-line) - 2 + strlen(symtab['A']) + strlen(loc+2) + 1);
Then patching up the new string is
strcpy(result,line);
strcpy(result + (loc-line), symtab['A']);
strcpy(result + (loc-line) + strlen(symtab['A']), loc+2);
Notice these are strcpy not strcat which appends strings together. The second and third strcpy calls overwrite the tail of the string just copied.