mux/src/stringutil.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	MUX_STRTOK_STATE
struct	ANSI_ColorState
struct	ANSI_In_Context
struct	ANSI_Out_Context
struct	tag_itl
struct	BMH_State
struct	ArtRuleset
struct	PARSE_FLOAT_RESULT
Defines
#define	mux_isprint(x)   (mux_isprint[(unsigned char)(x)])
#define	mux_isdigit(x)   (mux_isdigit[(unsigned char)(x)])
#define	mux_ishex(x)   (mux_ishex[(unsigned char)(x)])
#define	mux_isazAZ(x)   (mux_isazAZ[(unsigned char)(x)])
#define	mux_isalpha(x)   (mux_isalpha[(unsigned char)(x)])
#define	mux_isalnum(x)   (mux_isalnum[(unsigned char)(x)])
#define	mux_islower(x)   (mux_islower[(unsigned char)(x)])
#define	mux_isupper(x)   (mux_isupper[(unsigned char)(x)])
#define	mux_isspace(x)   (mux_isspace[(unsigned char)(x)])
#define	mux_hex2dec(x)   (mux_hex2dec[(unsigned char)(x)])
#define	mux_toupper(x)   (mux_toupper[(unsigned char)(x)])
#define	mux_tolower(x)   (mux_tolower[(unsigned char)(x)])
#define	mux_AttrNameInitialSet(x)   (mux_AttrNameInitialSet[(unsigned char)(x)])
#define	mux_AttrNameSet(x)   (mux_AttrNameSet[(unsigned char)(x)])
#define	mux_ObjectNameSet(x)   (mux_ObjectNameSet[(unsigned char)(x)])
#define	mux_PlayerNameSet(x)   (mux_PlayerNameSet[(unsigned char)(x)])
#define	mux_issecure(x)   (mux_issecure[(unsigned char)(x)])
#define	mux_isescape(x)   (mux_isescape[(unsigned char)(x)])
#define	mux_StripAccents(x)   (mux_StripAccents[(unsigned char)(x)])
#define	TOKEN_TEXT_ANSI   0
#define	TOKEN_ANSI   1
#define	ANSI_ENDGOAL_NORMAL   0
#define	ANSI_ENDGOAL_NOBLEED   1
#define	ANSI_ENDGOAL_LEAK   2
Typedefs
typedef tag_itl	ITL
Functions
int	ANSI_lex (int nString, const char *pString, int *nLengthToken0, int *nLengthToken1)
void	mux_strtok_src (MUX_STRTOK_STATE *tts, char *pString)
void	mux_strtok_ctl (MUX_STRTOK_STATE *tts, char *pControl)
char *	mux_strtok_parseLEN (MUX_STRTOK_STATE *tts, int *pnLen)
char *	mux_strtok_parse (MUX_STRTOK_STATE *tts)
char *	RemoveSetOfCharacters (char *pString, char *pSetToRemove)
size_t	mux_ltoa (long val, char *buf)
char *	mux_ltoa_t (long val)
void	safe_ltoa (long val, char *buff, char **bufc)
size_t	mux_i64toa (INT64 val, char *buf)
char *	mux_i64toa_t (INT64 val)
void	safe_i64toa (INT64 val, char *buff, char **bufc)
long	mux_atol (const char *pString)
INT64	mux_atoi64 (const char *pString)
double	mux_atof (char *szString, bool bStrict=true)
char *	mux_ftoa (double r, bool bRounded, int frac)
bool	is_integer (char *, int *)
bool	is_rational (char *)
bool	is_real (char *)
void	ANSI_String_In_Init (struct ANSI_In_Context *pacIn, const char *szString, int iEndGoal)
void	ANSI_String_Out_Init (struct ANSI_Out_Context *pacOut, char *pField, int nField, int vwMax, int iEndGoal)
void	ANSI_String_Skip (struct ANSI_In_Context *pacIn, int maxVisualWidth, int *pnVisualWidth)
void	ANSI_String_Copy (struct ANSI_Out_Context *pacOut, struct ANSI_In_Context *pacIn, int vwMax)
int	ANSI_String_Finalize (struct ANSI_Out_Context *pacOut, int *pnVisualWidth)
char *	ANSI_TruncateAndPad_sbuf (const char *pString, int nMaxVisualWidth, char fill= ' ')
int	ANSI_TruncateToField (const char *szString, int nField, char *pField, int maxVisual, int *nVisualWidth, int iEndGoal)
char *	strip_ansi (const char *szString, size_t *pnString=0)
char *	strip_accents (const char *szString, size_t *pnString=0)
char *	normal_to_white (const char *)
char *	munge_space (const char *)
char *	trim_spaces (char *)
char *	grabto (char **, char)
int	string_compare (const char *, const char *)
int	string_prefix (const char *, const char *)
const char *	string_match (const char *, const char *)
char *	replace_string (const char *, const char *, const char *)
char *	replace_tokens (const char *s, const char *pBound, const char *pListPlace, const char *pSwitch)
bool	minmatch (char *str, char *target, int min)
char *	StringCloneLen (const char *str, size_t nStr)
char *	StringClone (const char *str)
void	safe_copy_str (const char *src, char *buff, char **bufp, int max)
void	safe_copy_str_lbuf (const char *src, char *buff, char **bufp)
size_t	safe_copy_buf (const char *src, size_t nLen, char *buff, char **bufp)
size_t	safe_fill (char *buff, char **bufc, char chFile, size_t nSpaces)
bool	matches_exit_from_list (char *, const char *)
char *	translate_string (const char *, bool)
int	mux_stricmp (const char *a, const char *b)
int	mux_memicmp (const void *p1_arg, const void *p2_arg, size_t n)
void	mux_strlwr (char *tp)
void	mux_strupr (char *a)
void	ItemToList_Init (ITL *pContext, char *arg_buff, char **arg_bufc, char arg_chPrefix=0, char arg_chSep= ' ')
bool	ItemToList_AddInteger (ITL *pContext, int i)
bool	ItemToList_AddString (ITL *pContext, char *pStr)
bool	ItemToList_AddStringLEN (ITL *pContext, size_t nStr, char *pStr)
void	ItemToList_Final (ITL *pContext)
int DCL_CDECL	mux_vsnprintf (char *buff, int count, const char *fmt, va_list va)
int	GetLineTrunc (char *Buffer, size_t nBuffer, FILE *fp)
void	BMH_Prepare (BMH_State *bmhs, int nPat, const char *pPat)
int	BMH_Execute (BMH_State *bmhs, int nPat, const char *pPat, int nSrc, const char *pSrc)
int	BMH_StringSearch (int nPat, const char *pPat, int nSrc, const char *pSrc)
void	BMH_PrepareI (BMH_State *bmhs, int nPat, const char *pPat)
int	BMH_ExecuteI (BMH_State *bmhs, int nPat, const char *pPat, int nSrc, const char *pSrc)
int	BMH_StringSearchI (int nPat, const char *pPat, int nSrc, const char *pSrc)
bool	ParseFloat (PARSE_FLOAT_RESULT *pfr, const char *str, bool bStrict=true)
Variables
const bool	mux_isprint [256]
const bool	mux_isdigit [256]
const bool	mux_ishex [256]
const bool	mux_isazAZ [256]
const bool	mux_isalpha [256]
const bool	mux_isalnum [256]
const bool	mux_islower [256]
const bool	mux_isupper [256]
const bool	mux_isspace [256]
bool	mux_AttrNameInitialSet [256]
bool	mux_AttrNameSet [256]
const bool	mux_ObjectNameSet [256]
bool	mux_PlayerNameSet [256]
const bool	mux_issecure [256]
const bool	mux_isescape [256]
const unsigned char	mux_hex2dec [256]
const unsigned char	mux_toupper [256]
const unsigned char	mux_tolower [256]
const unsigned char	mux_StripAccents [256]

---

Define Documentation

#define ANSI_ENDGOAL_LEAK   2

Definition at line 120 of file stringutil.h.

Referenced by centerjustcombo().

#define ANSI_ENDGOAL_NOBLEED   1

Definition at line 119 of file stringutil.h.

Referenced by ANSI_String_Copy(), ANSI_String_Finalize(), normal_to_white(), and translate_string().

#define ANSI_ENDGOAL_NORMAL   0

Definition at line 118 of file stringutil.h.

Referenced by ANSI_Parse_m(), ANSI_String_Out_Init(), ANSI_TransitionColorBinary(), ANSI_TransitionColorEscape(), ANSI_TruncateAndPad_sbuf(), centerjustcombo(), db_read(), do_addcom(), do_cheader(), do_createchannel(), do_mail_list(), do_mail_proof(), do_mail_read(), do_mail_review(), FUNCTION(), load_comsystem(), MakeCanonicalDoing(), MakeCanonicalExitName(), MakeCanonicalMailAliasDesc(), MakeCanonicalObjectName(), mux_exec(), RestrictTitleValue(), tcache_add(), trimmed_name(), unparse_object(), and unparse_object_numonly().

#define mux_AttrNameInitialSet

(

x

)

(mux_AttrNameInitialSet[(unsigned char)(x)])

Definition at line 45 of file stringutil.h.

Referenced by FUNCTION(), getboolexp1(), init_attrtab(), and MakeCanonicalAttributeName().

#define mux_AttrNameSet

(

x

)

(mux_AttrNameSet[(unsigned char)(x)])

Definition at line 46 of file stringutil.h.

Referenced by init_attrtab(), and MakeCanonicalAttributeName().

#define mux_hex2dec

(

x

)

(mux_hex2dec[(unsigned char)(x)])

Definition at line 41 of file stringutil.h.

#define mux_isalnum

(

x

)

(mux_isalnum[(unsigned char)(x)])

Definition at line 37 of file stringutil.h.

Referenced by CF_HAND(), do_log(), do_mail_change_folder(), and string_match().

#define mux_isalpha

(

x

)

(mux_isalpha[(unsigned char)(x)])

Definition at line 36 of file stringutil.h.

Referenced by FUNCTION(), main(), MakeCanonicalMailAlias(), and ParseThreeLetters().

#define mux_isazAZ

(

x

)

(mux_isazAZ[(unsigned char)(x)])

Definition at line 35 of file stringutil.h.

Referenced by mux_exec().

#define mux_isdigit

(

x

)

(mux_isdigit[(unsigned char)(x)])

Definition at line 33 of file stringutil.h.

Referenced by ANSI_Parse_m(), atr_decode_flags_owner(), CF_HAND(), db_read(), decode_flags(), do_mail_stub(), FUNCTION(), fwdlist_load(), getboolexp1(), is_integer(), is_rational(), make_namelist(), MakeCanonicalMailAlias(), mux_atoi64(), mux_atol(), parse_dbref(), parse_folder(), parse_msglist(), ParseFloat(), ParseFractionalSecondsString(), CSpellNum::SpellNum(), test_atr(), and wild_match().

#define mux_isescape

(

x

)

(mux_isescape[(unsigned char)(x)])

Definition at line 50 of file stringutil.h.

Referenced by FUNCTION().

#define mux_ishex

(

x

)

(mux_ishex[(unsigned char)(x)])

Definition at line 34 of file stringutil.h.

#define mux_islower

(

x

)

(mux_islower[(unsigned char)(x)])

Definition at line 38 of file stringutil.h.

Referenced by ok_password().

#define mux_isprint

(

x

)

(mux_isprint[(unsigned char)(x)])

Definition at line 32 of file stringutil.h.

Referenced by db_read(), FUNCTION(), MakeCanonicalComAlias(), ok_password(), and process_input_helper().

#define mux_issecure

(

x

)

(mux_issecure[(unsigned char)(x)])

Definition at line 49 of file stringutil.h.

Referenced by FUNCTION().

#define mux_isspace

(

x

)

(mux_isspace[(unsigned char)(x)])

Definition at line 40 of file stringutil.h.

Referenced by add_folder_name(), CF_HAND(), cmdtest(), do_command(), do_force_prefixed(), do_icmd(), do_setvattr(), dump_users(), flag_set(), FUNCTION(), fwdlist_load(), get_folder_number(), helpindex_read(), is_integer(), is_rational(), MakeCanonicalObjectName(), match_player(), matches_exit_from_list(), munge_space(), munge_space_for_match(), mux_atoi64(), mux_atol(), mux_exec(), ok_password(), parse_boolexp_L(), parse_connect(), parse_msglist(), parse_range(), parse_to(), parse_to_cleanup(), ParseChannelLine(), ParseFloat(), ParseFractionalSecondsString(), power_set(), process_command(), set_userstring(), skip_whitespace(), CSpellNum::SpellNum(), string_compare(), trim_spaces(), ValidatePlayerName(), and xlate().

#define mux_isupper

(

x

)

(mux_isupper[(unsigned char)(x)])

Definition at line 39 of file stringutil.h.

Referenced by ok_password().

#define mux_ObjectNameSet

(

x

)

(mux_ObjectNameSet[(unsigned char)(x)])

Definition at line 47 of file stringutil.h.

Referenced by MakeCanonicalObjectName().

#define mux_PlayerNameSet

(

x

)

(mux_PlayerNameSet[(unsigned char)(x)])

Definition at line 48 of file stringutil.h.

Referenced by ValidatePlayerName().

#define mux_StripAccents

(

x

)

(mux_StripAccents[(unsigned char)(x)])

Definition at line 51 of file stringutil.h.

Referenced by strip_accents().

#define mux_tolower

(

x

)

(mux_tolower[(unsigned char)(x)])

Definition at line 43 of file stringutil.h.

Referenced by BMH_PrepareI(), CF_HAND(), ConvertR2RDG(), ConvertRDG2R(), DecodeN(), do_icmd(), FUNCTION(), get_gender(), get_list_type(), MakeCanonicalAttributeCommand(), MakeCanonicalFlagName(), matches_exit_from_list(), minmatch(), mux_exec(), mux_memicmp(), mux_stricmp(), mux_strlwr(), process_command(), string_compare(), and string_prefix().

#define mux_toupper

(

x

)

(mux_toupper[(unsigned char)(x)])

Definition at line 42 of file stringutil.h.

Referenced by add_folder_name(), BMH_ExecuteI(), BMH_PrepareI(), do_examine(), FUNCTION(), get_folder_number(), MakeCanonicalAttributeName(), mux_exec(), mux_strupr(), parse_msglist(), ParseFloat(), and ParseThreeLetters().

#define TOKEN_ANSI   1

Definition at line 55 of file stringutil.h.

Referenced by ANSI_lex().

#define TOKEN_TEXT_ANSI   0

Definition at line 54 of file stringutil.h.

Referenced by ANSI_lex(), ANSI_String_Copy(), ANSI_String_Skip(), ANSI_TransformTextReverseWithFunction(), ANSI_TransformTextWithTable(), FUNCTION(), strip_ansi(), and translate_string().

---

Typedef Documentation

typedef struct tag_itl ITL

---

Function Documentation

int ANSI_lex	(	int	nString,
		const char *	pString,
		int *	nLengthToken0,
		int *	nLengthToken1
	)

Definition at line 499 of file stringutil.cpp.

References ANSI_TokenTerminatorTable, ESC_CHAR, TOKEN_ANSI, and TOKEN_TEXT_ANSI.

Referenced by ANSI_String_Copy(), ANSI_String_Skip(), ANSI_TransformTextReverseWithFunction(), ANSI_TransformTextWithTable(), FUNCTION(), strip_ansi(), and translate_string().

{
    *nLengthToken0 = 0;
    *nLengthToken1 = 0;

    const char *p = pString;

    for (;;)
    {
        // Look for an ESC_CHAR
        //
        p = strchr(p, ESC_CHAR);
        if (!p)
        {
            // This is the most common case by far.
            //
            *nLengthToken0 = nString;
            return TOKEN_TEXT_ANSI;
        }

        // We have an ESC_CHAR. Let's look at the next character.
        //
        if (p[1] != '[')
        {
            // Could be a '\0' or another non-'[' character.
            // Move the pointer to position ourselves over it.
            // And continue looking for an ESC_CHAR.
            //
            p = p + 1;
            continue;
        }

        // We found the beginning of an ANSI sequence.
        // Find the terminating character.
        //
        const char *q = p+2;
        while (ANSI_TokenTerminatorTable[(unsigned char)*q] == 0)
        {
            q++;
        }
        if (q[0] == '\0')
        {
            // There was no good terminator. Treat everything like text.
            // Also, we are at the end of the string, so just return.
            //
            *nLengthToken0 = q - pString;
            return TOKEN_TEXT_ANSI;
        }
        else
        {
            // We found an ANSI sequence.
            //
            if (p == pString)
            {
                // The ANSI sequence started it.
                //
                *nLengthToken0 = q - pString + 1;
                return TOKEN_ANSI;
            }
            else
            {
                // We have TEXT followed by an ANSI sequence.
                //
                *nLengthToken0 = p - pString;
                *nLengthToken1 = q - p + 1;
                return TOKEN_TEXT_ANSI;
            }
        }
    }
}

void ANSI_String_Copy	(	struct ANSI_Out_Context *	pacOut,
		struct ANSI_In_Context *	pacIn,
		int	vwMax
	)

Definition at line 1055 of file stringutil.cpp.

References acsRestingStates, ANSI_ENDGOAL_NOBLEED, ANSI_lex(), ANSI_Parse_m(), ANSI_TransitionColorBinary(), ANSI_Out_Context::m_acs, ANSI_In_Context::m_acs, ANSI_Out_Context::m_bDone, ANSI_In_Context::m_bSawNormal, ANSI_Out_Context::m_iEndGoal, ANSI_Out_Context::m_n, ANSI_In_Context::m_n, ANSI_Out_Context::m_nMax, ANSI_In_Context::m_p, ANSI_Out_Context::m_p, ANSI_Out_Context::m_vw, ANSI_Out_Context::m_vwMax, and TOKEN_TEXT_ANSI.

Referenced by ANSI_TruncateToField(), centerjustcombo(), FUNCTION(), and mux_exec().

{
    // Check whether we have previous struck the session limits (given
    // by ANSI_String_Out_Init() for field size or visual width.
    //
    if (pacOut->m_bDone)
    {
        return;
    }

    // What is the working limit for visual width.
    //
    int vw = 0;
    int vwMax = pacOut->m_vwMax;
    if (maxVisualWidth0 < vwMax)
    {
        vwMax = maxVisualWidth0;
    }

    // What is the working limit for field size.
    //
    int nMax = pacOut->m_nMax;

    char *pField = pacOut->m_p;
    while (pacIn->m_n)
    {
        int nTokenLength0;
        int nTokenLength1;
        int iType = ANSI_lex(pacIn->m_n, pacIn->m_p, &nTokenLength0,
            &nTokenLength1);

        if (iType == TOKEN_TEXT_ANSI)
        {
            // We have a TEXT+[ANSI] phrase. The text length is given
            // by nTokenLength0, and the ANSI characters that follow
            // (if present) are of length nTokenLength1.
            //
            // Process TEXT part first.
            //
            // TODO: If there is a maximum size for the transitions,
            // and we have gobs of space, don't bother calculating
            // sizes so carefully. It might be faster

            // nFieldEffective is used to allocate and plan space for
            // the rest of the physical field (given by the current
            // nField length).
            //
            int nFieldEffective = nMax - 1; // Leave room for '\0'.

            int nTransitionFinal = 0;
            if (pacOut->m_iEndGoal <= ANSI_ENDGOAL_NOBLEED)
            {
                // If we lay down -any- of the TEXT part, we need to make
                // sure we always leave enough room to get back to the
                // required final ANSI color state.
                //
                if (memcmp( &(pacIn->m_acs),
                            &acsRestingStates[pacOut->m_iEndGoal],
                            sizeof(ANSI_ColorState)) != 0)
                {
                    // The color state of the TEXT isn't the final state,
                    // so how much room will the transition back to the
                    // final state take?
                    //
                    ANSI_TransitionColorBinary( &(pacIn->m_acs),
                                                &acsRestingStates[pacOut->m_iEndGoal],
                                                &nTransitionFinal,
                                                pacOut->m_iEndGoal);

                    nFieldEffective -= nTransitionFinal;
                }
            }

            // If we lay down -any- of the TEXT part, it needs to be
            // the right color.
            //
            int nTransition = 0;
            char *pTransition =
                ANSI_TransitionColorBinary( &(pacOut->m_acs),
                                            &(pacIn->m_acs),
                                            &nTransition,
                                            pacOut->m_iEndGoal);
            nFieldEffective -= nTransition;

            // If we find that there is no room for any of the TEXT,
            // then we're done.
            //
            // TODO: The visual width test can be done further up to save time.
            //
            if (  nFieldEffective <= nTokenLength0
               || vw + nTokenLength0 > vwMax)
            {
                // We have reached the limits of the field.
                //
                if (nFieldEffective > 0)
                {
                    // There was enough physical room in the field, but
                    // we would have exceeded the maximum visual width
                    // if we used all the text.
                    //
                    if (nTransition)
                    {
                        // Encode the TEXT color.
                        //
                        memcpy(pField, pTransition, nTransition);
                        pField += nTransition;
                    }

                    // Place just enough of the TEXT in the field.
                    //
                    int nTextToAdd = vwMax - vw;
                    if (nTextToAdd < nFieldEffective)
                    {
                        nFieldEffective = nTextToAdd;
                    }
                    memcpy(pField, pacIn->m_p, nFieldEffective);
                    pField += nFieldEffective;
                    pacIn->m_p += nFieldEffective;
                    pacIn->m_n -= nFieldEffective;
                    vw += nFieldEffective;
                    pacOut->m_acs = pacIn->m_acs;

                    // Was this visual width limit related to the session or
                    // the call?
                    //
                    if (vwMax != maxVisualWidth0)
                    {
                        pacOut->m_bDone = true;
                    }
                }
                else
                {
                    // Was size limit related to the session or the call?
                    //
                    pacOut->m_bDone = true;
                }
                pacOut->m_n += pField - pacOut->m_p;
                pacOut->m_nMax -= pField - pacOut->m_p;
                pacOut->m_p  = pField;
                pacOut->m_vw += vw;
                return;
            }

            if (nTransition)
            {
                memcpy(pField, pTransition, nTransition);
                pField += nTransition;
                nMax   -= nTransition;
            }
            memcpy(pField, pacIn->m_p, nTokenLength0);
            pField  += nTokenLength0;
            nMax    -= nTokenLength0;
            pacIn->m_p += nTokenLength0;
            pacIn->m_n -= nTokenLength0;
            vw += nTokenLength0;
            pacOut->m_acs = pacIn->m_acs;

            if (nTokenLength1)
            {
                // Process ANSI
                //
                ANSI_Parse_m(&(pacIn->m_acs), nTokenLength1, pacIn->m_p, &(pacIn->m_bSawNormal));
                pacIn->m_p += nTokenLength1;
                pacIn->m_n -= nTokenLength1;
            }
        }
        else
        {
            // Process ANSI
            //
            ANSI_Parse_m(&(pacIn->m_acs), nTokenLength0, pacIn->m_p, &(pacIn->m_bSawNormal));
            pacIn->m_n -= nTokenLength0;
            pacIn->m_p += nTokenLength0;
        }
    }
    pacOut->m_n += pField - pacOut->m_p;
    pacOut->m_nMax -= pField - pacOut->m_p;
    pacOut->m_p  = pField;
    pacOut->m_vw += vw;
}

int ANSI_String_Finalize	(	struct ANSI_Out_Context *	pacOut,
		int *	pnVisualWidth
	)

Definition at line 1241 of file stringutil.cpp.

References acsRestingStates, ANSI_ENDGOAL_NOBLEED, ANSI_TransitionColorBinary(), ANSI_Out_Context::m_acs, ANSI_Out_Context::m_iEndGoal, ANSI_Out_Context::m_n, ANSI_Out_Context::m_p, and ANSI_Out_Context::m_vw.

Referenced by ANSI_TruncateToField(), centerjustcombo(), FUNCTION(), and mux_exec().

{
    char *pField = pacOut->m_p;
    if (pacOut->m_iEndGoal <= ANSI_ENDGOAL_NOBLEED)
    {
        int nTransition = 0;
        char *pTransition =
            ANSI_TransitionColorBinary( &(pacOut->m_acs),
                                        &acsRestingStates[pacOut->m_iEndGoal],
                                        &nTransition, pacOut->m_iEndGoal);
        if (nTransition)
        {
            memcpy(pField, pTransition, nTransition);
            pField += nTransition;
        }
    }
    *pField = '\0';
    pacOut->m_n += pField - pacOut->m_p;
    pacOut->m_p  = pField;
    *pnVisualWidth = pacOut->m_vw;
    return pacOut->m_n;
}

void ANSI_String_In_Init	(	struct ANSI_In_Context *	pacIn,
		const char *	szString,
		int	iEndGoal
	)

Definition at line 948 of file stringutil.cpp.

References acsRestingStates, ANSI_In_Context::m_acs, ANSI_In_Context::m_bSawNormal, ANSI_In_Context::m_n, and ANSI_In_Context::m_p.

Referenced by ANSI_TruncateToField(), centerjustcombo(), FUNCTION(), and mux_exec().

{
    pacIn->m_acs = acsRestingStates[iEndGoal];
    pacIn->m_p   = szString;
    pacIn->m_n   = strlen(szString);
    pacIn->m_bSawNormal = false;
}

void ANSI_String_Out_Init	(	struct ANSI_Out_Context *	pacOut,
		char *	pField,
		int	nField,
		int	vwMax,
		int	iEndGoal
	)

Definition at line 961 of file stringutil.cpp.

References acsRestingStates, ANSI_ENDGOAL_NORMAL, ANSI_Out_Context::m_acs, ANSI_Out_Context::m_bDone, ANSI_Out_Context::m_iEndGoal, ANSI_Out_Context::m_n, ANSI_Out_Context::m_nMax, ANSI_Out_Context::m_p, ANSI_Out_Context::m_vw, and ANSI_Out_Context::m_vwMax.

Referenced by ANSI_TruncateToField(), centerjustcombo(), FUNCTION(), and mux_exec().

{
    pacOut->m_acs      = acsRestingStates[ANSI_ENDGOAL_NORMAL];
    pacOut->m_bDone    = false;
    pacOut->m_iEndGoal = iEndGoal;
    pacOut->m_n        = 0;
    pacOut->m_nMax     = nField;
    pacOut->m_p        = pField;
    pacOut->m_vw       = 0;
    pacOut->m_vwMax    = vwMax;
}

void ANSI_String_Skip	(	struct ANSI_In_Context *	pacIn,
		int	maxVisualWidth,
		int *	pnVisualWidth
	)

Definition at line 980 of file stringutil.cpp.

References ANSI_lex(), ANSI_Parse_m(), ANSI_In_Context::m_acs, ANSI_In_Context::m_bSawNormal, ANSI_In_Context::m_n, ANSI_In_Context::m_p, and TOKEN_TEXT_ANSI.

Referenced by centerjustcombo(), and FUNCTION().

{
    *pnVisualWidth = 0;
    while (pacIn->m_n)
    {
        int nTokenLength0;
        int nTokenLength1;
        int iType = ANSI_lex(pacIn->m_n, pacIn->m_p, &nTokenLength0, &nTokenLength1);

        if (iType == TOKEN_TEXT_ANSI)
        {
            // Process TEXT
            //
            int nTextToSkip = maxVisualWidth - *pnVisualWidth;
            if (nTokenLength0 > nTextToSkip)
            {
                // We have reached the limits of the field
                //
                *pnVisualWidth += nTextToSkip;
                pacIn->m_p     += nTextToSkip;
                pacIn->m_n     -= nTextToSkip;
                return;
            }

            pacIn->m_p     += nTokenLength0;
            pacIn->m_n     -= nTokenLength0;
            *pnVisualWidth += nTokenLength0;

            if (nTokenLength1)
            {
                // Process ANSI
                //
                ANSI_Parse_m(&(pacIn->m_acs), nTokenLength1, pacIn->m_p, &(pacIn->m_bSawNormal));
                pacIn->m_p     += nTokenLength1;
                pacIn->m_n     -= nTokenLength1;
            }
        }
        else
        {
            // Process ANSI
            //
            ANSI_Parse_m(&(pacIn->m_acs), nTokenLength0, pacIn->m_p, &(pacIn->m_bSawNormal));
            pacIn->m_n     -= nTokenLength0;
            pacIn->m_p     += nTokenLength0;
        }
    }
}

char* ANSI_TruncateAndPad_sbuf	(	const char *	pString,
		int	nMaxVisualWidth,
		char	fill = ' '
	)

Definition at line 1294 of file stringutil.cpp.

References alloc_sbuf, ANSI_ENDGOAL_NORMAL, ANSI_TruncateToField(), and SBUF_SIZE.

Referenced by do_chanlist().

{
    char *pStringModified = alloc_sbuf("ANSI_TruncateAndPad_sbuf");
    int nAvailable = SBUF_SIZE - nMaxVisualWidth;
    int nVisualWidth;
    int nLen = ANSI_TruncateToField(pString, nAvailable,
        pStringModified, nMaxVisualWidth, &nVisualWidth, ANSI_ENDGOAL_NORMAL);
    for (int i = nMaxVisualWidth - nVisualWidth; i > 0; i--)
    {
        pStringModified[nLen] = fill;
        nLen++;
    }
    pStringModified[nLen] = '\0';
    return pStringModified;
}

int ANSI_TruncateToField	(	const char *	szString,
		int	nField,
		char *	pField,
		int	maxVisual,
		int *	nVisualWidth,
		int	iEndGoal
	)

Definition at line 1272 of file stringutil.cpp.

References ANSI_String_Copy(), ANSI_String_Finalize(), ANSI_String_In_Init(), and ANSI_String_Out_Init().

Referenced by ANSI_TruncateAndPad_sbuf(), centerjustcombo(), db_read(), do_addcom(), do_cheader(), do_createchannel(), do_mail_list(), do_mail_proof(), do_mail_read(), do_mail_review(), FUNCTION(), load_comsystem(), MakeCanonicalDoing(), MakeCanonicalExitName(), MakeCanonicalMailAliasDesc(), MakeCanonicalObjectName(), normal_to_white(), RestrictTitleValue(), tcache_add(), trimmed_name(), unparse_object(), and unparse_object_numonly().

{
    if (!szString)
    {
        pField0[0] = '\0';
        return 0;
    }
    struct ANSI_In_Context aic;
    struct ANSI_Out_Context aoc;
    ANSI_String_In_Init(&aic, szString, iEndGoal);
    ANSI_String_Out_Init(&aoc, pField0, nField, maxVisualWidth, iEndGoal);
    ANSI_String_Copy(&aoc, &aic, maxVisualWidth);
    return ANSI_String_Finalize(&aoc, pnVisualWidth);
}

int BMH_Execute	(	BMH_State *	bmhs,
		int	nPat,
		const char *	pPat,
		int	nSrc,
		const char *	pSrc
	)

Definition at line 3302 of file stringutil.cpp.

References BMH_LARGE, BMH_State::m_d, and BMH_State::m_skip2.

Referenced by add_folder_name(), BMH_StringSearch(), and grep_util().

{
    if (nPat <= 0)
    {
        return -1;
    }
    for (int i = nPat-1; i < nSrc; i += bmhs->m_skip2)
    {
        while ((i += bmhs->m_d[(unsigned char)(pSrc[i])]) < nSrc)
        {
            ; // Nothing.
        }
        if (i < BMH_LARGE)
        {
            break;
        }
        i -= BMH_LARGE;
        int j = nPat - 1;
        const char *s = pSrc + (i - j);
        while (--j >= 0 && s[j] == pPat[j])
        {
            ; // Nothing.
        }
        if (j < 0)
        {
            return s-pSrc;
        }
    }
    return -1;
}

int BMH_ExecuteI	(	BMH_State *	bmhs,
		int	nPat,
		const char *	pPat,
		int	nSrc,
		const char *	pSrc
	)

Definition at line 3367 of file stringutil.cpp.

References BMH_LARGE, BMH_State::m_d, BMH_State::m_skip2, and mux_toupper.

Referenced by BMH_StringSearchI(), and grep_util().

{
    if (nPat <= 0)
    {
        return -1;
    }
    for (int i = nPat-1; i < nSrc; i += bmhs->m_skip2)
    {
        while ((i += bmhs->m_d[(unsigned char)(pSrc[i])]) < nSrc)
        {
            ; // Nothing.
        }
        if (i < BMH_LARGE)
        {
            break;
        }
        i -= BMH_LARGE;
        int j = nPat - 1;
        const char *s = pSrc + (i - j);
        while (  --j >= 0
              && mux_toupper(s[j]) == mux_toupper(pPat[j]))
        {
            ; // Nothing.
        }
        if (j < 0)
        {
            return s-pSrc;
        }
    }
    return -1;
}

void BMH_Prepare	(	BMH_State *	bmhs,
		int	nPat,
		const char *	pPat
	)

Definition at line 3277 of file stringutil.cpp.

References BMH_LARGE, BMH_State::m_d, and BMH_State::m_skip2.

Referenced by add_folder_name(), BMH_StringSearch(), and grep_util().

{
    if (nPat <= 0)
    {
        return;
    }
    int k;
    for (k = 0; k < 256; k++)
    {
        bmhs->m_d[k] = nPat;
    }

    char chLastPat = pPat[nPat-1];
    bmhs->m_skip2 = nPat;
    for (k = 0; k < nPat - 1; k++)
    {
        bmhs->m_d[(unsigned char)pPat[k]] = nPat - k - 1;
        if (pPat[k] == chLastPat)
        {
            bmhs->m_skip2 = nPat - k - 1;
        }
    }
    bmhs->m_d[(unsigned char)chLastPat] = BMH_LARGE;
}

void BMH_PrepareI	(	BMH_State *	bmhs,
		int	nPat,
		const char *	pPat
	)

Definition at line 3340 of file stringutil.cpp.

References BMH_LARGE, BMH_State::m_d, BMH_State::m_skip2, mux_tolower, and mux_toupper.

Referenced by BMH_StringSearchI(), and grep_util().

{
    if (nPat <= 0)
    {
        return;
    }
    int k;
    for (k = 0; k < 256; k++)
    {
        bmhs->m_d[k] = nPat;
    }

    char chLastPat = pPat[nPat-1];
    bmhs->m_skip2 = nPat;
    for (k = 0; k < nPat - 1; k++)
    {
        bmhs->m_d[mux_toupper(pPat[k])] = nPat - k - 1;
        bmhs->m_d[mux_tolower(pPat[k])] = nPat - k - 1;
        if (pPat[k] == chLastPat)
        {
            bmhs->m_skip2 = nPat - k - 1;
        }
    }
    bmhs->m_d[mux_toupper(chLastPat)] = BMH_LARGE;
    bmhs->m_d[mux_tolower(chLastPat)] = BMH_LARGE;
}

int BMH_StringSearch	(	int	nPat,
		const char *	pPat,
		int	nSrc,
		const char *	pSrc
	)

Definition at line 3333 of file stringutil.cpp.

References BMH_Execute(), and BMH_Prepare().

Referenced by FUNCTION(), get_folder_name(), and get_folder_number().

{
    BMH_State bmhs;
    BMH_Prepare(&bmhs, nPat, pPat);
    return BMH_Execute(&bmhs, nPat, pPat, nSrc, pSrc);
}

int BMH_StringSearchI	(	int	nPat,
		const char *	pPat,
		int	nSrc,
		const char *	pSrc
	)

Definition at line 3399 of file stringutil.cpp.

References BMH_ExecuteI(), and BMH_PrepareI().

{
    BMH_State bmhs;
    BMH_PrepareI(&bmhs, nPat, pPat);
    return BMH_ExecuteI(&bmhs, nPat, pPat, nSrc, pSrc);
}

int GetLineTrunc	(	char *	Buffer,
		size_t	nBuffer,
		FILE *	fp
	)

Definition at line 3235 of file stringutil.cpp.

References SBUF_SIZE.

Referenced by load_channels(), load_comsystem(), and malias_read().

{
    size_t lenBuffer = 0;
    if (fgets(Buffer, nBuffer, fp))
    {
        lenBuffer = strlen(Buffer);
    }
    if (lenBuffer <= 0)
    {
        memcpy(Buffer, "\n", 2);
        return 1;
    }
    if (Buffer[lenBuffer-1] != '\n')
    {
        // The line was too long for the buffer. Continue reading until the
        // end of the line.
        //
        char TruncBuffer[SBUF_SIZE];
        size_t lenTruncBuffer;
        do
        {
            if (!fgets(TruncBuffer, sizeof(TruncBuffer), fp))
            {
                break;
            }
            lenTruncBuffer = strlen(TruncBuffer);
        }
        while (TruncBuffer[lenTruncBuffer-1] != '\n');
    }
    return lenBuffer;
}

char* grabto	(	char **	,
		char
	)

Definition at line 1576 of file stringutil.cpp.

Referenced by decrypt_logindata().

{
    char *savec, *cp;

    if (!str || !*str || !**str)
        return NULL;

    savec = cp = *str;
    while (*cp && *cp != targ)
        cp++;
    if (*cp)
        *cp++ = '\0';
    *str = cp;
    return savec;
}

bool is_integer	(	char *	,
		int *
	)

Definition at line 2713 of file stringutil.cpp.

References mux_isdigit, and mux_isspace.

Referenced by autodetect_list(), centerjustcombo(), CF_HAND(), do_boot(), do_chanlog(), do_processcom(), FUNCTION(), and lookup_player().

{
    int nDigits = 0;
    if (pDigits)
    {
        *pDigits = 0;
    }

    // Leading spaces.
    //
    while (mux_isspace(*str))
    {
        str++;
    }

    // Leading minus or plus
    //
    if (*str == '-' || *str == '+')
    {
        str++;

        // Just a sign by itself isn't an integer.
        //
        if (!*str)
        {
            return false;
        }
    }

    // Need at least 1 integer
    //
    if (!mux_isdigit(*str))
    {
        return false;
    }

    // The number (int)
    //
    do
    {
        str++;
        nDigits++;
    } while (mux_isdigit(*str));

    if (pDigits)
    {
        *pDigits = nDigits;
    }

    // Trailing Spaces.
    //
    while (mux_isspace(*str))
    {
        str++;
    }

    return (!*str);
}

bool is_rational

(

char *

)

Definition at line 2772 of file stringutil.cpp.

References mux_isdigit, and mux_isspace.

Referenced by do_give(), do_poor(), do_wait(), and FUNCTION().

{
    // Leading spaces.
    //
    while (mux_isspace(*str))
    {
        str++;
    }

    // Leading minus or plus sign.
    //
    if (*str == '-' || *str == '+')
    {
        str++;

        // But not if just a sign.
        //
        if (!*str)
        {
            return false;
        }
    }

    // Need at least one digit.
    //
    bool got_one = false;
    if (mux_isdigit(*str))
    {
        got_one = true;
    }

    // The number (int)
    //
    while (mux_isdigit(*str))
    {
        str++;
    }

    // Decimal point.
    //
    if (*str == '.')
    {
        str++;
    }

    // Need at least one digit
    //
    if (mux_isdigit(*str))
    {
        got_one = true;
    }

    if (!got_one)
    {
        return false;
    }

    // The number (fract)
    //
    while (mux_isdigit(*str))
    {
        str++;
    }

    // Trailing spaces.
    //
    while (mux_isspace(*str))
    {
        str++;
    }

    // There must be nothing else after the trailing spaces.
    //
    return (!*str);
}

bool is_real

(

char *

)

Definition at line 2848 of file stringutil.cpp.

References ParseFloat().

Referenced by autodetect_list(), and FUNCTION().

{
    PARSE_FLOAT_RESULT pfr;
    return ParseFloat(&pfr, str);
}

bool ItemToList_AddInteger	(	ITL *	pContext,
		int	i
	)

Definition at line 3011 of file stringutil.cpp.

References tag_itl::bFirst, tag_itl::bufc, tag_itl::chPrefix, tag_itl::chSep, mux_ltoa(), tag_itl::nBufferAvailable, and SBUF_SIZE.

Referenced by do_page(), FUNCTION(), fwdlist_rewrite(), internalPlayerFind(), look_contents(), look_exits(), make_numlist(), make_portlist(), make_ulist(), and scan_zone().

{
    char smbuf[SBUF_SIZE];
    char *p = smbuf;
    if (  !pContext->bFirst
       && pContext->chSep)
    {
        *p++ = pContext->chSep;
    }
    if (pContext->chPrefix)
    {
        *p++ = pContext->chPrefix;
    }
    p += mux_ltoa(i, p);
    size_t nLen = p - smbuf;
    if (nLen > pContext->nBufferAvailable)
    {
        // Out of room.
        //
        return false;
    }
    if (pContext->bFirst)
    {
        pContext->bFirst = false;
    }
    memcpy(*(pContext->bufc), smbuf, nLen);
    *(pContext->bufc) += nLen;
    pContext->nBufferAvailable -= nLen;
    return true;
}

bool ItemToList_AddString	(	ITL *	pContext,
		char *	pStr
	)

Definition at line 3079 of file stringutil.cpp.

References ItemToList_AddStringLEN().

Referenced by cf_list(), FUNCTION(), list_attrtable(), and list_cmdtable().

{
    size_t nStr = strlen(pStr);
    return ItemToList_AddStringLEN(pContext, nStr, pStr);
}

bool ItemToList_AddStringLEN	(	ITL *	pContext,
		size_t	nStr,
		char *	pStr
	)

Definition at line 3042 of file stringutil.cpp.

References tag_itl::bFirst, tag_itl::bufc, tag_itl::chPrefix, tag_itl::chSep, and tag_itl::nBufferAvailable.

Referenced by ItemToList_AddString(), and make_port_ulist().

{
    size_t nLen = nStr;
    if (  !pContext->bFirst
       && pContext->chSep)
    {
        nLen++;
    }
    if (pContext->chPrefix)
    {
        nLen++;
    }
    if (nLen > pContext->nBufferAvailable)
    {
        // Out of room.
        //
        return false;
    }
    char *p = *(pContext->bufc);
    if (pContext->bFirst)
    {
        pContext->bFirst = false;
    }
    else if (pContext->chSep)
    {
        *p++ = pContext->chSep;
    }
    if (pContext->chPrefix)
    {
        *p++ = pContext->chPrefix;
    }
    memcpy(p, pStr, nStr);
    *(pContext->bufc) += nLen;
    pContext->nBufferAvailable -= nLen;
    return true;
}

void ItemToList_Final

(

ITL *

pContext

)

Definition at line 3085 of file stringutil.cpp.

References tag_itl::bufc.

Referenced by do_page(), FUNCTION(), fwdlist_rewrite(), internalPlayerFind(), list_attrtable(), look_contents(), look_exits(), make_numlist(), make_port_ulist(), make_portlist(), make_ulist(), and scan_zone().

{
    **(pContext->bufc) = '\0';
}

void ItemToList_Init	(	ITL *	pContext,
		char *	arg_buff,
		char **	arg_bufc,
		char	arg_chPrefix = 0,
		char	arg_chSep = ' '
	)

Definition at line 3000 of file stringutil.cpp.

References tag_itl::bFirst, tag_itl::bufc, tag_itl::buff, tag_itl::chPrefix, tag_itl::chSep, LBUF_SIZE, and tag_itl::nBufferAvailable.

Referenced by cf_list(), do_page(), FUNCTION(), fwdlist_rewrite(), internalPlayerFind(), list_attrtable(), list_cmdtable(), look_contents(), look_exits(), make_numlist(), make_port_ulist(), make_portlist(), make_ulist(), and scan_zone().

{
    p->bFirst = true;
    p->chPrefix = arg_chPrefix;
    p->chSep = arg_chSep;
    p->buff = arg_buff;
    p->bufc = arg_bufc;
    p->nBufferAvailable = LBUF_SIZE - (*arg_bufc - arg_buff) - 1;
}

bool matches_exit_from_list	(	char *	,
		const char *
	)

Definition at line 1992 of file stringutil.cpp.

References EXIT_DELIMITER, mux_isspace, and mux_tolower.

Referenced by match_exit_internal(), and process_command().

{
    char *s;

    while (*pattern)
    {
        for (s = str;   // check out this one
             ( *s
             && (mux_tolower(*s) == mux_tolower(*pattern))
             && *pattern
             && (*pattern != EXIT_DELIMITER));
             s++, pattern++) ;

        // Did we match it all?
        //
        if (*s == '\0')
        {
            // Make sure nothing afterwards
            //
            while (mux_isspace(*pattern))
            {
                pattern++;
            }

            // Did we get it?
            //
            if (  !*pattern
               || (*pattern == EXIT_DELIMITER))
            {
                return true;
            }
        }
        // We didn't get it, find next string to test
        //
        while (  *pattern
              && *pattern++ != EXIT_DELIMITER)
        {
            ; // Nothing.
        }
        while (mux_isspace(*pattern))
        {
            pattern++;
        }
    }
    return false;
}

bool minmatch	(	char *	str,
		char *	target,
		int	min
	)

Definition at line 1877 of file stringutil.cpp.

References mux_tolower.

Referenced by CF_HAND(), find_nametab_ent(), and search_nametab().

{
    while (*str && *target
          && (mux_tolower(*str) == mux_tolower(*target)))
    {
        str++;
        target++;
        min--;
    }
    if (*str)
    {
        return false;
    }
    if (!*target)
    {
        return true;
    }
    return (min <= 0);
}

char* munge_space

(

const char *

)

Definition at line 1487 of file stringutil.cpp.

References alloc_lbuf, and mux_isspace.

Referenced by create_obj().

{
    char *buffer = alloc_lbuf("munge_space");
    const char *p = string;
    char *q = buffer;

    if (p)
    {
        // Remove initial spaces.
        //
        while (mux_isspace(*p))
            p++;

        while (*p)
        {
            while (*p && !mux_isspace(*p))
                *q++ = *p++;

            while (mux_isspace(*p))
            {
                p++;
            }

            if (*p)
                *q++ = ' ';
        }
    }

    // Remove terminal spaces and terminate string.
    //
    *q = '\0';
    return buffer;
}

double mux_atof	(	char *	szString,
		bool	bStrict = true
	)

Definition at line 2494 of file stringutil.cpp.

References alloc_lbuf, ATOF_LIMIT, free_lbuf, PARSE_FLOAT_RESULT::iLeadingSign, PARSE_FLOAT_RESULT::iString, MakeSpecialFloat(), mux_atol(), mux_strtod(), PARSE_FLOAT_RESULT::nDigitsA, PARSE_FLOAT_RESULT::nDigitsB, PARSE_FLOAT_RESULT::nDigitsC, PARSE_FLOAT_RESULT::nMeat, ParseFloat(), PARSE_FLOAT_RESULT::pDigitsA, PARSE_FLOAT_RESULT::pDigitsB, and PARSE_FLOAT_RESULT::pMeat.

Referenced by do_asort(), FUNCTION(), and handle_vectors().

{
    PARSE_FLOAT_RESULT pfr;
    if (!ParseFloat(&pfr, szString, bStrict))
    {
        return 0.0;
    }

    if (pfr.iString)
    {
        // Return the double value which corresponds to the
        // string when HAVE_IEEE_FORMAT.
        //
#ifdef HAVE_IEEE_FP_FORMAT
        return MakeSpecialFloat(pfr.iString);
#else // HAVE_IEEE_FP_FORMAT
        return 0.0;
#endif // HAVE_IEEE_FP_FORMAT
    }

    // See if we can shortcut the decoding process.
    //
    double ret;
    if (  pfr.nDigitsA <= 9
       && pfr.nDigitsC == 0)
    {
        if (pfr.nDigitsB <= 9)
        {
            if (pfr.nDigitsB == 0)
            {
                // This 'floating-point' number is just an integer.
                //
                ret = (double)mux_atol(pfr.pDigitsA);
            }
            else
            {
                // This 'floating-point' number is fixed-point.
                //
                double rA = (double)mux_atol(pfr.pDigitsA);
                double rB = (double)mux_atol(pfr.pDigitsB);
                double rScale = powerstab[pfr.nDigitsB];
                ret = rA + rB/rScale;

                // As it is, ret is within a single bit of what a
                // a call to atof would return. However, we can
                // achieve that last lowest bit of precision by
                // computing a residual.
                //
                double residual = (ret - rA)*rScale;
                ret += (rB - residual)/rScale;
            }
            if (pfr.iLeadingSign == '-')
            {
                ret = -ret;
            }
            return ret;
        }
    }

    const char *p = pfr.pMeat;
    size_t n = pfr.nMeat;

    // We need to protect certain libraries from going nuts from being
    // force fed lots of ASCII.
    //
    char *pTmp = NULL;
    if (n > ATOF_LIMIT)
    {
        pTmp = alloc_lbuf("mux_atof");
        memcpy(pTmp, p, ATOF_LIMIT);
        pTmp[ATOF_LIMIT] = '\0';
        p = pTmp;
    }

    ret = mux_strtod(p, NULL);

    if (pTmp)
    {
        free_lbuf(pTmp);
    }

    return ret;
}

INT64 mux_atoi64

(

const char *

pString

)

Definition at line 2249 of file stringutil.cpp.

References mux_isdigit, and mux_isspace.

Referenced by do_asort(), CSpellNum::FractionalDigits(), FUNCTION(), and ParseFractionalSecondsString().

{
    INT64 sum = 0;
    int LeadingCharacter = 0;

    // Convert ASCII digits
    //
    unsigned int c1;
    unsigned int c0 = pString[0];
    if (!mux_isdigit(c0))
    {
        while (mux_isspace(pString[0]))
        {
            pString++;
        }
        LeadingCharacter = pString[0];
        if (  LeadingCharacter == '-'
           || LeadingCharacter == '+')
        {
            pString++;
        }
        c0 = pString[0];
        if (!mux_isdigit(c0))
        {
            return 0;
        }
    }

    do
    {
        c1 = pString[1];
        if (mux_isdigit(c1))
        {
            sum = 100 * sum + TableATOI[c0-'0'][c1-'0'];
            pString += 2;
        }
        else
        {
            sum = 10 * sum + (c0-'0');
            break;
        }
    } while (mux_isdigit(c0 = pString[0]));

    // Interpret sign
    //
    if (LeadingCharacter == '-')
    {
        sum = -sum;
    }
    return sum;
}

long mux_atol

(

const char *

pString

)

Definition at line 2197 of file stringutil.cpp.

References mux_isdigit, and mux_isspace.

Referenced by add_quota(), add_to(), announce_connect(), centerjustcombo(), CF_HAND(), connect_player(), dbnum(), decrypt_logindata(), desc_reload(), did_it(), do_boot(), do_chanlog(), do_clone(), do_comlast(), do_convtime(), do_create(), do_editchannel(), do_expmail_stop(), do_fixdb(), do_give(), do_kill(), do_mail_fwd(), do_mail_reply(), do_mail_stats(), do_malias_create(), do_notify(), do_page(), do_poor(), do_processcom(), do_queue(), do_quota(), do_timewarp(), fetch_ConnectionInfoField(), fetch_ConnectionInfoFields(), FUNCTION(), fwdlist_load(), get_exit_dest(), get_folder_number(), get_malias(), getref(), give_money(), idle_timeout_val(), iter_value(), load_comsystem(), load_mail_V5(), lookup_player(), mail_to_list(), make_namelist(), malias_read(), mung_quotas(), mux_atof(), nfy_que(), parse_boolexp_L(), parse_dbref(), parse_folder(), parse_msglist(), parse_range(), ParseDecimalSeconds(), pay_quota(), pcache_reload1(), PD_ScanNextToken(), Pennies(), player_folder(), purge_going(), search_setup(), SendChannelMessage(), show_quota(), test_atr(), u_comp(), and wild_match().

{
    long sum = 0;
    int LeadingCharacter = 0;

    // Convert ASCII digits
    //
    unsigned int c1;
    unsigned int c0 = pString[0];
    if (!mux_isdigit(c0))
    {
        while (mux_isspace(pString[0]))
        {
            pString++;
        }
        LeadingCharacter = pString[0];
        if (  LeadingCharacter == '-'
           || LeadingCharacter == '+')
        {
            pString++;
        }
        c0 = pString[0];
        if (!mux_isdigit(c0))
        {
            return 0;
        }
    }

    do
    {
        c1 = pString[1];
        if (mux_isdigit(c1))
        {
            sum = 100 * sum + TableATOI[c0-'0'][c1-'0'];
            pString += 2;
        }
        else
        {
            sum = 10 * sum + (c0-'0');
            break;
        }
    } while (mux_isdigit(c0 = pString[0]));

    // Interpret sign
    //
    if (LeadingCharacter == '-')
    {
        sum = -sum;
    }
    return sum;
}

char* mux_ftoa	(	double	r,
		bool	bRounded,
		int	frac
	)

Definition at line 2578 of file stringutil.cpp.

References mux_dtoa(), and mux_ltoa().

Referenced by FUNCTION(), and fval().

{
    static char buffer[100];
    char *q = buffer;
    char *rve = NULL;
    int iDecimalPoint = 0;
    int bNegative = 0;
    int mode = 0;
    int nRequest = 50;

    if (bRounded)
    {
        mode = 3;
        nRequest = frac;
        if (50 < nRequest)
        {
            nRequest = 50;
        }
        else if (nRequest < -20)
        {
            nRequest = -20;
        }
    }
    char *p = mux_dtoa(r, mode, nRequest, &iDecimalPoint, &bNegative, &rve);
    int nSize = rve - p;
    if (nSize > 50)
    {
        nSize = 50;
    }

    if (bNegative)
    {
        *q++ = '-';
    }

    if (iDecimalPoint == 9999)
    {
        // Inf or NaN
        //
        memcpy(q, p, nSize);
        q += nSize;
    }
    else if (nSize <= 0)
    {
        // Zero
        //
        if (bNegative)
        {
            // If we laid down a minus sign, we should remove it.
            //
            q--;
        }
        *q++ = '0';
        if (  bRounded
           && 0 < nRequest)
        {
            *q++ = '.';
            memset(q, '0', nRequest);
            q += nRequest;
        }
    }
    else if (  iDecimalPoint <= -6
            || 18 <= iDecimalPoint)
    {
        *q++ = *p++;
        if (1 < nSize)
        {
            *q++ = '.';
            memcpy(q, p, nSize-1);
            q += nSize-1;
        }
        *q++ = 'E';
        q += mux_ltoa(iDecimalPoint-1, q);
    }
    else if (iDecimalPoint <= 0)
    {
        // iDecimalPoint = -5 to 0
        //
        *q++ = '0';
        *q++ = '.';
        memset(q, '0', -iDecimalPoint);
        q += -iDecimalPoint;
        memcpy(q, p, nSize);
        q += nSize;
        if (bRounded)
        {
            int nPad = nRequest - (nSize - iDecimalPoint);
            if (0 < nPad)
            {
                memset(q, '0', nPad);
                q += nPad;
            }
        }
    }
    else
    {
        // iDecimalPoint = 1 to 17
        //
        if (nSize <= iDecimalPoint)
        {
            memcpy(q, p, nSize);
            q += nSize;
            memset(q, '0', iDecimalPoint - nSize);
            q += iDecimalPoint - nSize;
            if (  bRounded
               && 0 < nRequest)
            {
                *q++ = '.';
                memset(q, '0', nRequest);
                q += nRequest;
            }
        }
        else
        {
            memcpy(q, p, iDecimalPoint);
            q += iDecimalPoint;
            p += iDecimalPoint;
            *q++ = '.';
            memcpy(q, p, nSize - iDecimalPoint);
            q += nSize - iDecimalPoint;
            if (bRounded)
            {
                int nPad = nRequest - (nSize - iDecimalPoint);
                if (0 < nPad)
                {
                    memset(q, '0', nPad);
                    q += nPad;
                }
            }
        }
    }
    *q = '\0';
    return buffer;
}

size_t mux_i64toa	(	INT64	val,
		char *	buf
	)

Definition at line 2113 of file stringutil.cpp.

Referenced by ConvertToSecondsString(), list_bufstats(), put_ConnectionInfoFields(), RightJustifyNumber(), and safe_i64toa().

{
    char *p = buf;

    if (val < 0)
    {
        *p++ = '-';
        val = -val;
    }
    UINT64 uval = (UINT64)val;

    char *q = p;

    const char *z;
    while (uval > 99)
    {
        z = Digits100 + ((uval % 100) << 1);
        uval /= 100;
        *p++ = *z;
        *p++ = *(z+1);
    }
    z = Digits100 + (uval << 1);
    *p++ = *z;
    if (uval > 9)
    {
        *p++ = *(z+1);
    }

    size_t nLength = p - buf;
    *p-- = '\0';

    // The digits are in reverse order with a possible leading '-'
    // if the value was negative. q points to the first digit,
    // and p points to the last digit.
    //
    while (q < p)
    {
        // Swap characters are *p and *q
        //
        char temp = *p;
        *p = *q;
        *q = temp;

        // Move p and first digit towards the middle.
        //
        --p;
        ++q;

        // Stop when we reach or pass the middle.
        //
    }
    return nLength;
}

char* mux_i64toa_t

(

INT64

val

)

size_t mux_ltoa	(	long	val,
		char *	buf
	)

Definition at line 2045 of file stringutil.cpp.

Referenced by add_folder_name(), add_quota(), add_to(), create_obj(), db_write(), db_write_object(), did_it(), do_apply_marked(), do_dig(), do_open(), fcache_load(), FUNCTION(), GeneralTimeConversion(), get_folder_name(), ItemToList_AddInteger(), list_costs(), look_contents(), make_port_ulist(), mux_exec(), mux_ftoa(), mux_ltoa_t(), pay_quota(), pcache_save(), put_ConnectionInfoFields(), putref(), s_Pennies(), s_PenniesDirect(), safe_ltoa(), search_perform(), set_player_folder(), and CLogFile::WriteInteger().

{
    char *p = buf;

    if (val < 0)
    {
        *p++ = '-';
        val = -val;
    }
    unsigned long uval = (unsigned long)val;

    char *q = p;

    const char *z;
    while (uval > 99)
    {
        z = Digits100 + ((uval % 100) << 1);
        uval /= 100;
        *p++ = *z;
        *p++ = *(z+1);
    }
    z = Digits100 + (uval << 1);
    *p++ = *z;
    if (uval > 9)
    {
        *p++ = *(z+1);
    }

    size_t nLength = p - buf;
    *p-- = '\0';

    // The digits are in reverse order with a possible leading '-'
    // if the value was negative. q points to the first digit,
    // and p points to the last digit.
    //
    while (q < p)
    {
        // Swap characters are *p and *q
        //
        char temp = *p;
        *p = *q;
        *q = temp;

        // Move p and first digit towards the middle.
        //
        --p;
        ++q;

        // Stop when we reach or pass the middle.
        //
    }
    return nLength;
}

char* mux_ltoa_t

(

long

val

)

Definition at line 2099 of file stringutil.cpp.

References mux_ltoa().

Referenced by bind_and_queue(), do_chanlog(), do_destroy(), do_mail_fwd(), do_mail_reply(), dump_users(), FUNCTION(), mung_quotas(), and SendChannelMessage().

{
    static char buff[12];
    mux_ltoa(val, buff);
    return buff;
}

int mux_memicmp	(	const void *	p1_arg,
		const void *	p2_arg,
		size_t	n
	)

Definition at line 3119 of file stringutil.cpp.

References mux_tolower.

Referenced by PD_ScanNextToken().

{
    unsigned char *p1 = (unsigned char *)p1_arg;
    unsigned char *p2 = (unsigned char *)p2_arg;
    while (  n
          && mux_tolower(*p1) == mux_tolower(*p2))
    {
        n--;
        p1++;
        p2++;
    }
    if (n)
    {
        int c1 = mux_tolower(*p1);
        int c2 = mux_tolower(*p2);
        if (c1 < c2)
        {
            return -1;
        }
        else if (c1 > c2)
        {
            return 1;
        }
    }
    return 0;
}

int mux_stricmp	(	const char *	a,
		const char *	b
	)

Definition at line 3092 of file stringutil.cpp.

References mux_tolower.

Referenced by a_casecomp(), add_mail_message(), cf_display(), CF_HAND(), chanlist_comp(), do_chzone(), do_flag(), do_mail_stats(), do_mail_stub(), do_malias_create(), FUNCTION(), main(), and string_compare().

{
    while (  *a
          && *b
          && mux_tolower(*a) == mux_tolower(*b))
    {
        a++;
        b++;
    }
    int c1 = mux_tolower(*a);
    int c2 = mux_tolower(*b);
    if (c1 < c2)
    {
        return -1;
    }
    else if (c1 > c2)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

void mux_strlwr

(

char *

tp

)

Definition at line 3148 of file stringutil.cpp.

References mux_tolower.

Referenced by add_player_name(), CF_HAND(), delete_player_name(), do_addcommand(), do_delcommand(), do_destroy(), do_function(), do_listcommands(), find_power(), FUNCTION(), function_add(), functions_add(), helpindex_read(), init_flagtab(), init_powertab(), lookup_player(), MakeCanonicalTopicName(), and search_setup().

{
    while (*a)
    {
        *a = mux_tolower(*a);
        a++;
    }
}

void mux_strtok_ctl	(	MUX_STRTOK_STATE *	tts,
		char *	pControl
	)

Definition at line 2876 of file stringutil.cpp.

References MUX_STRTOK_STATE::aControl.

Referenced by add_helpfile(), CF_HAND(), do_attribute(), do_list(), do_mail_reply(), do_page(), do_pemit_list(), do_teleport(), make_namelist(), ParseConnectionInfoString(), process_command(), and RemoveSetOfCharacters().

{
    if (!tts || !pControl) return;

    // No character is a control character.
    //
    memset(tts->aControl, 0, sizeof(tts->aControl));

    // The NULL character is always a control character.
    //
    tts->aControl[0] = 1;

    // Record the user-specified control characters.
    //
    while (*pControl)
    {
        tts->aControl[(unsigned char)*pControl] = 1;
        pControl++;
    }
}

char* mux_strtok_parse

(

MUX_STRTOK_STATE *

tts

)

Definition at line 2959 of file stringutil.cpp.

References mux_strtok_parseLEN().

Referenced by add_helpfile(), CF_HAND(), do_attribute(), do_list(), do_mail_reply(), do_page(), do_pemit_list(), do_teleport(), make_namelist(), ParseConnectionInfoString(), and process_command().

{
    int nLen;
    char *p = mux_strtok_parseLEN(tts, &nLen);
    if (p)
    {
        p[nLen] = '\0';
    }
    return p;
}

char* mux_strtok_parseLEN	(	MUX_STRTOK_STATE *	tts,
		int *	pnLen
	)

Definition at line 2897 of file stringutil.cpp.

References MUX_STRTOK_STATE::aControl, and MUX_STRTOK_STATE::pString.

Referenced by mux_strtok_parse(), and RemoveSetOfCharacters().

{
    *pnLen = 0;
    if (!tts)
    {
        return NULL;
    }
    char *p = tts->pString;
    if (!p)
    {
        return NULL;
    }

    // Skip over leading control characters except for the NUL character.
    //
    while (tts->aControl[(unsigned char)*p] && *p)
    {
        p++;
    }

    char *pReturn = p;

    // Skip over non-control characters.
    //
    while (tts->aControl[(unsigned char)*p] == 0)
    {
        p++;
    }

    // What is the length of this token?
    //
    *pnLen = p - pReturn;

    // Terminate the token with a NUL.
    //
    if (p[0])
    {
        // We found a non-NUL delimiter, so the next call will begin parsing
        // on the character after this one.
        //
        tts->pString = p+1;
    }
    else
    {
        // We hit the end of the string, so the end of the string is where
        // the next call will begin.
        //
        tts->pString = p;
    }

    // Did we find a token?
    //
    if (*pnLen > 0)
    {
        return pReturn;
    }
    else
    {
        return NULL;
    }
}

void mux_strtok_src	(	MUX_STRTOK_STATE *	tts,
		char *	pString
	)

Definition at line 2867 of file stringutil.cpp.

References MUX_STRTOK_STATE::pString.

Referenced by add_helpfile(), CF_HAND(), do_attribute(), do_list(), do_mail_reply(), do_page(), do_pemit_list(), do_teleport(), make_namelist(), ParseConnectionInfoString(), process_command(), and RemoveSetOfCharacters().

{
    if (!tts || !arg_pString) return;

    // Remember the string to parse.
    //
    tts->pString = arg_pString;
}

void mux_strupr

(

char *

a

)

Definition at line 3159 of file stringutil.cpp.

References mux_toupper.

Referenced by CF_HAND(), dbclean_CheckATtoANH(), do_attribute(), do_function(), and flag_rename().

{
    while (*a)
    {
        *a = mux_toupper(*a);
        a++;
    }
}

int DCL_CDECL mux_vsnprintf	(	char *	buff,
		int	count,
		const char *	fmt,
		va_list	va
	)

Definition at line 3184 of file stringutil.cpp.

References VSNPRINTF.

Referenced by cf_log_syntax(), log_printf(), raw_broadcast(), safe_tprintf_str(), CLogFile::tinyprintf(), and tprintf().

{
    // From the manuals:
    //
    // vsnprintf returns the number of characters written, not
    // including the terminating '\0' character.
    //
    // It returns a -1 if an output error occurs.
    //
    // It can return a number larger than the size of the buffer
    // on some systems to indicate how much space it -would- have taken
    // if not limited by the request.
    //
    // On Win32, it can fill the buffer completely without a
    // null-termination and return -1.


    // To favor the Unix case, if there is an output error, but
    // vsnprint doesn't touch the buffer, we avoid undefined trash by
    // null-terminating the buffer to zero-length before the call.
    // Not sure that this happens, but it's a cheap precaution.
    //
    buff[0] = '\0';

    // If Unix version does start touching the buffer, null-terminates,
    // and returns -1, we are still safe. However, if Unix version
    // touches the buffer writes garbage, and then returns -1, we may
    // pass garbage, but this possibility seems very unlikely.
    //
    int len = VSNPRINTF(buff, count, fmt, va);
    if (len < 0 || len > count-1)
    {
        if (buff[0] == '\0')
        {
            // vsnprintf did not touch the buffer.
            //
            len = 0;
        }
        else
        {
            len = count-1;
        }
    }
    buff[len] = '\0';
    return len;
}

char* normal_to_white

(

const char *

)

Definition at line 1310 of file stringutil.cpp.

References ANSI_ENDGOAL_NOBLEED, ANSI_TruncateToField(), and LBUF_SIZE.

Referenced by queue_string().

{
    static char Buffer[LBUF_SIZE];
    int nVisualWidth;
    ANSI_TruncateToField( szString,
                          sizeof(Buffer),
                          Buffer,
                          sizeof(Buffer),
                          &nVisualWidth,
                          ANSI_ENDGOAL_NOBLEED
                        );
    return Buffer;
}

bool ParseFloat	(	PARSE_FLOAT_RESULT *	pfr,
		const char *	str,
		bool	bStrict = true
	)

Definition at line 2310 of file stringutil.cpp.

References IEEE_MAKE_IND, IEEE_MAKE_NAN, IEEE_MAKE_NINF, IEEE_MAKE_PINF, PARSE_FLOAT_RESULT::iExponentSign, PARSE_FLOAT_RESULT::iLeadingSign, PARSE_FLOAT_RESULT::iString, mux_isdigit, mux_isspace, mux_toupper, PARSE_FLOAT_RESULT::nDigitsA, PARSE_FLOAT_RESULT::nDigitsB, PARSE_FLOAT_RESULT::nDigitsC, PARSE_FLOAT_RESULT::nMeat, PARSE_FLOAT_RESULT::pDigitsA, PARSE_FLOAT_RESULT::pDigitsB, PARSE_FLOAT_RESULT::pDigitsC, and PARSE_FLOAT_RESULT::pMeat.

Referenced by is_real(), mux_atof(), and xlate().

{
    memset(pfr, 0, sizeof(PARSE_FLOAT_RESULT));

    // Parse Input
    //
    unsigned char ch;
    pfr->pMeat = str;
    if (  !mux_isdigit(*str)
       && *str != '.')
    {
        while (mux_isspace(*str))
        {
            str++;
        }

        pfr->pMeat = str;
        if (*str == '-')
        {
            pfr->iLeadingSign = '-';
            str++;
        }
        else if (*str == '+')
        {
            pfr->iLeadingSign = '+';
            str++;
        }

        if (  !mux_isdigit(*str)
           && *str != '.')
        {
            // Look for three magic strings.
            //
            ch = mux_toupper(str[0]);
            if (ch == 'I')
            {
                // Could be 'Inf' or 'Ind'
                //
                ch = mux_toupper(str[1]);
                if (ch == 'N')
                {
                    ch = mux_toupper(str[2]);
                    if (ch == 'F')
                    {
                        // Inf
                        //
                        if (pfr->iLeadingSign == '-')
                        {
                            pfr->iString = IEEE_MAKE_NINF;
                        }
                        else
                        {
                            pfr->iString = IEEE_MAKE_PINF;
                        }
                        str += 3;
                        goto LastSpaces;
                    }
                    else if (ch == 'D')
                    {
                        // Ind
                        //
                        pfr->iString = IEEE_MAKE_IND;
                        str += 3;
                        goto LastSpaces;
                    }
                }
            }
            else if (ch == 'N')
            {
                // Could be 'Nan'
                //
                ch = mux_toupper(str[1]);
                if (ch == 'A')
                {
                    ch = mux_toupper(str[2]);
                    if (ch == 'N')
                    {
                        // Nan
                        //
                        pfr->iString = IEEE_MAKE_NAN;
                        str += 3;
                        goto LastSpaces;
                    }
                }
            }
            return false;
        }
    }

    // At this point, we have processed the leading sign, handled all
    // the magic strings, skipped the leading spaces, and best of all
    // we either have a digit or a decimal point.
    //
    pfr->pDigitsA = str;
    while (mux_isdigit(*str))
    {
        pfr->nDigitsA++;
        str++;
    }

    if (*str == '.')
    {
        str++;
    }

    pfr->pDigitsB = str;
    while (mux_isdigit(*str))
    {
        pfr->nDigitsB++;
        str++;
    }

    if (  pfr->nDigitsA == 0
       && pfr->nDigitsB == 0)
    {
        return false;
    }

    ch = mux_toupper(*str);
    if (ch == 'E')
    {
        // There is an exponent portion.
        //
        str++;
        if (*str == '-')
        {
            pfr->iExponentSign = '-';
            str++;
        }
        else if (*str == '+')
        {
            pfr->iExponentSign = '+';
            str++;
        }
        pfr->pDigitsC = str;
        while (mux_isdigit(*str))
        {
            pfr->nDigitsC++;
            str++;
        }

        if (  pfr->nDigitsC < 1
           || 4 < pfr->nDigitsC)
        {
            return false;
        }
    }

LastSpaces:

    pfr->nMeat = str - pfr->pMeat;

    // Trailing spaces.
    //
    while (mux_isspace(*str))
    {
        str++;
    }

    if (bStrict)
    {
        return (!*str);
    }
    else
    {
        return true;
    }
}

char* RemoveSetOfCharacters	(	char *	pString,
		char *	pSetToRemove
	)

Definition at line 2973 of file stringutil.cpp.

References LBUF_SIZE, mux_strtok_ctl(), mux_strtok_parseLEN(), and mux_strtok_src().

Referenced by centerjustcombo(), do_addcommand(), do_cheader(), do_lock(), FUNCTION(), MakeCanonicalDoing(), MakeCanonicalMailAliasDesc(), and RestrictTitleValue().

{
    static char Buffer[LBUF_SIZE];
    char *pBuffer = Buffer;

    int nLen;
    int nLeft = sizeof(Buffer) - 1;
    char *p;
    MUX_STRTOK_STATE tts;
    mux_strtok_src(&tts, pString);
    mux_strtok_ctl(&tts, pSetToRemove);
    for ( p = mux_strtok_parseLEN(&tts, &nLen);
          p && nLeft;
          p = mux_strtok_parseLEN(&tts, &nLen))
    {
        if (nLeft < nLen)
        {
            nLen = nLeft;
        }
        memcpy(pBuffer, p, nLen);
        pBuffer += nLen;
        nLeft -= nLen;
    }
    *pBuffer = '\0';
    return Buffer;
}

char* replace_string	(	const char *	,
		const char *	,
		const char *
	)

Definition at line 1723 of file stringutil.cpp.

References alloc_lbuf, safe_chr, safe_copy_buf(), and safe_str.

Referenced by do_edit_msg(), edit_string(), and edit_string_ansi().

{
    if (!s)
    {
        return NULL;
    }
    size_t olen = strlen(old);
    char *result = alloc_lbuf("replace_string");
    char *r = result;
    while (*s)
    {
        // Find next occurrence of the first character of OLD string.
        //
        const char *p;
        if (  olen
           && (p = strchr(s, old[0])))
        {
            // Copy up to the next occurrence of the first char of OLD.
            //
            size_t n = p - s;
            if (n)
            {
                safe_copy_buf(s, n, result, &r);
                s += n;
            }

            // If we are really at an complete OLD, append NEW to the result
            // and bump the input string past the occurrence of OLD.
            // Otherwise, copy the character and try matching again.
            //
            if (!strncmp(old, s, olen))
            {
                safe_str(new0, result, &r);
                s += olen;
            }
            else
            {
                safe_chr(*s, result, &r);
                s++;
            }
        }
        else
        {
            // Finish copying source string. No matches. No further
            // work to perform.
            //
            safe_str(s, result, &r);
            break;
        }
    }
    *r = '\0';
    return result;
}

char* replace_tokens	(	const char *	s,
		const char *	pBound,
		const char *	pListPlace,
		const char *	pSwitch
	)

Definition at line 1781 of file stringutil.cpp.

References alloc_lbuf, safe_chr, safe_copy_buf(), and safe_str.

Referenced by bind_and_queue(), do_switch(), FUNCTION(), search_perform(), and switch_handler().

{
    if (!s)
    {
        return NULL;
    }
    char *result = alloc_lbuf("replace_tokens");
    char *r = result;

    while (*s)
    {
        // Find next '#'.
        //
        const char *p = strchr(s, '#');
        if (p)
        {
            // Copy up to the next occurrence of the first character.
            //
            size_t n = p - s;
            if (n)
            {
                safe_copy_buf(s, n, result, &r);
                s += n;
            }

            if (  s[1] == '#'
               && pBound)
            {
                // BOUND_VAR
                //
                safe_str(pBound, result, &r);
                s += 2;
            }
            else if (  s[1] == '@'
                    && pListPlace)
            {
                // LISTPLACE_VAR
                //
                safe_str(pListPlace, result, &r);
                s += 2;
            }
            else if (  s[1] == '$'
                    && pSwitch)
            {
                // SWITCH_VAR
                //
                safe_str(pSwitch, result, &r);
                s += 2;
            }
            else
            {
                safe_chr(*s, result, &r);
                s++;
            }
        }
        else
        {
            // Finish copying source string. No matches. No further
            // work to perform.
            //
            safe_str(s, result, &r);
            break;
        }
    }
    *r = '\0';
    return result;
}

size_t safe_copy_buf	(	const char *	src,
		size_t	nLen,
		char *	buff,
		char **	bufp
	)

Definition at line 1963 of file stringutil.cpp.

References LBUF_SIZE, and left.

Referenced by centerjustcombo(), do_itemfuns(), do_page(), FUNCTION(), get_handler(), mux_exec(), replace_string(), replace_tokens(), safe_i64toa(), safe_ltoa(), and translate_string().

{
    size_t left = LBUF_SIZE - (*bufc - buff) - 1;
    if (left < nLen)
    {
        nLen = left;
    }
    memcpy(*bufc, src, nLen);
    *bufc += nLen;
    return nLen;
}

void safe_copy_str	(	const char *	src,
		char *	buff,
		char **	bufp,
		int	max
	)

Definition at line 1934 of file stringutil.cpp.

{
    if (src == NULL) return;

    char *tp = *bufp;
    char *maxtp = buff + nSizeOfBuffer;
    while (tp < maxtp && *src)
    {
        *tp++ = *src++;
    }
    *bufp = tp;
}

void safe_copy_str_lbuf	(	const char *	src,
		char *	buff,
		char **	bufp
	)

Definition at line 1947 of file stringutil.cpp.

References LBUF_SIZE.

{
    if (src == NULL)
    {
        return;
    }

    char *tp = *bufp;
    char *maxtp = buff + LBUF_SIZE - 1;
    while (tp < maxtp && *src)
    {
        *tp++ = *src++;
    }
    *bufp = tp;
}

size_t safe_fill	(	char *	buff,
		char **	bufc,
		char	chFile,
		size_t	nSpaces
	)

Definition at line 1975 of file stringutil.cpp.

References LBUF_SIZE.

Referenced by centerjustcombo(), expand_tabs(), and FUNCTION().

{
    // Check for buffer limits.
    //
    size_t nBufferAvailable = LBUF_SIZE - (*bufc - buff) - 1;
    if (nSpaces > nBufferAvailable)
    {
        nSpaces = nBufferAvailable;
    }

    // Fill with spaces.
    //
    memset(*bufc, chFill, nSpaces);
    *bufc += nSpaces;
    return nSpaces;
}

void safe_i64toa	(	INT64	val,
		char *	buff,
		char **	bufc
	)

Definition at line 2176 of file stringutil.cpp.

References mux_i64toa(), and safe_copy_buf().

Referenced by FUNCTION().

{
    static char temp[22];
    size_t n = mux_i64toa(val, temp);
    safe_copy_buf(temp, n, buff, bufc);
}

void safe_ltoa	(	long	val,
		char *	buff,
		char **	bufc
	)

Definition at line 2106 of file stringutil.cpp.

References mux_ltoa(), and safe_copy_buf().

Referenced by cf_display(), do_mail_reply(), FUNCTION(), fval(), iter_value(), unparse_boolexp1(), unparse_object(), and unparse_object_numonly().

{
    static char temp[12];
    size_t n = mux_ltoa(val, temp);
    safe_copy_buf(temp, n, buff, bufc);
}

int string_compare	(	const char *	,
		const char *
	)

Definition at line 1592 of file stringutil.cpp.

References statedata::bStandAlone, mudconf, mudstate, mux_isspace, mux_stricmp(), mux_tolower, and confdata::space_compress.

Referenced by badname_remove(), do_chown(), do_icmd(), do_last(), do_move(), do_name(), do_teleport_single(), eval_boolexp(), FUNCTION(), lookup_player(), match_here(), match_home(), match_list(), match_me(), and process_command().

{
    if (  mudstate.bStandAlone
       || mudconf.space_compress)
    {
        while (mux_isspace(*s1))
        {
            s1++;
        }
        while (mux_isspace(*s2))
        {
            s2++;
        }

        while (  *s1 && *s2
              && (  (mux_tolower(*s1) == mux_tolower(*s2))
                 || (mux_isspace(*s1) && mux_isspace(*s2))))
        {
            if (mux_isspace(*s1) && mux_isspace(*s2))
            {
                // skip all other spaces.
                //
                do
                {
                    s1++;
                } while (mux_isspace(*s1));

                do
                {
                    s2++;
                } while (mux_isspace(*s2));
            }
            else
            {
                s1++;
                s2++;
            }
        }
        if (  *s1
           && *s2)
        {
            return 1;
        }

        if (mux_isspace(*s1))
        {
            while (mux_isspace(*s1))
            {
                s1++;
            }
            return *s1;
        }
        if (mux_isspace(*s2))
        {
            while (mux_isspace(*s2))
            {
                s2++;
            }
            return *s2;
        }
        if (  *s1
           || *s2)
        {
            return 1;
        }
        return 0;
    }
    else
    {
        return mux_stricmp(s1, s2);
    }
}

const char* string_match	(	const char *	,
		const char *
	)

Definition at line 1690 of file stringutil.cpp.

References mux_isalnum, and string_prefix().

Referenced by do_find(), and match_list().

{
    if ((*sub != '\0') && (src))
    {
        while (*src)
        {
            if (string_prefix(src, sub))
            {
                return src;
            }

            // else scan to beginning of next word
            //
            while (mux_isalnum(*src))
            {
                src++;
            }
            while (*src && !mux_isalnum(*src))
            {
                src++;
            }
        }
    }
    return 0;
}

int string_prefix	(	const char *	,
		const char *
	)

Definition at line 1665 of file stringutil.cpp.

References mux_tolower.

Referenced by atr_has_flag(), check_connect(), do_mail_debug(), dump_users(), find_connected_name(), search_perform(), search_setup(), and string_match().

{
    int count = 0;

    while (*string && *prefix
          && (mux_tolower(*string) == mux_tolower(*prefix)))
    {
        string++, prefix++, count++;
    }
    if (*prefix == '\0')
    {
        // Matched all of prefix.
        //
        return count;
    }
    else
    {
        return 0;
    }
}

char* StringClone

(

const char *

str

)

Definition at line 1912 of file stringutil.cpp.

References StringCloneLen().

Referenced by add_helpfile(), badname_add(), CF_HAND(), cf_init(), do_addcommand(), do_function(), do_joinchannel(), do_setnewtitle(), dup_bool(), getboolexp1(), init_cmdtab(), load_mail_V5(), main(), MessageAddWithNumber(), Moniker(), ParseChannelLine(), s_Name(), send_mail(), CLogFile::SetBasename(), and test_atr().

{
    return StringCloneLen(str, strlen(str));
}

char* StringCloneLen	(	const char *	str,
		size_t	nStr
	)

Definition at line 1900 of file stringutil.cpp.

References ISOUTOFMEMORY, and MEMALLOC.

Referenced by atr_add_raw_LEN(), CF_HAND(), do_malias_create(), do_malias_desc(), do_malias_rename(), flag_rename(), helpindex_read(), load_comsystem(), malias_read(), Moniker(), Name(), PureName(), and StringClone().

{
    char *buff = (char *)MEMALLOC(nStr+1);
    ISOUTOFMEMORY(buff);
    memcpy(buff, str, nStr);
    buff[nStr] = '\0';
    return buff;
}

char* strip_accents	(	const char *	szString,
		size_t *	pnString = 0
	)

Definition at line 618 of file stringutil.cpp.

References LBUF_SIZE, and mux_StripAccents.

Referenced by FUNCTION(), Moniker(), and queue_string().

{
    static char Buffer[LBUF_SIZE];
    char *pBuffer = Buffer;

    const char *pString = szString;
    if (pString)
    {
        while (*pString)
        {
            *pBuffer = mux_StripAccents(*pString);
            pBuffer++;
            pString++;
        }
    }
    if (pnString)
    {
        *pnString = pBuffer - Buffer;
    }
    *pBuffer = '\0';
    return Buffer;
}

char* strip_ansi	(	const char *	szString,
		size_t *	pnString = 0
	)

Definition at line 570 of file stringutil.cpp.

References ANSI_lex(), LBUF_SIZE, and TOKEN_TEXT_ANSI.

Referenced by atr_match(), CF_HAND(), crypt_code(), decompile_flags(), do_addcommand(), do_channelwho(), do_createchannel(), do_decomp(), do_log(), FUNCTION(), GenCode(), log_name(), log_text(), MakeCanonicalExitName(), MakeCanonicalObjectName(), Moniker(), process_sex(), PureName(), and queue_string().

{
    static char Buffer[LBUF_SIZE];
    char *pBuffer = Buffer;

    const char *pString = szString;
    if (!pString)
    {
        if (pnString)
        {
            *pnString = 0;
        }
        *pBuffer = '\0';
        return Buffer;
    }
    size_t nString = strlen(szString);

    while (nString)
    {
        int nTokenLength0;
        int nTokenLength1;
        int iType = ANSI_lex(nString, pString, &nTokenLength0, &nTokenLength1);

        if (iType == TOKEN_TEXT_ANSI)
        {
            memcpy(pBuffer, pString, nTokenLength0);
            pBuffer += nTokenLength0;

            int nSkipLength = nTokenLength0 + nTokenLength1;
            nString -= nSkipLength;
            pString += nSkipLength;
        }
        else
        {
            // TOKEN_ANSI
            //
            nString -= nTokenLength0;
            pString += nTokenLength0;
        }
    }
    if (pnString)
    {
        *pnString = pBuffer - Buffer;
    }
    *pBuffer = '\0';
    return Buffer;
}

char* translate_string	(	const char *	,
		bool
	)

Definition at line 1397 of file stringutil.cpp.

References acsRestingStates, ANSI_ENDGOAL_NOBLEED, ANSI_lex(), ANSI_Parse_m(), ANSI_TransitionColorEscape(), LBUF_SIZE, MU_Substitutes, safe_chr, safe_copy_buf(), safe_str, and TOKEN_TEXT_ANSI.

Referenced by do_decomp(), and FUNCTION().

{
    static char szTranslatedString[LBUF_SIZE];
    char *pTranslatedString = szTranslatedString;

    const char *pString = szString;
    if (!szString)
    {
        *pTranslatedString = '\0';
        return szTranslatedString;
    }
    size_t nString = strlen(szString);

    ANSI_ColorState acsCurrent;
    ANSI_ColorState acsPrevious;
    acsCurrent = acsRestingStates[ANSI_ENDGOAL_NOBLEED];
    acsPrevious = acsCurrent;
    bool bSawNormal = false;
    const unsigned char *MU_EscapeChar = (bConvert)? MU_EscapeConvert : MU_EscapeNoConvert;
    while (nString)
    {
        int nTokenLength0;
        int nTokenLength1;
        int iType = ANSI_lex(nString, pString, &nTokenLength0, &nTokenLength1);

        if (iType == TOKEN_TEXT_ANSI)
        {
            // Process TEXT
            //
            int nTransition = 0;
            if (bConvert)
            {
                char *pTransition = ANSI_TransitionColorEscape(&acsPrevious, &acsCurrent, &nTransition);
                safe_str(pTransition, szTranslatedString, &pTranslatedString);
            }
            nString -= nTokenLength0;

            while (nTokenLength0--)
            {
                unsigned char ch = *pString++;
                unsigned char code = MU_EscapeChar[ch];
                if (code)
                {
                    // The following can look one ahead off the end of the
                    // current token (and even at the '\0' at the end of the
                    // string, but this is acceptable. An extra look will
                    // always see either ESC from the next ANSI sequence,
                    // or the '\0' on the end of the string. No harm done.
                    //
                    if (ch == ' ' && pString[0] == ' ')
                    {
                        code = 5;
                    }
                    safe_copy_buf(MU_Substitutes[code].p,
                        MU_Substitutes[code].len, szTranslatedString,
                        &pTranslatedString);
                }
                else
                {
                    safe_chr(ch, szTranslatedString, &pTranslatedString);
                }
            }
            acsPrevious = acsCurrent;

            if (nTokenLength1)
            {
                // Process ANSI
                //
                ANSI_Parse_m(&acsCurrent, nTokenLength1, pString, &bSawNormal);
                pString += nTokenLength1;
                nString -= nTokenLength1;
            }
        }
        else
        {
            // Process ANSI
            //
            ANSI_Parse_m(&acsCurrent, nTokenLength0, pString, &bSawNormal);
            nString -= nTokenLength0;
            pString += nTokenLength0;
        }
    }
    *pTranslatedString = '\0';
    return szTranslatedString;
}

char* trim_spaces

(

char *

)

Definition at line 1524 of file stringutil.cpp.

References alloc_lbuf, and mux_isspace.

Referenced by create_player(), do_alias(), and do_name().

{
    char *buffer = alloc_lbuf("trim_spaces");
    char *p = string;
    char *q = buffer;

    if (p)
    {
        // Remove initial spaces.
        //
        while (mux_isspace(*p))
        {
            p++;
        }

        while (*p)
        {
            // Copy non-space characters.
            //
            while (*p && !mux_isspace(*p))
            {
                *q++ = *p++;
            }

            // Compress spaces.
            //
            while (mux_isspace(*p))
            {
                p++;
            }

            // Leave one space.
            //
            if (*p)
            {
                *q++ = ' ';
            }
        }
    }

    // Terminate string.
    //
    *q = '\0';
    return buffer;
}

---

Variable Documentation

bool mux_AttrNameInitialSet[256]

Definition at line 231 of file stringutil.cpp.

bool mux_AttrNameSet[256]

Definition at line 254 of file stringutil.cpp.

const unsigned char mux_hex2dec[256]

Definition at line 404 of file stringutil.cpp.

const bool mux_isalnum[256]

Definition at line 132 of file stringutil.cpp.

const bool mux_isalpha[256]

Definition at line 109 of file stringutil.cpp.

const bool mux_isazAZ[256]

Definition at line 86 of file stringutil.cpp.

const bool mux_isdigit[256]

Definition at line 40 of file stringutil.cpp.

const bool mux_isescape[256]

Definition at line 358 of file stringutil.cpp.

const bool mux_ishex[256]

Definition at line 63 of file stringutil.cpp.

const bool mux_islower[256]

Definition at line 178 of file stringutil.cpp.

const bool mux_isprint[256]

Definition at line 17 of file stringutil.cpp.

const bool mux_issecure[256]

Definition at line 332 of file stringutil.cpp.

const bool mux_isspace[256]

Definition at line 201 of file stringutil.cpp.

const bool mux_isupper[256]

Definition at line 155 of file stringutil.cpp.

const bool mux_ObjectNameSet[256]

Definition at line 280 of file stringutil.cpp.

bool mux_PlayerNameSet[256]

Definition at line 306 of file stringutil.cpp.

const unsigned char mux_StripAccents[256]

Definition at line 472 of file stringutil.cpp.

const unsigned char mux_tolower[256]

Definition at line 449 of file stringutil.cpp.

const unsigned char mux_toupper[256]

Definition at line 426 of file stringutil.cpp.

---