/*****
 ** ** Module Header ******************************************************* **
 **									     **
 **   Modules Revision 3.0						     **
 **   Providing a flexible user environment				     **
 **									     **
 **   File:		ModuleCmd_Whatis.c				     **
 **   First Edition:	95/12/31					     **
 **									     **
 **   Authors:	Jens Hamisch, jens@Strawberry.COM			     **
 **									     **
 **			ModuleCmd_Apropos				     **
 **									     **
 **   Notes:								     **
 **									     **
 ** ************************************************************************ **
 ****/

/** ** Copyright *********************************************************** **
 ** 									     **
 ** Copyright 1991-1994 by John L. Furlan.                      	     **
 ** see LICENSE.GPL, which must be provided, for details		     **
 ** 									     ** 
 ** ************************************************************************ **/

static char Id[] = "@(#)$Id: ModuleCmd_Whatis.c,v 1.2 2001/06/09 09:48:46 rkowen Exp $";
static void *UseId[] = { &UseId, Id };

/** ************************************************************************ **/
/**				      HEADERS				     **/
/** ************************************************************************ **/

#include "modules_def.h"

/** ************************************************************************ **/
/**				  LOCAL DATATYPES			     **/
/** ************************************************************************ **/

/** not applicable **/

/** ************************************************************************ **/
/**				     CONSTANTS				     **/
/** ************************************************************************ **/

/** not applicable **/

/** ************************************************************************ **/
/**				      MACROS				     **/
/** ************************************************************************ **/

#define WHATIS_SOME	0
#define WHATIS_ALL	1

/** ************************************************************************ **/
/**				    LOCAL DATA				     **/
/** ************************************************************************ **/

static	char	module_name[] = "ModuleCmd_Whatis.c";	/** File name of this module **/

#if WITH_DEBUGGING_MODULECMD
static	char	_proc_ModuleCmd_Whatis[] = "ModuleCmd_Whatis";
static	char	_proc_ModuleCmd_Apropos[] = "ModuleCmd_Apropos";
#endif
#if WITH_DEBUGGING_UTIL_1
static	char	_proc_whatis_dir[] = "whatis_dir";
static	char	_proc_read_cache[] = "read_cache";
static	char	_proc_apropos_cache[] = "apropos_cache";
#endif

static	char	cache_name[] = APR_CACHE;

/** ************************************************************************ **/
/**				    PROTOTYPES				     **/
/** ************************************************************************ **/

static	int	 read_cache( int, char**, FILE*, int);
static	int	 whatis_dir( char*, int, char**, FILE*, int);
static	char	*apropos_cache(void);

/*++++
 ** ** Function-Header ***************************************************** **
 **									     **
 **   Function:		ModuleCmd_Whatis				     **
 **									     **
 **   Description:	Display the passed modules 'whatis' information	     **
 **									     **
 **   First Edition:	95/12/31					     **
 **									     **
 **   Parameters:	Tcl_Interp	*interp		Attached Tcl Interp. **
 **			int		 argc		Number of arguments  **
 **			char		*argv[]		Argument list	     **
 **									     **
 **   Result:		int	TCL_ERROR	Failure			     **
 **				TCL_OK		Successfull operation	     **
 **									     **
 **   Attached Globals:	g_flags		These are set up accordingly before  **
 **					this function is called in order to  **
 **					control everything		     **
 **			g_current_module	The module which is handled  **
 **						by the current command	     **
 **									     **
 ** ************************************************************************ **
 ++++*/

int ModuleCmd_Whatis(	Tcl_Interp	*interp,
			int		 argc,
			char		*argv[])
{
    struct stat	 stats;
    Tcl_Interp	*whatis_interp;
    Tcl_DString	 cmdbuf;
    int		 i, result = TCL_OK, done = 0;
    char	 modulefile[ MOD_BUFSIZE];
    char	 modulename[ MOD_BUFSIZE];
    char	*modpath;		/** Buffer for the contents of the   **/
					/** environment variable MODULEPATH  **/
    char	**wptr;
    char	*dirname;
    char	*cache_file;		/** Name of the cache file	     **/
    FILE	*cachefp = (FILE *) NULL;	/** Cache file pointer	     **/

#if WITH_DEBUGGING_MODULECMD
    ErrorLogger( NO_ERR_START, LOC, _proc_ModuleCmd_Whatis, NULL);
#endif

    /**
     **	 Initialize the command buffer and set up the modules flag to
     **	 'whatisonly'
     **/

    Tcl_DStringInit( &cmdbuf);
    g_flags |= M_WHATIS;

    /**
     **	 Handle each passed module file. Create a Tcl interpreter for each
     **	 module file to be handled and initialize it with custom module commands
     **/

    if ( argc) {
    /**
     **	 User provided a list of modules for ``whatis'' info
     **/
	for(i=0; i<argc && argv[i]; i++) {

	    whatis_interp = Tcl_CreateInterp();
	    if( TCL_OK != (result = InitializeModuleCommands( whatis_interp))) {
		Tcl_DeleteInterp( whatis_interp);
		result = TCL_ERROR;
		break;
	    }

	    /**
	     **	 locate the filename related to the passed module
	     **/

	    if( TCL_ERROR ==
		Locate_ModuleFile(whatis_interp, argv[i], modulename, modulefile)) {
		Tcl_DeleteInterp( whatis_interp);
		if( OK != ErrorLogger( ERR_LOCATE, LOC, argv[i], NULL))
		    break;
		else
		    continue;
	    }

	    /**
	     **	 Print out everything that would happen if the module file were
	     **	 executed ...
	     **/

	    g_current_module = modulename;

	    cmdModuleWhatisInit();
	    result = CallModuleProcedure( whatis_interp, &cmdbuf, modulefile,
		"ModulesWhatis", 0);

	    /**
	     **	 Print the result ...
	     **/

	    if( whatis) {
		wptr = whatis;
		while( *wptr)
		    fprintf( stderr, "%-21s: %s\n", argv[i], *wptr++);
	    }

	    /**
	     **	 Remove the Tcl interpreter that has been used for printing ...
	     **/

	    Tcl_DeleteInterp( whatis_interp);
	    cmdModuleWhatisShut();

	} /** for **/
    } else {
       /**
	**  User wants all module ``whatis'' info
	**/

	/**
	 **  If no MODULEPATH defined, we can not output anything
	 **/

	if( !(modpath = (char *) xgetenv( "MODULEPATH"))) {
	    if( OK != ErrorLogger( ERR_MODULE_PATH, LOC, NULL))
		return( TCL_ERROR);	/** --- EXIT PROCEDURE (FAILURE) --> **/
	}

	/**
	 **  Check whether a cache file exists then list all the ``whatis'' info
	 **  Otherwise read all module files ...
	 **/

	cache_file = apropos_cache();
	if( !sw_create && cache_file && !stat( cache_file, &stats)) {

	    /**
	     **	 Open the cache file
	     **/

	    if((FILE *) NULL == (cachefp = fopen( cache_file, "r"))) {
		if( OK != ErrorLogger( ERR_OPEN, LOC, cache_file, NULL))
		    return( TCL_ERROR);		/** ---- EXIT (FAILURE) ---> **/
	
	    } else {
		
		/**
		 **  Read the cache and close the file
		 **/

		result = read_cache( argc, argv, cachefp, WHATIS_ALL);

		if( EOF == fclose( cachefp))
		    if( OK != ErrorLogger( ERR_CLOSE, LOC, cache_file, NULL))
			return( TCL_ERROR);		/** ---- EXIT (FAILURE) ---> **/

		done = 1;
	    }
	}
	/**
	 **  If we're not done now, we have to scan the files
	 **/

	 if( !done) {

	     /**
	      **  Open the cache file if neccessary
	      **/

	     if( sw_create && cache_file) {
		 if((FILE *) NULL == (cachefp = fopen( cache_file, "w")))
		     if( OK != ErrorLogger( ERR_OPEN, LOC, cache_file, NULL))
			 return( TCL_ERROR);	/** ---- EXIT (FAILURE) ---> **/
	     }
		
	     /**
	      **  Tokenize the module path string and check all dirs
	      **/

	     for( dirname = strtok( modpath, ":");
		  dirname;
		  dirname = strtok( NULL, ":") ) {
	
		 if( !check_dir( dirname))
		     continue;
	
		 whatis_dir( dirname, argc, argv, cachefp, WHATIS_ALL);

	     } /** for **/

	     /**
	      **  Close the cache file
	      **/

	     if( cachefp)
		 if( EOF == fclose( cachefp))
		     if( OK != ErrorLogger( ERR_CLOSE, LOC, cache_file, NULL))
			 return( TCL_ERROR);		/** ---- EXIT (FAILURE) ---> **/
	 }
    }

    /**
     **	 Leave the 'whatis only mode', free up what has been used and return
     **/

    g_flags &= ~M_WHATIS;
    fprintf( stderr, "\n");

    Tcl_DStringFree( &cmdbuf);

    /**
     **	 Free up allocated resources
     **/
    free( modpath);

    /**
     **	 Return on success
     **/

#if WITH_DEBUGGING_MODULECMD
    ErrorLogger( NO_ERR_END, LOC, _proc_ModuleCmd_Whatis, NULL);
#endif

    return( result);

} /** End of 'ModuleCmd_Whatis' **/

/*++++
 ** ** Function-Header ***************************************************** **
 **									     **
 **   Function:		ModuleCmd_Apropos				     **
 **									     **
 **   Description:	Scan the whatis database in order to find something  **
 **			matching the passed strings			     **
 **									     **
 **   First Edition:	95/12/31					     **
 **									     **
 **   Parameters:	Tcl_Interp	*interp		Attached Tcl Interp. **
 **			int		 argc		Number of arguments  **
 **			char		*argv[]		Argument list	     **
 **									     **
 **   Result:		int	TCL_ERROR	Failure			     **
 **				TCL_OK		Successfull operation	     **
 **									     **
 **   Attached Globals:							     **
 **									     **
 ** ************************************************************************ **
 ++++*/

int ModuleCmd_Apropos(	Tcl_Interp	*interp,
			int		 argc,
			char		*argv[])
{
    struct stat	 stats;
    char	*dirname;
    char	*modpath;		/** Buffer for the contents of the   **/
					/** environment variable MODULEPATH  **/
    int		 i, done = 0;
    char	*c;
    char	*cache_file;		/** Name of the cache file	     **/
    FILE	*cachefp = (FILE *) NULL;	/** Cache file pointer	     **/

#if WITH_DEBUGGING_MODULECMD
    ErrorLogger( NO_ERR_START, LOC, _proc_ModuleCmd_Apropos, NULL);
#endif

    /**
     **	 Ignore case ... convert all arguments to lower case
     **/

    if( sw_icase) {
	for( i=0; i<argc; i++)
	    for( c=argv[ i]; c && *c; c++)
		*c = tolower( *c);
    }

    /**
     **	 If there's no MODULEPATH defined, we cannot output anything
     **/

    if( !(modpath = (char *) xgetenv( "MODULEPATH"))) {
	if( OK != ErrorLogger( ERR_MODULE_PATH, LOC, NULL))
	    return( TCL_ERROR);		/** --- EXIT PROCEDURE (FAILURE) --> **/
    }

    /**
     **	 Check whether	there's a cache file. If it is, grep for the tokens
     **	 in this file. Otherwise read all module files ...
     **/

    cache_file = apropos_cache();
    if( !sw_create && cache_file && !stat( cache_file, &stats)) {

	/**
	 **  Open the cache file
	 **/

	if((FILE *) NULL == (cachefp = fopen( cache_file, "r"))) {
	    if( OK != ErrorLogger( ERR_OPEN, LOC, cache_file, NULL))
		return( TCL_ERROR);		/** ---- EXIT (FAILURE) ---> **/
	
	} else {
		
	    /**
	     **	 Read the cache and close the file
	     **/

	    read_cache( argc, argv, cachefp, WHATIS_SOME);

	    if( EOF == fclose( cachefp))
		if( OK != ErrorLogger( ERR_CLOSE, LOC, cache_file, NULL))
		    return( TCL_ERROR);		/** ---- EXIT (FAILURE) ---> **/

	    done = 1;
	}
    }

    /**
     **	 If we're not done now, we have to scan the files
     **/

    if( !done) {

	/**
	 **  Open the cache file if neccessary
	 **/

	if( sw_create && cache_file) {
	    if((FILE *) NULL == (cachefp = fopen( cache_file, "w")))
		if( OK != ErrorLogger( ERR_OPEN, LOC, cache_file, NULL))
		    return( TCL_ERROR);		/** ---- EXIT (FAILURE) ---> **/
	}
		
	/**
	 **  Tokenize the module path string and check all dirs
	 **/

	for( dirname = strtok( modpath, ":");
	     dirname;
	     dirname = strtok( NULL, ":") ) {
	
	    if( !check_dir( dirname))
		continue;
	
	    whatis_dir( dirname, argc, argv, cachefp, WHATIS_SOME);

	} /** for **/

	/**
	 **  Close the cache file
	 **/

	if( cachefp)
	    if( EOF == fclose( cachefp))
		if( OK != ErrorLogger( ERR_CLOSE, LOC, cache_file, NULL))
		    return( TCL_ERROR);		/** ---- EXIT (FAILURE) ---> **/
    }

    /**
     **	 Free up what has been allocated and exit from this procedure
     **/

    free( modpath);

#if WITH_DEBUGGING_MODULECMD
    ErrorLogger( NO_ERR_END, LOC, _proc_ModuleCmd_Apropos, NULL);
#endif

    return( TCL_OK);

} /** End of 'ModuleCmd_Apropos' **/

/*++++
 ** ** Function-Header ***************************************************** **
 **									     **
 **   Function:		whatis_dir					     **
 **									     **
 **   Description:	Print all files beyond the passed directory	     **
 **									     **
 **   First Edition:	91/10/23					     **
 **									     **
 **   Parameters:	char	*dir		Directory to be scanned	     **
 **			int	 argc		Number of tokens	     **
 **			char   **argv		List of tokens to check	     **
 **			FILE	*cfp		Cache file pointer	     **
 **									     **
 **   Result:		int	TCL_OK		Successfull operation	     **
 **									     **
 **   Attached Globals:	g_flags		These are set up accordingly before  **
 **					this function is called in order to  **
 **					control everything		     **
 **			g_current_module	The module which is handled  **
 **						by the current command	     **
 **									     **
 ** ************************************************************************ **
 ++++*/

static	int	whatis_dir( char *dir, int argc, char **argv, FILE *cfp,
			    int whatis_list)
{
    fi_ent	 *dirlst_head = NULL;	/** Directory list base pointer	     **/
    int		  count = 0;		/** Number of elements in the top    **/
					/** level directory list	     **/
    int		  tcount = 0;		/** Total number of files to print   **/
    char	**list;			/** flat list of module files	     **/
    int		  start = 0, i, k;
    int		  result = TCL_OK;
    Tcl_Interp	 *whatis_interp;
    Tcl_DString	  cmdbuf;
    char	  modulefile[ MOD_BUFSIZE];
    char	**wptr, *c;
    struct stat	 stats;

#if WITH_DEBUGGING_UTIL_1
    ErrorLogger( NO_ERR_START, LOC, _proc_whatis_dir, "dir='", dir, NULL);
#endif

    /**
     **	 Normal reading of the files
     **/

    if( NULL == (dirlst_head = get_dir( dir, NULL, &count, &tcount)))
	if( OK != ErrorLogger( ERR_READDIR, LOC, dir, NULL))
	    return( TCL_ERROR);		/** ------- EXIT (FAILURE) --------> **/

    if( NULL == (list = (char**) malloc( tcount * sizeof( char**))))
	if( OK != ErrorLogger( ERR_ALLOC, LOC, NULL))
	    return( TCL_ERROR);		/** ------- EXIT (FAILURE) --------> **/

    dirlst_to_list( list, dirlst_head, count, &start, NULL, NULL);

    /**
     **	 Initialize the command buffer and set up the modules flag to 'whatislay
     **	 only'
     **/

    Tcl_DStringInit( &cmdbuf);
    g_flags |= M_WHATIS;

    /**
     **	 Check all the files in the flat list for the passed tokens
     **/

    for( i=0; i<tcount; i++) {

	whatis_interp = Tcl_CreateInterp();
	if( TCL_OK != (result = InitializeModuleCommands( whatis_interp))) {
	    Tcl_DeleteInterp( whatis_interp);
	    result = TCL_ERROR;
	    break; /** for( i) **/
	}

	/**
	 **  locate the filename related to the passed module
	 **/

	/* sprintf( modulefile, "%s/%s", dir, list[ i]); */
	strcpy( modulefile, dir);
	strcat( modulefile, "/");
	strcat( modulefile, list[ i]);
	g_current_module = list[ i];

	if( stat( modulefile, &stats) || S_ISDIR( stats.st_mode))
	    continue;

	cmdModuleWhatisInit();
	result = CallModuleProcedure( whatis_interp, &cmdbuf, modulefile,
	    "ModulesApropos", 0);

	/**
	 **  Check if at least one of the passed tokens is found in the
	 **  retrieved whatis strings. If yes, print the string.
	 **/

	if( whatis) {
	    wptr = whatis;
	    while( *wptr) {

		/**
		 **  Cache output enabled?
		 **/

		if( cfp)
		    fprintf( cfp, "%-21s: %s\n", list[i], *wptr);

		/**
		 **  Ignore case?
		 **/

		if( sw_icase) {
		    strncpy( modulefile, *wptr, MOD_BUFSIZE);
		    for( c = modulefile; c && *c; c++)
			*c = tolower( *c);
		    c = modulefile;
		} else
		    c = *wptr;

		/**
		 **  Seek for the passed tokens
		 **/

		if( whatis_list)
		    fprintf( stderr, "%-21s: %s\n", list[i], *wptr);
		else
		    for( k=0; k<argc; k++) {
			if( strstr( c, argv[ k]))
		    	    fprintf( stderr, "%-21s: %s\n", list[i], *wptr);
		    }
		wptr++;
	    }
	}

	/**
	 **  Remove the Tcl interpreter that has been used for printing ...
	 **/

	Tcl_DeleteInterp( whatis_interp);
	cmdModuleWhatisShut();

    } /** for( i) **/

    /**
     **	 Cleanup
     **/

    g_flags &= ~M_WHATIS;
    delete_dirlst( dirlst_head, count);
    delete_cache_list( list, start);

#if WITH_DEBUGGING_UTIL_1
    ErrorLogger( NO_ERR_END, LOC, _proc_whatis_dir, NULL);
#endif

    return( result);

} /** End of 'whatis_dir' **/

/*++++
 ** ** Function-Header ***************************************************** **
 **									     **
 **   Function:		read_cache					     **
 **									     **
 **   Description:	Grep in the cache file for the passed tokens         **
 **									     **
 **   First Edition:	91/10/23					     **
 **									     **
 **   Parameters:	int	 argc		Number of tokens	     **
 **			char   **argv		List of tokens to check	     **
 **			FILE	*cfp		Cache file pointer	     **
 **									     **
 **   Result:		int	TCL_OK		Successfull operation	     **
 **									     **
 **   Attached Globals: -						     **
 **									     **
 ** ************************************************************************ **
 ++++*/

static	int	read_cache( int argc, char **argv, FILE *cfp, int whatis_list)
{
    char	*wptr, *c;
    char	 modulefile[ MOD_BUFSIZE];
    char	 buffer[ MOD_BUFSIZE];
    int		 k;

#if WITH_DEBUGGING_UTIL_1
/*
    ErrorLogger( NO_ERR_START, LOC, _proc_read_cache, "dir='", dir, NULL);
*/
#endif

    while( wptr = fgets( buffer, MOD_BUFSIZE, cfp)) {

	/**
	 **  Ingnore case?
	 **/

	if( sw_icase) {
	    strncpy( modulefile, wptr, MOD_BUFSIZE);
	    for( c = modulefile; c && *c; c++)
		*c = tolower( *c);
	    c = modulefile;
	} else
	    c = wptr;

	c = strchr( c, ':');
	c++;

	/**
	 **  Seek for the passed tokens
	 **/

	if ( whatis_list)
	    fprintf( stderr, "%s", wptr);
	else
	    for( k=0; k<argc; k++) {
		if( strstr( c, argv[ k]))
		    fprintf( stderr, "%s", wptr);
	    }
    }

#if WITH_DEBUGGING_UTIL_1
    ErrorLogger( NO_ERR_END, LOC, _proc_read_cache, NULL);
#endif

    return( TCL_OK);

} /** End of 'read_cache' **/

/*++++
 ** ** Function-Header ***************************************************** **
 **									     **
 **   Function:		apropos_cache					     **
 **									     **
 **   Description:	Figure out, what's the name of the apropos cache file**
 **									     **
 **   First Edition:	91/10/23					     **
 **									     **
 **   Parameters:	-						     **
 **									     **
 **   Result:		char*	NULL		No cache file configured     **
 **				Otherwise	Pointer to the file name     **
 **									     **
 **   Attached Globals: -						     **
 **									     **
 ** ************************************************************************ **
 ++++*/

static	char	*apropos_cache()
{
    static	char	 buffer[ MOD_BUFSIZE];
    char		*env, *env_file, *env_path;

#if WITH_DEBUGGING_UTIL_1
/*
    ErrorLogger( NO_ERR_START, LOC, _proc_apropos_cache, "dir='", dir, NULL);
*/
#endif

    /**
     **	 Figure out, what out global RC file is. This depends on the environ-
     **	 ment variable 'MODULEWHATISCACHE', which can be set to one of the
     **	 following:
     **
     **		<filename>	-->	INSTPATH/etc/<filename>
     **		<dir>/		-->	<dir>/RC_FILE
     **		<dir>/<file>	-->	<dir>/<file>
     **/

    if( env = getenv( "MODULEWHATISCACHE")) {

	if((char *) NULL == (env_file = strrchr( env, '/'))) {
	    env_file = env;
	    env_path = instpath;

	} else {
	    *env_file++ = '\0';
	    env_path = env;
	}
	
	if( !*env_file)
	    env_file = cache_name;

    } else {
	env_path = instpath;
	env_file = cache_name;
    }

    /**
     **	 Finaly we have to change INSTPATH -> INSTPATH/etc
     **/

    if( env_path == instpath) {
	/* sprintf( buffer, "%s/etc/%s", env_path, env_file); */
	strcpy( buffer, env_path);
	strcat( buffer, "/etc/");
	strcat( buffer, env_file);
    } else {
	/* sprintf( buffer, "%s/%s", env_path, env_file); */
	strcpy( buffer, env_path);
	strcat( buffer, "/");
	strcat( buffer, env_file);
    }

    /**
     **	 Return the name of the cache file
     **/

#if WITH_DEBUGGING_UTIL_1
    ErrorLogger( NO_ERR_END, LOC, _proc_apropos_cache, NULL);
#endif

    return( buffer);

} /** End of 'apropos_cache' **/