Source Code 1992 March/Source_Code_CD-ROM_Walnut_Creek_March_1992.iso/usenet/altsrcs/2/2956

Internet Message Format | 1991-03-04 | 50.9 KB

From: [e-mail] (Liam R. E. Quin)
Newsgroups: alt.sources
Subject: lq-text Full Text Retrieval Database Part 08/13
Message-ID: <[e-mail]>
Date: 4 Mar 91 02:07:23 GMT

: cut here --- cut here --
: To unbundle, sh this file
#! /bin/sh
: part 08
echo x - lq-text/src/lqtext/lqword.c 1>&2
sed 's/^X//' >lq-text/src/lqtext/lqword.c <<'@@@End of lq-text/src/lqtext/lqword.c'
X/* lqword.c -- Copyright 1989 Liam R. Quin.  All Rights Reserved.
X * This code is NOT in the public domain.
X * See the file COPYRIGHT for full details.
X */
X
X/* lqword -- simple program to print information about individual words.
X *
X * $Id: lqword.c,v 2.8 90/10/06 00:51:00 lee Rel1-10 $
X */
X
X#include "globals.h" /* defines and declarations for database filenames */
X
X#include <stdio.h>
X#include <sys/types.h>
X#include <malloc.h>
X#include <fcntl.h> /* for fileinfo.h */
X#include <ctype.h>
X
X#ifdef BSD
X# define USI_MAX ((unsigned int) -1)
X#else
X# include <limits.h>
X  /* for USI_MAX, the largest unsigned integer.
X   * 4.3 BSD doesn't seem to have this.  I don't know how to get this
X   * on BSD systems.
X   */
X#endif
X
X#include "fileinfo.h"
X#include "wordinfo.h"
X#include "smalldb.h"
X#include "pblock.h"
X#include "wordrules.h"
X#include "emalloc.h"
X
X/*** Declarations: ***/
X/** System calls and library routines: **/
Xextern void exit();
X
X/** System calls: **/
X
X/** Unix Library Functions: **/
Xextern char *strncpy();
X#ifndef tolower
X extern int tolower();
X#endif
X
X/** lqtext library functions: **/
Xextern char *UnFlag();
Xextern t_WordInfo *WID2WordInfo();
Xextern int TooCommon();
Xextern void cleanupdb();
Xextern void SetDefaults();
Xextern void DefaultUsage();
Xextern void DeleteWord();
X
X/** functions defined within this file: */
Xvoid PrintWordInfo(), AllWordInfo();
Xvoid Display(), ShowWordList();
Xvoid dbmmarch();
X
X/** Macros and variable definitions **/
X
X#define DISPLAY_ALL 1
X#define DISPLAY_NAME 2
X    /* These are the possible DisplayMode values -- see main() */
X
Xchar *progname = 0;
X    /* Used for error messages */
X
Xint SilentMode = 0;
X    /* Set if we were invoked with the -s option.  In this mode, we behave
X     * like grep -s, and exit with a zero exit status if one or more of
X     * the words were found in the database.
X     */
X
Xint ListMode = 0;
X    /* Set if we are to provide a terser output format suitable for use
X     * with lqshow(1L).
X     */
X
Xint AsciiTrace = 0;
X    /* If this is non-zero, we provide debugging information.  The lqtext
X     * library also uses this variable.  Setting it to values greater
X     * than 1 or 2 will generally provide large amounts of debugging
X     * information.  If the library was compiled with -UASCIITRACE,
X     * however, there will be much less diagnostic output at higher
X     * levels.
X     */
X
Xstatic char *Revision = "lqword 2.2";
X
X/** end of declarations... **/
X
X
Xint
Xmain(argc, argv)
X    int argc;
X    char *argv[];
X{
X    extern int optind, getopt();  /* For getopt(3) */
X    extern char *optarg;      /* For getopt(3) */
X    int ch;              /* For getopt(3) */
X    int ErrorFlag = 0;          /* For getopt(3) */
X    int DisplayMode = 0;
X    /* DisplayMode indicates what kind of information we are to
X     * print in response to queries.  The values understood are
X     * the DISPLAY_* constants.  Perhaps this should be an enum.
X     */
X
X    progname = argv[0];
X    /* I see this as a library program, so I am leaving the full
X     * path.  lqaddfile(1L) and lqphrase(1L) set progname to be
X     * the filename of the command, rather than the full pathname.
X     */
X
X    SetDefaults(argc, argv);
X    /* Deal with any arguments that are understood by all lqtext
X     * programs.
X     */
X
X    while ((ch = getopt(argc, argv, "aAD:lsVxZz:")) != EOF) {
X    switch (ch) {
X    case 'a':
X        DisplayMode = DISPLAY_NAME;
X        break;
X    case 'A':
X        DisplayMode = DISPLAY_ALL;
X        break;
X    case 'D':
X        DeleteWord(optarg); /* MISFEATURE */
X        /* This actually removes all entries for the given word
X         * from the database.  You need write permission, of
X         * course.
X         */
X        break;
X    case 'l':
X        ListMode = 1;
X        break;
X    case 's':
X        SilentMode = 1;
X        break;
X    case 'V':
X        fprintf(stderr, "%s version %s\n", progname, Revision);
X        break;
X    case 'x':
X        ErrorFlag++;
X        break;
X    case '?':
X        ErrorFlag++;
X        break;
X    case 'z':
X    case 'Z':
X        break; /* done by SetDefaults(); */
X    }
X    }
X
X    /* Normally put call to lrqError here to give a helpful message,
X     * but not yet ready to ship the error handling package, sorry
X     */
X    if (ErrorFlag) {
X    fprintf(stderr, "%s: options are:\n", progname);
X    fputs("\
X    -D Word -- delete the named word (DANGEROUS!)\n\
X    -l    -- list mode, for use with lqshow\n\
X    -s    -- silent mode (like grep -s)\n", stderr);
X    DefaultUsage();
X        /* DefaultUsage() prints the list of the standard options. */
X    fputs("\n\
XIn addition, if no words are given, the following are understood:\n\
X    -a    -- print all words\n\
X    -A    -- print all matches to all words\n", stderr);
X    exit(1);
X    }
X
X    if (optind >= argc) {
X    if (SilentMode) exit(1);
X        /* if there were no words given, none of them matched.
X         * It could be argued that this case should be an error.
X         */
X    if (DisplayMode) {
X        AllWordInfo(DisplayMode);
X    } else {
X        /* In this case, there were no command-line options and no
X         * display-mode flags, so we do the default thing.
X         * This happens to be to print every word in the database.
X         * This is probably bogus behaviour -- there should be a better
X         * way of finding words that match a given pattern than using
X         * lqword | grep
X         * which is what this allows.
X         */
X        dbmmarch();
X    }
X    } else {
X    if (!SilentMode && !ListMode) {
X        /* Print some pretty headers */
X        printf("       WID | Where   | Total   | Word\n");
X        puts(
X"===========|=========|=========|============================================");
X    }
X
X    while (optind < argc) {
X        PrintWordInfo(argv[optind++]);
X    }
X    }
X    cleanupdb();
X    /* close database files.  This is particularly important if we are
X     * updating the database -- the horrible -D option -- but should
X     * probably be done by liblqtext itself.
X     */
X    exit(SilentMode); /* 0 or 1 (this is a little devious) */
X#ifdef lint
X    /*NOTREACHED*/
X    return 1;
X    /* this is for versions of lint and gcc that don't understand
X     * that exit() doesn't return -- or, if it douse, that there is
X     * nothing that can be done about it!
X     */
X#endif
X}
X
Xvoid
XPrintWordInfo(Word)
X    char *Word;
X{
X    extern t_WordInfo *FindWordInfoFromIndex();
X    extern long atol();
X    extern t_WID Word2WID();
X    extern char *WordRoot();
X
X    register char *p;
X    t_WordInfo *WordInfo;
X    t_WID WID;
X    t_WordInfo Root;
X
X    Root.WordPlace.Flags = 0;
X
X    /** Find the canonical form of the word, with plurals reduced to the
X     ** singular and letters folded into lower case.
X     **/
X
X    /* First, remember if the word originally started with an upper case
X     * letter:
X     */
X    if (isupper(*Word)) {
X    Root.WordPlace.Flags |= WPF_UPPERCASE;
X    }
X
X    /* now convert to lower case and measure its length at the same time: */
X    for (p = Word; *p; p++) {
X    if (isupper(*p)) *p = tolower(*p);
X    }
X
X    Root.Length = p - Word;
X    Root.Word = Word;
X
X    /* Now call WordRoot() to find the canonical form: */
X    Word = WordRoot(&Root);
X
X    /** Now see if the canonical word is too common to list: **/
X
X    if (TooCommon(&Root)) {
X    /* It is listed in the common word list, so don't bother looking
X     * it up at all
X     */
X    if (!SilentMode) {
X        fprintf(stderr, "No index information for: %s (too common)\n",
X                                    Word);
X    }
X    return;
X    }
X
X    /** It is not too common, so look it up: **/
X
X    if (((WID = Word2WID(Word, Root.Length)) == (t_WID) 0) ||
X    (WordInfo = WID2WordInfo(WID)) == (t_WordInfo *) 0) {
X    if (!SilentMode) {
X        if (WID) {
X        /* In this case the word is in the database (since it has
X         * a non-zero WID), but not in the word index.  This might
X         * happen if the word is being deleted (or added) by someone
X         * else at this very moment, or if the database is corrupt.
X         */
X        fprintf(stderr, "No index information for: %s (WID %lu)\n",
X                                Word, WID);
X        } else {
X        /* In this case the word is neither listed as common nor
X         * found in the database.  Either it was spelt differently
X         * there or it isn't there at all.
X         */
X        fprintf(stderr, "No index information for: %s\n", Word);
X        }
X    }
X    return;
X    }
X    if (SilentMode && WordInfo->NumberOfWordPlaces > 0) {
X    /* We found something, so there is no point looking further --
X     * we already know enough to exit.  If a lot of words are given,
X     * this could be a big efficiency win.
X     */
X    exit(0);
X    }
X
X    /** Now we have the database entry for the word, so let's print it!
X     **/
X    Display(WordInfo, DISPLAY_ALL);
X
X    /** Now return the storage used...
X     **/
X    if (WordInfo) {
X    SlayWordInfo(WordInfo);
X    }
X
X    /** All done for this word.
X     **/
X}
X
X/* Display() -- print information about a single word */
Xvoid
XDisplay(WordInfo, Verbose)
X    t_WordInfo *WordInfo;
X    int Verbose;
X{
X    char *Buf = emalloc(WordInfo->Length + 1);
X
X    /* Words in a t_WordInfo might not be null terminated, since the
X     * storage overhead and the work of putting the nulls there might
X     * be significant...
X     */
X    (void) strncpy(Buf, WordInfo->Word, WordInfo->Length);
X    Buf[WordInfo->Length] = '\0';
X
X    if (!ListMode) {
X    /* Print a little header for the word, unless we were asked not to */
X    printf("%10lu | %7lu | %7lu | %s\n", WordInfo->WID,
X                         WordInfo->Offset,
X                         WordInfo->NumberOfWordPlaces,
X                         WordInfo->Word
X    );
X
X    }
X    if ((ListMode || Verbose == DISPLAY_ALL) && WordInfo->NumberOfWordPlaces) {
X    /* If  there are occurrences in the database (there might not be if
X     *     the word has been deleted, or has only just been added),
X     * and  we want all the matches,
X     * then  print the list of matches in the appropriate format:
X     */
X    ShowWordList(WordInfo);
X    }
X
X    (void) efree(Buf);
X    /* reclaim storage */
X}
X
Xvoid
XShowWordList(WordInfo)
X    t_WordInfo *WordInfo;
X{
X    extern t_pblock *Getpblock();
X    t_FileInfo *GetFileInfo();
X
X    t_FileInfo *FileInfo = (t_FileInfo *) 0;
X    t_pblock *pblock = (t_pblock *) 0;
X    t_WordPlace *PP = (t_WordPlace *) 0;
X    int Place;
X    char *LastRoot = "[internal error lqword.c 392]";
X    /* the message is in case I make a coding error!.  The number
X     * was once the line number of the message, but it only needs to
X     * be a distinct enough message to search for.
X     */
X
X    if (WordInfo->WordPlacesInHere >= WordInfo->NumberOfWordPlaces) {
X    /* In this case, the match info all fits in the index, so it
X     * does not matter if automatic pre-fetching from the overflow
X     * file "data" happens or not (i.e. if we are using Lazy Evaluation,
X     * it doesn't happen, but it makes no difference in this case).
X     */
X    PP = WordInfo->WordPlaces;
X    } else if ((pblock = Getpblock(WordInfo)) != (t_pblock *) 0) {
X    PP = pblock->WordPlaces;
X    /* If Lazy Evaluation is enabled, liblqtext might not have fetched
X     * all of the match information from the overflow database, in
X     * which case we must do it now.
X     */
X    }
X
X    if (PP) {
X    t_FID LastFID = USI_MAX;
X        /* This is not a plausible FID (File IDentifier), so it
X         * will force a call to GetFileInfo() in the loop below.
X         */
X    unsigned int LastFlags = 256 * 2;
X        /* Similarly, this is an impossible flag value, since the
X         * flags are constrained to fit in a single byte.
X         */
X
X    /* cycle through the Place... */
X    for (Place = 0; Place < WordInfo->NumberOfWordPlaces; Place++) {
X
X        char BIF[100]; char WIB[100];
X        register char *p;
X        char *Bp, *Wp;
X        long l;
X
X        if (LastFlags != PP[Place].Flags) {
X        LastFlags = PP[Place].Flags;
X        LastRoot = UnFlag(WordInfo, LastFlags);
X            /* UnFlag() takes a canonical (singular, lower-case)
X             * word and a set of flags, and reverses the
X             * transformations implied by the flags.  For example,
X             * if WordInfo->Word is "boy" and flags contain the
X             * Plural flag, you should get "boys" returned.
X             * Since we don't remember whether a word was in all
X             * caps or had only the first letter capitalised (at
X             * the moment, anyway), the routine will return Boys
X             * even if the input was BOYS or BoYs.
X             * Possessives (the boy's books) may also be indicated.
X             */
X        }
X
X        if (LastFID != PP[Place].FID || FileInfo == (t_FileInfo *) 0) {
X        /* The first part of the test means we don't call the
X         * function to retrieve the file name lots of times if
X         * there are multiple matches in the same data file.
X         * This turns out to be a common case.
X         */
X
X        /* Reclaim storage */
X        if (FileInfo) {
X            if (FileInfo->Name) {
X            (void) efree(FileInfo->Name);
X            }
X            (void) efree(FileInfo);
X        }
X
X        /* Find the file name from the FID.  This routine should
X         * be called FID2FileName(), and may in fact be renamed
X         * in the future.
X         */
X        if ((FileInfo = GetFileInfo(LastFID = PP[Place].FID)) ==
X                        (t_FileInfo *) 0) {
X            /* No filename information available.  This sometimes
X             * happens if you rin lqword diring an lqaddfile
X             * session and match a word in one of the new files.
X             * Note that if the output is for reuse, we don't
X             * want to include references to files whose names
X             * we don't have!
X             */
X            if (!ListMode) {
X            printf("%20s | %-.5lu/%-.3lu | [FID %d]\n",
X                LastRoot,
X                PP[Place].BlockInFile,
X                PP[Place].WordInBlock,
X                PP[Place].FID);
X            }
X            continue;
X        }
X        }
X
X        /* This is an inline printf, because otherwise this call
X         * to printf takes over 20% of the execution time, and nearly
X         * 40% for a frequent word (e.g. over 1000 places) !!
X         */
X        p = &BIF[sizeof(BIF) - 1];
X        *p = '\0';
X        if (PP[Place].BlockInFile == 0) {
X        *--p = '0';
X        } else for (l = PP[Place].BlockInFile; l; l /= 10) {
X        *--p = "0123456789"[l % 10];
X        }
X        Bp = p;
X
X        p = &WIB[sizeof(WIB) - 1];
X        *p = '\0';
X        {
X        register int i = PP[Place].WordInBlock;
X        if (i == 0) {
X            *--p = '0';
X        } else for (; i; i /= 10) {
X            *--p = "0123456789"[i % 10];
X        }
X        Wp = p;
X        }
X
X          if (ListMode) {
X        while (*Bp) {
X            putchar(*Bp);
X            Bp++;
X        }
X        putchar(' ');
X        while (*Wp) {
X            putchar(*Wp);
X            Wp++;
X        }
X        putchar(' ');
X        puts(FileInfo->Name);
X          } else {
X        /* Well, if we are not reusing the output, maybe the speed
X         * is not quite so critical...
X         */
X          printf("%20s | %5lu/%3lu F=%3u S=%3u | %s\n",
X            LastRoot,
X            PP[Place].BlockInFile,
X            PP[Place].WordInBlock,
X            PP[Place].Flags, /* XXX */
X            PP[Place].StuffBefore,
X            FileInfo->Name);
X        }
X    }
X    }
X
X    if (pblock) {
X    /* If we had to go and get the matches ourselves, we had better
X     * release the storage.
X     * Actually we should also be freeing the FileInfo and possibly
X     * the WordInfo as well, but the pblock is the biggest... and I
X     * am only adding comments today, not fixing code (I hope)...
X     * NOTDONE FIXME
X     */
X    (void) efree(pblock);
X    }
X}
X
Xvoid
XAllWordInfo(Verbose)
X    int Verbose;
X{
X    extern char *WID2Word();
X    extern t_WID GetMaxWID();
X
X    t_WID i;
X    t_WID MaxWid = GetMaxWID();
X    t_WordInfo *WordInfo;
X    char *Name;
X
X    /* Loop over all possible WID numbers and print information
X     * for each of them.
X     */
X    for (i = (t_WID) 1; i <= MaxWid; i++) {
X    if ((Name = WID2Word(i)) != (char *) 0) {
X
X        /* If Name is zero, that WID is unused.  There might be gaps
X         * if a word was deleted.
X         */
X
X        if ((WordInfo = WID2WordInfo(i)) != (t_WordInfo *) 0) {
X        Display(WordInfo, Verbose);
X        SlayWordInfo(WordInfo);
X        } else {
X        /* In this case the word is known, but there is no further
X         * information about it.  In the current inplementation,
X         * this cannot happen unless someone else is updating the
X         * database and replacing a WID whose word had been deleted.
X         */
X        if (!ListMode) {
X            /* If we are in list mode, it is probably because the
X             * output is wanted by another prpgram, so we had
X             * better not print out this (useless) entry.
X             */
X            printf("%10lu | %7lu |           | ?? %s\n",
X            i, 0L, Name);
X        }
X        }
X
X        /* Reclaim the storage used... */
X        (void) efree(Name);
X    } /* end if */
X    } /* for each WID */
X
X    if (!ListMode) {
X    printf("Maximum WID is %lu\n", MaxWid);
X    }
X}
X
X/* dbmmarch -- print every value in a dbm database.  This might go
X * wrong (omitting some values) if the database is being concurrently
X * updated.
X */
Xvoid
Xdbmmarch()
X{
X    DBM *db;
X    datum d;
X
X    if ((db = startdb(WordIndex)) == (DBM *) 0) {
X    /* WordIndex is the list of words, defined in "globals.h".
X     * If we didn't open it, the user probably has not set
X     * $LQTEXTDIR, or didn't use the -d database-dir option that
X     * is handled bu SetDefaults() called from main().
X     */
X    fprintf(stderr, "Can't open database file \"%s\"\n", WordIndex);
X    exit(1);
X    }
X
X    /* The word database contains WID-->word matches, that look like
X     * (key = "Word", content = WID)
X     */
X    for (d = dbm_firstkey(db); d.dsize != 0; d = dbm_nextkey(db)) {
X    register char *s;
X
X    /* IMPORTANT NOTE:
X     * The words are not nul-terminated in the database.  It is
X     * therefore not safe to use printf() or puts() unless we make
X     * a copy or are careful...
X     */
X    for (s = d.dptr; s - d.dptr < d.dsize; s++) {
X        putchar(*s);
X    }
X    putchar('\n');
X    }
X    enddb(db);
X}
X
X/*
X * $Log:    lqword.c,v $
X * Revision 2.8  90/10/06  00:51:00  lee
X * Prepared for first beta release.
X *
X * Revision 2.7  90/08/29  21:45:37  lee
X * Alpha release
X *
X * Revision 2.6  90/08/08  22:22:53  lee
X * Added heavy comments.  Cleaned up dbmmarch() and made some other
X * minor fixes.
X *
X * Revision 2.5  90/08/08  21:06:21  lee
X * Added -x option; removed rude message about getpts bugs.
X *
X * Revision 2.4  90/04/21  18:50:38  lee
X * fixed a serious bug in the -l mode -- now prints the entire match!
X *
X * Revision 2.3  90/03/27  13:20:57  lee
X * now passes gcc -Wall
X *
X * Revision 2.2  89/10/08  20:47:23  lee
X * Working version of nx-text engine.  Addfile and wordinfo work OK.
X *
X * Revision 2.1  89/10/02  01:16:10  lee
X * New index format, with Block/WordInBlock/Flags/BytesSkipped info.
X *
X * Revision 1.3  89/09/17  23:04:42  lee
X * Various fixes; NumberInBlock now a short...
X *
X * Revision 1.2  89/09/16  21:18:50  lee
X * First demonstratable version.
X *
X * Revision 1.1  89/09/07  21:06:14  lee
X * Initial revision
X *
X */
@@@End of lq-text/src/lqtext/lqword.c
echo x - lq-text/src/lqtext/matchword.sh 1>&2
sed 's/^X//' >lq-text/src/lqtext/matchword.sh <<'@@@End of lq-text/src/lqtext/matchword.sh'
X:
X# matchword pattern [...] -- grep for words in the database
X#
X# matchword -- Copyright 1990 Liam R. Quin.  All Rights Reserved.
X# This code is NOT in the public domain.
X# See the file ../COPYRIGHT for full details.
X#
X# $Id: matchword.sh,v 1.2 90/10/06 00:51:02 lee Rel1-10 $
X#
X
X# "echo" portability test:
XN=; C='\c'; if [ x"`echo -n hello`" = x"hello" ]; then N=-n;C=; fi
Xexport N C
X
Xans=no
Xwhile [ x"$ans" != x"q" ]
Xdo
X    echo $N "Enter a word or pattern: $C"
X    read pattern
X    if [ x"$pattern" = x"q" ]
X    then
X    break
X    fi
X    WORDS=`lqword | grep "^${pattern}\$"`
X    if [ "$WORDS" = "" ]
X    then echo "(no match in the database for ${pattern})"
X    else echo `echo "$WORDS" | wc -l` words found:
X     echo "$WORDS" | sort -d | rs | ${PAGER-more}
X     # If you don't have rs, you could use cat instead.
X     # PAGER could also be "pg -nse", or "less -q".
X    fi
Xdone
X
@@@End of lq-text/src/lqtext/matchword.sh
echo x - lq-text/src/lqtext/sizes.c 1>&2
sed 's/^X//' >lq-text/src/lqtext/sizes.c <<'@@@End of lq-text/src/lqtext/sizes.c'
X/* sizes.c -- Copyright 1990 Liam R. Quin.  All Rights Reserved.
X * This code is NOT in the public domain.
X * See the file COPYRIGHT for full details.
X */
X
X#ifndef lint
X static char *Rcs = "$Id: sizes.c,v 1.3 90/10/06 00:51:03 lee Rel1-10 $";
X#endif
X
X#include "globals.h" /* defines and declarations for database filenames */
X
X#include <stdio.h>
X#include <sys/types.h>
X#include "fileinfo.h"
X#include "wordinfo.h"
X#include "pblock.h"
X#include "wordrules.h"
X#include "wordindex.h"
X
Xmain()
X{
X    printf("FileInfo  %u bytes\n", sizeof(t_FileInfo));
X    printf("WordInfo  %u bytes\n", sizeof(t_WordInfo));
X    printf("WordPlace %u bytes\n", sizeof(t_WordPlace));
X    printf("pblock    %u bytes\n", sizeof(t_pblock));
X}
@@@End of lq-text/src/lqtext/sizes.c
echo x - lq-text/src/lqtext/wordtable.c 1>&2
sed 's/^X//' >lq-text/src/lqtext/wordtable.c <<'@@@End of lq-text/src/lqtext/wordtable.c'
X/* wordtable.c -- Copyright 1989, 1990 Liam R. Quin.  All Rights Reserved.
X * This code is NOT in the public domain.
X * See the file ../COPYRIGHT for full details.
X */
X
X/* Symbol Table Interface to text retrieval database.
X * Handles both the internal and external indexes.
X *
X * This originally used a linked list.  Converting to a hash table reduced
X * the time to index comp.os.vms from nearly an hour to one and a half
X * minutes...
X *
X * Liam Quin, 1989
X */
X
X/*
X * $Id: wordtable.c,v 2.11 91/02/20 19:07:37 lee Rel1-10 $
X */
X
X#ifndef lint
X static char *Rcs = "$Id: wordtable.c,v 2.11 91/02/20 19:07:37 lee Rel1-10 $";
X#endif
X
X#include "globals.h" /* defines and declarations for database filenames */
X
X#ifdef SYSV
Xextern int _filbuf();
X#endif
X#include <stdio.h>
X#include <malloc.h>
X#include <ctype.h>
X#include <sys/types.h>
X#include <fcntl.h> /* for O_RDWR wtc */
X#include "smalldb.h"
X#include "fileinfo.h"
X#include "wordinfo.h"
X#include "pblock.h"
X#include "wordrules.h"
X#include "emalloc.h"
X
X#define HASHSIZ 32768 /* MUST be a power of two */
X
X#ifndef MAXWORDSINCACHE
X# define MAXWORDSINCACHE  (HASHSIZ * 10)
X#endif
Xint MaxWordsInCache = MAXWORDSINCACHE;
X
Xextern int AsciiTrace;
X
X/* useful macros */
X#define NumberOfElements(array, type) (sizeof(array)/sizeof(type))
X#define STRCMP(a,b) ((*(a) > *(b)) ? 1 : ((*(a) < *(b)) ? -1 : strcmp(a,b)) )
X/* #define Hash(WordInfo) \
X *    (dbm_hash(WordInfo->Word, WordInfo->Length) % HashSize)
X */
X
X/** System calls and library functions used in this file: **/
X
X/** Lqtext calls */
Xextern unsigned int Putpblock();
Xextern void DeleteWordPlaces();
X
X/** System calls: */
X
X/** Library Functions: */
Xextern char *strncpy();
Xextern int strcmp();
Xextern void perror();
Xextern void exit();
X/**/
X
X#define enew(var, type) (var = (type *) emalloc(sizeof (type)))
X
Xextern char *progname;
Xstatic int HashSize = HASHSIZ; /* MUST be a power of two */
X
X#ifdef NEWSYM
X
X#define NPLACES 7
X/* THis is small to optimise the common case -- by far the majority of
X * words are used less than 10 times.  In the cases where we've gone
X * wrong, well, there'll be a few thousand.
X */
X
Xtypedef struct s_HashEl {
X    char *Word;
X    t_WID WID;
X    int PlacesUsed;
X    t_WordPlace Places[NPLACES];
X    struct s_HashEl *Next;
X} t_HashEl;
X
Xstatic t_HashEl *SymbolTable;
Xstatic t_HashEl *LastEl;
Xstatic int WordsInCache = 0;
X
XStartHash()
X{
X    if (MaxWordsInCache) HashSize = MaxWordsInCache / 16;
X    SymbolTable = (t_HashEl *) emalloc(sizeof(t_HashEl) * HashSize);
X    /* Note that we only need to initialise the Word pointers... */
X    for (LastEl = SymbolTable; LastEl != &SymbolTable[HashSize]; LastEl++) {
X    LastEl->Word = (char *) 0;
X    }
X    /* ASSERT: LastEl == &SymbolTable[HashSize] */
X    MaxWordsInCache = HashSize;
X}
X
XSetElEmpty(El)    /* Initialisation function for Hash Elements */
X    t_HashEl *El;
X{
X    El->Word = (char *) 0;
X    El->WID = (t_WID) -1;
X        /* NOT zero, so we can distinguish between unknown and
X         * "haven't looked"
X         */
X    El->PlacesUsed = 0;
X    El->Next = (t_HashEl *) 0;
X}
X
Xvoid DumpCache();
X
Xvoid
XAddWord(WordInfo)
X    t_WordInfo *WordInfo;
X{
X    register t_HashEl *HashEl;
X    int Slot;
X    t_HashEl *FirstEl;
X
X    if (!WordInfo || !WordInfo->Word || !WordInfo->Word[0]) {
X    (void) fprintf(stderr, "%s: warning: Null Word in AddWord\n", progname);
X    return;
X    }
X
X    if (!LastEl) {
X    StartHash();
X    } else if (MaxWordsInCache && ++WordsInCache > MaxWordsInCache) {
X    DumpCache(1);
X    }
X
X    if (WordInfo->Word[0] == 'q') {
X    register char *xp;
X
X    for (xp = &WordInfo->Word[1]; *xp && *xp == 'x'; xp++) {
X        /*NULLBODY*/
X    }
X    if (!*xp) {
X        if (AsciiTrace >= 10) {
X        (void) fprintf(stderr, "Discard %d\n", WordInfo->Word);
X        }
X        return;
X    }
X    }
X
X    Slot = Hash(WordInfo);
X    FirstEl = HashEl = &SymbolTable[Slot];
X
X
X    for (;;) {
X    if (!HashEl->Word) {
X        extern char *strcpy();
X        extern t_WID Word2WID();
X
X        if (AsciiTrace > 9) {
X        (void) fprintf(stderr, "New ", WordInfo->Word);
X        }
X        /* make a new element */
X        SetElEmpty(HashEl);
X        HashEl->Word = emalloc(WordInfo->Length + 1);
X        (void) strcpy(HashEl->Word, WordInfo->Word);
X        /**
X        HashEl->WID = (t_WID) -1;
X        **/
X        HashEl->WID = Word2WID(HashEl->Word, WordInfo->Length);
X        /** **/
X        break;
X    } else if (STREQ(HashEl->Word, WordInfo->Word)) {
X        break;
X    }
X
X    if (++HashEl == LastEl) HashEl = SymbolTable;
X
X    if (HashEl == FirstEl) {
X        /* We need to dump the cache and start again */
X        DumpCache(1);
X        AddWord(WordInfo);
X        return;
X    }
X    }
X    /* If we get here, all we need to do is add the WordPlace */
X    if (AsciiTrace > 9) {
X    (void) fprintf(stderr, "AddWord %s\n", WordInfo->Word);
X    }
X    FirstEl = HashEl;
X
X    while (HashEl->PlacesUsed >= NPLACES && HashEl->Next != (t_HashEl *) 0) {
X    HashEl = HashEl->Next;
X    }
X
X    if (HashEl->PlacesUsed >= NPLACES) {
X    t_HashEl *New;
X
X    New = (t_HashEl *) malloc(sizeof(t_HashEl));
X    SetElEmpty(New);
X
X    New->Next = FirstEl->Next;
X    FirstEl->Next = HashEl = New;
X    }
X    HashEl->Places[HashEl->PlacesUsed] = WordInfo->WordPlace; /* structure copy */
X    HashEl->PlacesUsed++;
X    return;
X}
X
Xvoid
XDumpCache(CallFree)
X    int CallFree;
X{
X    register t_HashEl *HashEl, *MeNext;
X    int Progress = 0;
X
X    for (HashEl = SymbolTable; HashEl != LastEl; HashEl++) {
X    if (HashEl->Word) {
X        extern t_WordInfo *MakeWordInfo();
X        unsigned len;
X        t_WordInfo *WP;
X
X        /* We are going to make a new index entry for the word.
X         * There are two cases -- depending on whether the word
X         * is already indexed or not.
X         * In the former case we must merge the new information.
X         * In the latter case we don't have to read the old info,
X         * but we must make a new entry in the WID Index.
X         */
X
X        len = strlen(HashEl->Word);
X        if (HashEl->WID == (t_WID) -1) {
X        HashEl->WID = Word2WID(HashEl->Word, len);
X        }
X        WP = MakeWordInfo(HashEl->WID, len, HashEl->Word);
X
X        if (HashEl->WID == (t_WID) 0) {
X        NewEntry(HashEl, WP);
X        } else {
X        UpdateEntry(HashEl, WP);
X        }
X        /* Reclaim storage */
X        if (CallFree) {
X        extern void SlayWordInfo();
X        register t_HashEl *FreeMe = HashEl;
X
X        (void) SlayWordInfo(WP);
X
X        efree(HashEl->Word);
X        FreeMe->Word = (char *) 0;
X        FreeMe = FreeMe->Next; /* don't do the first one */
X        while (FreeMe) {
X            MeNext = FreeMe->Next;
X            (void) efree((char *) FreeMe);
X            FreeMe = MeNext;
X        }
X        }
X    }
X    if (AsciiTrace > 1) {
X        if (HashEl - SymbolTable >= Progress * (HashSize / 16)) {
X        fputc(" 01234567890ABCDEFGHIJKL"[Progress], stderr);
X        ++Progress;
X        }
X    }
X    }
X    WordsInCache = 0;
X}
X
XNewEntry(HashEl, WP)
X    t_HashEl *HashEl;
X    t_WordInfo *WP;
X{
X    extern t_WID GetNextWID();
X    t_pblock *pblock;
X    long MatchCount;
X    t_HashEl *Ep;
X
X    /** Assign a new WID */
X    WP->WID = GetNextWID();
X
X    /** make a WIDIndex entry and mark it as invalid (NOTDONE) */
X
X    /* In order to do this, we must make a "pblock", a structure that
X     * reflects the physical database.  This is fairly low-level stuff
X     * for efficiency's sake...
X     */
X
X    /* count the total number of entries we're adding: */
X    for (Ep = HashEl, MatchCount = 0; Ep; Ep = Ep->Next) {
X    MatchCount += Ep->PlacesUsed;
X    }
X
X    /* allocate a pblock structure.  These are rather devious things, a
X     * structure with an array tacked onto the end.
X     */
X    pblock = (t_pblock *) emalloc(sizeof(t_pblock) +
X                MatchCount * sizeof(t_WordPlace));
X
X    pblock->WID = WP->WID;
X    pblock->ChainStart = 0L; /* address on disk -- not there yet, so 0! */
X    pblock->NumberOfWordPlaces = WP->NumberOfWordPlaces = MatchCount;
X
X    /* fill in the WordPlaces */
X    for (Ep = HashEl, MatchCount = 0; Ep; Ep = Ep->Next) {
X    register int i;
X
X    for (i = 0; i < Ep->PlacesUsed; i++) {
X        pblock->WordPlaces[MatchCount++] = Ep->Places[i]; /* struct copy */
X    }
X    }
X
X    /* Now fill in enough of WP to let us use the low-level routines: */
X    WP->FID = (t_FID) 0;
X    WP->Next = (t_WordInfo *) 0;
X    WP->DataBlock = (char *) 0;
X    WP->WordPlaceStart = (char *) 0;
X    WP->WordPlaces = (t_WordPlace *) 0;
X    WP->WordPlacesInHere = 0;
X    WP->WordPlace.FID = 0;
X    WP->WordPlace.Flags = 0;
X    WP->Offset = 0;
X
X    /* First, let's make an index entry: */
X#ifndef MaxWordPlacesInAWordBlock
X# define MaxWordPlacesInAWordBlock ((WIDBLOCKSIZE-(WP->Length+2)/3))
X#endif
X    if (pblock->NumberOfWordPlaces <= MaxWordPlacesInAWordBlock) {
X    (void) MkWIB(WP, pblock);
X    }
X
X    /** write out the new entry */
X    if (WP->WordPlacesInHere == pblock->NumberOfWordPlaces) {
X    /* In this case it all fits into the main index */
X    if (PutWordInfoIntoIndex(WP, (unsigned long) 0L) < 0) {
X        extern int errno;
X        int e = errno;
X        fprintf(stderr, "%s: Couldn't insert word \"%s\" into the index",
X                progname, WP->Word);
X        perror("");
X        exit(1);
X    }
X    } else {
X    (void) Putpblock(WP, pblock);
X    if (PutWordInfoIntoIndex(WP, pblock->ChainStart) < 0) {
X        extern int errno;
X        int e = errno;
X        fprintf(stderr, "%s: Couldn't re-insert word \"%s\" into the index",
X                progname, WP->Word);
X        perror("");
X        exit(1);
X    }
X    }
X
X    /** mark it as valid (NOTDONE) */
X
X    /** reclaim storage */
X    (void) efree((char *) pblock);
X    /* the caller *must* do SlayWordInfo(WP) */
X}
X
XUpdateEntry(HashEl, WP)
X    t_HashEl *HashEl;
X    t_WordInfo *WP;
X{
X    extern t_pblock *Getpblock();
X    extern t_WordInfo *WID2WordInfo();
X    t_pblock *pblock;
X    long MatchCount;
X    t_HashEl *Ep;
X    t_WordInfo *Wpp;
X
X    /** Mark the old entry as invalid (NOTDONE) */
X
X    /** get the old entry */
X    if ((Wpp = WID2WordInfo(WP->WID)) == (t_WordInfo *) 0) {
X    /* someone else has just deleted it! */
X    NewEntry(HashEl, WP);
X    return;
X    }
X    /* It would be best if we could append to the old entry... which is what
X     * I had in mind when I designed the disk storage stuff... but you can't.
X     */
X    pblock = Getpblock(Wpp);
X
X    /** merge the old and new entries */
X
X    /* count the total number of entries we're adding: */
X    for (Ep = HashEl, MatchCount = 0; Ep; Ep = Ep->Next) {
X    MatchCount += Ep->PlacesUsed;
X    }
X
X    pblock = (t_pblock *) erealloc((char *) pblock, sizeof(t_pblock) +
X         (Wpp->NumberOfWordPlaces + MatchCount) * sizeof(t_WordPlace));
X
X    /* delete the old entry from disk */
X    if (Wpp->Offset) {
X    DeleteWordPlaces(Wpp->Offset, Wpp->WID);
X    }
X
X    /* fill in the WordPlaces */
X    for (Ep = HashEl, MatchCount = 0; Ep; Ep = Ep->Next) {
X    register int i;
X
X    for (i = 0; i < Ep->PlacesUsed; i++) {
X        pblock->WordPlaces[pblock->NumberOfWordPlaces++] =
X                    Ep->Places[i]; /* struct copy */
X    }
X    }
X
X    Wpp->Offset = 0L; /* it's invalid now... */
X    Wpp->WordPlacesInHere = 0;
X
X    /* First, let's make an index entry: */
X    if (pblock->NumberOfWordPlaces <= MaxWordPlacesInAWordBlock) {
X    (void) MkWIB(WP, pblock);
X    }
X
X    /** write out the new entry */
X    if (Wpp->WordPlacesInHere == pblock->NumberOfWordPlaces) {
X    /* In this case it all fits into the main index */
X    if (PutWordInfoIntoIndex(Wpp, (unsigned long) 0L) < 0) {
X        extern int errno;
X        int e = errno;
X        fprintf(stderr, "%s: Couldn't insert word \"%s\" into the index",
X                progname, Wpp->Word);
X        perror("");
X        exit(1);
X    }
X    } else {
X    (void) Putpblock(Wpp, pblock);
X    if (PutWordInfoIntoIndex(Wpp, pblock->ChainStart) < 0) {
X        extern int errno;
X        int e = errno;
X        fprintf(stderr, "%s: Couldn't re-insert word \"%s\" into the index",
X                progname, Wpp->Word);
X        perror("");
X        exit(1);
X    }
X    }
X
X    /** mark it as valid (NOTDONE) */
X
X    /** reclaim storage */
X    (void) efree((char *)pblock);
X    /* the caller *must* do SlayWordInfo(WP) */
X    (void) SlayWordInfo(Wpp);
X}
X
X#else /* NEWSYM */
Xstatic t_WordPlaceList *SymbolTable[HASHSIZ]; /* static --> initialised to 0 */
X#endif /* NEWSYM */
X
X#ifdef __GNU__
Xinline
X#endif
X#ifndef Hash
Xint
XHash(WordInfo)
X    t_WordInfo *WordInfo;
X{
X    register unsigned long n = 0;
X    register int len = WordInfo->Length;
X    register char *str = WordInfo->Word;
X
X#ifdef DUFF /* clever stuff for speedup... dmr-approved!... */
X
X#define HASHC    n = *str++ + 65599 * n
X
X    if (len > 0) {
X    register int loop = (len + 8 - 1) >> 3;
X
X    switch(len & (8 - 1)) {
X    case 0:    do {
X        HASHC;    case 7:    HASHC;
X    case 6:    HASHC;    case 5:    HASHC;
X    case 4:    HASHC;    case 3:    HASHC;
X    case 2:    HASHC;    case 1:    HASHC;
X        } while (--loop);
X    }
X
X    }
X#else /* DUFF */
X    while (len--)
X    n = *str++ + 65599 * n;
X#endif /* DUFF */
X    /**
X    return n & (HashSize - 1);
X    **/
X    return n % HashSize;
X}
X#endif
X
Xstatic int HashOK = 0;
X
Xvoid
XInitHash()
X{
X    HashOK = 1;
X}
X
X#ifndef NEWSYM
Xstatic int WordsInCache = 0;
X
X/* FIXME: this ought to taks a WordInfo and a WordPlaceList instead.
X * Using a hash table means that we can end up with really pathalogical
X * paging pehaviour.  Nearly all of lqaddfile is resident when running
X * on a Sun.  Hence, I shall be replacing this code entirely soon with
X * something that has less memory fragmentation, perhaps by coalescing
X * list members or with a tree.
X * For now, MaxWordsInCache is a parameter that you can set to zero if
X * you want.
X *
X * Also, the cache structure should be cleaver enough to avoid writing
X * out the more common words if it can, so as to minimise the number
X * of data _fetches_ that have to be done.
X * You could also argue that it should be more efficient to add new data,
X * of course.  I couldn't disagree.
X *
X * Next change required is to make AddWord do a little more of the work --
X * in particular, to call Word2WID for each new word, in an attempt to
X * make cache dumping faster.
X */
X
XAddWord(WordInfo) /* old version */
X    t_WordInfo *WordInfo;
X{
X    int Slot;
X    int GreaterOrLess = 1;
X    t_WordPlaceList *SaveOldNext;
X    t_WordPlaceList **WPL;
X
X    if (!HashOK) InitHash();
X
X    /* The following are all awfully serious internal errors.
X     * They will only happen if I make a huge coding error, whereupon
X     * they tend to happen for every word in the input...
X     */
X    if (!WordInfo) {
X    fprintf(stderr, "AddWord(0)\n");
X    return;
X    } else if (!WordInfo->Word) {
X    fprintf(stderr, "AddWord(Word=0)\n");
X    return;
X    } else if (!WordInfo->Word[0]) {
X    fprintf(stderr, "AddWord(Word[0]=0)\n");
X    return;
X#ifdef ASCIITRACE
X    } else if (AsciiTrace > 20) {
X    fprintf(stderr, "[%s.len %d]\n", WordInfo->Word, WordInfo->Length);
X#endif
X    }
X
X    Slot = Hash(WordInfo);
X
X#ifdef ASCIITRACE
X    if (AsciiTrace > 10) {
X    fprintf(stderr, "H %d %s\n", Slot, WordInfo->Word);
X    }
X#endif
X
X    if (WordInfo->Word[0] == 'q') {
X    register char *p = WordInfo->Word;
X
X    /* Words of the form qxxxxx* are not indexed.  This is so the filters
X     * can preprocess the files without upsetting the word counts.
X     * If you can think of a better way to do this, well, tell me!
X     * Lee
X     */
X
X    for (++p; p - WordInfo->Word < WordInfo->Length; p++) {
X        if (*p != 'x') break;
X    }
X
X    if (p - WordInfo->Word == WordInfo->Length) {
X#ifdef ASCIITRACE
X        if (AsciiTrace > 10) {
X        (void) fprintf(stderr, "rejected %s (too boring)\n",
X                    WordInfo->Word);
X        }
X#endif
X        return;
X    }
X    }
X
X    for (WPL = &SymbolTable[Slot]; *WPL; WPL = &((*WPL)->Next)) {
X    if ((GreaterOrLess = STRCMP((*WPL)->Word, WordInfo->Word)) <= 0) {
X        break;
X    }
X    }
X
X    /* Insert the new word at the head of the Word Chain,
X     * i.e. at the start of the group of similar words
X     */
X    SaveOldNext = *WPL;
X
X    enew(*WPL, t_WordPlaceList);
X    (*WPL)->WordPlace = WordInfo->WordPlace; /* structure copy */
X    (*WPL)->WordPlace.FID = WordInfo->WordPlace.FID;
X    (*WPL)->Next = SaveOldNext;
X
X    if (GreaterOrLess || !SaveOldNext) {
X    (*WPL)->Word = emalloc(WordInfo->Length + 1);
X    (void) strncpy((*WPL)->Word, WordInfo->Word, (int) WordInfo->Length);
X    (*WPL)->Word[WordInfo->Length] = '\0';
X    } else {
X    /* The word is already saved, so we only need to link to it */
X    (*WPL)->Word = SaveOldNext->Word;
X    }
X    if (MaxWordsInCache && ++WordsInCache > MaxWordsInCache) {
X    void DumpCache();
X
X    DumpCache(1);
X    WordsInCache = 0;
X    }
X}
X
Xvoid
XDumpCache(CallFree)
X    int CallFree; /* call efree() if non-zero */
X{
X    extern int WriteWordChain();
X
X    register int Slot;
X    register t_WordPlaceList *WordPlaceList;
X    int WordsLeft = WordsInCache;
X    int EmptySlots = 0, UsedSlots = 0;
X    int Progress = 0;
X
X    if (WordsInCache == 0) return; /* save some work maybe */
X
X    if (AsciiTrace) {
X    fprintf(stderr, "Writing%s%d words\n",
X            (CallFree) ? " and freeing " : " ", WordsInCache);
X    }
X
X    for (Slot = 0; WordsLeft > 0 && Slot < HASHSIZ; Slot++) {
X
X    if (AsciiTrace > 1) {
X        if (Slot >= Progress * (HASHSIZ / 16)) {
X        fputc(" 01234567890ABCDEFGHIJKL"[Progress], stderr);
X        ++Progress;
X        }
X    }
X    if (SymbolTable[Slot] == (t_WordPlaceList *) 0) {
X        ++EmptySlots;
X        continue;
X    } else {
X        char *LastFreed = (char *) 0;
X
X        ++UsedSlots;
X        WordPlaceList = SymbolTable[Slot];
X        WordsLeft -= WriteWordChain(WordPlaceList);
X
X        if (CallFree) {
X        while (WordPlaceList) {
X            register t_WordPlaceList *SavePointer;
X
X            if (WordPlaceList->Word &&
X                    WordPlaceList->Word != LastFreed) {
X            efree(WordPlaceList->Word);
X            LastFreed = WordPlaceList->Word;
X            }
X
X            SavePointer = WordPlaceList->Next;
X            efree((char *) WordPlaceList);
X            WordPlaceList = SavePointer;
X        }
X        SymbolTable[Slot] = (t_WordPlaceList *) 0;
X        }
X    }
X    }
X
X    if (AsciiTrace) {
X    double d = UsedSlots;
X    d /= (EmptySlots + UsedSlots);
X    d *= 100.0;
X
X    fprintf(stderr, "%4.3f%% cache used -- %d out of (%d <= %d)\n",
X            d, UsedSlots, UsedSlots + EmptySlots, HASHSIZ);
X#ifdef MALLOCTRACE
X    mallocmap();
X#endif
X    }
X
X    if (WordsInCache != 0 && CallFree) {
X    WordsInCache = 0;
X    }
X}
X
X#endif /*!NEWSYM*/
X
X/*
X * $Log:    wordtable.c,v $
X * Revision 2.11  91/02/20  19:07:37  lee
X * The qxxx fix only worked if ASCIITRACE was defined!
X *
X * Revision 2.10  90/10/06  00:51:05  lee
X * Prepared for first beta release.
X *
X * Revision 2.9  90/10/05  23:44:30  lee
X * Major experimentation with new symbol table failed...
X *
X * Revision 2.8  90/09/26  19:45:02  lee
X * Added call to mallocmap() in ifdef MALLTRACE.
X *
X * Revision 2.7  90/09/20  18:58:25  lee
X * Added some comments, and deleted a needless test.  Reorderered a loop
X * in the (probably vain) hope of a speed-up in the face of paging...
X *
X * Revision 2.6  90/09/19  20:25:44  lee
X * Don't index "qxxxxxxxx" words (this is a hook for filters...)
X *
X * Revision 2.5  90/08/29  21:46:11  lee
X * Alpha release
X *
X * Revision 2.4  90/08/09  19:17:37  lee
X * BSD lint and Saber
X *
X * Revision 2.3  90/03/21  17:32:31  lee
X * new hashing function, masses, masses better -- the old one only ever
X * used abuot 6% of the available values!
X *
X * Revision 2.2  89/10/08  20:47:47  lee
X * Working version of nx-text engine.  Addfile and wordinfo work OK.
X *
X * Revision 2.1  89/10/02  01:16:22  lee
X * New index format, with Block/WordInBlock/Flags/BytesSkipped info.
X *
X * Revision 1.3  89/09/17  23:05:15  lee
X * Various fixes; NumberInBlock now a short...
X *
X * Revision 1.2  89/09/16  21:18:55  lee
X * First demonstratable version.
X *
X * Revision 1.1  89/09/07  21:06:20  lee
X * Initial revision
X *
X */
@@@End of lq-text/src/lqtext/wordtable.c
echo x - lq-text/src/menu/Makefile 1>&2
sed 's/^X//' >lq-text/src/menu/Makefile <<'@@@End of lq-text/src/menu/Makefile'
X# Makefile for simple curses-based menu interface.
X#
X# $Id: Makefile,v 1.3 90/10/06 01:28:02 lee Rel1-10 $
X
XPWD=menu
X
X# PERFORMANCE makes curses go faster
XEXTRA=-I../h -DPERFORMANCE
XOPT=-O -g
XDEFS= -DASCIITRACE -UBSD -DSYSV
XWHICHDBM=sdbm
X# change the next three lines to be the same as the lq-text definitions.
XDBMLIBS=$(LIBDIR)/libsdbm.a
XBCOPY=bcopy.o
X# DBMLIBS=-lndbm -linet # 386/ix with hbtcpip provides a good bcopy()
X
XCFLAGS= $(OPT) $(DEFS) -UBSD -DSYSV $(GCCF) -D$(WHICHDBM) $(EXTRA)
XCC=gcc
XTERMCAP=-lcurses
XRANLIB=ranlib
X
XTEXT=lqtext
XPROG=m # a simple example of using the library...
XPROGOBJS=example.o
XPROGSRC=example.c
XLIBDIR=../lib
XBINDIR=../bin
XLIAMLIB=$(LIBDIR)/liblq.a
XLQTEXTLIB=$(LIBDIR)/liblqtext.a
XMENULIB=liblqmenu.a
X
XPROGS=$(PROG) $(TEXT) # removed by make clean
X
XOBJS=menu.o error.o stringbox.o OldCurses.o
XSRCS=menu.c error.c stringbox.c OldCurses.c
X
Xall: $(TEXT) m
X
Xinstall: $(MENULIB) $(TEXT)
X    cp $(MENULIB) $(LIBDIR)/$(MENULIB)
X    cp $(TEXT) $(BINDIR)/$(TEXT)
X    strip $(BINDIR)/$(TEXT)
X
X$(TEXT): text.o $(LQTEXTLIB) $(LIAMLIB) $(MENULIB) $(BCOPY)
X    $(CC) $(CFLAGS) -o $(TEXT) text.o $(BCOPY) \
X    $(MENULIB) $(LQTEXTLIB) $(DBMLIBS) $(LIAMLIB) $(TERMCAP)
X
X$(MENULIB): $(OBJS)
X    rm -f $(MENULIB)
X    ar rv $(MENULIB) $(OBJS)
X    $(RANLIB) $(MENULIB)
X
X$(PROG): $(PROGOBJS)
X    $(CC) $(CFLAGS) -o $(PROG) $(OBJS) $(PROGOBJS) $(BCOPY) $(TERMCAP)
X
Xlint$(PROG): $(OBJS) $(SRCS) $(PROGSRCS)
X    lint $(CFLAGS) $(SRCS) $(TERMCAP) 2>&1 | tee lint$(PROG)
X
X# Tidy should leave the final executables, but otherwise remove all
X# generated files
Xtidy:
X    /bin/rm -f *.o core make.log .mk m.log
X
X# Clean should revert to a distribution state as far as possible
Xclean:
X    /bin/rm -f *.o core *.a $(PROGS) $(CHARGEN) make.log .mk m.log
X
Xtext.o: text.c
X    $(CC) $(CFLAGS) $(TEXTINC) -c text.c
X
X
Xdepend:
X    mkdep $(CFLAGS) *.c
X
X#
X# $Log:    Makefile,v $
X# Revision 1.3  90/10/06  01:28:02  lee
X# deleted mkdep output.
X#
X# Revision 1.2  90/10/01  20:33:09  lee
X# Added BSD compatibility hooks and improved "make clean".
X#
X# Revision 1.1  90/08/29  21:48:48  lee
X# Initial revision
X#
X# Revision 2.1  89/08/07  13:52:22  lee
X# First fully working release; this is the basis for all
X# future development.
X#
X# Revision 1.2  89/08/04  17:59:23  lee
X# Fully working with Basic Functionality.
X# Scrolling menubar, scrolling menus, moveable Info windows.
X#
X# Revision 1.1  89/07/27  11:41:39  lee
X# Initial revision
X#
X
X# DO NOT DELETE THIS LINE -- mkdep uses it.
X# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY.
X
X# IF YOU PUT ANYTHING HERE IT WILL GO AWAY
@@@End of lq-text/src/menu/Makefile
echo x - lq-text/src/menu/README 1>&2
sed 's/^X//' >lq-text/src/menu/README <<'@@@End of lq-text/src/menu/README'
XThis directory contains as much as necessary of my curses menu library
Xto demonstrate lq-text.  (and I just saw some more files I could remove...)
XThis is a fairly simple curses-based front end to the lq-text text retrieval
Xsoftware.
X
XIt has only been tested on System V Release 3.2, and almost certainly will
Xnot work on anything else without at least a little effort.
X
XSee the notes on porting below if you want to try...
X
XPlease do not ask me for the rest of the package.  If I get the time and the
Xnecessary facilities, I will make it available.  I am hoping to have a
Xversion which will run with no source changes under X windows as well as
Xunder Curses, but it is not trivial...  What you see here is a hacked version,
Xin order to minimise what I post.  Sorry.
X
X
XTo install:
X
X(1) You need to have lq-text already.
X    Make it and test that it works, for example by indexing the unix man pages.
X    In particular, check that lqphrase works with two-word phrases.  If it
X    doesn't, there is little point in proceeding.
X
X(2) You will need to edit Makefile in this directory to point to the directory
X    containing the lq-text source:
X    Change the defintion of $(NX) as appropriate -- for example,
X    NX=../../../src/lq-text/src
X    or something.
X
X(3) make text
X
X(4) ln text lqtext (if you want)
X
X(5) try it.  If you don't have working function keys, you can use ESC
X    followed by a digit (e.g. ESC 1 is the same as F1), and when you are
X    entering phrases, ^D at the start of the line will take you back to the
X    main menu just as F1 does.
X
X    **>>> You will need to have lqshow in your path for this to work. <<<**
X    **>>> You will need want to set $LQTEXTDIR, or use the -d option.
X    see the man page for lq-text for command-line options to "text".
X
X    Try
X    from the File menu, select "new words"
X    (you can type 'x' for an explanation at any point in the menus)
X
X    type some words or phrases
X
X    select "match all" from the "All Words" menu
X
X    the numbers by the phrases indicate the number of matches;
X    you can then do "browse all" from the "All Words" menu.
X
X    To exit, press "q" from the main menu, or select "Finish" from the
X    Main Menu.
X
X    When you have typed 'x', a box will appear containing an explanation.
X    You can type 'x' at this point for an explanation of what to do with
X    the box... for example, you can move the explain-box around the sceen
X    or resize it if you want.  I have no idea why you would want to do
X    this, but it can be a little fun for people who are bored... and is
X    a facility that came for free from my curses/menu package...
X
X(6) You might also like to try making "m", and running examples/vsh, which
X    is a simple shell-script.  It is not meant to be a useful shell -- just
X    a tiny demo I wrote at home in some spare time...
X
X
X(7) Now investigate internal.h and menu.h if you want to change things.
X    If you change these, go back to step (3)
X
XLee
Xsq.com
XThu Dec 14 21:06:34 EST 1989
@@@End of lq-text/src/menu/README
echo x - lq-text/src/menu/bcopy.c 1>&2
sed 's/^X//' >lq-text/src/menu/bcopy.c <<'@@@End of lq-text/src/menu/bcopy.c'
X#ifdef BCOPYTEST
X# include <stdio.h>
X#endif
X
X/* this is a simple replacement for bcopy() where the native bcopy()
X * does not handle overlapping blocks.
X * do
X *    cc -DBCOPYTEST -o bcopy bcopy.c
X * and run "./bcopy" for a simple test.  You should get three
X * identical lines of output.
X */
X
Xbcopy(src, dest, nbytes)
X    char *dest;
X    char *src;
X    int nbytes;
X{
X    /* We have to be clever about this...
X     * If src < dest then we copy from the top down
X     * otherwise, copy from the bottom up...
X     */
X
X    register char *p, *q;
X
X    if (src < dest) {
X    for (p = &src[nbytes - 1], q = &dest[nbytes - 1]; nbytes--; q--, p--) {
X        *q = *p;
X    }
X    } else {
X    for (p = src, q = dest; nbytes--; p++, q++) {
X        *q = *p;
X    }
X    }
X}
X
X#ifdef BCOPYTEST
Xmain()
X{
X    char buffer[4096];
X    char *s = "The naked children hugged each other";
X
X    puts(s); /* first line */
X    (void) sprintf(&buffer[12], "%s", s);
X    bcopy(&buffer[12], buffer, strlen(s) + 1);
X    printf("[%s]\n", buffer); /* 2nd line */
X    bcopy(buffer, &buffer[12], strlen(s) + 1);
X    printf("[%s]\n", &buffer[12]); /* 3rd line */
X}
X#endif
@@@End of lq-text/src/menu/bcopy.c
echo x - lq-text/src/menu/OldCurses.c 1>&2
sed 's/^X//' >lq-text/src/menu/OldCurses.c <<'@@@End of lq-text/src/menu/OldCurses.c'
X/* Compatibility routines for older versions of curses...
X * $Id: OldCurses.c,v 1.2 90/10/04 16:27:58 lee Rel1-10 $
X *
X */
X
X#include <curses.h>
X#include <ctype.h>
X
X#ifndef A_STANDOUT
X#include "oldcurses.h"
X
X#undef CONTROL
X#define CONTROL(c) (c ^ 64)
X
X#undef wgetch
X
Xchtype
XLqwgetch(w)
X    WINDOW *w;
X{
X    int ch = wgetch(w);
X
X    if (isprint(ch)) return ch;
X
X    switch (ch) {
X    case CONTROL('^'): return KEY_HOME;
X    case CONTROL('P'): return KEY_UP;
X    case CONTROL('N'): return KEY_DOWN;
X    case CONTROL('B'): return KEY_LEFT;
X    case CONTROL('F'): return KEY_RIGHT;
X    case CONTROL('X'): return KEY_HELP; /* Xplain.... (groan) */
X    case '\033': /* Escape */
X    (void) fprintf(stderr, "ESC\007");
X    (void) fflush(stderr);
X
X    switch (ch = wgetch(w)) {
X    case 0:        return KEY_F0;
X    case 1:        return KEY_F(1);
X    case 2:        return KEY_F(2);
X    case 3:        return KEY_F(3);
X    case 4:        return KEY_F(4);
X    case 5:        return KEY_F(5);
X    case 6:        return KEY_F(6);
X    case 7:        return KEY_F(7);
X    case 8:        return KEY_F(8);
X    case 9:        return KEY_F(9);
X    case 'a': case 'A':    return KEY_F(10);
X    case 'b': case 'B':    return KEY_F(11);
X    case 'c': case 'C':    return KEY_F(12);
X    case 'd': case 'D':    return KEY_F(13);
X    case 'e': case 'E':    return KEY_F(14);
X    case 'f': case 'F':    return KEY_F(15);
X    case 'h':    return KEY_HELP;
X    }
X    break;
X    }
X    return ch;
X}
X
Xvoid
Xbeep()
X{
X    (void) putc('\b', stderr);
X    (void) fflush(stderr);
X}
X
Xvoid
Xbox(win, vert, hor)
X    WINDOW *win;
X    int vert;
X    int hor;
X{
X#undef box
X    if (hor == 0) hor = ACS_HLINE;
X    if (vert == 0) vert = ACS_VLINE;
X    box(win, vert, hor);
X}
X
Xvoid
XLqattrset(win, attr)
X    WINDOW *win;
X    int attr;
X{
X    if (attr) {
X    wstandout(win);
X    } else {
X    wstandend(win);
X    }
X}
X
Xwnoutrefresh(win)
X    WINDOW *win;
X{
X    touchwin(win);
X}
X#endif
X
X/* $Log:    OldCurses.c,v $
X * Revision 1.2  90/10/04  16:27:58  lee
X * SysV compat improved.
X *
X * Revision 1.1  90/10/03  21:54:04  lee
X * Initial revision
X *
X *
X */
@@@End of lq-text/src/menu/OldCurses.c
echo x - lq-text/src/menu/oldcurses.h 1>&2
sed 's/^X//' >lq-text/src/menu/oldcurses.h <<'@@@End of lq-text/src/menu/oldcurses.h'
X/* oldcurses.h -- compatibility with pre-System V.3 curses...
X * $Id: oldcurses.h,v 1.2 90/10/04 16:28:31 lee Rel1-10 $
X */
X
Xtypedef int chtype;
X
X#define ACS_LARROW    '>'
X#define ACS_RARROW    '<'
X#define ACS_HLINE    '='
X#define ACS_VLINE    '|'
X#define ACS_LRCORNER    '+'
X#define ACS_LLCORNER    '+'
X
X/* Line drawing: */
X#define ACS_BSSS    '+'    /* T-piece */
X#define ACS_SBSS    '+'    /* -| */
X#define ACS_SSBS    '+'    /* inverted T-piece */
X#define ACS_SSSB    '+'    /* |- */
X#define ACS_BBSS    '+'    /* top right corner */
X#define ACS_BSSB    '+'    /* bottom left corner */
X
X#define KEY_DOWN    257
X#define KEY_UP      258
X#define KEY_LEFT    259
X#define KEY_RIGHT    260
X#define KEY_HELP    261
X#define KEY_HOME    262
X#define KEY_F0        300
X#define KEY_F(n)    (KEY_F0+n)
X
X#undef getch
X#define getch()    Lqwgetch(stdscr)
X#define wgetch    Lqwgetch
X
X#undef box
X#define box LqBox
X
X#define A_STANDOUT 1
X#undef standout
X#undef standend
X#define wattrset Lqattrset
X#define attrset(a) Lqattrset(stdscr, a)
X#define keypad(win, bool)    1 /* ignore this one please */
X
X/* $Log:    oldcurses.h,v $
X * Revision 1.2  90/10/04  16:28:31  lee
X * SysV compat improved.
X *
X * Revision 1.1  90/10/03  21:56:32  lee
X * Initial revision
X *
X *
X */
@@@End of lq-text/src/menu/oldcurses.h
echo end of part 08
--
Liam R. E. Quin,  [e-mail], SoftQuad Inc., Toronto, [phone]