635 lines
16 KiB
C
635 lines
16 KiB
C
/*
|
|
* Copyright (c) 1987 Fujitsu
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
/*
|
|
listing.c -- Routines to generate a Macross assembly listing.
|
|
|
|
Chip Morningstar -- Lucasfilm Ltd.
|
|
|
|
10-February-1985
|
|
*/
|
|
|
|
#include "macrossTypes.h"
|
|
#include "macrossGlobals.h"
|
|
#include "emitStuff.h"
|
|
#include "lexer.h"
|
|
#include "listing.h"
|
|
#include "semanticMisc.h"
|
|
|
|
#include <stdarg.h>
|
|
#include <string.h>
|
|
|
|
static char lineBuffer1[LINE_BUFFER_SIZE];
|
|
static char lineBuffer2[LINE_BUFFER_SIZE];
|
|
int cumulativeLineNumber = 0;
|
|
static char macroLineBuffer[LINE_BUFFER_SIZE];
|
|
static char nextMacroLineBuffer[LINE_BUFFER_SIZE];
|
|
static int macroAddress;
|
|
static int nextMacroAddress;
|
|
static int macroDepth;
|
|
static int nextMacroDepth;
|
|
|
|
void
|
|
outputListing(void)
|
|
{
|
|
rewind(saveFileForPass2);
|
|
rewind(indexFileForPass2);
|
|
rewind(macroFileForPass2);
|
|
generateListing();
|
|
}
|
|
|
|
void
|
|
terminateListingFiles(void)
|
|
{
|
|
saveLineForListing("\n");
|
|
saveIndexForListing(NULL_STATEMENT, cumulativeLineNumber);
|
|
saveLineForListing("\n");
|
|
saveIndexForListing(NULL_STATEMENT, cumulativeLineNumber);
|
|
}
|
|
|
|
#define advanceSourceFile() \
|
|
if (nextSourceAddress == -1) {\
|
|
readSourceFileLine(&sourceAddress, &sourceDepth,\
|
|
sourceText = lineBuffer1, saveFileForPass2);\
|
|
readSourceFileLine(&nextSourceAddress,\
|
|
&nextSourceDepth, nextSourceText =\
|
|
lineBuffer2, saveFileForPass2);\
|
|
sourceLineNumber++;\
|
|
} else {\
|
|
sourceAddress = nextSourceAddress;\
|
|
sourceDepth = nextSourceDepth;\
|
|
tempText = sourceText;\
|
|
sourceText = nextSourceText;\
|
|
nextSourceText = tempText;\
|
|
if (tempText == NULL)\
|
|
nextSourceText = (sourceText==lineBuffer1) ?\
|
|
lineBuffer2 : lineBuffer1;\
|
|
readSourceFileLine(&nextSourceAddress,\
|
|
&nextSourceDepth, nextSourceText,\
|
|
saveFileForPass2);\
|
|
sourceLineNumber++;\
|
|
}
|
|
|
|
#define advanceIndexFile() {\
|
|
indexAddress = nextIndexAddress;\
|
|
indexLineNumber = nextIndexLineNumber;\
|
|
indexKind = nextIndexKind;\
|
|
readIndexFileLine(&nextIndexKind, &nextIndexAddress,\
|
|
&nextIndexLineNumber);\
|
|
}
|
|
|
|
/* This is the most horrible piece of code I have ever written in my entire
|
|
life -- cbm */
|
|
void
|
|
generateListing(void)
|
|
{
|
|
int sourceAddress;
|
|
int sourceDepth;
|
|
char *sourceText = lineBuffer1;
|
|
int nextSourceAddress;
|
|
int nextSourceDepth;
|
|
char *nextSourceText = lineBuffer2;
|
|
int sourceLineNumber;
|
|
|
|
int indexAddress;
|
|
int indexLineNumber;
|
|
statementKindType indexKind;
|
|
int nextIndexAddress;
|
|
int nextIndexLineNumber;
|
|
statementKindType nextIndexKind;
|
|
|
|
bool firstLine;
|
|
bool alreadyListingMacroExpansion;
|
|
bool finishingListingMacroExpansion;
|
|
bool nullMacroLine;
|
|
int callLineNumber;
|
|
int targetLineNumber;
|
|
bool mifEndFlag;
|
|
int numberOfBytesToList;
|
|
int numberOfBytesListed;
|
|
char *tempText;
|
|
|
|
sourceLineNumber = 1;
|
|
alreadyListingMacroExpansion = FALSE;
|
|
readSourceFileLine(&sourceAddress, &sourceDepth, sourceText,
|
|
saveFileForPass2);
|
|
readSourceFileLine(&nextSourceAddress, &nextSourceDepth,
|
|
nextSourceText, saveFileForPass2);
|
|
if (expandMacros)
|
|
readSourceFileLine(&nextMacroAddress, &nextMacroDepth,
|
|
nextMacroLineBuffer, macroFileForPass2);
|
|
readIndexFileLine(&indexKind, &indexAddress, &indexLineNumber);
|
|
readIndexFileLine(&nextIndexKind, &nextIndexAddress,
|
|
&nextIndexLineNumber);
|
|
currentCodeMode = RELOCATABLE_BUFFER;
|
|
if (indexKind == ORG_STATEMENT || indexKind == ALIGN_STATEMENT ||
|
|
indexKind == REL_STATEMENT) {
|
|
if (indexKind == ORG_STATEMENT) {
|
|
currentCodeMode = ABSOLUTE_BUFFER;
|
|
}
|
|
advanceIndexFile();
|
|
}
|
|
while (!feof(saveFileForPass2) && !feof(indexFileForPass2)) {
|
|
mifEndFlag = FALSE;
|
|
if ((int)indexKind == -1) {
|
|
advanceIndexFile();
|
|
if ((int)indexKind == -1)
|
|
currentCodeMode = ABSOLUTE_BUFFER;
|
|
else
|
|
currentCodeMode = RELOCATABLE_BUFFER;
|
|
advanceIndexFile();
|
|
sourceLineNumber = indexLineNumber;
|
|
if (nextIndexKind == ORG_STATEMENT || nextIndexKind ==
|
|
ALIGN_STATEMENT || nextIndexKind ==
|
|
REL_STATEMENT) {
|
|
if (nextIndexKind == ORG_STATEMENT) {
|
|
currentCodeMode = ABSOLUTE_BUFFER;
|
|
} else if (nextIndexKind == REL_STATEMENT) {
|
|
currentCodeMode = RELOCATABLE_BUFFER;
|
|
}
|
|
advanceIndexFile();
|
|
}
|
|
}
|
|
if (indexKind == MACRO_STATEMENT || indexKind ==
|
|
FUNCTION_STATEMENT || indexKind ==
|
|
STRUCT_STATEMENT) {
|
|
while (sourceLineNumber < indexLineNumber) {
|
|
printListingLine(0, indexAddress, sourceText,
|
|
indexKind);
|
|
advanceSourceFile();
|
|
}
|
|
} else if (!alreadyListingMacroExpansion && isBlockOpener(
|
|
indexKind)) {
|
|
while (sourceLineNumber < nextIndexLineNumber) {
|
|
printListingLine(0, indexAddress, sourceText,
|
|
indexKind);
|
|
advanceSourceFile();
|
|
}
|
|
readIndexFileLine(&nextIndexKind, &nextIndexAddress,
|
|
&nextIndexLineNumber);
|
|
}
|
|
while ((indexLineNumber == nextIndexLineNumber &&
|
|
!alreadyListingMacroExpansion &&
|
|
(int)nextIndexKind != -1 && indexKind !=
|
|
ORG_STATEMENT) || (indexKind ==
|
|
NULL_STATEMENT && nextSourceAddress == -1)) {
|
|
while (nextSourceAddress == -1) {
|
|
printListingLine(0, indexAddress, sourceText,
|
|
indexKind);
|
|
advanceSourceFile();
|
|
}
|
|
readIndexFileLine(&nextIndexKind, &nextIndexAddress,
|
|
&nextIndexLineNumber);
|
|
}
|
|
if (nextIndexLineNumber >= 0) {
|
|
targetLineNumber = alreadyListingMacroExpansion ?
|
|
callLineNumber : sourceLineNumber;
|
|
while (nextIndexLineNumber < targetLineNumber &&
|
|
!isBlockOpener(indexKind)) {
|
|
readIndexFileLine(&nextIndexKind,
|
|
&nextIndexAddress,
|
|
&nextIndexLineNumber);
|
|
}
|
|
}
|
|
while (nextIndexAddress == -1 && !feof(indexFileForPass2)) {
|
|
readIndexFileLine(&nextIndexKind, &nextIndexAddress,
|
|
&nextIndexLineNumber);
|
|
mifEndFlag = TRUE;
|
|
}
|
|
numberOfBytesToList = nextIndexAddress - indexAddress;
|
|
firstLine = TRUE;
|
|
nullMacroLine = FALSE;
|
|
while (numberOfBytesToList > 0 || nextSourceAddress == -1 ||
|
|
firstLine) {
|
|
firstLine = FALSE;
|
|
if (alreadyListingMacroExpansion) {
|
|
if (nullMacroLine) {
|
|
numberOfBytesListed = printListingLine(
|
|
numberOfBytesToList, indexAddress,
|
|
NULL, indexKind);
|
|
nullMacroLine = FALSE;
|
|
} else {
|
|
numberOfBytesListed = printMacroLine(
|
|
numberOfBytesToList, indexAddress,
|
|
indexKind);
|
|
}
|
|
} else if (!feof(indexFileForPass2)) {
|
|
numberOfBytesListed = printListingLine(
|
|
numberOfBytesToList, indexAddress,
|
|
sourceText, indexKind);
|
|
}
|
|
numberOfBytesToList -= numberOfBytesListed;
|
|
indexAddress += numberOfBytesListed;
|
|
if (nextSourceAddress == -1 || (sourceLineNumber <
|
|
indexLineNumber && indexKind ==
|
|
INSTRUCTION_STATEMENT &&
|
|
!alreadyListingMacroExpansion)) {
|
|
advanceSourceFile();
|
|
firstLine = TRUE;
|
|
} else if (!alreadyListingMacroExpansion &&
|
|
nextIndexLineNumber >= 0) {
|
|
sourceText = NULL;
|
|
} else if (alreadyListingMacroExpansion &&
|
|
numberOfBytesToList > 0) {
|
|
nullMacroLine = TRUE;
|
|
}
|
|
}
|
|
while (mifEndFlag && sourceLineNumber+1<nextIndexLineNumber
|
|
&& !alreadyListingMacroExpansion) {
|
|
advanceSourceFile();
|
|
printListingLine(0, indexAddress, sourceText,
|
|
indexKind);
|
|
}
|
|
if (nextIndexKind == ORG_STATEMENT || nextIndexKind ==
|
|
ALIGN_STATEMENT || nextIndexKind ==
|
|
REL_STATEMENT) {
|
|
if (nextIndexKind == ORG_STATEMENT) {
|
|
currentCodeMode = ABSOLUTE_BUFFER;
|
|
} else if (nextIndexKind == REL_STATEMENT) {
|
|
currentCodeMode = RELOCATABLE_BUFFER;
|
|
}
|
|
advanceIndexFile();
|
|
}
|
|
advanceIndexFile();
|
|
if (!alreadyListingMacroExpansion)
|
|
advanceSourceFile();
|
|
if (indexLineNumber < 0) {
|
|
while (nextIndexAddress == -1) {
|
|
readIndexFileLine(&nextIndexKind,
|
|
&nextIndexAddress,
|
|
&nextIndexLineNumber);
|
|
}
|
|
if ((int)indexKind == -2) {
|
|
indexKind = NULL_STATEMENT;
|
|
}
|
|
if (!alreadyListingMacroExpansion) {
|
|
callLineNumber = sourceLineNumber;
|
|
sourceLineNumber = -indexLineNumber;
|
|
alreadyListingMacroExpansion = TRUE;
|
|
}
|
|
} else if (alreadyListingMacroExpansion) {
|
|
alreadyListingMacroExpansion = FALSE;
|
|
while (abs(indexLineNumber) < callLineNumber &&
|
|
!feof(indexFileForPass2)) {
|
|
advanceIndexFile();
|
|
}
|
|
sourceLineNumber = /*isBlockOpener(indexKind) ?*/
|
|
callLineNumber /*+ 1 : indexLineNumber*/;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool longLineFlag; /* defined in lexer.c */
|
|
|
|
int
|
|
printMacroLine(int numberOfBytes, int byteAddress, statementKindType kind)
|
|
{
|
|
macroAddress = nextMacroAddress;
|
|
macroDepth = nextMacroDepth;
|
|
strcpy(macroLineBuffer, nextMacroLineBuffer);
|
|
readSourceFileLine(&nextMacroAddress, &nextMacroDepth,
|
|
nextMacroLineBuffer, macroFileForPass2);
|
|
return(printListingLine(numberOfBytes, byteAddress, macroLineBuffer,
|
|
kind));
|
|
}
|
|
|
|
void
|
|
readSourceFileLine(int *sourceAddressPtr, int *sourceDepthPtr, char *lineBuffer, FILE *file)
|
|
{
|
|
char c;
|
|
|
|
*sourceAddressPtr = getw(file);
|
|
*sourceDepthPtr = getw(file);
|
|
myfgets(lineBuffer, LINE_BUFFER_SIZE, file);
|
|
if (longLineFlag) {
|
|
while ((c = getc(file)) != '\n' && c != EOF)
|
|
;
|
|
lineBuffer[LINE_BUFFER_SIZE - 2] = '\n';
|
|
}
|
|
}
|
|
|
|
void
|
|
readIndexFileLine(statementKindType *statementKindPtr, int *indexAddressPtr, int *indexLineNumberPtr)
|
|
{
|
|
statementKindType statementKindRead;
|
|
int indexAddressRead;
|
|
int indexLineNumberRead;
|
|
|
|
statementKindRead = (statementKindType) getw(indexFileForPass2);
|
|
indexAddressRead = getw(indexFileForPass2);
|
|
indexLineNumberRead = getw(indexFileForPass2) - 1;
|
|
if (!feof(indexFileForPass2)) {
|
|
*statementKindPtr = statementKindRead;
|
|
*indexAddressPtr = indexAddressRead;
|
|
*indexLineNumberPtr = indexLineNumberRead;
|
|
} else {
|
|
*indexLineNumberPtr += 1;
|
|
}
|
|
}
|
|
|
|
int
|
|
printListingLine(int numberOfBytes, int byteAddress, char *text, statementKindType kind)
|
|
{
|
|
int i;
|
|
|
|
if (kind != BLOCK_STATEMENT)
|
|
numberOfBytes = (numberOfBytes < 4) ? numberOfBytes : 4;
|
|
|
|
if (numberOfBytes==0 && isBlankStatement(kind))
|
|
fprintf(listFileOutput, " ");
|
|
else
|
|
#if TARGET_CPU == CPU_6502
|
|
fprintf(listFileOutput, "%04x ", byteAddress);
|
|
#elif TARGET_CPU == CPU_68000
|
|
fprintf(listFileOutput, "%06x ", byteAddress);
|
|
#endif
|
|
|
|
if (kind != BLOCK_STATEMENT) {
|
|
#if TARGET_CPU == CPU_6502
|
|
for (i=0; i<numberOfBytes; i++)
|
|
fprintf(listFileOutput, " %02x",
|
|
getByte(byteAddress++));
|
|
for (i=numberOfBytes; i<4; i++)
|
|
fprintf(listFileOutput, " ");
|
|
} else {
|
|
fprintf(listFileOutput, " ");
|
|
#elif TARGET_CPU == CPU_68000
|
|
for (i=0; i<numberOfBytes; i++) {
|
|
fprintf(listFileOutput, "%02x",
|
|
getByte(byteAddress++));
|
|
if (i==1) fprintf(listFileOutput, " ");
|
|
}
|
|
for (i=numberOfBytes; i<4; i++) {
|
|
fprintf(listFileOutput, " ");
|
|
if (i==1) fprintf(listFileOutput, " ");
|
|
}
|
|
} else {
|
|
fprintf(listFileOutput, " ");
|
|
#endif
|
|
}
|
|
|
|
if (text == NULL) {
|
|
fprintf(listFileOutput, "\n");
|
|
} else {
|
|
fprintf(listFileOutput, " ");
|
|
tabPrint(text);
|
|
}
|
|
return(numberOfBytes);
|
|
}
|
|
|
|
|
|
bool
|
|
isBlockOpener(statementKindType statementKind)
|
|
{
|
|
return (statementKind==IF_STATEMENT ||
|
|
statementKind==WHILE_STATEMENT ||
|
|
statementKind==DO_WHILE_STATEMENT ||
|
|
statementKind==DO_UNTIL_STATEMENT ||
|
|
statementKind==CONSTRAIN_STATEMENT ||
|
|
/* statementKind==STRUCT_STATEMENT ||*/
|
|
statementKind==MIF_STATEMENT ||
|
|
statementKind==MFOR_STATEMENT ||
|
|
statementKind==MDO_WHILE_STATEMENT ||
|
|
statementKind==MDO_UNTIL_STATEMENT ||
|
|
statementKind==MWHILE_STATEMENT ||
|
|
statementKind==INCLUDE_STATEMENT ||
|
|
statementKind==GROUP_STATEMENT
|
|
);
|
|
}
|
|
|
|
bool
|
|
isBlankStatement(statementKindType statementKind)
|
|
{
|
|
return( statementKind == DEFINE_STATEMENT ||
|
|
statementKind == NULL_STATEMENT ||
|
|
statementKind == VARIABLE_STATEMENT ||
|
|
statementKind == CONSTRAIN_STATEMENT ||
|
|
statementKind == MACRO_STATEMENT ||
|
|
statementKind == FUNCTION_STATEMENT ||
|
|
statementKind == UNDEFINE_STATEMENT ||
|
|
statementKind == MDEFINE_STATEMENT ||
|
|
statementKind == MVARIABLE_STATEMENT ||
|
|
statementKind == FRETURN_STATEMENT ||
|
|
statementKind == UNDEFINE_STATEMENT ||
|
|
statementKind == EXTERN_STATEMENT ||
|
|
statementKind == START_STATEMENT ||
|
|
statementKind == INCLUDE_STATEMENT ||
|
|
statementKind == MIF_STATEMENT ||
|
|
statementKind == MFOR_STATEMENT ||
|
|
statementKind == MDO_WHILE_STATEMENT ||
|
|
statementKind == MDO_UNTIL_STATEMENT ||
|
|
statementKind == MWHILE_STATEMENT ||
|
|
statementKind == PERFORM_STATEMENT
|
|
);
|
|
}
|
|
|
|
void
|
|
tabPrint(stringType *text)
|
|
{
|
|
int column;
|
|
int spaces;
|
|
|
|
column = 0;
|
|
while (*text != '\0') {
|
|
if (*text == '\t') {
|
|
for (spaces = 8 - (column % 8); spaces>0; spaces--) {
|
|
putc(' ', listFileOutput);
|
|
column++;
|
|
}
|
|
} else {
|
|
putc(*text, listFileOutput);
|
|
column++;
|
|
}
|
|
text++;
|
|
}
|
|
}
|
|
|
|
void
|
|
printNTimes(char aChar, int times)
|
|
{
|
|
while (times-- > 0)
|
|
moreText("%c", aChar, 0, 0);
|
|
}
|
|
|
|
void
|
|
tabIndent(void)
|
|
{
|
|
printNTimes('\t', tabCount);
|
|
}
|
|
|
|
static char expressionString[LINE_BUFFER_SIZE] = { '\0' };
|
|
static char *expressionStringPtr = expressionString;
|
|
static char expansionString[LINE_BUFFER_SIZE] = { '\0' };
|
|
static char *expansionStringPtr = expansionString;
|
|
static char labelString[LINE_BUFFER_SIZE] = { '\0' };
|
|
static char *labelStringPtr = labelString;
|
|
|
|
bool
|
|
labeledLine(void)
|
|
{
|
|
return(labelStringPtr != labelString);
|
|
}
|
|
|
|
void
|
|
vaddText(char *buffer, char **bufferPtr, char *format, va_list ap)
|
|
{
|
|
vsprintf(*bufferPtr, format, ap);
|
|
*bufferPtr = buffer + strlen(buffer);
|
|
}
|
|
|
|
void
|
|
addText(char *buffer, char **bufferPtr, char *format, ...)
|
|
{
|
|
va_list ap;
|
|
va_start(ap, format);
|
|
vaddText(buffer, bufferPtr, format, ap);
|
|
va_end(ap);
|
|
}
|
|
|
|
void
|
|
moreTextOptional(char *buffer, char **bufferPtr, char *format, ...)
|
|
{
|
|
va_list ap;
|
|
va_start(ap, format);
|
|
if (buffer == NULL)
|
|
vaddText(expansionString, &expansionStringPtr, format, ap);
|
|
else
|
|
vaddText(buffer, bufferPtr, format, ap);
|
|
va_end(ap);
|
|
}
|
|
|
|
void
|
|
moreText(char *format, ...)
|
|
{
|
|
va_list ap;
|
|
va_start(ap, format);
|
|
vaddText(expansionString, &expansionStringPtr, format, ap);
|
|
va_end(ap);
|
|
}
|
|
|
|
void
|
|
moreLabel(char *format, int arg1)
|
|
{
|
|
sprintf(labelStringPtr, format, arg1);
|
|
labelStringPtr = labelString + strlen(labelString);
|
|
}
|
|
|
|
static addressType savedCurrentLocationCounterValue;
|
|
static int savedIncludeNestingDepth;
|
|
|
|
void
|
|
startLine(void)
|
|
{
|
|
printNTimes('+', macroCallDepth);
|
|
savedCurrentLocationCounterValue = currentLocationCounter.value;
|
|
savedIncludeNestingDepth = includeNestingDepth;
|
|
}
|
|
|
|
void
|
|
endLine(void)
|
|
{
|
|
if (amListing()) {
|
|
putw(savedCurrentLocationCounterValue, macroFileForPass2);
|
|
putw(savedIncludeNestingDepth, macroFileForPass2);
|
|
fprintf(macroFileForPass2, "%s\n", expansionString);
|
|
}
|
|
expansionStringPtr = expansionString;
|
|
*expansionStringPtr = '\0';
|
|
}
|
|
|
|
void
|
|
flushExpressionString(void)
|
|
{
|
|
expressionStringPtr = expressionString;
|
|
*expressionStringPtr = '\0';
|
|
}
|
|
|
|
void
|
|
expandExpression(char *toBuffer, char **toBufferPtr)
|
|
{
|
|
if (toBuffer == NULL)
|
|
moreText("%s", expressionString, 0, 0);
|
|
else
|
|
addText(toBuffer, toBufferPtr, "%s", expressionString, 0, 0);
|
|
flushExpressionString();
|
|
}
|
|
|
|
void
|
|
expandNum(char *buffer, char **bufferPtr, int n)
|
|
{
|
|
moreTextOptional(buffer, bufferPtr, "%d", n, 0, 0);
|
|
}
|
|
|
|
void
|
|
flushOperand(int n)
|
|
{
|
|
moreText("%s", operandBuffer[n], 0, 0);
|
|
operandBuffer[n][0] = '\0';
|
|
}
|
|
|
|
void
|
|
expandOperands(int op)
|
|
{
|
|
int i;
|
|
|
|
if (op > 0) {
|
|
flushOperand(0);
|
|
for (i=1; i<op; i++) {
|
|
moreText(", ", 0, 0, 0);
|
|
flushOperand(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
expandLabel(void)
|
|
{
|
|
moreText("%s", labelString, 0, 0);
|
|
labelStringPtr = labelString;
|
|
*labelStringPtr = '\0';
|
|
}
|
|
|
|
void
|
|
moreExpression(char *format, ...)
|
|
{
|
|
va_list ap;
|
|
va_start(ap, format);
|
|
vsprintf(expressionStringPtr, format, ap);
|
|
va_end(ap);
|
|
expressionStringPtr = expressionString + strlen(expressionString);
|
|
}
|
|
|
|
void
|
|
startLineMarked(void)
|
|
{
|
|
startLine();
|
|
if (amListing())
|
|
saveIndexForListing(-2, cumulativeLineNumber);
|
|
}
|
|
|
|
bool
|
|
notListable(statementKindType statementKind)
|
|
{
|
|
return(!listableStatement(statementKind) &&
|
|
statementKind != INSTRUCTION_STATEMENT &&
|
|
(int)statementKind != -2);
|
|
}
|