size_t __fastcall__ strftime (char* buf, size_t bufsize, const char* format,
const struct tm* tm)
{
- static const char* days[7] = {
+ static const char* const days[7] = {
"Sunday", "Monday", "Tuesday", "Wednesday",
"Thursday", "Friday", "Saturday"
};
- static const char* months[12] = {
+ static const char* const months[12] = {
"January", "February", "March", "April", "May", "June",
"July", "August", "September", "October", "November", "December"
};
;
; Ullrich von Bassewitz, 06.08.1998
;
-; void cputsxy (unsigned char x, unsigned char y, char* s);
-; void cputs (char* s);
+; void cputsxy (unsigned char x, unsigned char y, const char* s);
+; void cputs (const char* s);
;
.export _cputsxy, _cputs
static char HelpHandler (void);
/* Forwards for other functions */
-static void DisplayPrompt (char* s);
+static void DisplayPrompt (const char* s);
static void SingleStep (char StepInto);
static void RedrawStatic (char Frame);
static void Redraw (char Frame);
typedef struct {
unsigned char x;
unsigned char y;
- char* text;
+ const char* text;
} TextDesc;
/* Window descriptor */
unsigned char fd_visible; /* Is the window currently visible? */
char (*fd_func) (void); /* Handler function */
unsigned char fd_textcount; /* Number of text lines to print */
- TextDesc* fd_text; /* Static text in the window */
+ const TextDesc* fd_text; /* Static text in the window */
} FrameDesc;
/* Texts for the windows */
-static TextDesc RegText [] = {
+static const TextDesc RegText [] = {
{ 1, 0, "PC" },
{ 1, 1, "SR" },
{ 1, 2, "A" },
{ 1, 6, "CS" },
{ 1, 7, "HI" }
};
-static TextDesc HelpText [] = {
+static const TextDesc HelpText [] = {
{ 1, 0, "F1, ? Help" },
{ 1, 1, "F2, t Toggle breakpoint" },
{ 1, 2, "F3, u Run until subroutine returns" },
/* Window data */
-static FrameDesc AsmFrame = {
+static const FrameDesc AsmFrame = {
CH_ULCORNER, CH_TTEE, CH_LTEE, CH_CROSS,
0, 0, MAX_X - 10, 15,
MAX_X - 11, 14,
AsmHandler,
0, 0
};
-static FrameDesc RegFrame = {
+static const FrameDesc RegFrame = {
CH_TTEE, CH_URCORNER, CH_LTEE, CH_RTEE,
MAX_X - 10, 0, MAX_X - 1, 9,
8, 8,
RegHandler,
sizeof (RegText) / sizeof (RegText [0]), RegText
};
-static FrameDesc StackFrame = {
+static const FrameDesc StackFrame = {
CH_LTEE, CH_RTEE, CH_CROSS, CH_RTEE,
MAX_X - 10, 9, MAX_X - 1, 15,
8, 5,
StackHandler,
0, 0
};
-static FrameDesc CStackFrame = {
+static const FrameDesc CStackFrame = {
CH_CROSS, CH_RTEE, CH_BTEE, CH_LRCORNER,
MAX_X - 10, 15, MAX_X - 1, MAX_Y - 1,
8, MAX_Y - 17,
CStackHandler,
0, 0
};
-static FrameDesc DumpFrame = {
+static const FrameDesc DumpFrame = {
CH_LTEE, CH_CROSS, CH_LLCORNER, CH_BTEE,
0, 15, MAX_X - 10, MAX_Y-1,
MAX_X - 11, MAX_Y - 17,
DumpHandler,
0, 0
};
-static FrameDesc HelpFrame = {
+static const FrameDesc HelpFrame = {
CH_ULCORNER, CH_URCORNER, CH_LLCORNER, CH_LRCORNER,
0, 0, MAX_X - 1, MAX_Y-1,
MAX_X - 2, MAX_Y - 2,
HelpHandler,
sizeof (HelpText) / sizeof (HelpText [0]), HelpText
};
-static FrameDesc* Frames [] = {
+static const FrameDesc* const Frames [] = {
&AsmFrame,
&RegFrame,
&StackFrame,
/* Prompt line data */
-static char* ActivePrompt = 0; /* Last prompt line displayed */
+static const char* ActivePrompt = 0; /* Last prompt line displayed */
static char PromptColor; /* Color behind prompt */
static char PromptLength; /* Length of current prompt string */
-static void DrawFrame (register FrameDesc* F, char Active)
+static void DrawFrame (register const FrameDesc* F, char Active)
/* Draw one window frame */
{
- TextDesc* T;
+ const TextDesc* T;
unsigned char Count;
unsigned char tl, tr, bl, br;
unsigned char x1, y1, width;
/* Draw all frames */
{
unsigned char I;
- FrameDesc* F;
+ const FrameDesc* F;
/* Build the frame layout of the screen */
for (I = 0; I < sizeof (Frames) / sizeof (Frames [0]); ++I) {
/* Activate a new frame, deactivate the old one */
{
unsigned char y;
- register FrameDesc* F;
+ register const FrameDesc* F;
if (ActiveFrame != Num) {
-static void DisplayPrompt (char* s)
+static void DisplayPrompt (const char* s)
/* Display a prompt */
{
unsigned char OldColor;
-static void ErrorPrompt (char* Msg)
+static void ErrorPrompt (const char* Msg)
/* Display an error message and wait for a key */
{
/* Save the current prompt */
- char* OldPrompt = ActivePrompt;
+ const char* OldPrompt = ActivePrompt;
/* Display the new one */
DisplayPrompt (Msg);
void _mbprintout(void);
-static dlgBoxStr _mbdlg_EMPTY = {
+static const dlgBoxStr _mbdlg_EMPTY = {
DB_DEFPOS(1),
DB_OPVEC(&RstrFrmDialogue),
DB_USRROUT(&_mbprintout),
DB_END,
};
-static dlgBoxStr _mbdlg_OK = {
+static const dlgBoxStr _mbdlg_OK = {
DB_DEFPOS(1),
DB_USRROUT(&_mbprintout),
DB_ICON(OK, DBI_X_1, DBI_Y_2),
DB_END,
};
-static dlgBoxStr _mbdlg_OKCANCEL = {
+static const dlgBoxStr _mbdlg_OKCANCEL = {
DB_DEFPOS(1),
DB_USRROUT(&_mbprintout),
DB_ICON(OK, DBI_X_0, DBI_Y_2),
DB_END,
};
-static dlgBoxStr _mbdlg_YESNO = {
+static const dlgBoxStr _mbdlg_YESNO = {
DB_DEFPOS(1),
DB_USRROUT(&_mbprintout),
DB_ICON(YES, DBI_X_0, DBI_Y_2),
DB_END,
};
-static dlgBoxStr *_mbboxes[] = {
+static const dlgBoxStr * const _mbboxes[] = {
&_mbdlg_EMPTY,
&_mbdlg_OK,
&_mbdlg_OKCANCEL,
void DbgInfoFunc (void)
/* Parse and handle func subcommand of the .dbg pseudo instruction */
{
- static const char* StorageKeys[] = {
+ static const char* const StorageKeys[] = {
"EXTERN",
"STATIC",
};
void DbgInfoSym (void)
/* Parse and handle SYM subcommand of the .dbg pseudo instruction */
{
- static const char* StorageKeys[] = {
+ static const char* const StorageKeys[] = {
"AUTO",
"EXTERN",
"REGISTER",
/* Names of the features */
-static const char* FeatureKeys[FEAT_COUNT] = {
+static const char* const FeatureKeys[FEAT_COUNT] = {
"dollar_is_pc",
"labels_without_colons",
"loose_string_term",
static void SetBoolOption (unsigned char* Flag)
/* Read a on/off/+/- option and set flag accordingly */
{
- static const char* Keys[] = {
+ static const char* const Keys[] = {
"OFF",
"ON",
};
static void DoAssert (void)
/* Add an assertion */
{
- static const char* ActionTab [] = {
+ static const char* const ActionTab [] = {
"WARN", "WARNING",
"ERROR",
"LDWARN", "LDWARNING",
static void DoConDes (void)
/* Export a symbol as constructor/destructor */
{
- static const char* Keys[] = {
+ static const char* const Keys[] = {
"CONSTRUCTOR",
"DESTRUCTOR",
"INTERRUPTOR",
static void DoDbg (void)
/* Add debug information from high level code */
{
- static const char* Keys[] = {
+ static const char* const Keys[] = {
"FILE",
"FUNC",
"LINE",
if (CurTok.Tok == TOK_IDENT) {
/* Option given as keyword */
- static const char* Keys [] = {
+ static const char* const Keys [] = {
"AUTHOR", "COMMENT", "COMPILER"
};
-int GetSubKey (const char** Keys, unsigned Count)
+int GetSubKey (const char* const* Keys, unsigned Count)
/* Search for a subkey in a table of keywords. The current token must be an
** identifier and all keys must be in upper case. The identifier will be
** uppercased in the process. The function returns the index of the keyword,
void NextRawTok (void);
/* Read the next raw token from the input stream */
-int GetSubKey (const char** Keys, unsigned Count);
+int GetSubKey (const char* const* Keys, unsigned Count);
/* Search for a subkey in a table of keywords. The current token must be an
** identifier and all keys must be in upper case. The identifier will be
** uppercased in the process. The function returns the index of the keyword,
-static void oper (unsigned Flags, unsigned long Val, const char** Subs)
+static void oper (unsigned Flags, unsigned long Val, const char* const* Subs)
/* Encode a binary operation. subs is a pointer to four strings:
** 0 --> Operate on ints
** 1 --> Operate on unsigneds
void g_add (unsigned flags, unsigned long val)
/* Primary = TOS + Primary */
{
- static const char* ops[12] = {
+ static const char* const ops[4] = {
"tosaddax", "tosaddax", "tosaddeax", "tosaddeax"
};
void g_sub (unsigned flags, unsigned long val)
/* Primary = TOS - Primary */
{
- static const char* ops[12] = {
- "tossubax", "tossubax", "tossubeax", "tossubeax",
+ static const char* const ops[4] = {
+ "tossubax", "tossubax", "tossubeax", "tossubeax"
};
if (flags & CF_CONST) {
void g_rsub (unsigned flags, unsigned long val)
/* Primary = Primary - TOS */
{
- static const char* ops[12] = {
- "tosrsubax", "tosrsubax", "tosrsubeax", "tosrsubeax",
+ static const char* const ops[4] = {
+ "tosrsubax", "tosrsubax", "tosrsubeax", "tosrsubeax"
};
oper (flags, val, ops);
}
void g_mul (unsigned flags, unsigned long val)
/* Primary = TOS * Primary */
{
- static const char* ops[12] = {
- "tosmulax", "tosumulax", "tosmuleax", "tosumuleax",
+ static const char* const ops[4] = {
+ "tosmulax", "tosumulax", "tosmuleax", "tosumuleax"
};
int p2;
void g_div (unsigned flags, unsigned long val)
/* Primary = TOS / Primary */
{
- static const char* ops[12] = {
- "tosdivax", "tosudivax", "tosdiveax", "tosudiveax",
+ static const char* const ops[4] = {
+ "tosdivax", "tosudivax", "tosdiveax", "tosudiveax"
};
/* Do strength reduction if the value is constant and a power of two */
void g_mod (unsigned flags, unsigned long val)
/* Primary = TOS % Primary */
{
- static const char* ops[12] = {
- "tosmodax", "tosumodax", "tosmodeax", "tosumodeax",
+ static const char* const ops[4] = {
+ "tosmodax", "tosumodax", "tosmodeax", "tosumodeax"
};
int p2;
void g_or (unsigned flags, unsigned long val)
/* Primary = TOS | Primary */
{
- static const char* ops[12] = {
- "tosorax", "tosorax", "tosoreax", "tosoreax",
+ static const char* const ops[4] = {
+ "tosorax", "tosorax", "tosoreax", "tosoreax"
};
/* If the right hand side is const, the lhs is not on stack but still
void g_xor (unsigned flags, unsigned long val)
/* Primary = TOS ^ Primary */
{
- static const char* ops[12] = {
- "tosxorax", "tosxorax", "tosxoreax", "tosxoreax",
+ static const char* const ops[4] = {
+ "tosxorax", "tosxorax", "tosxoreax", "tosxoreax"
};
void g_and (unsigned Flags, unsigned long Val)
/* Primary = TOS & Primary */
{
- static const char* ops[12] = {
- "tosandax", "tosandax", "tosandeax", "tosandeax",
+ static const char* const ops[4] = {
+ "tosandax", "tosandax", "tosandeax", "tosandeax"
};
/* If the right hand side is const, the lhs is not on stack but still
void g_asr (unsigned flags, unsigned long val)
/* Primary = TOS >> Primary */
{
- static const char* ops[12] = {
- "tosasrax", "tosshrax", "tosasreax", "tosshreax",
+ static const char* const ops[4] = {
+ "tosasrax", "tosshrax", "tosasreax", "tosshreax"
};
/* If the right hand side is const, the lhs is not on stack but still
void g_asl (unsigned flags, unsigned long val)
/* Primary = TOS << Primary */
{
- static const char* ops[12] = {
- "tosaslax", "tosshlax", "tosasleax", "tosshleax",
+ static const char* const ops[4] = {
+ "tosaslax", "tosshlax", "tosasleax", "tosshleax"
};
void g_eq (unsigned flags, unsigned long val)
/* Test for equal */
{
- static const char* ops[12] = {
- "toseqax", "toseqax", "toseqeax", "toseqeax",
+ static const char* const ops[4] = {
+ "toseqax", "toseqax", "toseqeax", "toseqeax"
};
unsigned L;
void g_ne (unsigned flags, unsigned long val)
/* Test for not equal */
{
- static const char* ops[12] = {
- "tosneax", "tosneax", "tosneeax", "tosneeax",
+ static const char* const ops[4] = {
+ "tosneax", "tosneax", "tosneeax", "tosneeax"
};
unsigned L;
void g_lt (unsigned flags, unsigned long val)
/* Test for less than */
{
- static const char* ops[12] = {
+ static const char* const ops[4] = {
"tosltax", "tosultax", "toslteax", "tosulteax",
};
void g_le (unsigned flags, unsigned long val)
/* Test for less than or equal to */
{
- static const char* ops[12] = {
- "tosleax", "tosuleax", "tosleeax", "tosuleeax",
+ static const char* const ops[4] = {
+ "tosleax", "tosuleax", "tosleeax", "tosuleeax"
};
void g_gt (unsigned flags, unsigned long val)
/* Test for greater than */
{
- static const char* ops[12] = {
- "tosgtax", "tosugtax", "tosgteax", "tosugteax",
+ static const char* const ops[4] = {
+ "tosgtax", "tosugtax", "tosgteax", "tosugteax"
};
void g_ge (unsigned flags, unsigned long val)
/* Test for greater than or equal to */
{
- static const char* ops[12] = {
- "tosgeax", "tosugeax", "tosgeeax", "tosugeeax",
+ static const char* const ops[4] = {
+ "tosgeax", "tosugeax", "tosgeeax", "tosugeeax"
};
unsigned Label;
** the pushax/op sequence when encountered.
*/
{
- static const char* Tab[] = {
+ static const char* const Tab[] = {
"aslax1",
"aslax2",
"aslax3",
IntStack Standard = INTSTACK(STD_UNKNOWN);
/* Table mapping names to standards, sorted by standard. */
-static const char* StdNames[STD_COUNT] = {
+static const char* const StdNames[STD_COUNT] = {
"c89", "c99", "cc65"
};
O65Model Model = O65_MODEL_NONE;
/* Name table */
-static const char* NameTable[O65_MODEL_COUNT] = {
+static const char* const NameTable[O65_MODEL_COUNT] = {
"none",
"os/a65",
"lunix",
** of unnamed labels, to determine the name.
*/
{
- static const char* FwdLabels[] = {
+ static const char* const FwdLabels[] = {
":+", ":++", ":+++", ":++++", ":+++++", ":++++++", ":+++++++",
":++++++++", ":+++++++++", ":++++++++++"
};
- static const char* BackLabels[] = {
+ static const char* const BackLabels[] = {
":-", ":--", ":---", ":----", ":-----", ":------", ":-------",
":--------", ":---------", ":----------"
};
}
-static int findToken (const char **tokenTbl, const char *token)
+static int findToken (const char * const *tokenTbl, const char *token)
{
/* takes as input table of tokens and token, returns position in table or -1 if not found */
- int a = 0;
-
- while (strlen (tokenTbl[a]) != 0) {
- if (strcmp (tokenTbl[a], token) == 0) break;
- a++;
+ int i;
+ for (i = 0; tokenTbl[i][0]; i++) {
+ if (strcmp (tokenTbl[i], token) == 0) return i;
}
- if (strlen (tokenTbl[a]) == 0) a = -1;
- return a;
+ return -1;
}
-Collection* ParseAttrList (const char* List, const char** NameList, unsigned NameCount)
+Collection* ParseAttrList (const char* List, const char* const* NameList, unsigned NameCount)
/* Parse a list containing name/value pairs into a sorted collection. Some
** attributes may not need a name, so NameList contains these names. If there
** were no errors, the function returns a alphabetically sorted collection
** Name is NULL, terminate with an error.
*/
-Collection* ParseAttrList (const char* List, const char** NameList, unsigned NameCount);
+Collection* ParseAttrList (const char* List, const char* const* NameList, unsigned NameCount);
/* Parse a list containing name/value pairs into a sorted collection. Some
** attributes may not need a name, so NameList contains these names. If there
** were no errors, the function returns a alphabetically sorted collection
static void OptConvertTo (const char* Opt attribute ((unused)), const char* Arg)
/* Convert the bitmap into a target format */
{
- static const char* NameList[] = {
+ static const char* const NameList[] = {
"format"
};
static void OptRead (const char* Opt attribute ((unused)), const char* Arg)
/* Read an input file */
{
- static const char* NameList[] = {
+ static const char* const NameList[] = {
"name", "format"
};
static void OptWrite (const char* Opt attribute ((unused)), const char* Arg)
/* Write an output file */
{
- static const char* NameList[] = {
+ static const char* const NameList[] = {
"name", "format"
};