/* ** 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 #include #include #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; }