mux/src/help.cpp File Reference

#include "copyright.h"
#include "autoconf.h"
#include "config.h"
#include "externs.h"
#include <fcntl.h>
#include "help.h"
#include "command.h"

Include dependency graph for help.cpp:

Go to the source code of this file.

Data Structures
struct	help_entry
Defines
#define	LINE_SIZE   4096
Functions
void	helpindex_clean (int iHelpfile)
static void	HelpIndex_Start (FILE *fp)
static bool	HelpIndex_Read (help_indx *pEntry)
static void	HelpIndex_End (void)
static int	helpindex_read (int iHelpfile)
void	helpindex_load (dbref player)
void	helpindex_init (void)
static const char *	MakeCanonicalTopicName (char *topic_arg)
static void	ReportMatchedTopics (dbref executor, const char *topic, CHashTable *htab)
static bool	ReportTopic (dbref executor, struct help_entry *htab_entry, int iHelpfile, char *result)
static void	help_write (dbref executor, char *topic_arg, int iHelpfile)
static bool	ValidateHelpFileIndex (int iHelpfile)
void	do_help (dbref executor, dbref caller, dbref enactor, int key, char *message)
void	help_helper (dbref executor, int iHelpfile, char *topic_arg, char *buff, char **bufc)
Variables
static bool	bHaveTopic
static long	pos
static int	lineno
static int	ntopics
static FILE *	rfp
static char	Line [LINE_SIZE+1]
static int	nLine

---

Define Documentation

#define LINE_SIZE   4096

Definition at line 53 of file help.cpp.

Referenced by HelpIndex_Read().

---

Function Documentation

void do_help	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		char *	message
	)

Definition at line 401 of file help.cpp.

References help_write(), notify, UNUSED_PARAMETER, and ValidateHelpFileIndex().

Referenced by add_helpfile(), and FUNCTION().

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);

    int iHelpfile = key;

    if (!ValidateHelpFileIndex(iHelpfile))
    {
        notify(executor, "No such indexed file found.");
        return;
    }
    help_write(executor, message, iHelpfile);
}

void help_helper	(	dbref	executor,
		int	iHelpfile,
		char *	topic_arg,
		char *	buff,
		char **	bufc
	)

Definition at line 416 of file help.cpp.

References statedata::aHelpDesc, alloc_lbuf, free_lbuf, hashfindLEN(), HELP_DESC::ht, MakeCanonicalTopicName(), mudstate, ReportTopic(), safe_str, and ValidateHelpFileIndex().

Referenced by FUNCTION().

{
    if (!ValidateHelpFileIndex(iHelpfile))
    {
        return;
    }

    const char *topic = MakeCanonicalTopicName(topic_arg);

    CHashTable *htab = mudstate.aHelpDesc[iHelpfile].ht;
    struct help_entry *htab_entry =
        (struct help_entry *)hashfindLEN(topic, strlen(topic), htab);
    if (htab_entry)
    {
        char *result = alloc_lbuf("help_helper");
        if (ReportTopic(executor, htab_entry, iHelpfile, result))
        {
            safe_str(result, buff, bufc);
        }
        else
        {
            safe_str("#-1 ERROR", buff, bufc);
        }
        free_lbuf(result);
    }
    else
    {
        safe_str("#-1 TOPIC DOES NOT EXIST", buff, bufc);
    }
}

static void help_write	(	dbref	executor,
		char *	topic_arg,
		int	iHelpfile
	)			[static]

Definition at line 353 of file help.cpp.

References statedata::aHelpDesc, alloc_lbuf, free_lbuf, hashfindLEN(), HELP_DESC::ht, MakeCanonicalTopicName(), mudstate, notify, ReportMatchedTopics(), and ReportTopic().

Referenced by do_help().

{
    const char *topic = MakeCanonicalTopicName(topic_arg);

    CHashTable *htab = mudstate.aHelpDesc[iHelpfile].ht;
    struct help_entry *htab_entry =
        (struct help_entry *)hashfindLEN(topic, strlen(topic), htab);
    if (htab_entry)
    {
        char *result = alloc_lbuf("help_write");
        if (ReportTopic(executor, htab_entry, iHelpfile, result))
        {
            notify(executor, result);
        }
        else
        {
            notify(executor, "Sorry, that function is temporarily unavailable.");
        }
        free_lbuf(result);
    }
    else
    {
        ReportMatchedTopics(executor, topic, htab);
        return;
    }
}

void helpindex_clean

(

int

iHelpfile

)

Definition at line 26 of file help.cpp.

References statedata::aHelpDesc, hash_firstentry(), hash_nextentry(), HELP_DESC::ht, help_entry::key, MEMFREE, and mudstate.

Referenced by helpindex_read(), and main().

{
    CHashTable *htab = mudstate.aHelpDesc[iHelpfile].ht;
    if (htab == NULL)
    {
        return;
    }
    struct help_entry *htab_entry;
    for (htab_entry = (struct help_entry *)hash_firstentry(htab);
         htab_entry;
         htab_entry = (struct help_entry *)hash_nextentry(htab))
    {
        MEMFREE(htab_entry->key);
        htab_entry->key = NULL;
        MEMFREE(htab_entry);
        htab_entry = NULL;
    }
    delete mudstate.aHelpDesc[iHelpfile].ht;
    mudstate.aHelpDesc[iHelpfile].ht = NULL;
}

static void HelpIndex_End

(

void

)

[static]

Definition at line 133 of file help.cpp.

References lineno, ntopics, pos, and rfp.

Referenced by helpindex_read().

{
    pos = 0L;
    lineno = 0;
    ntopics = 0;
    rfp = NULL;
}

void helpindex_init

(

void

)

Definition at line 230 of file help.cpp.

References helpindex_load(), and NOTHING.

Referenced by main().

{
    helpindex_load(NOTHING);
}

void helpindex_load

(

dbref

player

)

Definition at line 217 of file help.cpp.

References helpindex_read(), mudstate, statedata::nHelpDesc, NOTHING, notify, and Quiet.

Referenced by do_readcache(), and helpindex_init().

{
    for (int i = 0; i < mudstate.nHelpDesc; i++)
    {
        helpindex_read(i);
    }
    if (  player != NOTHING
       && !Quiet(player))
    {
        notify(player, "Cache for help indexes refreshed.");
    }
}

static int helpindex_read

(

int

iHelpfile

)

[static]

Definition at line 141 of file help.cpp.

References statedata::aHelpDesc, alloc_lbuf, DebugTotalFiles, ENDLOG, free_lbuf, hashaddLEN(), hashfindLEN(), hashreset(), helpindex_clean(), HelpIndex_End(), HelpIndex_Read(), HelpIndex_Start(), HELP_DESC::ht, ISOUTOFMEMORY, help_entry::key, LOG_PROBLEMS, log_text(), MEMALLOC, MEMFREE, mudstate, mux_isspace, mux_strlwr(), help_entry::original, HELP_DESC::pBaseFilename, help_indx::pos, help_entry::pos, SBUF_SIZE, STARTLOG, StringCloneLen(), and help_indx::topic.

Referenced by helpindex_load().

{
    helpindex_clean(iHelpfile);

    mudstate.aHelpDesc[iHelpfile].ht = new CHashTable;
    CHashTable *htab = mudstate.aHelpDesc[iHelpfile].ht;

    char szTextFilename[SBUF_SIZE+8];
    sprintf(szTextFilename, "%s.txt", mudstate.aHelpDesc[iHelpfile].pBaseFilename);

    help_indx entry;

    FILE *fp = fopen(szTextFilename, "rb");
    if (fp == NULL)
    {
        STARTLOG(LOG_PROBLEMS, "HLP", "RINDX");
        char *p = alloc_lbuf("helpindex_read.LOG");
        sprintf(p, "Can't open %s for reading.", szTextFilename);
        log_text(p);
        free_lbuf(p);
        ENDLOG;
        return -1;
    }
    DebugTotalFiles++;
    int count = 0;
    HelpIndex_Start(fp);
    while (HelpIndex_Read(&entry))
    {
        // Convert the entry to all lowercase letters and add all leftmost
        // substrings.
        //
        // Topic names which appear earlier in the help file have priority
        // over topics names which appear later in the help file.  That is,
        // we do not associate prefixes with this topic if they have already
        // been used on a previous topic.
        //
        mux_strlwr(entry.topic);
        bool bOriginal = true; // First is the longest.
        int nTopic = strlen(entry.topic);

        for (nTopic = strlen(entry.topic); nTopic > 0; nTopic--)
        {
            if (mux_isspace(entry.topic[nTopic-1]))
            {
                continue;
            }
            struct help_entry *htab_entry = (struct help_entry *)MEMALLOC(sizeof(struct help_entry));
            ISOUTOFMEMORY(htab_entry);
            htab_entry->pos = entry.pos;
            htab_entry->original = bOriginal;
            bOriginal = false;
            htab_entry->key = StringCloneLen(entry.topic, nTopic);

            if (!hashfindLEN(entry.topic, nTopic, htab))
            {
                hashaddLEN(entry.topic, nTopic, htab_entry, htab);
                count++;
            }
            else
            {
                MEMFREE(htab_entry->key);
                htab_entry->key = NULL;
                MEMFREE(htab_entry);
                htab_entry = NULL;
            }
        }
    }
    HelpIndex_End();
    if (fclose(fp) == 0)
    {
        DebugTotalFiles--;
    }
    hashreset(htab);
    return count;
}

static bool HelpIndex_Read

(

help_indx *

pEntry

)

[static]

Definition at line 67 of file help.cpp.

References bHaveTopic, help_indx::len, Line, LINE_SIZE, lineno, Log, nLine, ntopics, help_indx::pos, pos, rfp, CLogFile::tinyprintf(), help_indx::topic, and TOPIC_NAME_LEN.

Referenced by helpindex_read().

{
    for (;;)
    {
        while (nLine == 0)
        {
            if (fgets(Line, LINE_SIZE, rfp) == NULL)
            {
                if (bHaveTopic)
                {
                    pEntry->len = (int)(pos - pEntry->pos);
                    bHaveTopic = false;
                    return true;
                }
                return false;
            }
            ++lineno;

            nLine = strlen(Line);
            if (  nLine > 0
               && Line[nLine - 1] != '\n')
            {
                Log.tinyprintf("HelpIndex_Read, line %d: line too long\n", lineno);
            }
        }

        if (Line[0] == '&')
        {
            if (bHaveTopic)
            {
                pEntry->len = (int)(pos - pEntry->pos);
                bHaveTopic = false;
                return true;
            }

            ++ntopics;
            char *topic = Line + 1;
            while (  *topic == ' '
                  || *topic == '\t'
                  || *topic == '\r')
            {
                topic++;
            }
            char *s;
            int i;
            memset(pEntry->topic, 0, sizeof(pEntry->topic));
            for (i = -1, s = topic; *s != '\n' && *s != '\r' && *s != '\0'; s++)
            {
                if (i >= TOPIC_NAME_LEN - 1)
                {
                    break;
                }
                if (*s != ' ' || pEntry->topic[i] != ' ')
                {
                    pEntry->topic[++i] = *s;
                }
            }
            pEntry->topic[++i] = '\0';
            pEntry->pos = pos + (long)nLine;
            bHaveTopic = true;
        }
        pos += nLine;
        nLine = 0;
    }
}

static void HelpIndex_Start

(

FILE *

fp

)

[static]

Definition at line 57 of file help.cpp.

References bHaveTopic, lineno, nLine, ntopics, pos, and rfp.

Referenced by helpindex_read().

{
    pos = 0L;
    lineno = 0;
    ntopics = 0;
    rfp = fp;
    bHaveTopic = false;
    nLine = 0;
}

static const char* MakeCanonicalTopicName

(

char *

topic_arg

)

[static]

Definition at line 235 of file help.cpp.

References mux_strlwr().

Referenced by help_helper(), and help_write().

{
    const char *topic;
    if (topic_arg[0] == '\0')
    {
        topic = "help";
    }
    else
    {
        mux_strlwr(topic_arg);
        topic = topic_arg;
    }
    return topic;
}

static void ReportMatchedTopics	(	dbref	executor,
		const char *	topic,
		CHashTable *	htab
	)			[static]

Definition at line 250 of file help.cpp.

References alloc_lbuf, free_lbuf, hash_firstentry(), hash_nextentry(), help_entry::key, mudstate, notify, help_entry::original, quick_wild(), safe_chr, safe_str, tprintf(), and statedata::wild_invk_ctr.

Referenced by help_write().

{
    bool matched = false;
    char *topic_list = NULL;
    char *buffp = NULL;
    struct help_entry *htab_entry;
    for (htab_entry = (struct help_entry *)hash_firstentry(htab);
         htab_entry != NULL;
         htab_entry = (struct help_entry *)hash_nextentry(htab))
    {
        mudstate.wild_invk_ctr = 0;
        if (  htab_entry->original
           && quick_wild(topic, htab_entry->key))
        {
            if (!matched)
            {
                matched = true;
                topic_list = alloc_lbuf("help_write");
                buffp = topic_list;
            }
            safe_str(htab_entry->key, topic_list, &buffp);
            safe_chr(' ', topic_list, &buffp);
            safe_chr(' ', topic_list, &buffp);
        }
    }
    if (!matched)
    {
        notify(executor, tprintf("No entry for '%s'.", topic));
    }
    else
    {
        notify(executor, tprintf("Here are the entries which match '%s':", topic));
        *buffp = '\0';
        notify(executor, topic_list);
        free_lbuf(topic_list);
    }
}

static bool ReportTopic	(	dbref	executor,
		struct help_entry *	htab_entry,
		int	iHelpfile,
		char *	result
	)			[static]

Definition at line 288 of file help.cpp.

References statedata::aHelpDesc, alloc_lbuf, HELP_DESC::bEval, DebugTotalFiles, ENDLOG, EV_EVAL, EV_FIGNORE, EV_NO_COMPRESS, free_lbuf, LBUF_SIZE, LOG_PROBLEMS, log_text(), mudstate, mux_exec(), HELP_DESC::pBaseFilename, help_entry::pos, safe_str, SBUF_SIZE, and STARTLOG.

Referenced by help_helper(), and help_write().

{
    char szTextFilename[SBUF_SIZE+8];
    sprintf(szTextFilename, "%s.txt", mudstate.aHelpDesc[iHelpfile].pBaseFilename);

    int offset = htab_entry->pos;
    FILE *fp = fopen(szTextFilename, "rb");
    if (fp == NULL)
    {
        STARTLOG(LOG_PROBLEMS, "HLP", "OPEN");
        char *line = alloc_lbuf("ReportTopic.open");
        sprintf(line, "Can't open %s for reading.", szTextFilename);
        log_text(line);
        free_lbuf(line);
        ENDLOG;
        return false;
    }
    DebugTotalFiles++;
    if (fseek(fp, offset, 0) < 0L)
    {
        STARTLOG(LOG_PROBLEMS, "HLP", "SEEK");
        char *line = alloc_lbuf("ReportTopic.seek");
        sprintf(line, "Seek error in file %s.", szTextFilename);
        log_text(line);
        free_lbuf(line);
        ENDLOG;
        if (fclose(fp) == 0)
        {
            DebugTotalFiles--;
        }
        return false;
    }
    char *line = alloc_lbuf("ReportTopic");
    char *bp = result;
    for (;;)
    {
        if (  fgets(line, LBUF_SIZE - 1, fp) == NULL
           || line[0] == '&'
           || line[0] == '\0')
        {
            break;
        }

        bool bEval = mudstate.aHelpDesc[iHelpfile].bEval;
        if (bEval)
        {
            char *str = line;
            mux_exec(result, &bp, executor, executor, executor,
                     EV_NO_COMPRESS | EV_FIGNORE | EV_EVAL, &str, (char **)NULL, 0);
        }
        else
        {
            safe_str(line, result, &bp);
        }
    }
    *bp = '\0';
    if (fclose(fp) == 0)
    {
        DebugTotalFiles--;
    }
    free_lbuf(line);
    return true;
}

static bool ValidateHelpFileIndex

(

int

iHelpfile

)

[static]

Definition at line 380 of file help.cpp.

References alloc_mbuf, ENDLOG, free_mbuf, LOG_BUGS, log_text(), statedata::mHelpDesc, mudstate, and STARTLOG.

Referenced by do_help(), and help_helper().

{
    if (  iHelpfile < 0
       || mudstate.mHelpDesc <= iHelpfile)
    {
        char *buf = alloc_mbuf("do_help.LOG");
        STARTLOG(LOG_BUGS, "BUG", "HELP");
        sprintf(buf, "Unknown help file number: %d", iHelpfile);
        log_text(buf);
        ENDLOG;
        free_mbuf(buf);
        return false;
    }
    return true;
}

---

Variable Documentation

bool bHaveTopic [static]

Definition at line 47 of file help.cpp.

Referenced by HelpIndex_Read(), and HelpIndex_Start().

char Line[LINE_SIZE+1] [static]

Definition at line 54 of file help.cpp.

Referenced by HelpIndex_Read().

int lineno [static]

Definition at line 49 of file help.cpp.

Referenced by HelpIndex_End(), HelpIndex_Read(), and HelpIndex_Start().

int nLine [static]

Definition at line 55 of file help.cpp.

Referenced by getstring_noalloc(), HelpIndex_Read(), and HelpIndex_Start().

int ntopics [static]

Definition at line 50 of file help.cpp.

Referenced by HelpIndex_End(), HelpIndex_Read(), and HelpIndex_Start().

long pos [static]

Definition at line 48 of file help.cpp.

Referenced by FUNCTION(), HelpIndex_End(), HelpIndex_Read(), and HelpIndex_Start().

FILE* rfp [static]

Definition at line 51 of file help.cpp.

Referenced by HelpIndex_End(), HelpIndex_Read(), and HelpIndex_Start().

---