/*****************************************************************************
* NAME
* do_clear
* ARGUMENTS
* none
* DESCRIPTION
* Execute a CLEAR command.
* RETURN VALUE
* none
*/
void do_clear()
{
/*
* handle any embedded PC-Kimmo stuff
*/
freeKimmoRules(&sPCPATRKimmoData_g); /* remove existing rules */
freeKimmoLexicon(&sPCPATRKimmoData_g); /* remove existing lexicon */
freePATRGrammar(&sPCPATRKimmoData_g.sPATR); /* remove existing grammar */
/*
* handle any embedded AMPLE stuff
*/
resetAmpleData( &sPCPATRAmpleData_g );
/*
* handle the PC-PATR specific stuff
*/
freePATRGrammar(&sPCPATRData_g); /* remove existing grammar */
freePATRLexicon(&sPCPATRData_g); /* remove existing lexicon */
if (pszPCPATRGrammarFile_g != (char *)NULL)
{
freeMemory(pszPCPATRGrammarFile_g);
pszPCPATRGrammarFile_g = (char *)NULL;
}
if (pPCPATRLexiconFiles_g != (StringList *)NULL)
{
freeStringList(pPCPATRLexiconFiles_g);
pPCPATRLexiconFiles_g = (StringList *)NULL;
}
if (pPCPATRAmpleFiles_g != (StringList *)NULL)
{
freeStringList(pPCPATRAmpleFiles_g);
pPCPATRAmpleFiles_g = (StringList *)NULL;
}
freePATRInternalMemory(&sPCPATRData_g);
}
void freeOptions()
{
freeStringList(OPT_INCL_DIRS);
freeStringList(OPT_INCL_DIRS_REC);
freeStringList(OPT_EXCL_DIRS);
freeStringList(OPT_EXCL_DIRS_REC);
freeStringList(OPT_IGNORE_PREFIXES_LIST);
}
/*
* Return a linked list that contains elements according to specified set
* operation (setop). If there aren't options, return NULL.
*/
stringList *
setOperationOptions(char *a, char *b, int setop, bool withvalue, bool changed)
{
stringList *first, *second;
stringList *ret = NULL;
stringListCell *headitem = NULL;
logNoise("options: set operation %d", setop);
/* if a is NULL, there is neither intersection nor complement (except) */
if (a == NULL)
return NULL;
/* if b is NULL, there isn't intersection */
if (setop == PGQ_INTERSECT && b == NULL)
return NULL;
first = buildStringList(a);
second = buildStringList(b);
if (setop == PGQ_INTERSECT)
headitem = intersectWithSortedLists(first->head, second->head, withvalue, changed);
else if (setop == PGQ_SETDIFFERENCE)
headitem = setDifferenceWithSortedLists(first->head, second->head, withvalue);
else
logError("set operation not supported");
/* build a linked list */
if (headitem)
{
stringListCell *p;
ret = (stringList *) malloc(sizeof(stringList));
/* linked list head */
ret->head = headitem;
/* find linked list tail */
p = headitem;
while (p->next)
p = p->next;
ret->tail = p;
}
/* free temporary lists */
if (first)
freeStringList(first);
if (second)
freeStringList(second);
return ret;
}
/*
* buildDriveList - get a list of all drives
*/
static bool buildDriveList( void )
{
char drv;
int cnt;
char str[_MAX_PATH];
const char **list;
cnt = 0;
list = NULL;
for( drv = 'A'; drv <= 'Z'; drv++ ) {
if( getDriveType( drv ) != DRIVE_NONE ) {
str[0] = drv;
str[1] = ':';
str[2] = '\0';
if( !addToList( &list, cnt, str, 2 ) ) {
freeStringList( &list );
break;
}
cnt++;
}
}
SetDriveTextList( list );
return( list != NULL );
} /* buildDriveList */
static void readwordsfile(WORD_HASH_TABLE *table_ptr, char *stopw_file)
{
char line[MAXSTRLEN];
FILE *fp;
StringList *sl;
int i;
/* Not this reports "Sucess" on trying to open a directory. to lazy to fix now */
if ((fp = fopen(stopw_file, F_READ_TEXT)) == NULL || !isfile(stopw_file))
progerrno("Couldn't open the word file '%s': ", stopw_file);
/* read all lines and store each word as stopword */
while (fgets(line, MAXSTRLEN, fp) != NULL)
{
if (line[0] == '#' || line[0] == '\n')
continue;
sl = parse_line(line);
if (sl && sl->n)
{
for (i = 0; i < sl->n; i++)
add_word_to_hash_table( table_ptr, strtolower(sl->word[i]), HASHSIZE);
freeStringList(sl);
}
}
fclose(fp);
return;
}
void ParseComment (FILE* file,char type,Comment* doc){
char* line=NULL;
StringList bloc=NULL;
int end=0;
if(doc==NULL)doc=newComment();
if(doc==NULL)exit(EXIT_FAILURE);
switch(type){
case '/':
line=GetLine(file);
ParseLine(file,doc);
free(line);
break;
case '*':
bloc=newStringList();
while(end==0){
char* tmp=GetLine(file);
int length=strlen(tmp);
if(strstr(tmp,"*/")!=NULL)end=1;
addtoStringList(bloc,tmp);
}
StringCell* tmp;
int i;
for(tmp=bloc.first, i=1;i<=bloc.size;i++, tmp=tmp->suivant){
ParseLine(tmp->string,doc);
}
freeStringList(bloc);
break;
default:
break;
}
}
/*
* GUIGetFileName - get a file name from the user
*/
int GUIGetFileName( gui_window *gui, open_file_name *ofn )
{
char olddir[_MAX_PATH];
dlg_info dlg;
if( !ControlsInitialized ) {
InitDlgControls();
ControlsInitialized = true;
}
dlg.currOFN = ofn;
dlg.currExt = NULL;
dlg.currExtIndex = ofn->filter_index;
dlg.dialogRC = OFN_RC_NO_FILE_SELECTED;
#if !defined( __UNIX__ ) && !defined( __NETWARE__ )
dlgControls[DRIVE_LIST_INDEX].text = buildDriveList();
if( dlgControls[DRIVE_LIST_INDEX].text == NULL ) {
return( OFN_RC_FAILED_TO_INITIALIZE );
}
#endif
dlgControls[FILE_TYPES_INDEX].text =
buildFileTypes( &dlg, ofn->filter_list );
if( dlgControls[FILE_TYPES_INDEX].text == NULL || dlg.fileExtensions == NULL ) {
return( OFN_RC_FAILED_TO_INITIALIZE );
}
getcwd( olddir, sizeof( olddir ) );
goToDir( gui, ofn->initial_dir );
GUIModalDlgOpen( gui, ofn->title, DLG_FILE_ROWS, DLG_FILE_COLS,
dlgControls, NUM_CONTROLS, &GetFileNameEvent, &dlg );
if( !(ofn->flags & OFN_CHANGEDIR) ) {
goToDir( gui, olddir );
}
#if !defined( __UNIX__ ) && !defined( __NETWARE__ )
freeStringList( &dlgControls[DRIVE_LIST_INDEX].text );
#endif
freeStringList( &dlgControls[FILE_TYPES_INDEX].text );
freeStringList( &dlg.fileExtensions );
GUIMemFree( dlg.currExt );
return( dlg.dialogRC );
} /* GUIGetFileName */
/**
\fn void freeComment (Comment* comment)
\param the comment structure wich need to be free.
\brief a function in order to free a Comment structure.
*/
void freeComment (Comment* comment){
free(tmp->author);
free(tmp->version);
free(tmp->date);
free(tmp->brief);
free(tmp->details);
free(tmp->fn);
free(tmp->return_value);
free(tmp->bug);
free(tmp->file);
freeStringList(tmp->parameters);
}
/*
* buildFileTypesExts - get a lists of all file types and extensions
*/
static bool buildFileTypesExts( dlg_info *dlg, const char *data )
{
size_t len;
const char **list1;
const char **list2;
int num;
bool ok;
list1 = NULL;
list2 = NULL;
if( data != NULL ) {
num = 0;
ok = true;
while( *data != '\0' ) {
len = strlen( data );
ok = addToList( &list1, num, data, len );
if( !ok ) {
break;
}
data += len + 1;
len = strlen( data );
ok = addToList( &list2, num, data, len );
if( !ok ) {
break;
}
data += len + 1;
num++;
}
if( !ok ) {
freeStringList( &list1 );
freeStringList( &list2 );
}
}
SetFileTypesTextList( list1 );
SetFileExtsTextList( list2 );
return( list1 != NULL && list2 != NULL );
} /* buildFileTypesExts */
/*
* buildFileTypes - get a list of all file types
*/
static void *buildFileTypes( dlg_info *dlg, char *data )
{
size_t len;
char **list1;
int num;
char *ptr;
list1 = NULL;
dlg->fileExtensions = NULL;
num = 0;
if( data == NULL ) {
return( NULL );
}
for( ;; ) {
len = strlen( data );
if( len == 0 ) {
break;
}
ptr = data;
data += len+1;
if( !addToList( &list1, num, ptr, len ) ) {
freeStringList( &list1 );
freeStringList( &dlg->fileExtensions );
return( NULL );
}
len = strlen( data );
if( !addToList( &dlg->fileExtensions, num, data, len ) ) {
freeStringList( &list1 );
freeStringList( &dlg->fileExtensions );
return( NULL );
}
data += len+1;
num++;
}
return( list1 );
} /* buildFileTypes */
SWISH *SwishInit(char *indexfiles)
{
StringList *sl = NULL;
SWISH *sw;
int i;
sw = SwishNew();
if (!indexfiles || !*indexfiles)
{
set_progerr(INDEX_FILE_ERROR, sw, "No index file supplied" );
return sw;
}
/* Parse out index files, and append to indexlist */
sl = parse_line(indexfiles);
if ( 0 == sl->n )
{
set_progerr(INDEX_FILE_ERROR, sw, "No index file supplied" );
return sw;
}
for (i = 0; i < sl->n; i++)
addindexfile(sw, sl->word[i]);
if (sl)
freeStringList(sl);
if ( !sw->lasterror )
SwishAttach(sw);
return sw;
}
/*
* buildDriveList - get a list of all drives
*/
static void *buildDriveList( void )
{
char drv;
int cnt;
char str[_MAX_PATH];
char **dirlist;
cnt = 0;
dirlist = NULL;
for( drv = 'A'; drv <= 'Z'; drv++ ) {
if( getDriveType( drv ) != DRIVE_NONE ) {
str[0] = drv;
str[1] = ':';
str[2] = 0;
if( !addToList( &dirlist, cnt, str, 2 ) ) {
freeStringList( &dirlist );
return( NULL );
}
cnt++;
}
}
return( dirlist );
} /* buildDriveList */
/*
* setDirList - set current directory list
*/
static bool setDirList( gui_window *gui )
{
char path[_MAX_PATH];
char dir[_MAX_DIR];
char drive[_MAX_DRIVE + 3];
DIR *directory;
struct dirent *dent;
char *ptr,*start;
char indent[80];
char tmp[256];
const char **drvlist;
int i;
size_t len;
int curr,cnt;
const char **list;
GUIClearList( gui, CTL_DIR_LIST );
cnt = 0;
list = NULL;
if( getcwd( path, sizeof( path ) ) == NULL ) {
return( true );
}
if( path[strlen( path ) - 1] == FILE_SEP_CHAR ) {
#if !defined( __UNIX__ ) && !defined( __NETWARE__ )
strcat( path, FILES_ALL );
#endif
} else {
#if defined( __UNIX__ ) || defined( __NETWARE__ )
strcat( path, FILE_SEP );
#else
strcat( path, FILE_SEP FILES_ALL );
#endif
}
splitPath( path, drive + 1, dir, NULL, NULL );
directory = opendir( path );
if( directory == NULL ) {
return( false );
}
drive[0] = OPENED_DIR_CHAR;
drvlist = NULL;
#if !defined( __UNIX__ ) && !defined( __NETWARE__ )
drvlist = GetDriveTextList();
#endif
i = 0;
while( drvlist != NULL ) {
if( drvlist[i] == NULL ) {
break;
}
if( drvlist[i][0] == drive[1] ) {
GUISetCurrSelect( gui, CTL_DRIVES, i );
break;
}
i++;
}
#if !defined( __UNIX__ ) && !defined( __NETWARE__ )
drive[3] = '\\';
drive[4] = '\0';
#endif
if( !addToList( &list, cnt, drive, strlen( drive ) ) ) {
freeStringList( &list );
return( false );
}
cnt++;
strcpy( indent, INDENT_STR );
ptr = dir + 1;
start = ptr;
while( *ptr != 0 ) {
if( *ptr == FILE_SEP_CHAR ) {
*ptr = 0;
len = strlen( indent );
memcpy( tmp, indent, len );
tmp[len++] = OPENED_DIR_CHAR;
strcpy( tmp + len, start );
if( !addToList( &list, cnt, tmp, strlen( tmp ) ) ) {
freeStringList( &list );
return( false );
}
cnt++;
start = ptr + 1;
strcat( indent, INDENT_STR );
}
ptr++;
}
curr = cnt;
while( ( dent = readdir( directory ) ) != NULL ) {
if( isdir( dent, path ) ) {
if( (dent->d_name[0] == '.') && ((dent->d_name[1] == 0) ||
(dent->d_name[1] == '.' && dent->d_name[2] == 0)) ) {
continue;
}
len = strlen( indent );
memcpy( tmp, indent, len );
tmp[len++] = UNOPENED_DIR_CHAR;
strcpy( tmp + len, dent->d_name );
if( !addToList( &list, cnt, tmp, strlen( tmp ) ) ) {
freeStringList( &list );
return( false );
}
cnt++;
}
}
closedir( directory );
qsort( list, cnt, sizeof( char * ), Compare );
for( i = 0; i < cnt; i++ ) {
GUIAddText( gui, CTL_DIR_LIST, list[i] );
}
GUISetCurrSelect( gui, CTL_DIR_LIST, curr - 1 );
freeStringList( &list );
return( true );
} /* setDirList */
/*
* setFileList - get list of files in current directory
*/
static bool setFileList( gui_window *gui, const char *ext )
{
char path[_MAX_PATH];
DIR *directory;
struct dirent *dent;
char *ptr;
const char **list;
int cnt;
char ext1[_MAX_PATH];
int i;
dlg_info *dlg = GUIGetExtra( gui );
cnt = 0;
list = NULL;
strcpy( ext1, ext );
ptr = strtok( ext1, ";" );
while( ptr != NULL ) {
if( getcwd( path, sizeof( path ) ) == NULL ) {
break;
}
#if !defined( __UNIX__ ) && !defined( __NETWARE__ )
if( path[strlen(path)-1] != FILE_SEP_CHAR ) {
strcat( path, FILE_SEP );
}
strcat( path, ptr );
#endif
directory = opendir( path );
if( directory != NULL ) {
while( ( dent = readdir( directory ) ) != NULL ) {
if( !isdir( dent, path ) ) {
if( ( dlg->currOFN->flags & OFN_HIDEREADONLY ) && isrdonly( dent, path ) ) {
continue;
}
#if defined( __UNIX__ ) || defined( __NETWARE__ )
if( fnmatch( ptr, dent->d_name, FNM_PATHNAME ) != 0 ) {
continue;
}
#endif
if( !addToList( &list, cnt, dent->d_name, strlen( dent->d_name ) ) ) {
freeStringList( &list );
closedir( directory );
return( false );
}
cnt++;
}
}
closedir( directory );
}
ptr = strtok( NULL, ";" );
}
GUIClearList( gui, CTL_FILE_LIST );
if( cnt > 0 ) {
qsort( list, cnt, sizeof( char * ), Compare );
for( i = 0; i < cnt; i++ ) {
GUIAddText( gui, CTL_FILE_LIST, list[i] );
}
freeStringList( &list );
}
return( true );
} /* setFileList */
void getdefaults(SWISH * sw, char *conffile, int *hasdir, int *hasindex, int hasverbose)
{
int i,
gotdir,
gotindex;
char *line = NULL;
FILE *fp;
int linenumber = 0;
int baddirective = 0;
StringList *sl;
IndexFILE *indexf = NULL;
unsigned char *StringValue = NULL;
struct swline *tmplist;
char *w0;
gotdir = gotindex = 0;
if ((fp = fopen(conffile, F_READ_TEXT)) == NULL || !isfile(conffile))
progerrno("Couldn't open the configuration file '%s': ", conffile);
if ( sw->verbose >= 2 )
printf("Parsing config file '%s'\n", conffile );
/* Init default index file */
addindexfile(sw, INDEXFILE);
indexf = sw->indexlist;
sl = NULL;
while ( !feof( fp ) )
{
/* Free previous line */
if ( line )
efree( line );
/* Read a line */
line = read_line_from_file( &linenumber, fp );
if ( sl )
freeStringList(sl);
/* Parse line */
if (!(sl = parse_line(line)))
continue;
if (!sl->n)
continue;
w0 = sl->word[0]; /* Config Direct. = 1. word */
if (w0[0] == '#')
continue; /* comment */
if (strcasecmp(w0, "IndexDir") == 0)
{
if (sl->n > 1)
{
if (!*hasdir)
{
gotdir = 1;
grabCmdOptions(sl, 1, &sw->dirlist);
}
}
else
progerr("%s: requires at least one value", w0);
continue;
}
if (strcasecmp(w0, "IncludeConfigFile") == 0)
{
if (sl->n == 2)
{
normalize_path( sl->word[1] );
getdefaults(sw, sl->word[1], hasdir, hasindex, hasverbose);
}
else
progerr("%s: requires one value", w0);
continue;
}
if (strcasecmp(w0, "NoContents") == 0)
{
if (sl->n > 1)
{
grabCmdOptions(sl, 1, &sw->nocontentslist);
}
else
progerr("%s: requires at least one value", w0);
continue;
}
if (strcasecmp(w0, "IndexFile") == 0)
{
if (!(*hasindex))
{
if (sl->n == 2)
{
gotindex = 1;
if (indexf->line)
efree(indexf->line);
indexf->line = estrdup(sl->word[1]);
normalize_path( indexf->line );
}
else
progerr("%s: requires one value", w0);
}
continue;
}
if (strcasecmp(w0, "IndexReport") == 0)
{
if (sl->n == 2)
{
if (!hasverbose)
sw->verbose = read_integer( sl->word[1], w0, 0, 4 );
}
else
progerr("%s: requires one value", w0);
continue;
}
if (strcasecmp(w0, "ParserWarnLevel") == 0)
{
if (sl->n == 2)
sw->parser_warn_level = read_integer( sl->word[1], w0, 0, 9 );
else
progerr("%s: requires one value", w0);
continue;
}
if (strcasecmp(w0, "obeyRobotsNoIndex") == 0)
{
sw->obeyRobotsNoIndex = getYesNoOrAbort(sl, 1, 1);
continue;
}
if (strcasecmp(w0, "AbsoluteLinks") == 0)
{
sw->AbsoluteLinks = getYesNoOrAbort(sl, 1, 1);
continue;
}
if (strcasecmp(w0, "MinWordLimit") == 0)
{
if (sl->n == 2)
{
indexf->header.minwordlimit = read_integer( sl->word[1], w0, 0, INT_MAX );
}
else
progerr("%s: requires one value", w0);
continue;
}
if (strcasecmp(w0, "MaxWordLimit") == 0)
{
if (sl->n == 2)
{
indexf->header.maxwordlimit = read_integer( sl->word[1], w0, 0, INT_MAX );
}
else
progerr("%s: requires one value", w0);
continue;
}
if (strcasecmp(w0, "IndexComments") == 0)
{
sw->indexComments = getYesNoOrAbort(sl, 1, 1);
continue;
}
if (strcasecmp(w0, "IgnoreNumberChars") == 0)
{
if (sl->n == 2)
{
indexf->header.numberchars = SafeStrCopy(indexf->header.numberchars, sl->word[1], &indexf->header.lennumberchars);
sortstring(indexf->header.numberchars);
makelookuptable(indexf->header.numberchars, indexf->header.numbercharslookuptable);
indexf->header.numberchars_used_flag = 1; /* Flag that it is used */
}
else
progerr("%s: requires one value (a set of characters)", w0);
continue;
}
if (strcasecmp(w0, "WordCharacters") == 0)
{
if (sl->n == 2)
{
indexf->header.wordchars = SafeStrCopy(indexf->header.wordchars, sl->word[1], &indexf->header.lenwordchars);
sortstring(indexf->header.wordchars);
makelookuptable(indexf->header.wordchars, indexf->header.wordcharslookuptable);
}
else
progerr("%s: requires one value", w0);
continue;
}
if (strcasecmp(w0, "BeginCharacters") == 0)
{
if (sl->n == 2)
{
indexf->header.beginchars = SafeStrCopy(indexf->header.beginchars, sl->word[1], &indexf->header.lenbeginchars);
sortstring(indexf->header.beginchars);
makelookuptable(indexf->header.beginchars, indexf->header.begincharslookuptable);
}
else
progerr("%s: requires one value", w0);
continue;
}
if (strcasecmp(w0, "EndCharacters") == 0)
{
if (sl->n == 2)
{
indexf->header.endchars = SafeStrCopy(indexf->header.endchars, sl->word[1], &indexf->header.lenendchars);
sortstring(indexf->header.endchars);
makelookuptable(indexf->header.endchars, indexf->header.endcharslookuptable);
}
else
progerr("%s: requires one value", w0);
continue;
}
if (strcasecmp(w0, "IgnoreLastChar") == 0)
{
if (sl->n == 2)
{
indexf->header.ignorelastchar = SafeStrCopy(indexf->header.ignorelastchar, sl->word[1], &indexf->header.lenignorelastchar);
sortstring(indexf->header.ignorelastchar);
makelookuptable(indexf->header.ignorelastchar, indexf->header.ignorelastcharlookuptable);
} /* Do nothing */
/* else progerr("%s: requires one value",w0); */
continue;
}
if (strcasecmp(w0, "IgnoreFirstChar") == 0)
{
if (sl->n == 2)
{
indexf->header.ignorefirstchar = SafeStrCopy(indexf->header.ignorefirstchar, sl->word[1], &indexf->header.lenignorefirstchar);
sortstring(indexf->header.ignorefirstchar);
makelookuptable(indexf->header.ignorefirstchar, indexf->header.ignorefirstcharlookuptable);
} /* Do nothing */
/* else progerr("%s: requires one value",w0); */
continue;
}
if (strcasecmp(w0, "ReplaceRules") == 0)
{
if (sl->n > 2)
Build_ReplaceRules( w0, sl->word, &sw->replaceRegexps );
else
progerr("%s: requires at least two values", w0);
continue;
}
if (strcasecmp(w0, "IndexName") == 0)
{
if (sl->n > 1)
{
StringValue = StringListToString(sl, 1);
indexf->header.indexn = SafeStrCopy(indexf->header.indexn, (char *)StringValue, &indexf->header.lenindexn);
efree(StringValue);
}
else
progerr("%s: requires a value", w0);
continue;
}
if (strcasecmp(w0, "IndexDescription") == 0)
{
if (sl->n > 1)
{
StringValue = StringListToString(sl, 1);
indexf->header.indexd = SafeStrCopy(indexf->header.indexd, (char *)StringValue, &indexf->header.lenindexd);
efree(StringValue);
}
else
progerr("%s: requires a value", w0);
continue;
}
if (strcasecmp(w0, "IndexPointer") == 0)
{
if (sl->n > 1)
{
StringValue = StringListToString(sl, 1);
indexf->header.indexp = SafeStrCopy(indexf->header.indexp, (char *)StringValue, &indexf->header.lenindexp);
efree(StringValue);
}
else
progerr("%s: requires a value", w0);
continue;
}
if (strcasecmp(w0, "IndexAdmin") == 0)
{
if (sl->n > 1)
{
StringValue = StringListToString(sl, 1);
indexf->header.indexa = SafeStrCopy(indexf->header.indexa, (char *)StringValue, &indexf->header.lenindexa);
efree(StringValue);
}
else
progerr("%s: requires one value", w0);
continue;
}
if (strcasecmp(w0, "UseStemming") == 0)
{
progwarn("UseStemming is deprecated. See FuzzyIndexingMode in the docs");
if ( getYesNoOrAbort(sl, 1, 1) )
fuzzy_or_die( indexf, "Stemming_en" );
continue;
}
if (strcasecmp(w0, "UseSoundex") == 0)
{
if ( getYesNoOrAbort(sl, 1, 1) )
fuzzy_or_die( indexf, "Soundex" );
continue;
}
if (strcasecmp(w0, "FuzzyIndexingMode") == 0)
{
if (sl->n != 2)
progerr("%s: requires one value", w0);
fuzzy_or_die( indexf, sl->word[1] );
continue;
}
if (strcasecmp(w0, "IgnoreTotalWordCountWhenRanking") == 0)
{
indexf->header.ignoreTotalWordCountWhenRanking = getYesNoOrAbort(sl, 1, 1);
continue;
}
if (strcasecmp(w0, "TranslateCharacters") == 0)
{
if (sl->n >= 2)
{
if (!BuildTranslateChars(indexf->header.translatecharslookuptable, (unsigned char *)sl->word[1], (unsigned char *)sl->word[2]))
{
progerr("%s: requires two values (same length) or one translation rule", w0);
}
}
continue;
}
if (strcasecmp(w0, "ExtractPath") == 0)
{
struct metaEntry *m;
char **words;
if (sl->n < 4)
progerr("%s: requires at least three values: metaname expression type and a expression/strings", w0);
if ( !( m = getMetaNameByName( &indexf->header, sl->word[1])) )
m = addMetaEntry(&indexf->header, sl->word[1], META_INDEX, 0);
words = sl->word;
words++; /* past metaname */
add_ExtractPath( w0, sw, m, words );
continue;
}
if (strcasecmp(w0, "ExtractPathDefault") == 0)
{
struct metaEntry *m;
if (sl->n != 3)
progerr("%s: requires two values: metaname default_value", w0);
if ( !( m = getMetaNameByName( &indexf->header, sl->word[1])) )
m = addMetaEntry(&indexf->header, sl->word[1], META_INDEX, 0);
if ( m->extractpath_default )
progerr("%s already defined for meta '%s' as '%s'", w0, m->metaName, m->extractpath_default );
m->extractpath_default = estrdup( sl->word[2] );
continue;
}
if (strcasecmp(w0, "MetaNames") == 0)
{
if (sl->n <= 1)
progerr("%s: requires at least one value", w0);
for (i = 1; i < sl->n; i++)
{
if ( getMetaNameByName( &indexf->header, sl->word[i]) )
progerr("%s - name '%s' is already a MetaName", w0, sl->word[i] );
addMetaEntry(&indexf->header, sl->word[i], META_INDEX, 0);
}
continue;
}
if (strcasecmp(w0, "MetaNameAlias") == 0)
{
struct metaEntry *meta_entry;
struct metaEntry *new_meta;
if (sl->n < 3)
progerr("%s: requires at least two values", w0);
/* Make sure first entry is not an alias */
/* Lookup entry, and do not follow alias */
if ( !(meta_entry = getMetaNameByNameNoAlias( &indexf->header, sl->word[1]) ) )
progerr("%s - name '%s' not a MetaName", w0, sl->word[1] );
if ( meta_entry->alias )
progerr("%s - name '%s' must not be an alias", w0, sl->word[1] );
for (i = 2; i < sl->n; i++)
{
if ( getMetaNameByNameNoAlias( &indexf->header, sl->word[i]) )
progerr("%s - name '%s' is already a MetaName or MetaNameAlias", w0, sl->word[i] );
new_meta = addMetaEntry(&indexf->header, sl->word[i], meta_entry->metaType, 0);
new_meta->alias = meta_entry->metaID;
}
continue;
}
/* Allow setting a bias on MetaNames */
if (strcasecmp(w0, "MetaNamesRank") == 0)
{
struct metaEntry *meta_entry;
int rank = 0;
if (sl->n < 3)
progerr("%s: requires only two or more values, a rank (integer) and a list of property names", w0);
rank = read_integer( sl->word[1], w0, -RANK_BIAS_RANGE, RANK_BIAS_RANGE ); // NOTE: if this is changed db.c must match
for (i = 2; i < sl->n; i++)
{
/* already exists? */
if ( (meta_entry = getMetaNameByNameNoAlias( &indexf->header, sl->word[i])) )
{
if ( meta_entry->alias )
progerr("Can't assign a rank to metaname '%s': it is an alias", meta_entry->metaName );
if ( meta_entry->rank_bias )
progwarn("Why are you redefining the rank of metaname '%s'?", meta_entry->metaName );
}
else
meta_entry = addMetaEntry(&indexf->header, sl->word[i], META_INDEX, 0);
meta_entry->rank_bias = rank;
}
continue;
}
/* Meta name to extract out <a href> links */
if (strcasecmp(w0, "HTMLLinksMetaName") == 0)
{
if (sl->n <= 1)
progerr("%s: requires one value", w0);
if ( !( sw->links_meta = getMetaNameByName( &indexf->header, sl->word[1]) ))
sw->links_meta = addMetaEntry(&indexf->header, sl->word[1], META_INDEX, 0);
continue;
}
/* What to do with IMG ATL tags? */
if (strcasecmp(w0, "IndexAltTagMetaName") == 0)
{
if (sl->n <= 1)
progerr("%s: requires one value", w0);
if ( strcasecmp( sl->word[1], "as-text" ) == 0)
{
sw->IndexAltTag = 1;
if ( sw->IndexAltTagMeta )
{
efree( sw->IndexAltTagMeta );
sw->IndexAltTagMeta = NULL;
}
}
else
{
sw->IndexAltTag = 1;
if ( sw->IndexAltTagMeta )
{
efree( sw->IndexAltTagMeta );
sw->IndexAltTagMeta = NULL;
}
sw->IndexAltTagMeta = estrdup( sl->word[1] );
}
continue;
}
/* Meta name to extract out <img src> links */
if (strcasecmp(w0, "ImageLinksMetaName") == 0)
{
if (sl->n <= 1)
progerr("%s: requires one value", w0);
if ( !( sw->images_meta = getMetaNameByName( &indexf->header, sl->word[1]) ))
sw->images_meta = addMetaEntry(&indexf->header, sl->word[1], META_INDEX, 0);
continue;
}
if (strcasecmp(w0, "PropCompressionLevel") == 0)
{
#ifdef HAVE_ZLIB
if (sl->n == 2)
{
sw->PropCompressionLevel = read_integer( sl->word[1], w0, 0, 9 );
}
else
progerr("%s: requires one value", w0);
#else
progwarn("%s: Swish not built with zlib support -- cannot compress", w0);
#endif
continue;
}
if (strcasecmp(w0, "PropertyNames") == 0)
{
if (sl->n <= 1)
progerr("%s: requires at least one value", w0);
for (i = 1; i < sl->n; i++)
{
if ( getPropNameByName( &indexf->header, sl->word[i]) )
progerr("%s - name '%s' is already a PropertyName", w0, sl->word[i] );
addMetaEntry(&indexf->header, sl->word[i], META_PROP|META_STRING|META_IGNORE_CASE, 0);
}
continue;
}
if (strcasecmp(w0, "PropertyNamesIgnoreCase") == 0)
{
struct metaEntry *m;
if (sl->n <= 1)
progerr("%s: requires at least one value", w0);
for (i = 1; i < sl->n; i++)
{
if ( !(m = getPropNameByName( &indexf->header, sl->word[i])) )
addMetaEntry(&indexf->header, sl->word[i], META_PROP|META_STRING|META_IGNORE_CASE, 0);
else
{
if ( !is_meta_string( m ) )
progerr("%s - name '%s' is not a STRING type of Property", w0, sl->word[i] );
m->metaType |= META_IGNORE_CASE;
}
}
continue;
}
if (strcasecmp(w0, "PropertyNamesCompareCase") == 0)
{
struct metaEntry *m;
if (sl->n <= 1)
progerr("%s: requires at least one value", w0);
for (i = 1; i < sl->n; i++)
{
if ( !(m = getPropNameByName( &indexf->header, sl->word[i])) )
addMetaEntry(&indexf->header, sl->word[i], META_PROP|META_STRING, 0);
else
{
if ( !is_meta_string( m ) )
progerr("%s - name '%s' is not a STRING type of Property", w0, sl->word[i] );
m->metaType &= ~META_IGNORE_CASE;
}
}
continue;
}
/* --- this is duplicating.. */
if (strcasecmp(w0, "PropertyNamesNoStripChars") == 0)
{
struct metaEntry *m;
if (sl->n <= 1)
progerr("%s: requires at least one value", w0);
for (i = 1; i < sl->n; i++)
{
if ( !(m = getPropNameByName( &indexf->header, sl->word[i])) )
addMetaEntry(&indexf->header, sl->word[i], META_PROP|META_STRING|META_IGNORE_CASE|META_NOSTRIP, 0);
else
{
if ( !is_meta_string( m ) )
progerr("%s - name '%s' is not a STRING type of Property", w0, sl->word[i] );
m->metaType |= META_NOSTRIP;
}
}
continue;
}
if (strcasecmp(w0, "PropertyNamesStripChars") == 0)
{
struct metaEntry *m;
if (sl->n <= 1)
progerr("%s: requires at least one value", w0);
for (i = 1; i < sl->n; i++)
{
if ( !(m = getPropNameByName( &indexf->header, sl->word[i])) )
addMetaEntry(&indexf->header, sl->word[i], META_PROP|META_STRING|META_IGNORE_CASE, 0);
else
{
if ( !is_meta_string( m ) )
progerr("%s - name '%s' is not a STRING type of Property", w0, sl->word[i] );
m->metaType &= ~META_NOSTRIP;
}
}
continue;
}
if (strcasecmp(w0, "PropertyNamesNumeric") == 0)
{
if (sl->n <= 1)
progerr("%s: requires at least one value", w0);
for (i = 1; i < sl->n; i++)
{
if ( getPropNameByName( &indexf->header, sl->word[i]) )
progerr("%s - name '%s' is already a PropertyName", w0, sl->word[i] );
addMetaEntry(&indexf->header, sl->word[i], META_PROP|META_NUMBER, 0);
}
continue;
}
if (strcasecmp(w0, "PropertyNamesDate") == 0)
{
if (sl->n <= 1)
progerr("%s: requires at least one value", w0);
for (i = 1; i < sl->n; i++)
{
if ( getPropNameByName( &indexf->header, sl->word[i]) )
progerr("%s - name '%s' is already a PropertyName", w0, sl->word[i] );
addMetaEntry(&indexf->header, sl->word[i], META_PROP|META_DATE, 0);
}
continue;
}
if (strcasecmp(w0, "PropertyNameAlias") == 0)
{
struct metaEntry *meta_entry;
struct metaEntry *new_meta;
if (sl->n < 3)
progerr("%s: requires at least two values", w0);
/* Make sure first entry is not an alias */
/* Lookup entry, and do not follow alias */
if ( !(meta_entry = getPropNameByNameNoAlias( &indexf->header, sl->word[1]) ) )
progerr("%s - name '%s' not a PropertyName", w0, sl->word[1] );
if ( meta_entry->alias )
progerr("%s - name '%s' must not be an alias", w0, sl->word[1] );
for (i = 2; i < sl->n; i++)
{
if ( getPropNameByNameNoAlias( &indexf->header, sl->word[i]) )
progerr("%s - name '%s' is already a PropertyName or PropertyNameAlias", w0, sl->word[i] );
new_meta = addMetaEntry(&indexf->header, sl->word[i], meta_entry->metaType, 0);
new_meta->alias = meta_entry->metaID;
}
continue;
}
/* This allows setting a limit on a property's string length */
// One question would be if this should set the length on the alias, or the real property. */
// If on the alias then you could really fine tune:
// PropertyNames description
// PropertyNameAlias description td h1 h2 h3
// PropertyNameMaxLength 5000 description
// PropertyNameMaxLength 100 td
// PropertyNameMaxLength 10 h1 h2 h3
// then the total length would be 5000, but each one would be limited, too. I find that hard to imagine
// it would be useful. So the current design is you can only assign to a non-alias.
if (strcasecmp(w0, "PropertyNamesMaxLength") == 0)
{
struct metaEntry *meta_entry;
int max_length = 0;
if (sl->n < 3)
progerr("%s: requires only two or more values, a length and a list of property names", w0);
max_length = read_integer( sl->word[1], w0, 0, INT_MAX );
for (i = 2; i < sl->n; i++)
{
/* already exists? */
if ( (meta_entry = getPropNameByNameNoAlias( &indexf->header, sl->word[i])) )
{
if ( meta_entry->alias )
progerr("Can't assign a length to property '%s': it is an alias", meta_entry->metaName );
if ( meta_entry->max_len )
progwarn("Why are you redefining the max length of property '%s'?", meta_entry->metaName );
if ( !is_meta_string( meta_entry ) )
progerr("%s - name '%s' is not a STRING type of Property", w0, sl->word[i] );
}
else
meta_entry = addMetaEntry(&indexf->header, sl->word[i], META_PROP|META_STRING, 0);
meta_entry->max_len = max_length;
}
continue;
}
/* Set the sort length */
if (strcasecmp(w0, "PropertyNamesSortKeyLength") == 0)
{
struct metaEntry *meta_entry;
int max_length = 0;
if (sl->n < 3)
progerr("%s: requires only two or more values, a length and a list of property names", w0);
max_length = read_integer( sl->word[1], w0, 1, INT_MAX );
for (i = 2; i < sl->n; i++)
{
/* already exists? */
if ( (meta_entry = getPropNameByNameNoAlias( &indexf->header, sl->word[i])) )
{
if ( meta_entry->alias )
progerr("Can't assign a length to property '%s': it is an alias", meta_entry->metaName );
if ( meta_entry->max_len )
progwarn("Why are you redefining the max sort key length of property '%s'?", meta_entry->metaName );
if ( !is_meta_string( meta_entry ) )
progerr("%s - name '%s' is not a STRING type of Property", w0, sl->word[i] );
}
else
meta_entry = addMetaEntry(&indexf->header, sl->word[i], META_PROP|META_STRING, 0);
meta_entry->sort_len = max_length;
}
continue;
}
/* Hashed word lists */
if ( !strcasecmp(w0, "IgnoreWords") || !strcasecmp(w0, "StopWords"))
{
word_hash_config( sl, &indexf->header.hashstoplist );
continue;
}
if (strcasecmp(w0, "BuzzWords") == 0) /* 2001-04-24 moseley */
{
word_hash_config( sl, &indexf->header.hashbuzzwordlist );
continue;
}
if (strcasecmp(w0, "UseWords") == 0)
{
word_hash_config( sl, &indexf->header.hashuselist );
continue;
}
/* IndexVerbose is supported for backwards compatibility */
if (strcasecmp(w0, "IndexVerbose") == 0)
{
sw->verbose = getYesNoOrAbort(sl, 1, 1);
if (sw->verbose)
sw->verbose = 3;
continue;
}
if (strcasecmp(w0, "IndexOnly") == 0)
{
if (sl->n > 1)
{
grabCmdOptions(sl, 1, &sw->suffixlist);
}
else
progerr("%s: requires at least one value", w0);
continue;
}
if (strcasecmp(w0, "IndexContents") == 0)
{
if (sl->n > 2)
{
struct IndexContents *ic = (struct IndexContents *) emalloc(sizeof(struct IndexContents));
ic->DocType = getDocTypeOrAbort(sl, 1);
ic->patt = NULL;
for (i = 2; i < sl->n; i++)
ic->patt = addswline(ic->patt, sl->word[i]);
if (sw->indexcontents)
ic->next = sw->indexcontents;
else
ic->next = NULL;
sw->indexcontents = ic;
}
else
progerr("%s: requires at least two values", w0);
continue;
}
/* $$$ this needs fixing */
if (strcasecmp(w0, "StoreDescription") == 0)
{
if (sl->n == 3 || sl->n == 4)
{
struct StoreDescription *sd = (struct StoreDescription *) emalloc(sizeof(struct StoreDescription));
sd->DocType = getDocTypeOrAbort(sl, 1);
sd->size = 0;
sd->field = NULL;
i = 2;
if (sl->word[i][0] == '<' && sl->word[i][strlen(sl->word[i]) - 1] == '>')
{
sl->word[i][strlen(sl->word[i]) - 1] = '\0';
sd->field = estrdup(sl->word[i] + 1);
i++;
}
if (i < sl->n && isnumstring( (unsigned char *)sl->word[i] ))
{
sd->size = read_integer( sl->word[i], w0, 0, INT_MAX );
}
if (sl->n == 3 && !sd->field && !sd->size)
progerr("%s: second parameter must be <fieldname> or a number", w0);
if (sl->n == 4 && sd->field && !sd->size)
progerr("%s: third parameter must be empty or a number", w0);
if (sw->storedescription)
sd->next = sw->storedescription;
else
sd->next = NULL;
sw->storedescription = sd;
/* Make sure there's a property name */
if ( !getPropNameByName( &indexf->header, AUTOPROPERTY_SUMMARY) )
addMetaEntry(&indexf->header, AUTOPROPERTY_SUMMARY, META_PROP|META_STRING, 0);
}
else
progerr("%s: requires two or three values", w0);
continue;
}
if (strcasecmp(w0, "DefaultContents") == 0)
{
if (sl->n == 2 )
{
sw->DefaultDocType = getDocTypeOrAbort(sl, 1);
}
else
progerr("%s: requires one value -- a parser type", w0);
continue;
}
if (strcasecmp(w0, "BumpPositionCounterCharacters") == 0)
{
if (sl->n > 1)
{
indexf->header.bumpposchars = SafeStrCopy(indexf->header.bumpposchars, sl->word[1], &indexf->header.lenbumpposchars);
sortstring(indexf->header.bumpposchars);
makelookuptable(indexf->header.bumpposchars, indexf->header.bumpposcharslookuptable);
}
else
progerr("%s: requires at least one value", w0);
continue;
}
/* #### Added UndefinedMetaTags as defined by Bill Moseley */
if (strcasecmp(w0, "UndefinedMetaTags") == 0)
{
get_undefined_meta_flags( w0, sl, &sw->UndefinedMetaTags );
if ( !sw->UndefinedMetaTags )
progerr("%s: possible values are error, ignore, index or auto", w0);
continue;
}
if (strcasecmp(w0, "UndefinedXMLAttributes") == 0)
{
get_undefined_meta_flags( w0, sl, &sw->UndefinedXMLAttributes );
continue;
}
if (strcasecmp(w0, "IgnoreMetaTags") == 0)
{
if (sl->n > 1)
{
grabCmdOptions(sl, 1, &sw->ignoremetalist);
/* Go lowercase */
for (tmplist = sw->ignoremetalist; tmplist; tmplist = tmplist->next)
(void)strtolower(tmplist->line);
}
else
progerr("%s: requires at least one value", w0);
continue;
}
if (strcasecmp(w0, "XMLClassAttributes") == 0)
{
if (sl->n > 1)
{
grabCmdOptions(sl, 1, &sw->XMLClassAttributes);
/* Go lowercase */
for (tmplist = sw->XMLClassAttributes; tmplist; tmplist = tmplist->next)
(void)strtolower(tmplist->line);
}
else
progerr("%s: requires at least one value", w0);
continue;
}
if (strcasecmp(w0, "DontBumpPositionOnStartTags") == 0)
{
if (sl->n > 1)
grabCmdOptions(sl, 1, &sw->dontbumpstarttagslist);
else
progerr("%s: requires at least one value", w0);
continue;
}
if (strcasecmp(w0, "DontBumpPositionOnEndTags") == 0)
{
if (sl->n > 1)
grabCmdOptions(sl, 1, &sw->dontbumpendtagslist);
else
progerr("%s: requires at least one value", w0);
continue;
}
if (strcasecmp(w0, "TruncateDocSize") == 0)
{ /* rasc 2001-03 */
if (sl->n == 2 && isnumstring( (unsigned char *)sl->word[1] ))
sw->truncateDocSize = atol(sl->word[1]);
else
progerr("%s: requires size parameter in bytes", w0);
continue;
}
if (strcasecmp(w0, "CompressPositions") == 0)
{
sw->compressPositions = getYesNoOrAbort(sl, 1, 1);
continue;
}
else if (configModule_Entities(sw, sl));
else if (configModule_Filter(sw, sl)); /* rasc */
else if (configModule_ResultOutput(sw, sl)); /* rasc */
else if (configModule_ResultSort(sw, sl)); /* jmruiz */
else if (configModule_Index(sw, sl)); /* jmruiz */
else if (configModule_Prog(sw, sl));
else if (!parseconfline(sw, sl))
{
printf("Bad directive on line #%d of file %s: %s\n", linenumber, conffile, line);
if ( ++baddirective > 30 )
progerr("Too many errors. Can not continue.");
}
}
freeStringList(sl);
fclose(fp);
if (baddirective)
exit(1);
if (gotdir && !(*hasdir))
*hasdir = 1;
if (gotindex && !(*hasindex))
*hasindex = 1;
}
//==============================================================
int main(int argc, char **argv)
//--------------------------------------------------------------
// メインプログラム
//--------------------------------------------------------------
// in: argc = 引数の数
// argv = 引数のポインタ列
//--------------------------------------------------------------
// out: 0 = 処理完了
//==============================================================
{
int count;
char **pp;
// タイトル表示
//--------------
l_title();
// ワークを初期化
//----------------
l_workInit();
// コマンドラインからのオプション解析
//------------------------------------
l_getOption(argc - 1, argv + 1);
// stdin からのオプション解析
//----------------------------
pp = l_getStdin(stdin, &count);
l_getOption(count, pp);
freeStringList(pp);
if(!pack.pack_num)
{
l_usage();
return 1;
}
// 同じ名前のファイルをチェックする
//----------------------------------
l_checkEvenFile();
// ファイルの存在チェック
//------------------------
l_checkFileExist();
// ヘッダ作成
//------------
l_createHeadder();
// 解析結果(TEST)
//----------------
l_printOption();
// データ出力
//------------
l_packFiles();
// 後始末
//--------
l_workFin();
return 0;
}
