VOID
PrintStringList (
IN STRING_LIST *StringList
)
/*++
Routine Description:
Prints out the string list
Arguments:
StringList The string list to print
Returns:
EFI_STATUS
--*/
{
CHAR8* String;
String = StringListToString (StringList);
if (String != NULL) {
printf ("%s", String);
free (String);
}
}
////////////////////////////////////////////
// OnExecute
// Demonstrate:
// IDirectorySearch::ExecuteSearch
// IDirectorySearch::GetNextRow
// IDirectorySearch::GetColumn
// IDirectorySearch::SetSearchPreference
//
/////////////////////////////////////////////
void CDlgIDirectorySearch::OnExecute()
{
ASSERT( m_pSearch );
CWaitCursor wait;
UpdateData(TRUE); // Get data from the Dialog Box
HRESULT hr;
ADS_SEARCH_HANDLE hSearch;
ADS_SEARCH_COLUMN col;
CString s;
int idx=0;
int nCount;
LPWSTR *pszAttr=NULL;
POSITION pos;
USES_CONVERSION;
/////////////////////////////////
// Reset the Total Number
//////////////////////////////////
SetDlgItemText( IDC_TOTAL, _T(""));
/////////////////////////////////////////////
// Get the attribute list, and preparing..
///////////////////////////////////////////
CStringList sAttrList;
m_cListView.DeleteAllItems(); // Reset the UI
while( m_cListView.DeleteColumn(0))
{
;
}
//////////////////////////////////////////////////
// Preparing for attribute list
// and columns to display
CString sTemp;
m_cAttrList.GetWindowText(s);
// we need to add adspath, so that we can refer to this object later when user dblclk the item
if ( !s.IsEmpty() )
{
sTemp = s;
sTemp.MakeLower();
if ( s.Find(_T("adspath"),0) == -1 )
{
s += _T(",ADsPath");
}
}
// convert to string list for easy manipulation
StringToStringList( s, sAttrList );
nCount = sAttrList.GetCount();
idx=0;
if ( nCount )
{
pszAttr = (LPWSTR*) AllocADsMem( nCount * sizeof(LPWSTR));
pos = sAttrList.GetHeadPosition();
while ( pos != NULL )
{
s = sAttrList.GetAt(pos);
pszAttr[idx] = T2OLE(s);
sAttrList.GetNext(pos );
idx++;
}
}
else
{
nCount = -1;
}
/////////////////////////////////////////
// BEGIN Set the preferences
///////////////////////////////////////
DWORD dwCountPref = 0;
ADS_SEARCHPREF_INFO prefInfo[ MAX_SEARCH_PREF ];
ADS_SORTKEY *pSortKey = NULL;
if ( m_bEnableFilter == FALSE )
{
// Reset the preference
m_pSearch->SetSearchPreference( prefInfo, dwCountPref );
}
else // Preferences are specified
{
////////////////////////
// Timeout Pref
////////////////////////////
if ( m_nTimeOut != 0 )
{
prefInfo[dwCountPref].dwSearchPref = ADS_SEARCHPREF_TIMEOUT;
prefInfo[dwCountPref].vValue.dwType = ADSTYPE_INTEGER;
prefInfo[dwCountPref].vValue.Integer = m_nTimeOut;
dwCountPref++;
}
//////////////////////////////
// Search Scope
/////////////////////////////
idx = m_CADsSearchScope.GetCurSel();
if ( idx != CB_ERR )
{
prefInfo[dwCountPref].dwSearchPref = ADS_SEARCHPREF_SEARCH_SCOPE;
prefInfo[dwCountPref].vValue.dwType = ADSTYPE_INTEGER;
prefInfo[dwCountPref].vValue.Integer = idx;
dwCountPref++;
}
///////////////////////////////////////////////////
// Cache Result. The default is to cache the result
/////////////////////////////////////////////////
if ( !m_bCacheResult )
{
prefInfo[dwCountPref].dwSearchPref = ADS_SEARCHPREF_SEARCH_SCOPE;
prefInfo[dwCountPref].vValue.dwType = ADSTYPE_BOOLEAN;
prefInfo[dwCountPref].vValue.Boolean = FALSE;
dwCountPref++;
}
//////////////////////////////////////////////////
// Page Size
///////////////////////////////////////////////////
if ( m_nPageSize > 0 )
{
prefInfo[dwCountPref].dwSearchPref = ADS_SEARCHPREF_PAGESIZE;
prefInfo[dwCountPref].vValue.dwType = ADSTYPE_INTEGER;;
prefInfo[dwCountPref].vValue.Integer = m_nPageSize;
dwCountPref++;
}
////////////////////////////////////////////////
// Chase Referrals
///////////////////////////////////////////////
idx = m_cChaseReferrals.GetCurSel();
if ( idx != CB_ERR )
{
prefInfo[dwCountPref].dwSearchPref = ADS_SEARCHPREF_CHASE_REFERRALS;
prefInfo[dwCountPref].vValue.dwType = ADSTYPE_INTEGER;
switch( idx )
{
case 0:
prefInfo[dwCountPref].vValue.Integer = ADS_CHASE_REFERRALS_NEVER;
break;
case 1:
prefInfo[dwCountPref].vValue.Integer = ADS_CHASE_REFERRALS_SUBORDINATE;
break;
case 2:
prefInfo[dwCountPref].vValue.Integer = ADS_CHASE_REFERRALS_EXTERNAL;
break;
default:
prefInfo[dwCountPref].vValue.Integer = ADS_CHASE_REFERRALS_EXTERNAL;
}
dwCountPref++;
}
///////////////////////////////////////////////
// Sort On
////////////////////////////////////////////////
if ( !m_sSortOn.IsEmpty() )
{
CStringList sList;
UINT nCount;
prefInfo[dwCountPref].dwSearchPref = ADS_SEARCHPREF_SORT_ON;
prefInfo[dwCountPref].vValue.dwType = ADSTYPE_PROV_SPECIFIC;
StringToStringList( m_sSortOn, sList );
nCount = sList.GetCount();
if ( nCount > 0 )
{
POSITION pos;
pos= sList.GetHeadPosition();
pSortKey = (ADS_SORTKEY *) LocalAlloc( LMEM_FIXED | LMEM_ZEROINIT, sizeof(ADS_SORTKEY) * nCount );
idx = 0;
while( pos != NULL )
{
pSortKey[idx].pszAttrType = T2OLE(sList.GetAt(pos));
pSortKey[idx].pszReserved = NULL;
pSortKey[idx].fReverseorder =0;
// Next
idx++;
sList.GetNext( pos );
}
prefInfo[dwCountPref].vValue.ProviderSpecific.dwLength = sizeof(ADS_SORTKEY) * nCount;
prefInfo[dwCountPref].vValue.ProviderSpecific.lpValue = (LPBYTE) pSortKey;
dwCountPref++;
}
}
//////////////////////////////////////////////
// Size Limit
//////////////////////////////////////////////
if ( m_nSizeLimit > 0 )
{
prefInfo[dwCountPref].dwSearchPref = ADS_SEARCHPREF_SIZE_LIMIT;
prefInfo[dwCountPref].vValue.dwType = ADSTYPE_INTEGER;
prefInfo[dwCountPref].vValue.Integer = m_nSizeLimit;
dwCountPref++;
}
//////////////////////////////////////////////////
// A Synchronous
///////////////////////////////////////////////////
if ( m_bAsynch )
{
prefInfo[dwCountPref].dwSearchPref = ADS_SEARCHPREF_ASYNCHRONOUS;
prefInfo[dwCountPref].vValue.dwType = ADSTYPE_BOOLEAN;
prefInfo[dwCountPref].vValue.Integer = TRUE;
dwCountPref++;
}
/////////////////////////////////////////////////////
// Attribute Type Only
//////////////////////////////////////////////////////
if ( m_bAttrib )
{
prefInfo[dwCountPref].dwSearchPref = ADS_SEARCHPREF_ATTRIBTYPES_ONLY;
prefInfo[dwCountPref].vValue.dwType = ADSTYPE_BOOLEAN;
prefInfo[dwCountPref].vValue.Integer = TRUE;
dwCountPref++;
}
/////////////////////////////////////////////////////
// Derefence Alias
//////////////////////////////////////////////////////
if ( m_nDeref != CB_ERR )
{
prefInfo[dwCountPref].dwSearchPref = ADS_SEARCHPREF_DEREF_ALIASES;
prefInfo[dwCountPref].vValue.dwType = ADSTYPE_INTEGER;
prefInfo[dwCountPref].vValue.Integer = m_nDeref;
dwCountPref++;
}
///////////////////////////////////////////////
// Now Set the selected preferences
//////////////////////////////////////////////
hr = m_pSearch->SetSearchPreference( prefInfo, dwCountPref );
}
/////////////////////////////////////////
// END Set the preferences
///////////////////////////////////////
////////////////////////////////////////
// Execute the Search
//////////////////////////////////////
DWORD dwCount=0;
hr = m_pSearch->ExecuteSearch(T2OLE(m_sFilter), pszAttr, nCount, &hSearch );
////////////////////////////////
//// cleanup
////////////////////////////////
if ( pszAttr )
{
FreeADsMem( pszAttr );
}
if ( pSortKey )
{
LocalFree( pSortKey );
}
if ( !SUCCEEDED(hr) )
{
AfxMessageBox(GetErrorMessage(hr));
return;
}
////////////////////////////////////////////////////////
// Enumerate the rows
////////////////////////////////////////////////////////
sAttrList.RemoveAll();
/////////////////////////////////////////////////////////
// Retrieve the column names returned from the server
///////////////////////////////////////////////////////////
LPWSTR pszColumn;
hr = m_pSearch->GetFirstRow( hSearch );
if ( !SUCCEEDED(hr) )
{
return;
}
idx=0;
while( (hr=m_pSearch->GetNextColumnName( hSearch, &pszColumn )) != S_ADS_NOMORE_COLUMNS )
{
s = OLE2T( pszColumn );
m_cListView.InsertColumn(idx, s, LVCFMT_LEFT, 150 ); // adding columns to the UI
sAttrList.AddTail(s);
FreeADsMem( pszColumn );
idx++;
}
/////////////////////////////////////////////
// Start iterating the result set
////////////////////////////////////////////
int nCol;
CStringList sValueList;
do
{
nCol=0;
pos = sAttrList.GetHeadPosition();
while( pos != NULL )
{
s = sAttrList.GetAt(pos); //column name
// Get the Name and display it in the list
hr = m_pSearch->GetColumn( hSearch, T2OLE(s), &col );
if ( SUCCEEDED(hr) )
{
s =_T("");
if ( col.dwADsType != ADSTYPE_INVALID ) // if we request for attrib only, no value will be returned
{
ADsToStringList(col.pADsValues, col.dwNumValues, sValueList );
StringListToString( sValueList, s );
}
if ( nCol )
{
m_cListView.SetItemText(0,nCol, s);
}
else
{
m_cListView.InsertItem(0, s);
}
m_pSearch->FreeColumn( &col );
}
nCol++;
sAttrList.GetNext(pos);
}
dwCount++;
/////////////////////////////
//Display the total so far
////////////////////////////////
s.Format("%ld object(s)", dwCount );
SetDlgItemText( IDC_TOTAL, s );
}
while( (hr=m_pSearch->GetNextRow( hSearch)) != S_ADS_NOMORE_ROWS );
m_pSearch->CloseSearchHandle( hSearch );
}
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;
}
