void GetEA (EffAddr* A)
/* Parse an effective address, return the result in A */
{
unsigned long Restrictions;
token_t IndirectEnter;
token_t IndirectLeave;
const char* IndirectExpect;
/* Choose syntax for indirection */
if (BracketAsIndirect) {
IndirectEnter = TOK_LBRACK;
IndirectLeave = TOK_RBRACK;
IndirectExpect = "']' expected";
} else {
IndirectEnter = TOK_LPAREN;
IndirectLeave = TOK_RPAREN;
IndirectExpect = "')' expected";
}
/* Clear the output struct */
A->AddrModeSet = 0;
A->Expr = 0;
/* Handle an addressing size override */
switch (CurTok.Tok) {
case TOK_OVERRIDE_ZP:
Restrictions = AM65_DIR | AM65_DIR_X | AM65_DIR_Y;
NextTok ();
break;
case TOK_OVERRIDE_ABS:
Restrictions = AM65_ABS | AM65_ABS_X | AM65_ABS_Y;
NextTok ();
break;
case TOK_OVERRIDE_FAR:
Restrictions = AM65_ABS_LONG | AM65_ABS_LONG_X;
NextTok ();
break;
default:
Restrictions = ~0UL; /* None */
break;
}
/* Parse the effective address */
if (TokIsSep (CurTok.Tok)) {
A->AddrModeSet = AM65_IMPLICIT;
} else if (CurTok.Tok == TOK_HASH) {
/* #val */
NextTok ();
A->Expr = Expression ();
A->AddrModeSet = AM65_ALL_IMM;
} else if (CurTok.Tok == TOK_A) {
NextTok ();
A->AddrModeSet = AM65_ACCU;
} else if (CurTok.Tok == IndirectEnter) {
/* One of the indirect modes */
NextTok ();
A->Expr = Expression ();
if (CurTok.Tok == TOK_COMMA) {
/* (expr,X) or (rel,S),y */
NextTok ();
if (CurTok.Tok == TOK_X) {
/* (adr,x) */
NextTok ();
A->AddrModeSet = AM65_ABS_X_IND | AM65_DIR_X_IND;
Consume (IndirectLeave, IndirectExpect);
} else if (CurTok.Tok == TOK_S) {
/* (rel,s),y */
NextTok ();
A->AddrModeSet = AM65_STACK_REL_IND_Y;
Consume (IndirectLeave, IndirectExpect);
ConsumeComma ();
Consume (TOK_Y, "`Y' expected");
} else {
Error ("Syntax error");
}
} else {
/* (adr) or (adr),y */
Consume (IndirectLeave, IndirectExpect);
if (CurTok.Tok == TOK_COMMA) {
/* (adr),y */
NextTok ();
Consume (TOK_Y, "`Y' expected");
A->AddrModeSet = AM65_DIR_IND_Y;
} else {
/* (adr) */
A->AddrModeSet = AM65_ABS_IND | AM65_ABS_IND_LONG | AM65_DIR_IND;
}
}
} else if (CurTok.Tok == TOK_LBRACK) {
/* Never executed if BracketAsIndirect feature is enabled. */
/* [dir] or [dir],y */
NextTok ();
A->Expr = Expression ();
Consume (TOK_RBRACK, "']' expected");
if (CurTok.Tok == TOK_COMMA) {
/* [dir],y */
NextTok ();
Consume (TOK_Y, "`Y' expected");
A->AddrModeSet = AM65_DIR_IND_LONG_Y;
} else {
/* [dir] */
A->AddrModeSet = AM65_DIR_IND_LONG | AM65_ABS_IND_LONG;
}
} else {
/* Remaining stuff:
**
** adr
** adr,x
** adr,y
** adr,s
*/
A->Expr = Expression ();
if (CurTok.Tok == TOK_COMMA) {
NextTok ();
switch (CurTok.Tok) {
case TOK_X:
A->AddrModeSet = AM65_ABS_LONG_X | AM65_ABS_X | AM65_DIR_X;
NextTok ();
break;
case TOK_Y:
A->AddrModeSet = AM65_ABS_Y | AM65_DIR_Y;
NextTok ();
break;
case TOK_S:
A->AddrModeSet = AM65_STACK_REL;
NextTok ();
break;
default:
Error ("Syntax error");
}
} else {
A->AddrModeSet = AM65_ABS_LONG | AM65_ABS | AM65_DIR;
}
}
/* Apply addressing mode overrides */
A->AddrModeSet &= Restrictions;
}
void DbgInfoSym (void)
/* Parse and handle SYM subcommand of the .dbg pseudo instruction */
{
static const char* const StorageKeys[] = {
"AUTO",
"EXTERN",
"REGISTER",
"STATIC",
};
unsigned Name;
int Type;
unsigned AsmName = EMPTY_STRING_ID;
unsigned Flags;
int Offs = 0;
HLLDbgSym* S;
/* Parameters are separated by a comma */
ConsumeComma ();
/* Name */
if (CurTok.Tok != TOK_STRCON) {
ErrorSkip ("String constant expected");
return;
}
Name = GetStrBufId (&CurTok.SVal);
NextTok ();
/* Comma expected */
ConsumeComma ();
/* Type */
if (CurTok.Tok != TOK_STRCON) {
ErrorSkip ("String constant expected");
return;
}
Type = ValidateType (&CurTok.SVal);
if (Type < 0) {
return;
}
NextTok ();
/* Comma expected */
ConsumeComma ();
/* The storage class follows */
if (CurTok.Tok != TOK_IDENT) {
ErrorSkip ("Storage class specifier expected");
return;
}
switch (GetSubKey (StorageKeys, sizeof (StorageKeys)/sizeof (StorageKeys[0]))) {
case 0: Flags = HLL_SC_AUTO; break;
case 1: Flags = HLL_SC_EXTERN; break;
case 2: Flags = HLL_SC_REG; break;
case 3: Flags = HLL_SC_STATIC; break;
default: ErrorSkip ("Storage class specifier expected"); return;
}
/* Skip the storage class token and the following comma */
NextTok ();
ConsumeComma ();
/* The next tokens depend on the storage class */
if (Flags == HLL_SC_AUTO) {
/* Auto: Stack offset follows */
Offs = ConstExpression ();
} else {
/* Register, extern or static: Assembler name follows */
if (CurTok.Tok != TOK_STRCON) {
ErrorSkip ("String constant expected");
return;
}
AsmName = GetStrBufId (&CurTok.SVal);
NextTok ();
/* For register, an offset follows */
if (Flags == HLL_SC_REG) {
ConsumeComma ();
Offs = ConstExpression ();
}
}
/* Add the function */
S = NewHLLDbgSym (Flags | HLL_TYPE_SYM, Name, Type);
S->AsmName = AsmName;
S->Offs = Offs;
CollAppend (&HLLDbgSyms, S);
}
static void FuncSPrintF (void)
/* Handle the .SPRINTF function */
{
StrBuf Format = STATIC_STRBUF_INITIALIZER; /* User supplied format */
StrBuf R = STATIC_STRBUF_INITIALIZER; /* Result string */
StrBuf F1 = STATIC_STRBUF_INITIALIZER; /* One format spec from F */
StrBuf R1 = STATIC_STRBUF_INITIALIZER; /* One result */
char C;
int Done;
long IVal; /* Integer value */
/* Skip the .SPRINTF token */
NextTok ();
/* Left paren expected */
ConsumeLParen ();
/* First argument is a format string. Remember and skip it */
if (!LookAtStrCon ()) {
return;
}
SB_Copy (&Format, &CurTok.SVal);
NextTok ();
/* Walk over the format string, generating the function result in R */
while (1) {
/* Get the next char from the format string and check for EOS */
if (SB_Peek (&Format) == '\0') {
break;
}
/* Check for a format specifier */
if (SB_Peek (&Format) != '%') {
/* No format specifier, just copy */
SB_AppendChar (&R, SB_Get (&Format));
continue;
}
SB_Skip (&Format);
if (SB_Peek (&Format) == '%') {
/* %% */
SB_AppendChar (&R, '%');
SB_Skip (&Format);
continue;
}
if (SB_Peek (&Format) == '\0') {
InvalidFormatString ();
break;
}
/* Since a format specifier follows, we do expect anotehr argument for
* the .sprintf function.
*/
ConsumeComma ();
/* We will copy the format spec into F1 checking for the things we
* support, and later use xsprintf to do the actual formatting. This
* is easier than adding another printf implementation...
*/
SB_Clear (&F1);
SB_AppendChar (&F1, '%');
/* Check for flags */
Done = 0;
while ((C = SB_Peek (&Format)) != '\0' && !Done) {
switch (C) {
case '-': /* FALLTHROUGH */
case '+': /* FALLTHROUGH */
case ' ': /* FALLTHROUGH */
case '#': /* FALLTHROUGH */
case '0': SB_AppendChar (&F1, SB_Get (&Format)); break;
default: Done = 1; break;
}
}
/* We do only support a numerical width field */
while (IsDigit (SB_Peek (&Format))) {
SB_AppendChar (&F1, SB_Get (&Format));
}
/* Precision - only positive numerical fields supported */
if (SB_Peek (&Format) == '.') {
SB_AppendChar (&F1, SB_Get (&Format));
while (IsDigit (SB_Peek (&Format))) {
SB_AppendChar (&F1, SB_Get (&Format));
}
}
/* Length modifiers aren't supported, so read the conversion specs */
switch (SB_Peek (&Format)) {
case 'd':
case 'i':
case 'o':
case 'u':
case 'X':
case 'x':
/* Our ints are actually longs, so we use the 'l' modifier when
* calling xsprintf later. Terminate the format string.
*/
SB_AppendChar (&F1, 'l');
SB_AppendChar (&F1, SB_Get (&Format));
SB_Terminate (&F1);
/* The argument must be a constant expression */
IVal = ConstExpression ();
/* Format this argument according to the spec */
SB_Printf (&R1, SB_GetConstBuf (&F1), IVal);
/* Append the formatted argument to the result */
SB_Append (&R, &R1);
break;
case 's':
/* Add the format spec and terminate the format */
SB_AppendChar (&F1, SB_Get (&Format));
SB_Terminate (&F1);
/* The argument must be a string constant */
if (!LookAtStrCon ()) {
/* Make it one */
SB_CopyStr (&CurTok.SVal, "**undefined**");
}
/* Format this argument according to the spec */
SB_Printf (&R1, SB_GetConstBuf (&F1), SB_GetConstBuf (&CurTok.SVal));
/* Skip the string constant */
NextTok ();
/* Append the formatted argument to the result */
SB_Append (&R, &R1);
break;
case 'c':
/* Add the format spec and terminate the format */
SB_AppendChar (&F1, SB_Get (&Format));
SB_Terminate (&F1);
/* The argument must be a constant expression */
IVal = ConstExpression ();
/* Check for a valid character range */
if (IVal <= 0 || IVal > 255) {
Error ("Char argument out of range");
IVal = ' ';
}
/* Format this argument according to the spec. Be sure to pass
* an int as the char value.
*/
SB_Printf (&R1, SB_GetConstBuf (&F1), (int) IVal);
/* Append the formatted argument to the result */
SB_Append (&R, &R1);
break;
default:
Error ("Invalid format string");
SB_Skip (&Format);
break;
}
}
/* Terminate the result string */
SB_Terminate (&R);
/* We expect a closing parenthesis, but will not skip it but replace it
* by the string token just created.
*/
if (CurTok.Tok != TOK_RPAREN) {
Error ("`)' expected");
} else {
CurTok.Tok = TOK_STRCON;
SB_Copy (&CurTok.SVal, &R);
SB_Terminate (&CurTok.SVal);
}
/* Delete the string buffers */
SB_Done (&Format);
SB_Done (&R);
SB_Done (&F1);
SB_Done (&R1);
}
void DbgInfoFunc (void)
/* Parse and handle func subcommand of the .dbg pseudo instruction */
{
static const char* const StorageKeys[] = {
"EXTERN",
"STATIC",
};
unsigned Name;
int Type;
unsigned AsmName;
unsigned Flags;
HLLDbgSym* S;
/* Parameters are separated by a comma */
ConsumeComma ();
/* Name */
if (CurTok.Tok != TOK_STRCON) {
ErrorSkip ("String constant expected");
return;
}
Name = GetStrBufId (&CurTok.SVal);
NextTok ();
/* Comma expected */
ConsumeComma ();
/* Type */
if (CurTok.Tok != TOK_STRCON) {
ErrorSkip ("String constant expected");
return;
}
Type = ValidateType (&CurTok.SVal);
if (Type < 0) {
return;
}
NextTok ();
/* Comma expected */
ConsumeComma ();
/* The storage class follows */
if (CurTok.Tok != TOK_IDENT) {
ErrorSkip ("Storage class specifier expected");
return;
}
switch (GetSubKey (StorageKeys, sizeof (StorageKeys)/sizeof (StorageKeys[0]))) {
case 0: Flags = HLL_TYPE_FUNC | HLL_SC_EXTERN; break;
case 1: Flags = HLL_TYPE_FUNC | HLL_SC_STATIC; break;
default: ErrorSkip ("Storage class specifier expected"); return;
}
NextTok ();
/* Comma expected */
ConsumeComma ();
/* Assembler name follows */
if (CurTok.Tok != TOK_STRCON) {
ErrorSkip ("String constant expected");
return;
}
AsmName = GetStrBufId (&CurTok.SVal);
NextTok ();
/* There may only be one function per scope */
if (CurrentScope == RootScope) {
ErrorSkip ("Functions may not be used in the root scope");
return;
} else if (CurrentScope->Type != SCOPE_SCOPE || CurrentScope->Label == 0) {
ErrorSkip ("Functions can only be tagged to .PROC scopes");
return;
} else if (CurrentScope->Label->HLLSym != 0) {
ErrorSkip ("Only one HLL symbol per asm symbol is allowed");
return;
} else if (CurrentScope->Label->Name != AsmName) {
ErrorSkip ("Scope label and asm name for function must match");
return;
}
/* Add the function */
S = NewHLLDbgSym (Flags, Name, Type);
S->Sym = CurrentScope->Label;
CurrentScope->Label->HLLSym = S;
CollAppend (&HLLDbgSyms, S);
}
