swish-e/src/error.c

/*
$Id: error.c,v 1.19 2002/08/22 22:58:39 whmoseley Exp $
** Copyright (C) 1995, 1996, 1997, 1998 Hewlett-Packard Company
** Originally by Kevin Hughes, kev@kevcom.com, 3/11/94
**
** This program and library is free software; you can redistribute it and/or
** modify it under the terms of the GNU (Library) General Public License
** as published by the Free Software Foundation; either version 2
** of the License, or any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU (Library) General Public License for more details.
**
** You should have received a copy of the GNU (Library) General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
**
**
** 2001-02-12 rasc   rewritten (progerr uses vargs, now)
**
*/

#include "swish.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include "error.h"
#include <errno.h>


/*
  -- print program error message  (like printf)
  -- exit (1)
*/


/* Allow overriding swish-e's old behavior of errors to stdout */

FILE *error_handle;

void set_error_handle( FILE *where )
{
    error_handle = where;
}

void SwishErrorsToStderr( void )
{
    error_handle = stderr;
}


void progerr(char *msgfmt,...)
{
  va_list args;

  va_start (args,msgfmt);
  fprintf  (error_handle, "err: ");
  vfprintf (error_handle, msgfmt, args);
  fprintf  (error_handle, "\n.\n");
  va_end   (args);

  exit(1);
 }


/*
  -- print program error message  (like printf)
  -- includes text of errno at end of message
  -- exit (1)
*/

void progerrno(char *msgfmt,...)
{
  va_list args;

  va_start (args,msgfmt);
  fprintf  (error_handle, "err: ");
  vfprintf (error_handle, msgfmt, args);
  fprintf  (error_handle, "%s", strerror(errno));
  fprintf  (error_handle, "\n.\n");
  va_end   (args);
  exit(1);
 }

/********** These are an attempt to prevent aborting in the library *********/

void set_progerr(int errornum, SWISH *sw, char *msgfmt,...)
{
  va_list args;

  sw->lasterror = errornum;

  va_start (args,msgfmt);
  vsnprintf (sw->lasterrorstr, MAX_ERROR_STRING_LEN, msgfmt, args);
  va_end   (args);
}


void set_progerrno(int errornum, SWISH *sw, char *msgfmt,...)
{
  va_list args;
  char *errstr = strerror(errno);

  sw->lasterror = errornum;

  va_start (args,msgfmt);
  vsnprintf (sw->lasterrorstr, MAX_ERROR_STRING_LEN - strlen( errstr ), msgfmt, args);
  strcat( sw->lasterrorstr, errstr );
  va_end   (args);
}
 

/* only print a warning (also to error_handle) and return */
/* might want to have an enum level WARN_INFO, WARN_ERROR, WARN_CRIT, WARN_DEBUG */
void progwarn(char *msgfmt,...)
{
  va_list args;

  va_start (args,msgfmt);
  fprintf  (error_handle, "\nWarning: ");
  vfprintf (error_handle, msgfmt, args);
  fprintf  (error_handle, "\n");
  va_end   (args);
 }

/* only print a warning (also to error_handle) and return */
/* might want to have an enum level WARN_INFO, WARN_ERROR, WARN_CRIT, WARN_DEBUG */
/* includes text of errno at end of message */ 
void progwarnno(char *msgfmt,...)
{
  va_list args;

  va_start (args,msgfmt);
  fprintf  (error_handle, "\nWarning: ");
  vfprintf (error_handle, msgfmt, args);
  fprintf  (error_handle, "%s", strerror(errno));
  fprintf  (error_handle, "\n");
  va_end   (args);
 }

typedef struct
{
    int     critical;   /* If true the calling code needs to call SwishClose */
    int     error_num;
    char    *message_string;
} error_msg_map;

/* See errors.h to the correspondant numerical value */
static error_msg_map swishErrors[]={
    { 0, RC_OK,                                    "" },
    { 0, NO_WORDS_IN_SEARCH,                       "No search words specified" },
    { 0, WORDS_TOO_COMMON,                         "All search words too common to be useful" },
    { 0, UNKNOWN_PROPERTY_NAME_IN_SEARCH_DISPLAY,  "Unknown property name in display properties" },
    { 0, UNKNOWN_PROPERTY_NAME_IN_SEARCH_SORT,     "Unknown property name to sort by" },
    { 0, INVALID_PROPERTY_TYPE,                    "Invalid property type" },
    { 0, UNKNOWN_METANAME,                         "Unknown metaname" },
    { 0, UNIQUE_WILDCARD_NOT_ALLOWED_IN_WORD,      "Single wildcard not allowed as word" },
    { 0, WORD_NOT_FOUND,                           "Word not found" },
    { 0, SEARCH_WORD_TOO_BIG,                      "Search word exceeded maxwordlimit setting" },
    { 0, QUERY_SYNTAX_ERROR,                       "Syntax error in query (missing end quote or unbalanced parenthesis?)" },
    { 0, PROP_LIMIT_ERROR,                         "Failed to setup limit by property"},
    { 0, SWISH_LISTRESULTS_EOF,                    "No more results" },
    { 1, INDEX_FILE_NOT_FOUND,                     "Could not open index file" },
    { 1, UNKNOWN_INDEX_FILE_FORMAT,                "Unknown index file format" },
    { 1, INDEX_FILE_IS_EMPTY,                      "Index file(s) is empty" },
    { 1, INDEX_FILE_ERROR,                         "Index file error" },
    { 1, INVALID_SWISH_HANDLE,                     "Invalid swish handle" },
};


/*****************************************************************
* SwishError
*
*   Pass:
*       SWISH *sw
*
*   Returns:
*       value of the last error number, or zero
*
******************************************************************/

int     SwishError(SWISH * sw)
{
    if (!sw)
        return INVALID_SWISH_HANDLE;
    return (sw->lasterror);
}


/*****************************************************************
* SwishErrorString
*
*   Pass:
*       SWISH *sw
*
*   Returns:
*       pointer to string of generic error message related to
*       the last error number
*
******************************************************************/


char   *SwishErrorString(SWISH *sw)
{
    return getErrorString(sw ? sw->lasterror : INVALID_SWISH_HANDLE);
}


/*****************************************************************
* SwishLastErrorMsg
*
*   Pass:
*       SWISH *sw
*
*   Returns:
*       pointer to the string comment of the last error message, if any
*
******************************************************************/


char   *SwishLastErrorMsg(SWISH *sw )
{
    return sw->lasterrorstr;
}


/*****************************************************************
* getErrorString
*
*   Pass:
*       error number
*
*   Returns:
*       value of the last error number, or zero
*
******************************************************************/


char *getErrorString(int number)
{
    int i;
    static char message[50];
    
    for (i = 0; i < sizeof(swishErrors) / sizeof(swishErrors[0]); i++)
        if ( number == swishErrors[i].error_num )
            return swishErrors[i].message_string;

    sprintf( message, "Invalid error number '%d'", number );
    return( message );
}

/*****************************************************************
* SwishCriticalError
*
*   This returns true if the last error was critical and means that
*   the swish object should be destroyed
*
*   Pass:
*       *sw
*
*   Returns:
*       true if the current sw->lasterror is a critical error
*       or if the number is invalid or the sw is null
*
******************************************************************/


int SwishCriticalError(SWISH *sw)
{
    int i;

    if ( !sw )
        return 1;
    
    for (i = 0; i < sizeof(swishErrors) / sizeof(swishErrors[0]); i++)
        if ( sw->lasterror == swishErrors[i].error_num )
            return swishErrors[i].critical;

    return 1;
}


/*****************************************************************
* SwishAbortLastError
*
*   Aborts with the error message type, and the optional comment message
*
*   Pass:
*       SWISH *sw
*
*   Returns:
*       nope
*
******************************************************************/

void SwishAbortLastError(SWISH *sw)
{
    if ( sw->lasterror < 0 )
    {
        if ( *(SwishLastErrorMsg( sw )) )
            progerr( "%s: %s", SwishErrorString( sw ), SwishLastErrorMsg( sw ) );
        else
            progerr( "%s", SwishErrorString( sw ) );
    }

    progerr("Swish aborted with non-negative lasterror");
}

typedef struct
{
    FuzzyIndexType  fuzzy_mode;
    char            *name;
}
FUZZY_OPTS;

static FUZZY_OPTS fuzzy_opts[] = {

    { FUZZY_NONE, "None" },
    { FUZZY_STEMMING, "Stemming" },
    { FUZZY_STEMMING, "Stem" },
    { FUZZY_SOUNDEX, "Soundex" },
    { FUZZY_METAPHONE, "Metaphone" },
    { FUZZY_DOUBLE_METAPHONE, "DoubleMetaphone" }
};

FuzzyIndexType set_fuzzy_mode( char *param )
{
    int     i;
    
    for (i = 0; i < sizeof(fuzzy_opts) / sizeof(fuzzy_opts[0]); i++)
        if ( 0 == strcasecmp(fuzzy_opts[i].name, param ) )
            return fuzzy_opts[i].fuzzy_mode;


    progerr("Invalid FuzzyIndexingMode '%s' in configuation file", param);
    return FUZZY_NONE;
}


char *fuzzy_mode_to_string( FuzzyIndexType mode )
{
    int     i;
    for (i = 0; i < sizeof(fuzzy_opts) / sizeof(fuzzy_opts[0]); i++)
        if ( mode == fuzzy_opts[i].fuzzy_mode )
            return fuzzy_opts[i].name;

    return "Unknown FuzzyIndexingMode";
}


1	/*
2	$Id: error.c,v 1.19 2002/08/22 22:58:39 whmoseley Exp $
3	** Copyright (C) 1995, 1996, 1997, 1998 Hewlett-Packard Company
4	** Originally by Kevin Hughes, kev@kevcom.com, 3/11/94
5	**
6	** This program and library is free software; you can redistribute it and/or
7	** modify it under the terms of the GNU (Library) General Public License
8	** as published by the Free Software Foundation; either version 2
9	** of the License, or any later version.
10	**
11	** This program is distributed in the hope that it will be useful,
12	** but WITHOUT ANY WARRANTY; without even the implied warranty of
13	** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	** GNU (Library) General Public License for more details.
15	**
16	** You should have received a copy of the GNU (Library) General Public License
17	** along with this program; if not, write to the Free Software
18	** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19	**
20	**
21	** 2001-02-12 rasc rewritten (progerr uses vargs, now)
22	**
23	*/
24
25	#include "swish.h"
26	#include <stdio.h>
27	#include <stdlib.h>
28	#include <stdarg.h>
29	#include <string.h>
30	#include "error.h"
31	#include <errno.h>
32
33
34	/*
35	-- print program error message (like printf)
36	-- exit (1)
37	*/
38
39
40	/* Allow overriding swish-e's old behavior of errors to stdout */
41
42	FILE *error_handle;
43
44	void set_error_handle( FILE *where )
45	{
46	error_handle = where;
47	}
48
49	void SwishErrorsToStderr( void )
50	{
51	error_handle = stderr;
52	}
53
54
55	void progerr(char *msgfmt,...)
56	{
57	va_list args;
58
59	va_start (args,msgfmt);
60	fprintf (error_handle, "err: ");
61	vfprintf (error_handle, msgfmt, args);
62	fprintf (error_handle, "\n.\n");
63	va_end (args);
64
65	exit(1);
66	}
67
68
69	/*
70	-- print program error message (like printf)
71	-- includes text of errno at end of message
72	-- exit (1)
73	*/
74
75	void progerrno(char *msgfmt,...)
76	{
77	va_list args;
78
79	va_start (args,msgfmt);
80	fprintf (error_handle, "err: ");
81	vfprintf (error_handle, msgfmt, args);
82	fprintf (error_handle, "%s", strerror(errno));
83	fprintf (error_handle, "\n.\n");
84	va_end (args);
85	exit(1);
86	}
87
88	/******** These are an attempt to prevent aborting in the library *******/
89
90	void set_progerr(int errornum, SWISH sw, char msgfmt,...)
91	{
92	va_list args;
93
94	sw->lasterror = errornum;
95
96	va_start (args,msgfmt);
97	vsnprintf (sw->lasterrorstr, MAX_ERROR_STRING_LEN, msgfmt, args);
98	va_end (args);
99	}
100
101
102
103	void set_progerrno(int errornum, SWISH sw, char msgfmt,...)
104	{
105	va_list args;
106	char *errstr = strerror(errno);
107
108	sw->lasterror = errornum;
109
110	va_start (args,msgfmt);
111	vsnprintf (sw->lasterrorstr, MAX_ERROR_STRING_LEN - strlen( errstr ), msgfmt, args);
112	strcat( sw->lasterrorstr, errstr );
113	va_end (args);
114	}
115
116
117
118	/* only print a warning (also to error_handle) and return */
119	/* might want to have an enum level WARN_INFO, WARN_ERROR, WARN_CRIT, WARN_DEBUG */
120	void progwarn(char *msgfmt,...)
121	{
122	va_list args;
123
124	va_start (args,msgfmt);
125	fprintf (error_handle, "\nWarning: ");
126	vfprintf (error_handle, msgfmt, args);
127	fprintf (error_handle, "\n");
128	va_end (args);
129	}
130
131	/* only print a warning (also to error_handle) and return */
132	/* might want to have an enum level WARN_INFO, WARN_ERROR, WARN_CRIT, WARN_DEBUG */
133	/* includes text of errno at end of message */
134	void progwarnno(char *msgfmt,...)
135	{
136	va_list args;
137
138	va_start (args,msgfmt);
139	fprintf (error_handle, "\nWarning: ");
140	vfprintf (error_handle, msgfmt, args);
141	fprintf (error_handle, "%s", strerror(errno));
142	fprintf (error_handle, "\n");
143	va_end (args);
144	}
145
146	typedef struct
147	{
148	int critical; /* If true the calling code needs to call SwishClose */
149	int error_num;
150	char *message_string;
151	} error_msg_map;
152
153	/* See errors.h to the correspondant numerical value */
154	static error_msg_map swishErrors[]={
155	{ 0, RC_OK, "" },
156	{ 0, NO_WORDS_IN_SEARCH, "No search words specified" },
157	{ 0, WORDS_TOO_COMMON, "All search words too common to be useful" },
158	{ 0, UNKNOWN_PROPERTY_NAME_IN_SEARCH_DISPLAY, "Unknown property name in display properties" },
159	{ 0, UNKNOWN_PROPERTY_NAME_IN_SEARCH_SORT, "Unknown property name to sort by" },
160	{ 0, INVALID_PROPERTY_TYPE, "Invalid property type" },
161	{ 0, UNKNOWN_METANAME, "Unknown metaname" },
162	{ 0, UNIQUE_WILDCARD_NOT_ALLOWED_IN_WORD, "Single wildcard not allowed as word" },
163	{ 0, WORD_NOT_FOUND, "Word not found" },
164	{ 0, SEARCH_WORD_TOO_BIG, "Search word exceeded maxwordlimit setting" },
165	{ 0, QUERY_SYNTAX_ERROR, "Syntax error in query (missing end quote or unbalanced parenthesis?)" },
166	{ 0, PROP_LIMIT_ERROR, "Failed to setup limit by property"},
167	{ 0, SWISH_LISTRESULTS_EOF, "No more results" },
168	{ 1, INDEX_FILE_NOT_FOUND, "Could not open index file" },
169	{ 1, UNKNOWN_INDEX_FILE_FORMAT, "Unknown index file format" },
170	{ 1, INDEX_FILE_IS_EMPTY, "Index file(s) is empty" },
171	{ 1, INDEX_FILE_ERROR, "Index file error" },
172	{ 1, INVALID_SWISH_HANDLE, "Invalid swish handle" },
173	};
174
175
176	/*****************************************************************
177	* SwishError
178	*
179	* Pass:
180	* SWISH *sw
181	*
182	* Returns:
183	* value of the last error number, or zero
184	*
185	******************************************************************/
186
187	int SwishError(SWISH * sw)
188	{
189	if (!sw)
190	return INVALID_SWISH_HANDLE;
191	return (sw->lasterror);
192	}
193
194
195
196	/*****************************************************************
197	* SwishErrorString
198	*
199	* Pass:
200	* SWISH *sw
201	*
202	* Returns:
203	* pointer to string of generic error message related to
204	* the last error number
205	*
206	******************************************************************/
207
208
209	char SwishErrorString(SWISH sw)
210	{
211	return getErrorString(sw ? sw->lasterror : INVALID_SWISH_HANDLE);
212	}
213
214
215
216	/*****************************************************************
217	* SwishLastErrorMsg
218	*
219	* Pass:
220	* SWISH *sw
221	*
222	* Returns:
223	* pointer to the string comment of the last error message, if any
224	*
225	******************************************************************/
226
227
228	char SwishLastErrorMsg(SWISH sw )
229	{
230	return sw->lasterrorstr;
231	}
232
233
234
235
236
237	/*****************************************************************
238	* getErrorString
239	*
240	* Pass:
241	* error number
242	*
243	* Returns:
244	* value of the last error number, or zero
245	*
246	******************************************************************/
247
248
249	char *getErrorString(int number)
250	{
251	int i;
252	static char message[50];
253
254	for (i = 0; i < sizeof(swishErrors) / sizeof(swishErrors[0]); i++)
255	if ( number == swishErrors[i].error_num )
256	return swishErrors[i].message_string;
257
258	sprintf( message, "Invalid error number '%d'", number );
259	return( message );
260	}
261
262	/*****************************************************************
263	* SwishCriticalError
264	*
265	* This returns true if the last error was critical and means that
266	* the swish object should be destroyed
267	*
268	* Pass:
269	* *sw
270	*
271	* Returns:
272	* true if the current sw->lasterror is a critical error
273	* or if the number is invalid or the sw is null
274	*
275	******************************************************************/
276
277
278	int SwishCriticalError(SWISH *sw)
279	{
280	int i;
281
282	if ( !sw )
283	return 1;
284
285	for (i = 0; i < sizeof(swishErrors) / sizeof(swishErrors[0]); i++)
286	if ( sw->lasterror == swishErrors[i].error_num )
287	return swishErrors[i].critical;
288
289	return 1;
290	}
291
292
293
294
295	/*****************************************************************
296	* SwishAbortLastError
297	*
298	* Aborts with the error message type, and the optional comment message
299	*
300	* Pass:
301	* SWISH *sw
302	*
303	* Returns:
304	* nope
305	*
306	******************************************************************/
307
308	void SwishAbortLastError(SWISH *sw)
309	{
310	if ( sw->lasterror < 0 )
311	{
312	if ( *(SwishLastErrorMsg( sw )) )
313	progerr( "%s: %s", SwishErrorString( sw ), SwishLastErrorMsg( sw ) );
314	else
315	progerr( "%s", SwishErrorString( sw ) );
316	}
317
318	progerr("Swish aborted with non-negative lasterror");
319	}
320
321	typedef struct
322	{
323	FuzzyIndexType fuzzy_mode;
324	char *name;
325	}
326	FUZZY_OPTS;
327
328	static FUZZY_OPTS fuzzy_opts[] = {
329
330	{ FUZZY_NONE, "None" },
331	{ FUZZY_STEMMING, "Stemming" },
332	{ FUZZY_STEMMING, "Stem" },
333	{ FUZZY_SOUNDEX, "Soundex" },
334	{ FUZZY_METAPHONE, "Metaphone" },
335	{ FUZZY_DOUBLE_METAPHONE, "DoubleMetaphone" }
336	};
337
338	FuzzyIndexType set_fuzzy_mode( char *param )
339	{
340	int i;
341
342	for (i = 0; i < sizeof(fuzzy_opts) / sizeof(fuzzy_opts[0]); i++)
343	if ( 0 == strcasecmp(fuzzy_opts[i].name, param ) )
344	return fuzzy_opts[i].fuzzy_mode;
345
346
347	progerr("Invalid FuzzyIndexingMode '%s' in configuation file", param);
348	return FUZZY_NONE;
349	}
350
351
352
353
354
355	char *fuzzy_mode_to_string( FuzzyIndexType mode )
356	{
357	int i;
358	for (i = 0; i < sizeof(fuzzy_opts) / sizeof(fuzzy_opts[0]); i++)
359	if ( mode == fuzzy_opts[i].fuzzy_mode )
360	return fuzzy_opts[i].name;
361
362	return "Unknown FuzzyIndexingMode";
363	}
364
365