#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define PARSETHIS "[$2] [$2] [$3] [$4] [$300] [$030]"
 
typedef struct acumstrings
{
    char **ptr;
    size_t count;
} acumstrings;
 
acumstrings acum;
 
inline const char* getTokenIndex(const char *str, long *Index)
{
    if (!str) return NULL;
    char *ptr = strstr(str, "[$");
    char *end = NULL;
 
    if (ptr) {
        ptr += strlen("[$");
        (*Index) = strtol(ptr, &end, 10);
    }
 
    return ptr;
}
 
inline char* replace(const char *str, const char *find, const char *rep)
{
    char *ret = NULL;
    size_t strOln;
    size_t strFln;
    size_t strRln;
    const char *end[2];
    size_t sizeL;
    size_t sizeR;
 
 
    if (!str) return NULL;
 
    strOln = strlen(str);
 
    if (!find || (end[0] = strstr(str, find)) == NULL) {
        ret = (char*)malloc(strOln + 1);
        memcpy(ret, str, strOln + 1);
        return ret;
    }
 
    strRln = strlen(rep);
    strFln = strlen(find);
 
    end[1] = (char*)((size_t)end[0] + strFln);
 
    sizeL = (size_t)end[0] - (size_t)str;
    sizeR = ((size_t)str + strOln) - (size_t)end[1];
 
    ret = (char*)malloc(sizeL + strRln + sizeR + 1);
 
    memcpy(ret, str, sizeL);
    memcpy((void*)((int)ret + sizeL), rep, strRln);
    memcpy((void*)((int)ret + sizeL + strRln), end[1], sizeR);
 
    ret[sizeL + strRln + sizeR] = '\0';
 
    return ret;
}
 
int main ()
{
    FILE* file;
    size_t ret;
    char* strLast = NULL;
    char* strNew = NULL;
    char* strNewFind = NULL;
    char strToken[20];
    long index;
 
    file = fopen("C:\\a.txt", "rb+");
 
    //  Obtenemos cada palabra.
    while (!feof(file))
    {
        acum.ptr = (char**)realloc(acum.ptr, (acum.count + 1) * sizeof(char**));
        acum.ptr[acum.count] = (char*)calloc(256, 1);
        ret = fscanf(file, "%s", acum.ptr[acum.count]);
        puts(acum.ptr[acum.count]);
        ++acum.count;
    }
 
    fclose(file);
 
    strNew = (char*)malloc(strlen(PARSETHIS) + 1);
    strcpy(strNew, PARSETHIS);
    strNewFind = strNew;
 
    //  reemplazamos cada token por cada una de las palabras respectivas.
    while(strNewFind = getTokenIndex(strNewFind, &index))
    {
        sprintf(strToken, "[%$%d]\0", index);
        if (acum.count > index) {
            strLast = strNew;
            strNew = replace(strLast, strToken, acum.ptr[index - 1]);
            free(strLast);
            strNewFind = strNew;
        } else {
            ++strNewFind;
        }
    }
 
    while(acum.count--)
        free(acum.ptr[acum.count]);
    free(acum.ptr);
 
    puts(strNew);
 
    free(strNew);
 
    getchar();
 
    return 0;
}
 
 

#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
 
int main()
{
	char * tokens[] = {"cosas","hacerlas"};
    char s1[] = "Las [$0] hay que [$1] en el momento que hay que [$1].\n";
    char s2[] = "[$";
    char *ptr;
    ptr = strtok( s1, s2 );    // Primera llamada => Primer token
    if ( (isdigit(ptr[0])) && (ptr[1] == ']') ) {
		//Es un token
		printf("%s%s", tokens[atoi(ptr)], ptr+2);
	} else {
		printf("%s",ptr);
    }
    while( (ptr = strtok( NULL, s2 )) != NULL )    // Posteriores llamadas
		if ( (isdigit(ptr[0])) && (ptr[1] == ']') ) {
			//Es un token
			printf("%s%s", tokens[atoi(ptr)], ptr+2);
		} else {
			printf("%s",ptr);
		}
    return 0;
}