Quebra de texto em índices de códigos de palavras, em C

#include <cstdlib>
#include <iostream>

/*
 Demonstração, em C, de estruturas de dados simples para referência a strings
 por palavras, gerando resultados para pós-processamento mais rápido


 2012 - CEAC
*/


using namespace std;

// preenche o buffer "destino" com a proxima palavra em uma frase (origem)

int proximaPalavra(int indiceInicial,
                   char * origem, int tamOrigem, char * destino,
                   int tamMaxDestino,
                   bool * fimFrase) {

    // checa condições e retorna erro se :
    if ((destino == NULL)  // destino for nulo
    || (origem == NULL)    // origem for nula
    || (indiceInicial < 0) // indiceInicial for menor que zero
    || (indiceInicial >= tamOrigem))

    return -1;

    int indice = indiceInicial;
    int contador = 0;
    int caractere = 0;
    int charEspaco = ' ';
    int charPonto = '.';

    bool fimDeFrase = false;

    // repete até o fim da frase ou da palavra (espaço)
    do {

        caractere = origem[indice]; // o contador/indice é usado aqui

        fimDeFrase = caractere == charPonto;

        destino[contador] = caractere; // copia

        indice++; // incrementa o índice
        contador++; // incremanta o contador (esse contador registra as cópias)

    }while ((caractere!= 0)
              && (caractere!= charEspaco)
              && (!fimDeFrase)
              && (contador < tamMaxDestino));


    // define o fim da palavra como sendo o fim da string
    // assim, strlen vai retornar o tamanho correto da palavra e não da
    // quantidade de memória alocada no array para onde essa string aponta
    // (corta o indicador de fim para o fim da palavra copiada)
    // a próxima condição também modifica esse índice
    destino[contador] = 0;

    // define o ponteiro para onde há uma variável booleana
    // (se existir) como a mesma condição que a variável local
    // fimDeFrase (o fim da palavra foi com um ponto)
    if (fimFrase!=NULL) {
       * fimFrase = fimDeFrase;
       // se termina com um ponto, a palavra não deverá conter esse ponto:
       // a próxima linha exclui o último caractere (o ponto) do string
       if (contador > 0)
       destino[contador-1] = 0;
    }

    // retorna o índice que corresponde ao final da palavra na frase
    // (o fim de "destino" - cópia -  na origem)

    return indice;
}


// retorna um código único para cada palavra e também pode tornar a palavra
// maiúscula ou minúscula enquanto faz o cálculo
// o código usado é resultado = resultado + (caractere * indiceCaractere);

int codigoPalavra (char * palavra, bool caixaAlta,
    bool caixaBaixa, bool semConversao) {

    if (palavra) { // comparar com NULL é o mesmo que checar se o ponteiro é zero

        int tamPalavra = strlen(palavra);

        int resultado = 0;

        for (int i = 0; i < tamPalavra; i++) {

            char caractere = palavra[i];

            // deixando a primeira checagem como sendo semConversão
            // evita que as outras condições sejam sempre verificadas
            // maiusculas/minusculas

            if (semConversao) {

            }
            else
            if (caixaAlta) { // maiúsculas
               if (caractere > 'A')

               // o compilador vai transformar 'a' e 'A' em números constantes
               // (97 e 65) e essa expressão irá se transformar em:
               // caractere = caractere +/- 32;
               // no código compilado

               caractere = caractere - ('a' - 'A');
            }
            else
            if (caixaBaixa) {
               if (caractere < 'a')
               caractere = caractere + ('a' - 'A');
            }

            // aqui o caractere já está convertido
            // e o próximo código é o cálculo que define o resultado
            resultado = resultado + (caractere * i);
        }

        return resultado;
    }

    return 0; // retorna zero se palavra == null
}

int main(int argc, char *argv[])
{
    // * argv[] é alocado/desalocado pelo sistema operacional

    if (argc < 2)
    return -1;

    // obtém os ponteiros para os dois parâmetros
    // o parametro argv[0] é a linha de comando (ex.: c:/pasta/programa.exe)
    // o parametro argv[1] pode ter várias palavras desde que seja separado por
    // aspas duplas "p1 p2 p3"
    // argv[1] = texto
    // argv[2] = palavra

    char * texto = argv[1];
    char * palavra = argv[2];

    // usa a função strlen para contar os caracteres de cada
    // string (essa função faz um "for" e pára quando encontra um zero/null,
    // retornando o contador como sendo a quantidade de caracteres, já que
    // as strings no C são um array de caracteres que terminam com zero
    int tf = strlen(texto);
    int tp = strlen(palavra);

    int maximoPalavras = 100;
    int codigosPalavrasEncontradas[100];

    int quantidadePalavrasEncontradas = 0;

    char palavraTemporaria[256];
    int indiceProximaPalavra = 0;

    char bufferSaida[256];

    int indiceFimUltimaFrase = 0;

    do {
        bool fimFrase = false;

        indiceProximaPalavra = proximaPalavra(indiceProximaPalavra,
        texto,tf,palavraTemporaria,255,&fimFrase);

        int codPalavra = codigoPalavra(palavraTemporaria,false,false,true);

        sprintf(bufferSaida,"novaPalavra(%d):%s\n",
        codPalavra,palavraTemporaria);

        printf(bufferSaida);

        codigosPalavrasEncontradas[quantidadePalavrasEncontradas] = codPalavra;
        quantidadePalavrasEncontradas++;

        if (fimFrase){
           printf("nova frase");
           printf("\n");
           indiceProximaPalavra++;
           indiceFimUltimaFrase = indiceProximaPalavra;
        }
    }
    while ((indiceProximaPalavra > 0)
    && (indiceProximaPalavra < tf)
    && (quantidadePalavrasEncontradas < maximoPalavras));



    // nesse ponto, o texto pode ser analisado de uma maneira mais rápida
    // utilizando só os metadados (as estruturas de dados) que mantém as referências
    // às palavras e talvez com o acréscimo de mais dados que mantenham informações
    // sobre parágrafos em vez de somente sobre palavras, aprimorando os dados gereados
    // e facilitando as análises seguintes
    // no estado em que está, esses metadados já permitem que seja feita uma
    // análise mais rápida da recorrência de uma palavra
    // sem que seja necessário reprocessar os dados

    system("PAUSE");
    return EXIT_SUCCESS;
}
/**/