StringValueList* groupSymbols(char * input, char *alphabet)
{
if(input == NULL || alphabet == NULL){
return NULL;
}
char *inputCopy = NULL;
StringValueList* auxExpandPrefix = NULL;
StringValueList* symbolsGrouped = malloc(sizeof(StringValueList));
initStringValueList(symbolsGrouped);
int* symbolCount = NULL;
char *bestCombination = NULL;
double bestEvaluation = 0.0;
double evaluation = 0.0;
int inputLength = 0;
inputLength = strlen(input);
inputCopy = malloc((inputLength + 1) * sizeof(char));
inputCopy = strncpy(inputCopy, input, inputLength);
inputCopy[inputLength] = '\0';
do{
/* Contamos cada simbolo del alfabeto en input. */
symbolCount = charCount(inputCopy, alphabet);
bestEvaluation = 0;
/* Buscamos el simbolo que tiene una evaluacion mayor para seguir buscando un patron a partir de el. */
for(int i = 0; i < strlen(alphabet); i++){
evaluation = evaluate(symbolCount[i], strlen(input), 1);
if (evaluation > bestEvaluation){
free(bestCombination);
bestCombination = createString(alphabet[i]);
bestEvaluation = evaluation;
}
}
free(symbolCount);
/* A partir del simbolo mas puntos, se empiezan a buscar subcadenas a partir de el en input */
//printf("Mejor simbolo encontrado: %s -> %.3f\n", bestCombination, bestEvaluation);
auxExpandPrefix = malloc(sizeof(StringValueList));
initStringValueList(auxExpandPrefix);
expandBestCombination(inputCopy, alphabet, bestCombination, bestEvaluation, auxExpandPrefix);
/* Insertamos el elemento de mas valor en la lista de simbolos agrupados. */
int posMaxValue = getPosMaxStringValue(auxExpandPrefix);
addStringValue(symbolsGrouped, strdup(auxExpandPrefix->string[posMaxValue]), auxExpandPrefix->value[posMaxValue]);
freeStringValueList(auxExpandPrefix);
/* Eliminamos de la copia de input las repeticiones de la agrupacion encontrada, sustituyendola por BLANK_CHAR */
//printf("%s\n", inputCopy);
deleteSubstring(inputCopy, symbolsGrouped->string[symbolsGrouped->length - 1]);
inputLength = countValidCharacters(inputCopy);
//printf("%s\n", inputCopy);
/* Repetimos todo el proceso hasta que se haya agrupado todo el input */
} while(inputLength != 0);
free(inputCopy);
free(bestCombination);
return symbolsGrouped;
}
void expandBestCombination(char * input, char *alphabet, char *prefix, double prefixValue, StringValueList* expansionList)
{
int nPositions1 = 0;
int nPositions2 = 0;
int nSymbols = strlen(alphabet);
char * newPrefix1 = NULL;
char * newPrefix2 = NULL;
int * positions1 = NULL;
int * positions2 = NULL;
double newPrefixValue1 = 0.0;
double newPrefixValue2 = 0.0;
int newPrefixLenght = strlen(prefix) + 1;
addStringValue(expansionList, strdup(prefix), prefixValue);
for(int i = 0; i < nSymbols; i++){
newPrefix1 = malloc((newPrefixLenght + 1) * sizeof(char));
newPrefix1 = strncpy(newPrefix1, prefix, strlen(prefix));
newPrefix1[newPrefixLenght - 1] = alphabet[i];
newPrefix1[newPrefixLenght] = '\0';
newPrefix2 = malloc((newPrefixLenght + 1) * sizeof(char));
strncpy(newPrefix2 + 1, prefix, strlen(prefix));
newPrefix2[0] = alphabet[i];
newPrefix2[newPrefixLenght] = '\0';
positions1 = searchSubstring(input, newPrefix1, &nPositions1, !OVERLAPPED_SEARCH);
positions2 = searchSubstring(input, newPrefix2, &nPositions2, !OVERLAPPED_SEARCH);
free(positions1);
free(positions2);
newPrefixValue1 = evaluate(nPositions1, strlen(input), newPrefixLenght);
newPrefixValue2 = evaluate(nPositions2, strlen(input), newPrefixLenght);
//printf("\t%s -> %.3f\n", newPrefix1, newPrefixValue1);
//printf("\t%s -> %.3f\n", newPrefix2, newPrefixValue2);
if(newPrefixValue1 >= newPrefixValue2 && newPrefixValue1 >= prefixValue * 0.7){
//printf("Expandiendo: %s con valor: %.3f\n", newPrefix1, newPrefixValue1);
expandBestCombination(input, alphabet, newPrefix1, newPrefixValue1, expansionList);
}
if(newPrefixValue2 >= newPrefixValue1 && newPrefixValue2 >= prefixValue * 0.7){
//printf("Expandiendo: %s con valor: %.3f\n", newPrefix2, newPrefixValue2);
expandBestCombination(input, alphabet, newPrefix2, newPrefixValue2, expansionList);
}
free(newPrefix1);
free(newPrefix2);
}
}
/* scanXmlEntry
*
* We've found a '<' character. We ignore this if it is a comment or a
* directive. If it is something else, then whatever it is we are looking
* at is bogus. Returning NULL stops processing.
*/
static char const*
scanXmlEntry( char const* pzName, tOptionValue* pRes )
{
size_t nameLen = 1, valLen = 0;
char const* pzScan = ++pzName;
char const* pzVal;
tOptionValue valu;
tOptionValue* pNewVal;
tOptionLoadMode save_mode = option_load_mode;
if (! IS_VAR_FIRST_CHAR(*pzName)) {
switch (*pzName) {
default:
pzName = NULL;
break;
case '!':
pzName = strstr( pzName, "-->" );
if (pzName != NULL)
pzName += 3;
break;
case '?':
pzName = strchr( pzName, '>' );
if (pzName != NULL)
pzName++;
break;
}
return pzName;
}
pzScan++;
while (IS_VALUE_NAME_CHAR( (int)*pzScan )) { pzScan++; nameLen++; }
if (nameLen > 64)
return NULL;
valu.valType = OPARG_TYPE_STRING;
switch (*pzScan) {
case ' ':
case '\t':
pzScan = parseAttributes(NULL, (char *)(intptr_t)pzScan,
&option_load_mode, &valu );
if (*pzScan == '>') {
pzScan++;
break;
}
if (*pzScan != '/') {
option_load_mode = save_mode;
return NULL;
}
/* FALLTHROUGH */
case '/':
if (*++pzScan != '>') {
option_load_mode = save_mode;
return NULL;
}
addStringValue(&(pRes->v.nestVal), pzName, nameLen, NULL, (size_t)0);
option_load_mode = save_mode;
return pzScan+1;
default:
option_load_mode = save_mode;
return NULL;
case '>':
pzScan++;
break;
}
pzVal = pzScan;
{
char z[68];
char* pzD = z;
int ct = nameLen;
char const* pzS = pzName;
*(pzD++) = '<';
*(pzD++) = '/';
do {
*(pzD++) = *(pzS++);
} while (--ct > 0);
*(pzD++) = '>';
*pzD = NUL;
pzScan = strstr( pzScan, z );
if (pzScan == NULL) {
option_load_mode = save_mode;
return NULL;
}
valLen = (pzScan - pzVal);
pzScan += nameLen + 3;
while (IS_WHITESPACE_CHAR(*pzScan)) pzScan++;
}
switch (valu.valType) {
case OPARG_TYPE_NONE:
addStringValue( &(pRes->v.nestVal), pzName, nameLen, NULL, (size_t)0);
break;
case OPARG_TYPE_STRING:
pNewVal = addStringValue(
&(pRes->v.nestVal), pzName, nameLen, pzVal, valLen);
if (option_load_mode == OPTION_LOAD_KEEP)
break;
mungeString( pNewVal->v.strVal, option_load_mode );
break;
case OPARG_TYPE_BOOLEAN:
addBoolValue( &(pRes->v.nestVal), pzName, nameLen, pzVal, valLen );
break;
case OPARG_TYPE_NUMERIC:
addNumberValue( &(pRes->v.nestVal), pzName, nameLen, pzVal, valLen );
break;
case OPARG_TYPE_HIERARCHY:
{
char* pz = AGALOC( valLen+1, "hierarchical scan" );
if (pz == NULL)
break;
memcpy( pz, pzVal, valLen );
pz[valLen] = NUL;
addNestedValue( &(pRes->v.nestVal), pzName, nameLen, pz, valLen );
AGFREE(pz);
break;
}
case OPARG_TYPE_ENUMERATION:
case OPARG_TYPE_MEMBERSHIP:
default:
break;
}
option_load_mode = save_mode;
return pzScan;
}
void ScanParseSkel::addBufferAsStringValue(void)
{
addStringValue(_pLexer->YYText());
}
/* scanNameEntry
*
* We have an entry that starts with a name. Find the end of it, cook it
* (if called for) and create the name/value association.
*/
static char const*
scanNameEntry(char const* pzName, tOptionValue* pRes)
{
tOptionValue* pNV;
char const * pzScan = pzName+1; /* we know first char is a name char */
char const * pzVal;
size_t nameLen = 1;
size_t dataLen = 0;
/*
* Scan over characters that name a value. These names may not end
* with a colon, but they may contain colons.
*/
while (IS_VALUE_NAME_CHAR(*pzScan)) { pzScan++; nameLen++; }
if (pzScan[-1] == ':') { pzScan--; nameLen--; }
while (IS_HORIZ_WHITE_CHAR(*pzScan)) pzScan++;
re_switch:
switch (*pzScan) {
case '=':
case ':':
while (IS_HORIZ_WHITE_CHAR( (int)*++pzScan )) ;
if ((*pzScan == '=') || (*pzScan == ':'))
goto default_char;
goto re_switch;
case '\n':
case ',':
pzScan++;
/* FALLTHROUGH */
case NUL:
addStringValue(&(pRes->v.nestVal), pzName, nameLen, NULL, (size_t)0);
break;
case '"':
case '\'':
pzVal = pzScan;
pzScan = scanQuotedString( pzScan );
dataLen = pzScan - pzVal;
pNV = addStringValue( &(pRes->v.nestVal), pzName, nameLen, pzVal,
dataLen );
if ((pNV != NULL) && (option_load_mode == OPTION_LOAD_COOKED))
ao_string_cook( pNV->v.strVal, NULL );
break;
default:
default_char:
/*
* We have found some strange text value. It ends with a newline
* or a comma.
*/
pzVal = pzScan;
for (;;) {
char ch = *(pzScan++);
switch (ch) {
case NUL:
pzScan--;
dataLen = pzScan - pzVal;
goto string_done;
/* FALLTHROUGH */
case '\n':
if ( (pzScan > pzVal + 2)
&& (pzScan[-2] == '\\')
&& (pzScan[ 0] != NUL))
continue;
/* FALLTHROUGH */
case ',':
dataLen = (pzScan - pzVal) - 1;
string_done:
pNV = addStringValue( &(pRes->v.nestVal), pzName, nameLen,
pzVal, dataLen );
if (pNV != NULL)
removeLineContinue( pNV->v.strVal );
goto leave_scan_name;
}
}
break;
} leave_scan_name:;
return pzScan;
}
