7bdb5aee8d
- Initialize local state variable to 0. Likely non functional changes due to lack of depth in static analysis scan. Coverity detects real problems like this. - Migrate use of strncpy to strlcpy to assure safe buffer operations
329 lines
16 KiB
C
329 lines
16 KiB
C
/*********************************************************************************************
|
|
* ibm1130_fmt.c : interpret tabs in 1130 Assembler or Fortran source
|
|
* Bob Flanders
|
|
* -------------------------------------------------------------------------------------------
|
|
*
|
|
* These routines are used by ibm1130_cr.c when the user has indicated
|
|
* that the input text is formatted with tabs. Input lines are edited
|
|
* into the appropriate column format. Three edit modes are recognized:
|
|
*
|
|
* Assembler mode:
|
|
* Input lines of the form
|
|
*
|
|
* [label]<whitespace>[opcode]<tab>[tag][L]<tab>[argument]
|
|
*
|
|
* are rearranged so that the input fields are placed in the appropriate columns
|
|
*
|
|
* The label must start on the first character of the line. If there is no label,
|
|
* the first character(s) before the opcode must be whitespace. Following the opcode, there
|
|
* MUST be a tab character, followed by the format and tag. Following the format and tag
|
|
* may be exactly one whitespace character, and then starts the argument.
|
|
*
|
|
* Input lines with * in column 1 and blank lines are turned into Assembler comments,
|
|
* with the * in the Opcode field.
|
|
*
|
|
* Assembler directive lines at the beginning of the deck must be preceded by
|
|
* ! to indicate that they are not comments. For example,
|
|
*
|
|
* !*LIST
|
|
* * This is a comment
|
|
*
|
|
* Fortran mode:
|
|
* Input lines of the form
|
|
*
|
|
* [label]<tab>statement
|
|
*
|
|
* or
|
|
*
|
|
* [label]<tab>Xcontinuation
|
|
*
|
|
* where X is a non alphabetic contination character are rearranged in the
|
|
* appropriate manner:
|
|
*
|
|
* 1 2
|
|
* 12345678901234567890...
|
|
* ------------------------
|
|
* label statement
|
|
* labelXcontinuation
|
|
*
|
|
* However, you must take care that you don't end up with statement text after column 72.
|
|
*
|
|
* Input lines with * or C in column 1 are left alone (comments and directives)
|
|
*
|
|
* (The ! escape is not used before Fortran directives as before Assembler directives)
|
|
*
|
|
* Tab mode:
|
|
* Tabs are replaced with spaces. Tab settings are assumed to be eight characters wide,
|
|
* as is standard for vi, notepad, etc.
|
|
*********************************************************************************************/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <memory.h>
|
|
#include <ctype.h>
|
|
#include <string.h>
|
|
#include "ibm1130_fmt.h"
|
|
#include "sim_defs.h"
|
|
|
|
#define MAXLINE 81 /* maximum output line size */
|
|
#define WORKSZ 256 /* size for tab work area */
|
|
#define TAGOFFSET 12 /* offset for tag field */
|
|
#define FMTOFFSET 11 /* offset for format field */
|
|
|
|
#define MIN(a,b) ((a < b) ? a : b)
|
|
#define AMSG " with Assembler Reformat"
|
|
#define FMSG " with FORTRAN Reformat"
|
|
#define WMSG " with tab replacement"
|
|
#define AFORMAT "%20.20s%-60.60s"," "
|
|
#define ACOMMENTFMT "%20.20s%-60.60s"," "
|
|
#define ABLANKLINE "%20.20s*"," "
|
|
#define FFORMAT "%-5.5s %-74.74s"
|
|
#define FCONTFMT "%-5.5s%-75.75s"
|
|
|
|
static char gszLabel[6]; /* work area for label */
|
|
static char gszArg[MAXLINE]; /* .. argument */
|
|
static char gszOutput[MAXLINE]; /* .. output */
|
|
static short gaiAsmTabs[] = {7,12,15,20,25,30,35,40,45,52,0};/* tab stops for assembler */
|
|
static short gaiPlainTabs[42]; /* tab stops for plain tabs. Settings will be made later. Max # positions when tabs are every 2 positions */
|
|
static int giPlainTabWidth = 0;
|
|
|
|
/*
|
|
* helper routines
|
|
*/
|
|
|
|
/*************************************************
|
|
* ExpandTabs: Expand tabs to spaces
|
|
*/
|
|
|
|
char* ExpandTabs(char* p_szInbuf, /* expand tabs .. input buffer */
|
|
char* p_szOutbuf, /* .. output buffer */
|
|
short* p_aiTabs) /* .. array of tab stops (1 based) -- 0 end of array */
|
|
{
|
|
short iI, /* input position */
|
|
iO, /* output position */
|
|
iT; /* next tab stop */
|
|
|
|
char cX; /* character to test */
|
|
|
|
iI = 0; /* init input position */
|
|
iO = 0; /* init output position */
|
|
iT = 0; /* init tab stop */
|
|
|
|
while ((cX = *(p_szInbuf + iI)) != 0) /* while there are characters */
|
|
{
|
|
if (cX == '\t') /* q. tab character? */
|
|
{ /* a. yes .. */
|
|
while ((p_aiTabs[iT] <= iO + 1) /* search for next valid stop .. */
|
|
&& (p_aiTabs[iT] != 0)) /* .. or end of table */
|
|
iT++; /* .. go to next tab */
|
|
|
|
if (p_aiTabs[iT] != 0) /* q. end of tab array? */
|
|
{ /* a. no .. */
|
|
while (iO < (p_aiTabs[iT] - 1)) /* fill to tab with blanks */
|
|
*(p_szOutbuf + iO++) = ' '; /* .. put in a blank */
|
|
|
|
}
|
|
else /* Otherwise ... */
|
|
*(p_szOutbuf + iO++) = ' '; /* .. Translate to blank */
|
|
}
|
|
else /* Otherwise .. not tab */
|
|
*(p_szOutbuf + iO++) = cX; /* .. save the input char */
|
|
|
|
iI++; /* next input character */
|
|
}
|
|
|
|
*(p_szOutbuf + iO) = 0; /* end the string.. */
|
|
return p_szOutbuf; /* .. return output area addr */
|
|
}
|
|
|
|
/*************************************************
|
|
* extract next token, modify pointer
|
|
*/
|
|
|
|
char* GetToken(char* p_szOut, /* output location */
|
|
int p_iLen, /* max output length */
|
|
char**p_pszToken) /* pointer to input token */
|
|
{
|
|
int iI; /* work integer */
|
|
char* pszX; /* work pointer */
|
|
|
|
pszX = *p_pszToken; /* get pointer to token */
|
|
|
|
for (iI = 0; *(pszX + iI) && (!isspace(*(pszX + iI)));) /* while not whitespace & not end */
|
|
iI++; /* .. count token length */
|
|
|
|
memset(p_szOut, 0, p_iLen); /* zero out output area */
|
|
|
|
if (iI > 0) /* q. any chars? */
|
|
memcpy(p_szOut, *p_pszToken, MIN(iI, p_iLen-1)); /* a. yes.. copy max of p_iLen-1 */
|
|
|
|
*p_pszToken += iI; /* point beyond token */
|
|
return p_szOut; /* .. return token pointer */
|
|
}
|
|
|
|
/*************************************************
|
|
* EditToAsm - convert tab-formatted text line to 1130 Assembler format
|
|
*/
|
|
|
|
const char *EditToAsm (char* p_pszEdit, int width) /* convert line to 1130 assembler */
|
|
{
|
|
char pszLine[MAXLINE]; /* source line */
|
|
char pszWork[WORKSZ]; /* work buffer */
|
|
char acTFWrk[2]; /* tag/format work area */
|
|
size_t iI; /* work integer */
|
|
|
|
if (p_pszEdit == NULL) /* q. null request? */
|
|
return AMSG; /* a. yes .. return display message */
|
|
|
|
if (*p_pszEdit == '!') /* leave lines starting with ! alone */
|
|
return EditToWhitespace(p_pszEdit+1, width);
|
|
|
|
if (*p_pszEdit == '*') /* q. comment line? */
|
|
{ /* a. yes.. */
|
|
strlcpy(pszWork, EditToWhitespace(p_pszEdit, width), sizeof pszWork);/* .. convert any tabs */
|
|
sprintf(gszOutput, ACOMMENTFMT, pszWork); /* .. put the comment out there in the opcode column */
|
|
return gszOutput; /* .. and return it */
|
|
}
|
|
|
|
strlcpy(pszLine, p_pszEdit, sizeof pszLine); /* copy the line local */
|
|
|
|
ExpandTabs(pszLine, pszWork, gaiAsmTabs); /* expand the tabs */
|
|
strlcpy(pszLine, pszWork, sizeof pszLine); /* copy the line back */
|
|
|
|
for (iI = strlen(pszLine); iI--;) /* trim trailing whitespace */
|
|
{
|
|
if (*(pszLine + iI) <= ' ') /* q. space or less? */
|
|
*(pszLine + iI) = 0; /* a. yes .. remove it */
|
|
else /* otherwise */
|
|
break; /* .. done. Leave loop. */
|
|
}
|
|
|
|
if (strlen(pszLine) == 0) /* q. blank line? */
|
|
{ /* a. yes .. Assembler abhors these so */
|
|
sprintf(gszOutput, ABLANKLINE); /* format as comment statement */
|
|
return gszOutput; /* .. and return it */
|
|
}
|
|
|
|
|
|
/* TODO: Add code to process a strip switch
|
|
* comment?
|
|
*/
|
|
|
|
if (strlen(pszLine) > (TAGOFFSET + 1)) /* q. line long enough? */
|
|
{ /* a. yes.. reorder tag/format */
|
|
memcpy(acTFWrk, pszLine + FMTOFFSET, 2); /* get tag/format */
|
|
memset((pszLine + FMTOFFSET), ' ', 2); /* .. blank 'em out */
|
|
|
|
for (iI = 0; iI < 2; iI ++)
|
|
if (isalpha(acTFWrk[iI])) /* q. alpha char? */
|
|
*(pszLine + FMTOFFSET) = acTFWrk[iI]; /* a. yes .. make it format */
|
|
else if (isdigit(acTFWrk[iI])) /* q. digit? */
|
|
*(pszLine + TAGOFFSET) = acTFWrk[iI]; /* a. yes .. make it the tag */
|
|
}
|
|
|
|
sprintf(gszOutput, AFORMAT, pszLine); /* format the line */
|
|
|
|
return gszOutput; /* return formatted line */
|
|
}
|
|
|
|
/*************************************************
|
|
* EditToFortran - convert tab-formatted input text line to FORTRAN format
|
|
* (a la DEC Fortran)
|
|
*/
|
|
|
|
const char *EditToFortran(char* p_pszEdit, int width) /* convert line to 1130 assembler */
|
|
{
|
|
char pszLine[MAXLINE]; /* source line */
|
|
char* pszWork; /* work pointer */
|
|
size_t iI; /* work integer */
|
|
int bContinue; /* true if continue */
|
|
|
|
if (p_pszEdit == NULL) /* q. null request? */
|
|
return FMSG; /* a. yes .. return display message */
|
|
|
|
if (strchr(p_pszEdit, '\t') == NULL) /* q. no tab in the line? */
|
|
return p_pszEdit; /* a. nope, return line as is, assume it's formatted correctly */
|
|
|
|
if (*p_pszEdit == 'C' || *p_pszEdit == '*' || *p_pszEdit == '\0') /* q. comment or directive or blank line? */
|
|
{ /* a. yes.. don't restructure */
|
|
return EditToWhitespace(p_pszEdit, width);
|
|
}
|
|
|
|
strlcpy(pszLine, p_pszEdit, sizeof pszLine); /* copy the line local */
|
|
|
|
for (iI = strlen(pszLine); iI--;) /* trim trailing whitespace */
|
|
{
|
|
if (*(pszLine + iI) <= ' ') /* q. space or less? */
|
|
*(pszLine + iI) = 0; /* a. yes .. remove it */
|
|
else /* otherwise */
|
|
break; /* .. done. Leave loop. */
|
|
}
|
|
|
|
/*
|
|
* TODO: Add code to process a strip switch
|
|
* comment?
|
|
*/
|
|
|
|
pszWork = (char*) pszLine; /* set pointer to line */
|
|
GetToken(gszLabel, 6, &pszWork); /* get the line, if any. */
|
|
|
|
pszWork++; /* skip tab/whitespace */
|
|
|
|
/* continuation... */
|
|
bContinue = ((isdigit(*pszWork) && (*pszWork != '0')) /* if first char non-zero digit */
|
|
|| (!isspace(*pszWork) && !isalpha(*pszWork))); /* .. or non-alpha non-blank */
|
|
|
|
memset(gszArg, 0, MAXLINE); /* .. and arguments */
|
|
|
|
strncpy(gszArg, pszWork, 75); /* copy rest to argument */
|
|
|
|
sprintf(gszOutput, (bContinue) ? FCONTFMT : FFORMAT, /* format the line */
|
|
gszLabel, /* .. statement # */
|
|
gszArg); /* .. code */
|
|
|
|
return gszOutput; /* return formatted line */
|
|
}
|
|
|
|
/*************************************************
|
|
* EditToWhitespace - expand tabs at n space intervals.
|
|
*/
|
|
|
|
const char* EditToWhitespace(char *p_pszEdit, int width)
|
|
{
|
|
int iI; /* work integer */
|
|
int iPos; /* work integer for settings tab stops */
|
|
char pszLine[MAXLINE]; /* source line */
|
|
char pszWork[WORKSZ]; /* work buffer */
|
|
|
|
if (p_pszEdit == NULL) /* q. null request? */
|
|
return WMSG; /* a. yes .. return display message */
|
|
|
|
strncpy(pszLine, p_pszEdit, MAXLINE-1); /* copy the line local */
|
|
|
|
if (width == 0) width = 8; /* default */
|
|
|
|
if ((width != giPlainTabWidth) && (width > 1) && (width < 30)) {
|
|
giPlainTabWidth = width; /* if width is different, and valid, rebuild tabstop array */
|
|
iI = 0; /* output index */
|
|
iPos = width + 1; /* first tab position */
|
|
while (iPos < 80) { /* fill array up to but not including position 80 */
|
|
gaiPlainTabs[iI++] = iPos;
|
|
iPos += width;
|
|
}
|
|
gaiPlainTabs[iI] = 0; /* mark end of array */
|
|
}
|
|
|
|
ExpandTabs(pszLine, pszWork, gaiPlainTabs); /* expand the tabs */
|
|
strlcpy(gszOutput, pszWork, sizeof gszOutput); /* copy the line back */
|
|
|
|
for (iI = strlen(gszOutput); iI--;) /* look at each character */
|
|
{
|
|
if (*(gszOutput + iI) <= ' ') /* q. space or less? */
|
|
*(gszOutput + iI) = 0; /* a. yes .. remove it */
|
|
else /* otherwise */
|
|
break; /* .. done. Leave loop. */
|
|
}
|
|
|
|
|
|
return gszOutput; /* ... return buffer */
|
|
}
|