mux/src/stringutil.cpp File Reference

#include "copyright.h"
#include "autoconf.h"
#include "config.h"
#include "externs.h"
#include "ansi.h"
#include "pcre.h"

Include dependency graph for stringutil.cpp:

Go to the source code of this file.

Data Structures
struct	LITERAL_STRING_STRUCT
Defines
#define	ANSI_COLOR_INDEX_BLACK   0
#define	ANSI_COLOR_INDEX_RED   1
#define	ANSI_COLOR_INDEX_GREEN   2
#define	ANSI_COLOR_INDEX_YELLOW   3
#define	ANSI_COLOR_INDEX_BLUE   4
#define	ANSI_COLOR_INDEX_MAGENTA   5
#define	ANSI_COLOR_INDEX_CYAN   6
#define	ANSI_COLOR_INDEX_WHITE   7
#define	ANSI_COLOR_INDEX_DEFAULT   8
#define	ANSI_MAXIMUM_BINARY_TRANSITION_LENGTH   60
#define	ANSI_MAXIMUM_ESCAPE_TRANSITION_LENGTH   42
#define	ATOF_LIMIT   100
#define	VSNPRINTF   vsnprintf
#define	BMH_LARGE   32767
Functions
int	ANSI_lex (int nString, const char *pString, int *nLengthToken0, int *nLengthToken1)
char *	strip_ansi (const char *szString, size_t *pnString)
char *	strip_accents (const char *szString, size_t *pnString)
static void	ANSI_Parse_m (ANSI_ColorState *pacsCurrent, int nANSI, const char *pANSI, bool *pbSawNormal)
static char *	ANSI_TransitionColorBinary (ANSI_ColorState *acsCurrent, const ANSI_ColorState *pcsNext, int *nTransition, int iEndGoal)
static char *	ANSI_TransitionColorEscape (ANSI_ColorState *acsCurrent, ANSI_ColorState *acsNext, int *nTransition)
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 maxVisualWidth0)
int	ANSI_String_Finalize (struct ANSI_Out_Context *pacOut, int *pnVisualWidth)
int	ANSI_TruncateToField (const char *szString, int nField, char *pField0, int maxVisualWidth, int *pnVisualWidth, int iEndGoal)
char *	ANSI_TruncateAndPad_sbuf (const char *pString, int nMaxVisualWidth, char fill)
char *	normal_to_white (const char *szString)
char *	translate_string (const char *szString, bool bConvert)
char *	munge_space (const char *string)
char *	trim_spaces (char *string)
char *	grabto (char **str, char targ)
int	string_compare (const char *s1, const char *s2)
int	string_prefix (const char *string, const char *prefix)
const char *	string_match (const char *src, const char *sub)
char *	replace_string (const char *old, const char *new0, const char *s)
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 nSizeOfBuffer)
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 **bufc)
size_t	safe_fill (char *buff, char **bufc, char chFill, size_t nSpaces)
bool	matches_exit_from_list (char *str, const char *pattern)
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)
void	safe_i64toa (INT64 val, char *buff, char **bufc)
long	mux_atol (const char *pString)
INT64	mux_atoi64 (const char *pString)
bool	ParseFloat (PARSE_FLOAT_RESULT *pfr, const char *str, bool bStrict)
double	mux_atof (char *szString, bool bStrict)
char *	mux_ftoa (double r, bool bRounded, int frac)
bool	is_integer (char *str, int *pDigits)
bool	is_rational (char *str)
bool	is_real (char *str)
void	mux_strtok_src (MUX_STRTOK_STATE *tts, char *arg_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)
void	ItemToList_Init (ITL *p, char *arg_buff, char **arg_bufc, char arg_chPrefix, char arg_chSep)
bool	ItemToList_AddInteger (ITL *pContext, int i)
bool	ItemToList_AddStringLEN (ITL *pContext, size_t nStr, char *pStr)
bool	ItemToList_AddString (ITL *pContext, char *pStr)
void	ItemToList_Final (ITL *pContext)
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 *a)
void	mux_strupr (char *a)
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)
	CF_HAND (cf_art_rule)
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_isupper [256]
const bool	mux_islower [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 bool	ANSI_TokenTerminatorTable [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]
static const ANSI_ColorState	acsRestingStates [3]
static LITERAL_STRING_STRUCT	MU_Substitutes []
const unsigned char	MU_EscapeConvert [256]
const unsigned char	MU_EscapeNoConvert [256]
const char	Digits100 [201]
const char	TableATOI [16][10]
static const double	powerstab [10]

---

Define Documentation

#define ANSI_COLOR_INDEX_BLACK   0

Definition at line 641 of file stringutil.cpp.

#define ANSI_COLOR_INDEX_BLUE   4

Definition at line 645 of file stringutil.cpp.

#define ANSI_COLOR_INDEX_CYAN   6

Definition at line 647 of file stringutil.cpp.

#define ANSI_COLOR_INDEX_DEFAULT   8

Definition at line 649 of file stringutil.cpp.

Referenced by ANSI_TransitionColorBinary(), and ANSI_TransitionColorEscape().

#define ANSI_COLOR_INDEX_GREEN   2

Definition at line 643 of file stringutil.cpp.

#define ANSI_COLOR_INDEX_MAGENTA   5

Definition at line 646 of file stringutil.cpp.

#define ANSI_COLOR_INDEX_RED   1

Definition at line 642 of file stringutil.cpp.

#define ANSI_COLOR_INDEX_WHITE   7

Definition at line 648 of file stringutil.cpp.

#define ANSI_COLOR_INDEX_YELLOW   3

Definition at line 644 of file stringutil.cpp.

#define ANSI_MAXIMUM_BINARY_TRANSITION_LENGTH   60

Definition at line 771 of file stringutil.cpp.

Referenced by ANSI_TransitionColorBinary().

#define ANSI_MAXIMUM_ESCAPE_TRANSITION_LENGTH   42

Definition at line 859 of file stringutil.cpp.

Referenced by ANSI_TransitionColorEscape().

#define ATOF_LIMIT   100

Definition at line 2479 of file stringutil.cpp.

Referenced by mux_atof().

#define BMH_LARGE   32767

Definition at line 3276 of file stringutil.cpp.

Referenced by BMH_Execute(), BMH_ExecuteI(), BMH_Prepare(), and BMH_PrepareI().

#define VSNPRINTF   vsnprintf

Definition at line 3174 of file stringutil.cpp.

Referenced by mux_vsnprintf().

---

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;
            }
        }
    }
}

static void ANSI_Parse_m	(	ANSI_ColorState *	pacsCurrent,
		int	nANSI,
		const char *	pANSI,
		bool *	pbSawNormal
	)			[static]

Definition at line 658 of file stringutil.cpp.

References acsRestingStates, ANSI_ENDGOAL_NORMAL, ANSI_ColorState::bBlink, ANSI_ColorState::bHighlite, ANSI_ColorState::bInverse, ANSI_ColorState::bNormal, ANSI_ColorState::bUnder, ANSI_ColorState::iBackground, ANSI_ColorState::iForeground, and mux_isdigit.

Referenced by ANSI_String_Copy(), ANSI_String_Skip(), and translate_string().

{
    // If the last character isn't an 'm', then it's an ANSI sequence we
    // don't support, yet. TODO: There should be a ANSI_Parse() function
    // that calls into this one -only- if there's an 'm', but since 'm'
    // is the only command this game understands at the moment, it's easier
    // to put the test here.
    //
    if (pANSI[nANSI-1] != 'm')
    {
        return;
    }

    // Process entire string and update the current color state structure.
    //
    while (nANSI)
    {
        // Process the next attribute phrase (terminated by ';' or 'm'
        // typically).
        //
        const char *p = pANSI;
        while (mux_isdigit(*p))
        {
            p++;
        }
        size_t nLen = p - pANSI + 1;
        if (p[0] == 'm' || p[0] == ';')
        {
            // We have an attribute.
            //
            if (nLen == 2)
            {
                int iCode = pANSI[0] - '0';
                switch (iCode)
                {
                case 0:
                    // Normal.
                    //
                    *pacsCurrent = acsRestingStates[ANSI_ENDGOAL_NORMAL];
                    *pbSawNormal = true;
                    break;

                case 1:
                    // High Intensity.
                    //
                    pacsCurrent->bHighlite = true;
                    pacsCurrent->bNormal = false;
                    break;

                case 2:
                    // Low Intensity.
                    //
                    pacsCurrent->bHighlite = false;
                    pacsCurrent->bNormal = false;
                    break;

                case 4:
                    // Underline.
                    //
                    pacsCurrent->bUnder = true;
                    pacsCurrent->bNormal = false;
                    break;

                case 5:
                    // Blinking.
                    //
                    pacsCurrent->bBlink = true;
                    pacsCurrent->bNormal = false;
                    break;

                case 7:
                    // Reverse Video
                    //
                    pacsCurrent->bInverse = true;
                    pacsCurrent->bNormal = false;
                    break;
                }
            }
            else if (nLen == 3)
            {
                int iCode0 = pANSI[0] - '0';
                int iCode1 = pANSI[1] - '0';
                if (iCode0 == 3)
                {
                    // Foreground Color
                    //
                    if (iCode1 <= 7)
                    {
                        pacsCurrent->iForeground = iCode1;
                        pacsCurrent->bNormal = false;
                    }
                }
                else if (iCode0 == 4)
                {
                    // Background Color
                    //
                    if (iCode1 <= 7)
                    {
                        pacsCurrent->iBackground = iCode1;
                        pacsCurrent->bNormal = false;
                    }
                }
            }
        }
        pANSI += nLen;
        nANSI -= nLen;
    }
}

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

Definition at line 1055 of file stringutil.cpp.

References acsRestingStates, ANSI_ENDGOAL_NOBLEED, ANSI_lex(), ANSI_Parse_m(), ANSI_TransitionColorBinary(), ANSI_In_Context::m_acs, ANSI_Out_Context::m_acs, ANSI_Out_Context::m_bDone, ANSI_In_Context::m_bSawNormal, ANSI_Out_Context::m_iEndGoal, ANSI_In_Context::m_n, ANSI_Out_Context::m_n, ANSI_Out_Context::m_nMax, ANSI_Out_Context::m_p, ANSI_In_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;
        }
    }
}

static char* ANSI_TransitionColorBinary	(	ANSI_ColorState *	acsCurrent,
		const ANSI_ColorState *	pcsNext,
		int *	nTransition,
		int	iEndGoal
	)			[static]

Definition at line 777 of file stringutil.cpp.

References acsRestingStates, ANSI_ATTR_CMD, ANSI_BACKGROUND, ANSI_BLINK, ANSI_COLOR_INDEX_DEFAULT, ANSI_ENDGOAL_NORMAL, ANSI_FOREGROUND, ANSI_HILITE, ANSI_INVERSE, ANSI_MAXIMUM_BINARY_TRANSITION_LENGTH, ANSI_NORMAL, ANSI_UNDER, ANSI_ColorState::bBlink, ANSI_ColorState::bHighlite, ANSI_ColorState::bInverse, ANSI_ColorState::bNormal, ANSI_ColorState::bUnder, ANSI_ColorState::iBackground, and ANSI_ColorState::iForeground.

Referenced by ANSI_String_Copy(), and ANSI_String_Finalize().

{
    static char Buffer[ANSI_MAXIMUM_BINARY_TRANSITION_LENGTH+1];

    if (memcmp(acsCurrent, pcsNext, sizeof(ANSI_ColorState)) == 0)
    {
        *nTransition = 0;
        Buffer[0] = '\0';
        return Buffer;
    }
    ANSI_ColorState tmp = *acsCurrent;
    char *p = Buffer;

    if (pcsNext->bNormal)
    {
        // With NOBLEED, we can't stay in the normal mode. We must eventually
        // be on a white foreground.
        //
        pcsNext = &acsRestingStates[iEndGoal];
    }

    // Do we need to go through the normal state?
    //
    if (  tmp.bHighlite && !pcsNext->bHighlite
       || tmp.bUnder    && !pcsNext->bUnder
       || tmp.bBlink    && !pcsNext->bBlink
       || tmp.bInverse  && !pcsNext->bInverse
       || (  tmp.iBackground != ANSI_COLOR_INDEX_DEFAULT
          && pcsNext->iBackground == ANSI_COLOR_INDEX_DEFAULT)
       || (  tmp.iForeground != ANSI_COLOR_INDEX_DEFAULT
          && pcsNext->iForeground == ANSI_COLOR_INDEX_DEFAULT))
    {
        memcpy(p, ANSI_NORMAL, sizeof(ANSI_NORMAL)-1);
        p += sizeof(ANSI_NORMAL)-1;
        tmp = acsRestingStates[ANSI_ENDGOAL_NORMAL];
    }
    if (tmp.bHighlite != pcsNext->bHighlite)
    {
        memcpy(p, ANSI_HILITE, sizeof(ANSI_HILITE)-1);
        p += sizeof(ANSI_HILITE)-1;
    }
    if (tmp.bUnder != pcsNext->bUnder)
    {
        memcpy(p, ANSI_UNDER, sizeof(ANSI_UNDER)-1);
        p += sizeof(ANSI_UNDER)-1;
    }
    if (tmp.bBlink != pcsNext->bBlink)
    {
        memcpy(p, ANSI_BLINK, sizeof(ANSI_BLINK)-1);
        p += sizeof(ANSI_BLINK)-1;
    }
    if (tmp.bInverse != pcsNext->bInverse)
    {
        memcpy(p, ANSI_INVERSE, sizeof(ANSI_INVERSE)-1);
        p += sizeof(ANSI_INVERSE)-1;
    }
    if (tmp.iForeground != pcsNext->iForeground)
    {
        memcpy(p, ANSI_FOREGROUND, sizeof(ANSI_FOREGROUND)-1);
        p += sizeof(ANSI_FOREGROUND)-1;
        *p++ = pcsNext->iForeground + '0';
        *p++ = ANSI_ATTR_CMD;
    }
    if (tmp.iBackground != pcsNext->iBackground)
    {
        memcpy(p, ANSI_BACKGROUND, sizeof(ANSI_BACKGROUND)-1);
        p += sizeof(ANSI_BACKGROUND)-1;
        *p++ = pcsNext->iBackground + '0';
        *p++ = ANSI_ATTR_CMD;
    }
    *p = '\0';
    *nTransition = p - Buffer;
    return Buffer;
}

static char* ANSI_TransitionColorEscape	(	ANSI_ColorState *	acsCurrent,
		ANSI_ColorState *	acsNext,
		int *	nTransition
	)			[static]

Definition at line 865 of file stringutil.cpp.

References acsRestingStates, ANSI_COLOR_INDEX_DEFAULT, ANSI_ENDGOAL_NORMAL, ANSI_MAXIMUM_ESCAPE_TRANSITION_LENGTH, ANSI_ColorState::bBlink, ANSI_ColorState::bHighlite, ANSI_ColorState::bInverse, ANSI_ColorState::bUnder, ANSI_ColorState::iBackground, and ANSI_ColorState::iForeground.

Referenced by translate_string().

{
    static char Buffer[ANSI_MAXIMUM_ESCAPE_TRANSITION_LENGTH+1];
    static const char cForegroundColors[9] = "xrgybmcw";
    static const char cBackgroundColors[9] = "XRGYBMCW";

    if (memcmp(acsCurrent, acsNext, sizeof(ANSI_ColorState)) == 0)
    {
        *nTransition = 0;
        Buffer[0] = '\0';
        return Buffer;
    }
    ANSI_ColorState tmp = *acsCurrent;
    int  i = 0;

    // Do we need to go through the normal state?
    //
    if (  tmp.bBlink    && !acsNext->bBlink
       || tmp.bHighlite && !acsNext->bHighlite
       || tmp.bInverse  && !acsNext->bInverse
       || (  tmp.iBackground != ANSI_COLOR_INDEX_DEFAULT
          && acsNext->iBackground == ANSI_COLOR_INDEX_DEFAULT)
       || (  tmp.iForeground != ANSI_COLOR_INDEX_DEFAULT
          && acsNext->iForeground == ANSI_COLOR_INDEX_DEFAULT))
    {
        Buffer[i  ] = '%';
        Buffer[i+1] = 'x';
        Buffer[i+2] = 'n';
        i = i + 3;
        tmp = acsRestingStates[ANSI_ENDGOAL_NORMAL];
    }
    if (tmp.bHighlite != acsNext->bHighlite)
    {
        Buffer[i  ] = '%';
        Buffer[i+1] = 'x';
        Buffer[i+2] = 'h';
        i = i + 3;
    }
    if (tmp.bUnder != acsNext->bUnder)
    {
        Buffer[i  ] = '%';
        Buffer[i+1] = 'x';
        Buffer[i+2] = 'u';
        i = i + 3;
    }
    if (tmp.bBlink != acsNext->bBlink)
    {
        Buffer[i  ] = '%';
        Buffer[i+1] = 'x';
        Buffer[i+2] = 'f';
        i = i + 3;
    }
    if (tmp.bInverse != acsNext->bInverse)
    {
        Buffer[i  ] = '%';
        Buffer[i+1] = 'x';
        Buffer[i+2] = 'i';
        i = i + 3;
    }
    if (tmp.iForeground != acsNext->iForeground)
    {
        Buffer[i  ] = '%';
        Buffer[i+1] = 'x';
        Buffer[i+2] = cForegroundColors[acsNext->iForeground];
        i = i + 3;
    }
    if (tmp.iBackground != acsNext->iBackground)
    {
        Buffer[i  ] = '%';
        Buffer[i+1] = 'x';
        Buffer[i+2] = cBackgroundColors[acsNext->iBackground];
        i = i + 3;
    }
    Buffer[i] = '\0';
    *nTransition = i;
    return Buffer;
}

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,