{

int nLenDst = _tcslen( pDst );

int nLenSrc = _tcslen( pSrc );

int nSpcDst = nDstSize - nLenDst;

int nChars = MIN( nLenSrc, nSpcDst );

bool bOverflow = (nSpcDst <= nLenSrc); // 2.5.6.25 BUGFIX

if (bOverflow)

{

return false;

}

return true;

{

int nLenDst = _tcslen( pDst );

int nLenSrc = _tcslen( pSrc );

int nSpcDst = nDstSize - nLenDst;

int nChars = MIN( nLenSrc, nSpcDst );

bool bOverflow = (nSpcDst < nLenSrc);

if (bOverflow)

{

return false;

}

_tcsncat( pDst, pSrc, nChars );

return true;

{

int nLenDst = _tcslen( pDst );

int nLenSrc = _tcslen( pSrc );

int nSpcDst = nDstSize - nLenDst;

int nChars = MIN( nLenSrc, nSpcDst );

_tcsncat( pDst, pSrc, nChars );

bool bOverflow = (nSpcDst < nLenSrc);

if (bOverflow)

return 0;

return nChars;

{

_Arg_1( iCommandHelp );

wsprintf( g_aArgs[ 1 ].sArg, "%s", g_aCommands[ iCommandHelp ].m_sName ); // .3 Fixed: Help_Arg_1() now copies command name into arg.name

return CmdHelpSpecific( 1 );

{

const int nBuf = CONSOLE_WIDTH * 2;

char sText[ nBuf ] = "";

int nLen = 0;

// TODO/FIXME: Colorize( sText, ... )

// Colorize("Usage:")

nLen += StringCat( sText, CHC_USAGE , nBuf );

nLen += StringCat( sText, "Usage", nBuf );

nLen += StringCat( sText, CHC_DEFAULT, nBuf );

nLen += StringCat( sText, ": " , nBuf );

nLen += StringCat( sText, CHC_ARG_OPT, nBuf );

nLen += StringCat( sText, "[ ", nBuf );

nLen += StringCat( sText, CHC_ARG_MAND, nBuf );

nLen += StringCat( sText, "< ", nBuf );

for (int iCategory = _PARAM_HELPCATEGORIES_BEGIN ; iCategory < _PARAM_HELPCATEGORIES_END; iCategory++)

{

char *pName = g_aParameters[ iCategory ].m_sName;

if (nLen + strlen( pName ) >= (CONSOLE_WIDTH - 1))

{

ConsolePrint( sText );

sText[ 0 ] = 0;

nLen = StringCat( sText, " ", nBuf ); // indent

}

StringCat( sText, CHC_COMMAND, nBuf );

nLen += StringCat( sText, pName , nBuf );

if (iCategory < (_PARAM_HELPCATEGORIES_END - 1))

{

char sSep[] = " | ";

if (nLen + strlen( sSep ) >= (CONSOLE_WIDTH - 1))

{

ConsolePrint( sText );

sText[ 0 ] = 0;

nLen = StringCat( sText, " ", nBuf ); // indent

}

StringCat( sText, CHC_ARG_SEP, nBuf );

nLen += StringCat( sText, sSep, nBuf );

}

}

StringCat( sText, CHC_ARG_MAND, nBuf );

StringCat( sText, " >", nBuf);

StringCat( sText, CHC_ARG_OPT, nBuf );

StringCat( sText, " ]", nBuf);

ConsolePrint( sText ); // Transcode colored text to native console color text

ConsolePrintFormat( sText, "%sNotes%s: %s<>%s = mandatory, %s[]%s = optional, %s|%s argument option"

, CHC_USAGE

, CHC_DEFAULT

, CHC_ARG_MAND

, CHC_DEFAULT

, CHC_ARG_OPT

, CHC_DEFAULT

, CHC_ARG_SEP

, CHC_DEFAULT

);

{

char sText[ CONSOLE_WIDTH ];

ConsolePrintFormat( sText, " %sExamples%s:"

, CHC_USAGE

, CHC_DEFAULT

);

{

ConsoleBufferPush( " Where <range> is of the form:" );

ConsoleBufferPush( " address , length [address,address+length)" );

ConsoleBufferPush( " address : end [address,end]" );

{

char sText[ CONSOLE_WIDTH ];

ConsolePrintFormat( sText," Operators: (%sMath%s)" , CHC_USAGE, CHC_DEFAULT );

ConsolePrintFormat( sText," %s+%s Addition" , CHC_USAGE, CHC_DEFAULT );

ConsolePrintFormat( sText," %s-%s Subtraction" , CHC_USAGE, CHC_DEFAULT );

ConsolePrintFormat( sText," %s*%s Multiplication" , CHC_USAGE, CHC_DEFAULT );

ConsolePrintFormat( sText," %s/%s Division" , CHC_USAGE, CHC_DEFAULT );

ConsolePrintFormat( sText," %s%%%s Modulas or Remainder" , CHC_USAGE, CHC_DEFAULT );

ConsolePrintFormat( sText," Operators: (%sBit Wise%s)" , CHC_USAGE, CHC_DEFAULT );

ConsolePrintFormat( sText," %s&%s Bit-wise and (AND)" , CHC_USAGE, CHC_DEFAULT );

ConsolePrintFormat( sText," %s|%s Bit-wise or (OR )" , CHC_USAGE, CHC_DEFAULT );

ConsolePrintFormat( sText," %s^%s Bit-wise exclusive-or (EOR/XOR)" , CHC_USAGE, CHC_DEFAULT );

ConsolePrintFormat( sText," %s!%s Bit-wise negation (NOT)" , CHC_USAGE, CHC_DEFAULT );

ConsolePrintFormat( sText," Operators: (%sInput%s)" , CHC_USAGE, CHC_DEFAULT );

ConsolePrintFormat( sText," %s@%s next number refers to search results", CHC_USAGE, CHC_DEFAULT );

ConsolePrintFormat( sText," %s\"%s Designate string in ASCII format" , CHC_USAGE, CHC_DEFAULT );

ConsolePrintFormat( sText," %s\'%s Desginate string in High-Bit apple format", CHC_USAGE, CHC_DEFAULT );

ConsolePrintFormat( sText," %s$%s Designate number/symbol" , CHC_USAGE, CHC_DEFAULT );

ConsolePrintFormat( sText," %s#%s Designate number in hex" , CHC_USAGE, CHC_DEFAULT );

ConsolePrintFormat( sText," Operators: (%sRange%s)" , CHC_USAGE, CHC_DEFAULT );

ConsolePrintFormat( sText," %s,%s range seperator (2nd address is relative)", CHC_USAGE, CHC_DEFAULT );

ConsolePrintFormat( sText," %s:%s range seperator (2nd address is absolute)", CHC_USAGE, CHC_DEFAULT );

ConsolePrintFormat( sText," Operators: (%sMisc%s)" , CHC_USAGE, CHC_DEFAULT );

ConsolePrintFormat( sText," %s//%s comment until end of line" , CHC_USAGE, CHC_DEFAULT );

ConsolePrintFormat( sText," Operators: (%sBreakpoint%s)" , CHC_USAGE, CHC_DEFAULT );

_tcscpy( sText, " " );

_tcscat( sText, CHC_USAGE );

int iBreakOp = 0;

for( iBreakOp = 0; iBreakOp < NUM_BREAKPOINT_OPERATORS; iBreakOp++ )

{

if ((iBreakOp >= PARAM_BP_LESS_EQUAL) &&

(iBreakOp <= PARAM_BP_GREATER_EQUAL))

{

_tcscat( sText, g_aBreakpointSymbols[ iBreakOp ] );

_tcscat( sText, " " );

}

}

_tcscat( sText, CHC_DEFAULT );

ConsolePrint( sText );

{

ConsoleBufferPush(" Scrolling:" );

ConsoleBufferPush(" Up Arrow" );

ConsoleBufferPush(" Down Arrow" );

ConsoleBufferPush(" Shift + Up Arrow" );

ConsoleBufferPush(" Shift + Down Arrow" );

ConsoleBufferPush(" Page Up" );

ConsoleBufferPush(" Page Down" );

ConsoleBufferPush(" Shift + Page Up" );

ConsoleBufferPush(" Shift + Page Down" );

ConsoleBufferPush(" Bookmarks:" );

ConsoleBufferPush(" Ctrl-Shift-#" );

ConsoleBufferPush(" Ctrl-# " );

char * & pDst,const char * & pSrc,

const char * pHeader, const int nHeaderLen )

{

int nLen;

nLen = strlen( CHC_USAGE );

strcpy( pDst, CHC_USAGE );

pDst += nLen;

nLen = nHeaderLen - 1;

strncpy( pDst, pHeader, nLen );

pDst += nLen;

pSrc += nHeaderLen;

nLen = strlen( CHC_ARG_SEP );

strcpy( pDst, CHC_ARG_SEP );

pDst += nLen;

*pDst = ':';

pDst++;

nLen = strlen( CHC_DEFAULT );

strcpy( pDst, CHC_DEFAULT );

pDst += nLen;

char * & pDst, const char * & pSrc,

char * pOperator )

{

int nLen;

nLen = strlen( pOperator );

strcpy( pDst, pOperator );

pDst += nLen;

*pDst = *pSrc;

pDst++;

nLen = strlen( CHC_DEFAULT );

strcpy( pDst, CHC_DEFAULT );

pDst += nLen;

pSrc++;

{

if (! pSrc)

return false;

if (! pDst)

return false;

const char sNote [] = "Note:";

const int nNote = sizeof( sNote ) - 1;

const char sSeeAlso[] = "See also:";

const char nSeeAlso = sizeof( sSeeAlso ) - 1;

const char sUsage[] = "Usage:";

const int nUsage = sizeof( sUsage ) - 1;

const char sTotal[] = "Total:";

const int nTotal = sizeof( sTotal ) - 1;

int nLen = 0;

while (*pSrc)

{

if (strncmp( sUsage, pSrc, nUsage) == 0)

{

_ColorizeHeader( pDst, pSrc, sUsage, nUsage );

}

else

if (strncmp( sSeeAlso, pSrc, nSeeAlso) == 0)

{

_ColorizeHeader( pDst, pSrc, sSeeAlso, nSeeAlso );

}

else

if (strncmp( sNote, pSrc, nNote) == 0)

{

_ColorizeHeader( pDst, pSrc, sNote, nNote );

}

else

if (strncmp( sTotal, pSrc, nNote) == 0)

{

_ColorizeHeader( pDst, pSrc, sTotal, nTotal );

}

else

if (*pSrc == '[')

{

_ColorizeOperator( pDst, pSrc, CHC_ARG_OPT );

}

else

if (*pSrc == ']')

{

_ColorizeOperator( pDst, pSrc, CHC_ARG_OPT );

}

else

if (*pSrc == '<')

{

_ColorizeOperator( pDst, pSrc, CHC_ARG_MAND );

}

else

if (*pSrc == '>')

{

_ColorizeOperator( pDst, pSrc, CHC_ARG_MAND );

}

else

if (*pSrc == '|')

{

_ColorizeOperator( pDst, pSrc, CHC_ARG_SEP );

}

else

if (*pSrc == '\'')

{

_ColorizeOperator( pDst, pSrc, CHC_ARG_SEP );

}

else

{

*pDst = *pSrc;

pDst++;

pSrc++;

}

}

*pDst = 0;

return true;

const char* pText )

{

if (!Colorize(colorizeBuf, pText)) return false;

return ConsolePrint(colorizeBuf);

const char* pText )

{

return ConsoleColorizePrint(colorizeBuf, _ColorizeBufSz, pText);

char* buf, size_t bufsz,

const char* format, va_list va )

{

vsnprintf_s(buf, bufsz, _TRUNCATE, format, va);

return ConsoleColorizePrint(colorizeBuf, colorizeBufSz, buf);

char (&buf)[_BufSz],

const char* format, va_list va )

{

return ConsoleColorizePrintVa(colorizeBuf, _ColorizeBufSz, buf, _BufSz, format, va);

char* buf, size_t bufsz,

const char* format, ... )

{

va_list va;

va_start(va, format);

bool const r = ConsoleColorizePrintVa(colorizeBuf, colorizeBufSz, buf, bufsz, format, va);

va_end(va);

return r;

char (&buf)[_BufSz],

const char* format, ... )

{

va_list va;

va_start(va, format);

bool const r = ConsoleColorizePrintVa(colorizeBuf, buf, format, va);

va_end(va);

return r;

{

char sText[ CONSOLE_WIDTH*2 ];

char sTemp[ CONSOLE_WIDTH*2 ];

#if DEBUG_COLOR_CONSOLE

ConsolePrint( "`" );

ConsolePrint( "`A" );

ConsolePrint( "`2`A" );

#endif

ConsolePrintFormat( sText, "`9`A`7 Apple `9][ ][+ //e `7Emulator for Windows (TM) `9`@" );

CmdVersion(0);

CmdSymbols(0);

ConsoleColorizePrintFormat( sTemp, sText, " '%sCtrl ~'%s console, '%s%s'%s (specific), '%s%s'%s (all)"

, CHC_KEY

, CHC_DEFAULT

, CHC_COMMAND

, g_aCommands[ CMD_HELP_SPECIFIC ].m_sName

, CHC_DEFAULT

, CHC_COMMAND

, g_aCommands[ CMD_HELP_LIST ].m_sName

, CHC_DEFAULT

);

ConsoleUpdate();

return UPDATE_ALL;

{

int iArg;

char sText[ CONSOLE_WIDTH * 2 ];

char sTemp[ CONSOLE_WIDTH * 2 ];

ZeroMemory( sText, CONSOLE_WIDTH*2 );

ZeroMemory( sTemp, CONSOLE_WIDTH*2 );

if (! nArgs)

{

Help_Categories();

return ConsoleUpdate();

}

CmdFuncPtr_t pFunction = NULL;

bool bAllCommands = false;

bool bCategory = false;

bool bDisplayCategory = true;

if ((! _tcscmp( g_aArgs[1].sArg, g_aParameters[ PARAM_WILDSTAR ].m_sName)) ||

(! _tcscmp( g_aArgs[1].sArg, g_aParameters[ PARAM_MEM_SEARCH_WILD ].m_sName)) )

{

bAllCommands = true;

nArgs = NUM_COMMANDS;

}

// If Help on category, push command name as arg

// Mame has categories:

// General, Memory, Execution, Breakpoints, Watchpoints, Expressions, Comments

int iParam = 0;

int nNewArgs = 0;

int iCmdBegin = 0;

int iCmdEnd = 0;

int nFound = 0;

int iCommand = 0;

if (! bAllCommands)

{

for (iArg = 1; iArg <= nArgs; iArg++ )

{

// int nFoundCategory = FindParam( g_aArgs[ iArg ].sArg, MATCH_EXACT, iParam, _PARAM_HELPCATEGORIES_BEGIN, _PARAM_HELPCATEGORIES_END );

int nFoundCategory = FindParam( g_aArgs[ iArg ].sArg, MATCH_FUZZY, iParam, _PARAM_HELPCATEGORIES_BEGIN, _PARAM_HELPCATEGORIES_END );

if( nFoundCategory )

bCategory = true;

else

bCategory = false;

switch( iParam )

{

case PARAM_CAT_BOOKMARKS : iCmdBegin = CMD_BOOKMARK ; iCmdEnd = CMD_BOOKMARK_SAVE ; break;

case PARAM_CAT_BREAKPOINTS: iCmdBegin = CMD_BREAK_INVALID ; iCmdEnd = CMD_BREAKPOINT_SAVE ; break;

case PARAM_CAT_CONFIG : iCmdBegin = CMD_BENCHMARK ; iCmdEnd = CMD_CONFIG_SET_DEBUG_DIR; break;

case PARAM_CAT_CPU : iCmdBegin = CMD_ASSEMBLE ; iCmdEnd = CMD_UNASSEMBLE ; break;

case PARAM_CAT_FLAGS :

nFound = FindCommand( g_aArgs[iArg].sArg, pFunction, & iCommand ); // check if we have an exact command match first

if ( nFound ) // && (iCommand != CMD_MEMORY_FILL))

bCategory = false;

else if ( nFoundCategory )

{

iCmdBegin = CMD_FLAG_CLEAR ; iCmdEnd = CMD_FLAG_SET_N;

}

break;

case PARAM_CAT_HELP : iCmdBegin = CMD_HELP_LIST ; iCmdEnd = CMD_MOTD ; break;

case PARAM_CAT_KEYBOARD :

nFound = FindCommand( g_aArgs[iArg].sArg, pFunction, & iCommand ); // check if we have an exact command match first

if ((!nFound) || (iCommand != CMD_INPUT_KEY))

{

nArgs = 0;

Help_KeyboardShortcuts();

}

bCategory = false;

break;

case PARAM_CAT_MEMORY :

nFound = FindCommand( g_aArgs[iArg].sArg, pFunction, & iCommand ); // check if we have an exact command match first

if ( nFound )// && (iCommand != CMD_MEMORY_MOVE))

bCategory = false;

else if ( nFoundCategory )

{

iCmdBegin = CMD_MEMORY_COMPARE ; iCmdEnd = CMD_MEMORY_FILL ;

}

break;

case PARAM_CAT_OUTPUT :

nFound = FindCommand( g_aArgs[iArg].sArg, pFunction, & iCommand ); // check if we have an exact command match first

if ( nFound ) // && (iCommand != CMD_OUT))

bCategory = false;

else if ( nFoundCategory )

{

iCmdBegin = CMD_OUTPUT_CALC ; iCmdEnd = CMD_OUTPUT_RUN ;

}

break;

case PARAM_CAT_SYMBOLS :

nFound = FindCommand( g_aArgs[iArg].sArg, pFunction, & iCommand ); // check if we have an exact command match first

if ( nFound ) // && (iCommand != CMD_SYMBOLS_LOOKUP) && (iCommand != CMD_MEMORY_SEARCH))

bCategory = false;

else if ( nFoundCategory )

{

iCmdBegin = CMD_SYMBOLS_LOOKUP ; iCmdEnd = CMD_SYMBOLS_LIST ;

}

break;

case PARAM_CAT_VIEW :

{

iCmdBegin = CMD_VIEW_TEXT4X ; iCmdEnd = CMD_VIEW_DHGR2 ;

}

break;

case PARAM_CAT_WATCHES :

nFound = FindCommand( g_aArgs[iArg].sArg, pFunction, & iCommand ); // check if we have an exact command match first

if (nFound) {

bCategory = false;

} else // 2.7.0.17: HELP <category> wasn't displaying when category was one of: FLAGS, OUTPUT, WATCHES

if( nFoundCategory )

{

iCmdBegin = CMD_WATCH_ADD ; iCmdEnd = CMD_WATCH_LIST ;

}

break;

case PARAM_CAT_WINDOW : iCmdBegin = CMD_WINDOW ; iCmdEnd = CMD_WINDOW_OUTPUT ; break;

case PARAM_CAT_ZEROPAGE : iCmdBegin = CMD_ZEROPAGE_POINTER; iCmdEnd = CMD_ZEROPAGE_POINTER_SAVE; break;

case PARAM_CAT_OPERATORS : nArgs = 0; Help_Operators(); break;

case PARAM_CAT_RANGE :

// HACK: check if we have an exact command match first

nFound = FindCommand( g_aArgs[iArg].sArg, pFunction, & iCommand );

if ((!nFound) || (iCommand != CMD_REGISTER_SET))

{

nArgs = 0;

Help_Range();

}

bCategory = false;

break;

default:

bCategory = false;

break;

}

if (iCmdEnd)

iCmdEnd++;

nNewArgs = (iCmdEnd - iCmdBegin);

if (nNewArgs > 0)

break;

}

}

if (nNewArgs > 0)

{

nArgs = nNewArgs;

for (iArg = 1; iArg <= nArgs; iArg++ )

{

#if DEBUG_VAL_2

g_aArgs[ iArg ].nVal2 = iCmdBegin + iArg - 1;

#endif

g_aArgs[ iArg ].nValue = iCmdBegin + iArg - 1;

}

}

for (iArg = 1; iArg <= nArgs; iArg++ )

{

iCommand = 0;

nFound = 0;

if (bCategory)

{

#if DEBUG_VAL_2

iCommand = g_aArgs[iArg].nVal2;

#endif

iCommand = g_aArgs[ iArg ].nValue;

nFound = 1;

}

else

if (bAllCommands)

{

iCommand = iArg;

if (iCommand == NUM_COMMANDS) // skip: Internal Consistency Check __COMMANDS_VERIFY_TXT__

continue;

nFound = 1;

}

else

nFound = FindCommand( g_aArgs[iArg].sArg, pFunction, & iCommand );

if (nFound > 1)

{

DisplayAmbigiousCommands( nFound );

}

if (iCommand > NUM_COMMANDS)

continue;

if ((nArgs == 1) && (! nFound))

iCommand = g_aArgs[iArg].nValue;

Command_t *pCommand = & g_aCommands[ iCommand ];

if (! nFound)

{

iCommand = NUM_COMMANDS;

pCommand = NULL;

}

if (nFound && (! bAllCommands) && bDisplayCategory)

{

char sCategory[ CONSOLE_WIDTH ];

int iCmd = g_aCommands[ iCommand ].iCommand; // Unaliased command

// HACK: Major kludge to display category!!!

if (iCmd <= CMD_UNASSEMBLE)

wsprintf( sCategory, "%s", g_aParameters[ PARAM_CAT_CPU ].m_sName );

else

if (iCmd <= CMD_BOOKMARK_SAVE)

wsprintf( sCategory, "%s", g_aParameters[ PARAM_CAT_BOOKMARKS ].m_sName );

else

if (iCmd <= CMD_BREAKPOINT_SAVE)

wsprintf( sCategory, "%s", g_aParameters[ PARAM_CAT_BREAKPOINTS ].m_sName );

else

if (iCmd <= CMD_CONFIG_SET_DEBUG_DIR)

wsprintf( sCategory, "%s", g_aParameters[ PARAM_CAT_CONFIG ].m_sName );

else

if (iCmd <= CMD_CURSOR_PAGE_DOWN_4K)

wsprintf( sCategory, "Scrolling" );

else

if (iCmd <= CMD_FLAG_SET_N)

wsprintf( sCategory, "%s", g_aParameters[ PARAM_CAT_FLAGS ].m_sName );

else

if (iCmd <= CMD_MOTD)

wsprintf( sCategory, "%s", g_aParameters[ PARAM_CAT_HELP ].m_sName );

else

if (iCmd <= CMD_MEMORY_FILL)

wsprintf( sCategory, "%s", g_aParameters[ PARAM_CAT_MEMORY ].m_sName );

else

if (iCmd <= CMD_OUTPUT_RUN)

wsprintf( sCategory, "%s", g_aParameters[ PARAM_CAT_OUTPUT ].m_sName );

else

if (iCmd <= CMD_SYNC)

wsprintf( sCategory, "Source" );

else

if (iCmd <= CMD_SYMBOLS_LIST)

wsprintf( sCategory, "%s", g_aParameters[ PARAM_CAT_SYMBOLS ].m_sName );

else

if (iCmd <= CMD_VIEW_DHGR2)

wsprintf( sCategory, "%s", g_aParameters[ PARAM_CAT_VIEW ].m_sName );

else

if (iCmd <= CMD_WATCH_SAVE)

wsprintf( sCategory, "%s", g_aParameters[ PARAM_CAT_WATCHES ].m_sName );

else

if (iCmd <= CMD_WINDOW_OUTPUT)

wsprintf( sCategory, "%s", g_aParameters[ PARAM_CAT_WINDOW ].m_sName );

else

if (iCmd <= CMD_ZEROPAGE_POINTER_SAVE)

wsprintf( sCategory, "%s", g_aParameters[ PARAM_CAT_ZEROPAGE ].m_sName );

else

wsprintf( sCategory, "Unknown!" );

ConsolePrintFormat( sText, "%sCategory%s: %s%s"

, CHC_USAGE

, CHC_DEFAULT

, CHC_CATEGORY

, sCategory );

if (bCategory)

if (bDisplayCategory)

bDisplayCategory = false;

}

if (pCommand)

{

char *pHelp = pCommand->pHelpSummary;

if (pHelp)

{

if (bCategory)

sprintf( sText, "%s%8s%s, "

, CHC_COMMAND

, pCommand->m_sName

, CHC_ARG_SEP

);

else

sprintf( sText, "%s%s%s, "

, CHC_COMMAND

, pCommand->m_sName

, CHC_ARG_SEP

);

strncat( sText, CHC_DEFAULT, CONSOLE_WIDTH );

strncat( sText, pHelp , CONSOLE_WIDTH );

ConsolePrint( sText );

}

else

{

#if _DEBUG

ConsoleBufferPushFormat( sText, "%s <-- Missing", pCommand->m_sName );

#if DEBUG_COMMAND_HELP

if (! bAllCommands) // Release version doesn't display message

{

ConsoleBufferPushFormat( sText, "Missing Summary Help: %s", g_aCommands[ iCommand ].aName );

}

#endif

#endif

}

if (bCategory)

continue;

}

// MASTER HELP

switch (iCommand)

{

// CPU / General

case CMD_ASSEMBLE:

ConsoleBufferPush( " Built-in assember isn't functional yet." );

break;

case CMD_UNASSEMBLE:

ConsoleColorizePrint( sText, " Usage: [address | symbol]" );

ConsoleBufferPush( " Disassembles memory." );

break;

case CMD_GO_NORMAL_SPEED:

case CMD_GO_FULL_SPEED:

ConsoleColorizePrint( sText, " Usage: address | symbol [Skip,Length]" );

ConsoleColorizePrint( sText, " Usage: address | symbol [Start:End]" );

ConsoleBufferPush( " Skip : Start address to skip stepping" );

ConsoleBufferPush( " Length: Range of bytes past start address to skip stepping" );

ConsoleBufferPush( " End : Inclusive end address to skip stepping" );

ConsoleBufferPush( " If the Program Counter is outside the skip range, resumes single-stepping." );

ConsoleBufferPush( " Can be used to skip ROM/OS/user code." );

Help_Examples();

ConsolePrintFormat( sText, "%s G[G] C600 FA00,600" , CHC_EXAMPLE );

ConsolePrintFormat( sText, "%s G[G] C600 F000:FFFF", CHC_EXAMPLE );

break;

case CMD_JSR:

ConsoleColorizePrint( sText, " %sUsage%s: %s[symbol | address]" );

ConsoleBufferPush( " Pushes PC on stack; calls the named subroutine." );

break;

case CMD_NOP:

ConsoleBufferPush( TEXT(" Puts a NOP opcode at current instruction") );

break;

case CMD_OUT:

ConsoleColorizePrint( sText, " Usage: [address8 | address16 | symbol] ## [##]" );

ConsoleBufferPush( TEXT(" Output a byte or word to the IO address $C0xx" ) );

break;

case CMD_PROFILE:

ConsoleColorizePrintFormat( sTemp, sText, " Usage: [%s | %s | %s]"

, g_aParameters[ PARAM_RESET ].m_sName

, g_aParameters[ PARAM_SAVE ].m_sName

, g_aParameters[ PARAM_LIST ].m_sName

);

ConsoleBufferPush( " No arguments resets the profile." );

break;

// Registers

case CMD_REGISTER_SET:

ConsoleColorizePrint( sText, " Usage: <reg> <value | expression | symbol>" );

ConsoleBufferPush( " Where <reg> is one of: A X Y PC SP " );

ConsoleColorizePrintFormat( sTemp, sText, " See also: %s%s"

, CHC_CATEGORY

, g_aParameters[ PARAM_CAT_OPERATORS ].m_sName );

Help_Examples();

ConsolePrintFormat( sText, "%s R PC RESET + 1", CHC_EXAMPLE );

ConsolePrintFormat( sText, "%s R PC $FC58" , CHC_EXAMPLE );

ConsolePrintFormat( sText, "%s R A A1" , CHC_EXAMPLE );

ConsolePrintFormat( sText, "%s R A $A1" , CHC_EXAMPLE );

ConsolePrintFormat( sText, "%s R A #A1" , CHC_EXAMPLE );

break;

case CMD_SOURCE:

ConsoleColorizePrintFormat( sTemp, sText, " Usage: [ %s | %s ] \"filename\"" , g_aParameters[ PARAM_SRC_MEMORY ].m_sName, g_aParameters[ PARAM_SRC_SYMBOLS ].m_sName );

ConsoleBufferPushFormat( sText, " %s: read source bytes into memory." , g_aParameters[ PARAM_SRC_MEMORY ].m_sName );

ConsoleBufferPushFormat( sText, " %s: read symbols into Source symbol table.", g_aParameters[ PARAM_SRC_SYMBOLS ].m_sName );

ConsoleBufferPushFormat( sText, " Supports: %s." , g_aParameters[ PARAM_SRC_MERLIN ].m_sName );

break;

case CMD_STEP_OUT:

ConsoleBufferPush( " Steps out of current subroutine" );

ConsoleBufferPush( " Hotkey: Ctrl-Space" ); // TODO: FIXME

break;

case CMD_STEP_OVER: // Bad name? FIXME/TODO: do we need to rename?

ConsoleColorizePrint( sText, " Usage: [#]" );

ConsoleBufferPush( " Steps, # times, thru current instruction" );

ConsoleBufferPush( " JSR will be stepped into AND out of." );

ConsoleBufferPush( " Hotkey: Ctrl-Space" ); // TODO: FIXME

break;

case CMD_TRACE:

ConsoleColorizePrint( sText, " Usage: [#]" );

ConsoleBufferPush( " Traces, # times, current instruction(s)" );

ConsoleBufferPush( " JSR will be stepped into" );

ConsoleBufferPush( " Hotkey: Shift-Space" );

break;

case CMD_TRACE_FILE:

ConsoleColorizePrint( sText, " Usage: \"[filename]\" [v]" );

break;

case CMD_TRACE_LINE:

ConsoleColorizePrint( sText, " Usage: [#]" );

ConsoleBufferPush( " Traces into current instruction" );

ConsoleBufferPush( " with cycle counting." );

break;

// Bookmarks

case CMD_BOOKMARK:

case CMD_BOOKMARK_ADD:

ConsoleColorizePrint( sText, " Usage: [address | symbol]" );

ConsoleColorizePrint( sText, " Usage: # <address | symbol>" );

ConsoleBufferPush(" If no address or symbol is specified, lists the current bookmarks." );

ConsoleBufferPush(" Updates the specified bookmark (#)" );

Help_Examples();

ConsolePrintFormat( sText, "%s %s RESET ", CHC_EXAMPLE, pCommand->m_sName );

ConsolePrintFormat( sText, "%s %s 1 HOME", CHC_EXAMPLE, pCommand->m_sName );

break;

case CMD_BOOKMARK_CLEAR:

ConsoleColorizePrint( sText, " Usage: [# | *]" );

ConsoleBufferPush( " Clears specified bookmark, or all." );

Help_Examples();

ConsolePrintFormat( sText, "%s %s 1", CHC_EXAMPLE, pCommand->m_sName );

break;

case CMD_BOOKMARK_LIST:

case CMD_BOOKMARK_SAVE:

break;

// Breakpoints

case CMD_BREAK_INVALID:

ConsoleColorizePrintFormat( sTemp, sText, TEXT(" Usage: [%s%s | %s%s] | [ # | # %s%s | # %s%s ]")

, CHC_COMMAND

, g_aParameters[ PARAM_ON ].m_sName

, CHC_COMMAND

, g_aParameters[ PARAM_OFF ].m_sName

, CHC_COMMAND

, g_aParameters[ PARAM_ON ].m_sName

, CHC_COMMAND

, g_aParameters[ PARAM_OFF ].m_sName

);

ConsoleColorizePrint( sTemp, TEXT("Where: # is 0=BRK, 1=Invalid Opcode_1, 2=Invalid Opcode_2, 3=Invalid Opcode_3"));

break;

case CMD_BREAKPOINT:

ConsoleColorizePrintFormat( sTemp, sText, TEXT(" Usage: [%s%s | %s%s | %s%s]")

, CHC_COMMAND

, g_aParameters[ PARAM_LOAD ].m_sName

, CHC_COMMAND

, g_aParameters[ PARAM_SAVE ].m_sName

, CHC_COMMAND

, g_aParameters[ PARAM_RESET ].m_sName );

ConsolePrintFormat( sText, " Maximum breakpoints: %s%d", CHC_NUM_DEC, MAX_BREAKPOINTS );

ConsoleBufferPush( " Set breakpoint at PC if no args." );

ConsoleBufferPush( " Loading/Saving not yet implemented." );

break;

case CMD_BREAKPOINT_ADD_REG:

ConsoleColorizePrint( sText, " Usage: [A|X|Y|PC|S] [op] <range | value>" );

ConsoleBufferPush( " Set breakpoint when reg is [op] value" );

ConsoleBufferPush( " Default operator is '='" );

ConsoleColorizePrintFormat( sTemp, sText, " See also: %s%s"

, CHC_CATEGORY

, g_aParameters[ PARAM_CAT_OPERATORS ].m_sName );

// ConsoleBufferPush( " Examples:" );

Help_Examples();

ConsolePrintFormat( sText, "%s %s PC < D000" , CHC_EXAMPLE, pCommand->m_sName );

ConsolePrintFormat( sText, "%s %s PC = F000:FFFF PC < D000,1000", CHC_EXAMPLE, pCommand->m_sName );

ConsolePrintFormat( sText, "%s %s A <= D5" , CHC_EXAMPLE, pCommand->m_sName );

ConsolePrintFormat( sText, "%s %s A != 01:FF" , CHC_EXAMPLE, pCommand->m_sName );

ConsolePrintFormat( sText, "%s %s X = A5" , CHC_EXAMPLE, pCommand->m_sName );

break;

case CMD_BREAKPOINT_ADD_SMART:

ConsoleColorizePrint( sText, " Usage: [address | register]" );

ConsoleBufferPush( " If address, sets two breakpoints" );

ConsoleBufferPush( " 1. one memory access at address" );

ConsoleBufferPush( " 2. if PC reaches address" );

ConsoleBufferPush( " If an IO address, sets breakpoint on IO access." );

ConsoleBufferPush( " If register, sets a breakpoint on memory access at address of register." );

break;

case CMD_BREAKPOINT_ADD_PC:

ConsoleColorizePrint( sText, " Usage: [address]" );

ConsoleBufferPush( " Sets a breakpoint at the current PC or at the specified address." );

break;

case CMD_BREAKPOINT_CLEAR:

ConsoleColorizePrint( sText, " Usage: [# | *]" );

ConsoleBufferPush( " Clears specified breakpoint, or all." );

Help_Examples();

ConsolePrintFormat( sText, "%s %s 1", CHC_EXAMPLE, pCommand->m_sName );

break;

case CMD_BREAKPOINT_DISABLE:

ConsoleColorizePrint( sText, " Usage: [# [,#] | *]" );

ConsoleBufferPush( " Disable breakpoint previously set, or all." );

Help_Examples();

ConsolePrintFormat( sText, "%s %s 1", CHC_EXAMPLE, pCommand->m_sName );

break;