408 lines
15 KiB
C
408 lines
15 KiB
C
|
/*
|
|||
|
|
** Justify Z extension
|
|||
|
|
**
|
|||
|
|
** History:
|
|||
|
|
** 12-Sep-1988 mz Made WhenLoaded match declaration
|
|||
|
|
** 01-Sep-1988 Corrected hang when flush-justifying a line with no
|
|||
|
|
** spaces.
|
|||
|
|
** 14-Aug-1988 Corrected right-justification on non-column-1 based
|
|||
|
|
** lines. Corrected justification over multiple
|
|||
|
|
** paragraphs.
|
|||
|
|
** 30-Mar-1988 Extracted from "myext".
|
|||
|
|
**
|
|||
|
|
*/
|
|||
|
|
#include <ctype.h>
|
|||
|
|
#include <stdlib.h>
|
|||
|
|
#include <string.h>
|
|||
|
|
|
|||
|
|
#include "zext.h"
|
|||
|
|
|
|||
|
|
#ifndef TRUE
|
|||
|
|
#define TRUE -1
|
|||
|
|
#define FALSE 0
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
void pascal near DumpLine (char far *, PFILE, COL, COL, LINE, char far *, int);
|
|||
|
|
int pascal near NextLine (char far *, PFILE, LINE, LINE far *, int far *);
|
|||
|
|
flagType pascal near isterm (char);
|
|||
|
|
void pascal near _stat (char *);
|
|||
|
|
|
|||
|
|
flagType just2space = TRUE;
|
|||
|
|
int justwidth = 79;
|
|||
|
|
|
|||
|
|
/*************************************************************************
|
|||
|
|
**
|
|||
|
|
** justify
|
|||
|
|
** justify paragraph(s)
|
|||
|
|
**
|
|||
|
|
** NOARG: Justify between columns 0 and 78, from the current line to
|
|||
|
|
** blank line.
|
|||
|
|
** NULLARG: Justify between current column and 78, from the current line to
|
|||
|
|
** blank line.
|
|||
|
|
** LINEARG: Justify between current column and 78, the specified lines.
|
|||
|
|
** "STREAMARG": Justify between specified columns from current line to blank.
|
|||
|
|
** (handled by boxarg)
|
|||
|
|
** BOXARG: justify between specified columns the specified rows
|
|||
|
|
** TEXTARG: Justify between columns 0 and 78, from the current line to
|
|||
|
|
** blank line, prepending each resulting line with the textarg.
|
|||
|
|
*/
|
|||
|
|
flagType pascal EXTERNAL
|
|||
|
|
justify (
|
|||
|
|
CMDDATA argData,
|
|||
|
|
ARG far *pArg,
|
|||
|
|
flagType fMeta
|
|||
|
|
)
|
|||
|
|
{
|
|||
|
|
int cbLine; /* length of line just read */
|
|||
|
|
char inbuf[BUFLEN]; /* input buffer */
|
|||
|
|
PFILE pFile; /* file handle */
|
|||
|
|
char far *pText; /* pointer to prepending text */
|
|||
|
|
COL x1; /* justify to left column */
|
|||
|
|
COL x2; /* justify to right columne */
|
|||
|
|
LINE y1; /* start line */
|
|||
|
|
LINE y2; /* end line */
|
|||
|
|
LINE yOut; /* output line */
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Unreferenced parameters
|
|||
|
|
//
|
|||
|
|
(void)argData;
|
|||
|
|
|
|||
|
|
switch (pArg->argType) {
|
|||
|
|
|
|||
|
|
case NOARG: /* justify paragraph */
|
|||
|
|
x1 = 0; /* between cols 0... */
|
|||
|
|
x2 = justwidth; /* ...and 79 */
|
|||
|
|
y1 = pArg->arg.noarg.y; /* current line... */
|
|||
|
|
y2 = -1; /* ...to blank line*/
|
|||
|
|
pText = 0; /* there is no text */
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case NULLARG: /* justify indented */
|
|||
|
|
x1 = pArg->arg.nullarg.x; /* between cur col... */
|
|||
|
|
x2 = justwidth; /* ...and 79 */
|
|||
|
|
y1 = pArg->arg.nullarg.y; /* current line... */
|
|||
|
|
y2 = -1; /* ...to blank line*/
|
|||
|
|
pText = 0; /* there is no text */
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case LINEARG: /* justify line range */
|
|||
|
|
x1 = 0; /* between cols 0... */
|
|||
|
|
x2 = justwidth; /* ...and 79 */
|
|||
|
|
y1 = pArg->arg.linearg.yStart; /* and range of lines */
|
|||
|
|
y2 = pArg->arg.linearg.yEnd;
|
|||
|
|
pText = 0; /* there is no text */
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case BOXARG: /* justify box */
|
|||
|
|
x1 = pArg->arg.boxarg.xLeft; /* from left corner... */
|
|||
|
|
x2 = pArg->arg.boxarg.xRight; /* ...to right */
|
|||
|
|
y1 = pArg->arg.boxarg.yTop; /* from top... */
|
|||
|
|
y2 = pArg->arg.boxarg.yBottom; /* ...to bottom */
|
|||
|
|
pText = 0; /* there is no text */
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case TEXTARG: /* justify & prepend */
|
|||
|
|
x1 = 0; /* between 0... */
|
|||
|
|
x2 = justwidth; /* ...and 79 */
|
|||
|
|
y1 = pArg->arg.textarg.y; /* current line... */
|
|||
|
|
y2 = -1; /* ...to blank line */
|
|||
|
|
pText = pArg->arg.textarg.pText; /* there IS text */
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
pFile = FileNameToHandle ("", "");
|
|||
|
|
|
|||
|
|
if (y1 == y2) /* if same line, then */
|
|||
|
|
y2 = -1; /* just to blank line */
|
|||
|
|
if (x1 == x2) /* if same column */
|
|||
|
|
x2 = justwidth; /* then just to default */
|
|||
|
|
if (x2 < x1) { /* if bas-ackwards */
|
|||
|
|
x1 = 0; /* revert to default */
|
|||
|
|
x2 = justwidth;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
** while we can get data within the specified limits, format each new line
|
|||
|
|
** and output back to the file.
|
|||
|
|
*/
|
|||
|
|
inbuf[0] = 0;
|
|||
|
|
yOut = y1;
|
|||
|
|
while (NextLine(inbuf,pFile,y1,&y2,&cbLine)) {
|
|||
|
|
/*
|
|||
|
|
** if the line was blank, NextLine returned TRUE becase we're formating a
|
|||
|
|
** range of text. This means we've reached the end of one paragraph. We dump
|
|||
|
|
** the text collected so far (if any), and then a blank line.
|
|||
|
|
*/
|
|||
|
|
if (cbLine == 0) {
|
|||
|
|
if (inbuf[0]) {
|
|||
|
|
DumpLine(inbuf,pFile,x1,x2,yOut++,pText,0);
|
|||
|
|
y1++;
|
|||
|
|
if (y2 != (LINE)-1)
|
|||
|
|
y2++;
|
|||
|
|
}
|
|||
|
|
DumpLine("",pFile,x1,x2,yOut++,pText,0);/* dump blank line */
|
|||
|
|
y1++;
|
|||
|
|
if (y2 != (LINE)-1)
|
|||
|
|
y2++;
|
|||
|
|
} else
|
|||
|
|
/*
|
|||
|
|
** inbuf contains the data collected so far for output. Output one newly
|
|||
|
|
** formated line at a time until the contents of inbuf are narrower than
|
|||
|
|
** our output columns.
|
|||
|
|
*/
|
|||
|
|
while ((COL)strlen(inbuf) > (x2-x1)) { /* while data to output */
|
|||
|
|
DumpLine(inbuf,pFile,x1,x2,yOut++,pText,fMeta);
|
|||
|
|
y1++; /* line moves with insert*/
|
|||
|
|
if (y2 != (LINE)-1)
|
|||
|
|
y2++;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
/*
|
|||
|
|
** Dump any partial last line. Then if we were formatting to a blank line,
|
|||
|
|
** dump out one of those too.;
|
|||
|
|
*/
|
|||
|
|
if (inbuf[0])
|
|||
|
|
DumpLine (inbuf,pFile,x1,x2,yOut++,pText,0); /* dump last line */
|
|||
|
|
if (y2 == -1)
|
|||
|
|
DumpLine (NULL,pFile,x1,x2,yOut++,pText,0); /* dump blank line */
|
|||
|
|
|
|||
|
|
return TRUE;
|
|||
|
|
|
|||
|
|
/* end justify */
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*** NextLine - Get next line from file
|
|||
|
|
*
|
|||
|
|
* Get next line from file, remove leading and trailing spaces, and append
|
|||
|
|
* it to the input buffer. Each line is deleted from the file as it is
|
|||
|
|
* read in. This means that the target terminator, (*py2), is decremented
|
|||
|
|
* by one for each line read in.
|
|||
|
|
*
|
|||
|
|
* Input:
|
|||
|
|
* pBuf = pointer to input buffer
|
|||
|
|
* pFile = file pointer
|
|||
|
|
* y1 = line # to read
|
|||
|
|
* py2 = pointer to line # to stop at (updated)
|
|||
|
|
* pcbLine = pointer to place to put the count of bytes read
|
|||
|
|
*
|
|||
|
|
* Output:
|
|||
|
|
* Returns TRUE on a line being read & more reformatting should occurr.
|
|||
|
|
*
|
|||
|
|
*************************************************************************/
|
|||
|
|
int pascal near NextLine (
|
|||
|
|
char far *pBuf, /* input buffer */
|
|||
|
|
PFILE pFile, /* file pointer */
|
|||
|
|
LINE y1, /* line # to read */
|
|||
|
|
LINE far *py2, /* line # to stop at */
|
|||
|
|
int far *pcbLine /* loc to place bytes read*/
|
|||
|
|
) {
|
|||
|
|
flagType fRet = TRUE;
|
|||
|
|
char far *pT; /* working pointer */
|
|||
|
|
char workbuf[BUFLEN]; /* working buffer */
|
|||
|
|
|
|||
|
|
|
|||
|
|
*pcbLine = 0;
|
|||
|
|
workbuf[0] = 0;
|
|||
|
|
/*
|
|||
|
|
** If asked for line that is not in file, we're done.
|
|||
|
|
*/
|
|||
|
|
if (y1 >= FileLength(pFile))
|
|||
|
|
return FALSE;
|
|||
|
|
/*
|
|||
|
|
** if current line past range, (and range is not "-1"), then we're done.
|
|||
|
|
*/
|
|||
|
|
if ((*py2 != (LINE)-1) && (y1 > *py2))
|
|||
|
|
return FALSE;
|
|||
|
|
/*
|
|||
|
|
** Get the next line in the file & remove it.
|
|||
|
|
*/
|
|||
|
|
*pcbLine = GetLine(y1, workbuf, pFile);
|
|||
|
|
DelLine(pFile, y1, y1);
|
|||
|
|
if (*py2 == 0)
|
|||
|
|
fRet = FALSE;
|
|||
|
|
else if (*py2 != (LINE)-1)
|
|||
|
|
(*py2)--;
|
|||
|
|
/*
|
|||
|
|
** If the line is blank, and the range is "-1", we're done.
|
|||
|
|
*/
|
|||
|
|
if (!*pcbLine && (*py2 == -1))
|
|||
|
|
return FALSE;
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
** strip leading spaces in newly input line
|
|||
|
|
*/
|
|||
|
|
pT = workbuf; /* point into line */
|
|||
|
|
while (*pT == ' ')
|
|||
|
|
pT++; /* skip leading spaces */
|
|||
|
|
/*
|
|||
|
|
** If existing buffer is non-empty, append a space & set pointer to end
|
|||
|
|
*/
|
|||
|
|
if (strlen(pBuf)) { /* if non-null string */
|
|||
|
|
pBuf += strlen(pBuf); /* point to null */
|
|||
|
|
*pBuf++ = ' '; /* append space */
|
|||
|
|
if (isterm(*(pBuf-2))) /* if sentence term... */
|
|||
|
|
*pBuf++ = ' '; /* append another */
|
|||
|
|
}
|
|||
|
|
/*
|
|||
|
|
** append new line, but compress multiple spaces into one
|
|||
|
|
*/
|
|||
|
|
while (*pT) { /* copy line over */
|
|||
|
|
if (isterm(*pT)) /* if sentence term... */
|
|||
|
|
if (*(pT+1) == ' ') { /* ...space */
|
|||
|
|
*pBuf++ = *pT++; /* copy period */
|
|||
|
|
*pBuf++ = *pT; /* copy space */
|
|||
|
|
}
|
|||
|
|
if ((*pBuf++ = *pT++) == ' ' ) /* copy a char */
|
|||
|
|
while (*pT == ' ') pT++; /* skip multiple spaces */
|
|||
|
|
}
|
|||
|
|
if (*(pBuf-1) == ' ') /* if a trailing space */
|
|||
|
|
pBuf--; /* remove it */
|
|||
|
|
*pBuf = 0;
|
|||
|
|
|
|||
|
|
return fRet;
|
|||
|
|
/* end NextLine */}
|
|||
|
|
|
|||
|
|
/*** DumpLine - Dump one line of text to the file
|
|||
|
|
*
|
|||
|
|
* Dump one line of text to the file. Prepend any required text or spaces,
|
|||
|
|
* and perform word break/cut at right hand column.
|
|||
|
|
*
|
|||
|
|
* Input:
|
|||
|
|
* pBuf = Pointer to the buffer containing data to output. If NULL, pText
|
|||
|
|
* will not be prepended to output text.
|
|||
|
|
* pFile
|
|||
|
|
* x1
|
|||
|
|
* x2
|
|||
|
|
* yOut
|
|||
|
|
* pText
|
|||
|
|
* fFlush
|
|||
|
|
*
|
|||
|
|
* Output:
|
|||
|
|
* Returns .....
|
|||
|
|
*
|
|||
|
|
* Exceptions:
|
|||
|
|
*
|
|||
|
|
* Notes:
|
|||
|
|
*
|
|||
|
|
*************************************************************************/
|
|||
|
|
void pascal near DumpLine (
|
|||
|
|
char far *pBuf, /* data to output */
|
|||
|
|
PFILE pFile, /* file to output to */
|
|||
|
|
COL x1, /* left-hand column */
|
|||
|
|
COL x2, /* right-hand column */
|
|||
|
|
LINE yOut, /* line to output to */
|
|||
|
|
char far *pText, /* text to prepend */
|
|||
|
|
int fFlush /* flush both sides */
|
|||
|
|
) {
|
|||
|
|
int i;
|
|||
|
|
char far *pT;
|
|||
|
|
char far *pT2;
|
|||
|
|
char workbuf[BUFLEN]; /* working buffer */
|
|||
|
|
char flushbuf[BUFLEN]; /* working buffer */
|
|||
|
|
char fSpace; /* space seen flag */
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
** Start by prepending any text, and then filling out to the left hand column
|
|||
|
|
** to justify to.
|
|||
|
|
*/
|
|||
|
|
workbuf[0] = 0; /* start with null */
|
|||
|
|
if (pText && pBuf)
|
|||
|
|
strcpy(workbuf,pText); /* if starting with text*/
|
|||
|
|
i = strlen(workbuf); /* length of line-so-far*/
|
|||
|
|
while (i++ < x1)
|
|||
|
|
strcat(workbuf," "); /* fill out with spaces */
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
** Append the data to be output, and then starting at the right column, scan
|
|||
|
|
** back for a space to break at. If one is not found before the left hand
|
|||
|
|
** column, then break at the right hand column. Copy any line left over back
|
|||
|
|
** to the passed in buffer
|
|||
|
|
*/
|
|||
|
|
if (pBuf) {
|
|||
|
|
strcat(workbuf,pBuf); /* get total line */
|
|||
|
|
*pBuf = 0; /* empty input buffer */
|
|||
|
|
}
|
|||
|
|
if ((COL)strlen(workbuf) > x2) { /* if we need to cut */
|
|||
|
|
pT = &workbuf[x2]; /* point at potential cut*/
|
|||
|
|
while ((pT > (char far *)&workbuf[0]) && (*pT != ' ')) pT--; /* back up to space*/
|
|||
|
|
if (pT <= (char far *)&workbuf[x1]) { /* if none found in range*/
|
|||
|
|
if (pBuf)
|
|||
|
|
strcpy(pBuf,&workbuf[x2]); /* copy remainder of line*/
|
|||
|
|
workbuf[x2] = 0; /* and terminate this one*/
|
|||
|
|
} else {
|
|||
|
|
while (*++pT == ' '); /* Skip leading spaces */
|
|||
|
|
if (pBuf)
|
|||
|
|
strcpy(pBuf,pT); /* copy remainder of line*/
|
|||
|
|
*pT = 0; /* and terminate this one*/
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
/*
|
|||
|
|
** This code is invoked when the user wants to justify both right and left
|
|||
|
|
** sides of his text. We determine how many spaces we need to add, and scan
|
|||
|
|
** through and add one space to each run of spaces until we've added enough
|
|||
|
|
*/
|
|||
|
|
if (fFlush) { /* right & left justify?*/
|
|||
|
|
pT = workbuf + strlen(workbuf) - 1;
|
|||
|
|
if (pT)
|
|||
|
|
while (*pT == ' ')
|
|||
|
|
*pT-- = 0;
|
|||
|
|
if (strchr(workbuf,' ')) {
|
|||
|
|
while ((i = x2 - strlen(workbuf)) > 0) {/* count of spaces to add */
|
|||
|
|
strcpy(flushbuf,workbuf); /* start with unmodified*/
|
|||
|
|
pT = workbuf + x1;
|
|||
|
|
pT2 = flushbuf + x1; /* skip fixed part */
|
|||
|
|
fSpace = FALSE; /* assume no spaces */
|
|||
|
|
while (*pT) { /* while data to copy */
|
|||
|
|
if ((*pT == ' ') && i) { /* time to insert a space*/
|
|||
|
|
fSpace = TRUE; /* we've seen a space */
|
|||
|
|
*pT2++ = ' ';
|
|||
|
|
i--;
|
|||
|
|
while (*pT == ' ')
|
|||
|
|
*pT2++ = *pT++; /* copy run of spaces */
|
|||
|
|
}
|
|||
|
|
if (*pT)
|
|||
|
|
*pT2++ = *pT++; /* copy line */
|
|||
|
|
else if (!fSpace)
|
|||
|
|
break; /* no embedded spaces */
|
|||
|
|
}
|
|||
|
|
*pT2 = 0;
|
|||
|
|
strcpy(workbuf,flushbuf); /* copy back */
|
|||
|
|
if (!fSpace)
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
CopyLine ((PFILE) NULL, pFile, yOut, yOut, yOut); /* create new line */
|
|||
|
|
PutLine (yOut, workbuf, pFile); /* output line */
|
|||
|
|
|
|||
|
|
/* end DumpLine */
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*************************************************************************
|
|||
|
|
**
|
|||
|
|
** isterm
|
|||
|
|
** returns true/false based on the character being a sentence terminator:
|
|||
|
|
** one of '.', '?', '!'. Also, always returns false if just2space is off.
|
|||
|
|
*/
|
|||
|
|
flagType pascal near isterm(
|
|||
|
|
char c /* character to test */
|
|||
|
|
)
|
|||
|
|
{
|
|||
|
|
return (flagType)(just2space && ((c == '.') || (c == '!') || (c == '?')));
|
|||
|
|
/* end isterm */}
|
|||
|
|
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
** WhenLoaded
|
|||
|
|
** Executed when these extensions get loaded. Identify self & assign keys.
|
|||
|
|
*/
|
|||
|
|
void justifyWhenLoaded () {
|
|||
|
|
PSWI pwidth;
|
|||
|
|
|
|||
|
|
if (pwidth = FindSwitch("rmargin"))
|
|||
|
|
justwidth = *pwidth->act.ival;
|
|||
|
|
}
|