Apple-2gs-SW
/
gno
mirror of https://github.com/GnoConsortium/gno.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
gno/usr.bin/nroff/low.c

930 lines
15 KiB
C
Raw Permalink Blame History

/*
* low.c - misc low-level functions for nroff word processor
*
* adapted for atariST/TOS by Bill Rosenkranz 11/89
* net: rosenkra@hall.cray.com
* CIS: 71460,17
* GENIE: W.ROSENKRANZ
*
* original author:
*
* Stephen L. Browning
* 5723 North Parker Avenue
* Indianapolis, Indiana 46220
*
* history:
*
* - Originally written in BDS C;
* - Adapted for standard C by W. N. Paul
* - Heavily hacked up to conform to "real" nroff by Bill Rosenkranz
* - Heavily modified by Devin Reade to avoid memory trashing bugs.
*
* $Id: low.c,v 1.2 1997/03/20 06:40:50 gdr Exp $
*/
#ifdef __ORCAC__
segment "low_______";
#pragma noroot
#pragma optimize 79
#endif
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#ifdef __GNO__
#include <err.h>
#else
#include "unix/err.h"
#endif
#ifdef sparc
#include "unix/sunos.h"
#endif
#include "nroff.h"
/* convert ascii character to decimal */
#define ATOD(c) (((c) < '0') || ((c) > '9')) ? -1 : ((c) - '0')
#if 0 /* not currently used */
static void inptobu (char *); /* convert input units to b.u. */
static void butochar (char *); /* convert b.u. to char spaces */
#endif
/*
* ctod
*
* convert string to decimal. processes only positive values.
* this takes a constant like "1", "1.0i", etc.
*
* Returns converted value (including zero) on success, zero on failure.
*/
int
ctod (char *p) {
long val;
int d;
char *pp = p;
char *ptmp;
int rside = 0;
int lside = 0;
int has_rside = 0;
int has_lside = 0;
if (*p == EOS) {
return 0;
}
ptmp = skipwd (pp);
pp = --ptmp;
switch (*pp) {
case 'i':
case 'c':
val = 0L;
while (*p != EOS && isdigit (*p)) {
has_lside++;
lside = ATOD(*p);
p++;
if (lside == -1) {
break;
}
val = 10L * val + (long) lside;
}
lside = (int) val;
if (*p == '.') {
p++;
val = 0L;
while (*p != EOS && isdigit (*p)) {
has_rside++;
rside = ATOD(*p);
p++;
if (rside == -1) {
break;
}
val = 10L * val + (long) rside;
if (has_rside > 2) { /* more than enough */
break;
}
}
rside = (int) val;
}
/*
* now put it together. 1.0i -> 240, 1.50i -> 360, etc.
*/
val = 0L;
if (has_lside) {
val = (long) lside * BU_INCH;
}
switch (has_rside) {
case 1:
val = val + ((long) rside * BU_INCH / 10L);
break;
case 2:
val = val + ((long) rside * BU_INCH / 100L);
break;
case 3:
val = val + ((long) rside * BU_INCH / 1000L);
break;
default:
break;
}
if (*pp == 'c') {
val = (val * BU_CM) / BU_INCH;
}
/*
* for now we convert to basic char size, 1 em...
*/
val = val / BU_EM;
break;
case 'P':
case 'm':
case 'n':
case 'p':
case 'u':
case 'v':
val = 0L;
while (*p != EOS) {
d = ATOD(*p);
p++;
if (d == -1)
break;
val = 10L * val + (long) d;
}
switch (*pp) {
case 'P':
val = val * BU_PICA;
break;
case 'p':
val = val * BU_POINT;
break;
case 'u':
val = val * BU_BU;
break;
case 'm':
val = val * BU_EM;
break;
case 'n':
val = val * BU_EN;
break;
case 'v':
val = val * BU_EM;
break;
}
/*
* for now we convert to basic char size, 1 em...
*/
val = val / BU_EM;
break;
default:
/*
* this is the default behavior. it SHOULD make things
* compatible with the old way...
*/
val = 0L;
while (*p != EOS) {
d = ATOD(*p);
p++;
if (d == -1) {
break;
}
val = 10L * val + (long) d;
}
break;
}
return (int) val;
}
#if 0 /* not currently used */
/*
* inptobu
*
* convert input units to b.u.
*/
static void
inptobu (char *ps)
{
return;
}
/*
* butochar
*
* convert b.u. to char spaces
*/
static void
butochar (char *ps)
{
return;
}
#endif /* 0 */
/*
* skipbl
*
* skip blanks and tabs in character buffer. return ptr to first
* non-space or non-tab char. this could mean EOS or \r or \n.
*/
char *
skipbl (register char *p)
{
while ((*p != EOS) && (*p == ' ' || *p == '\t')) {
p++;
}
return (p);
}
/*
* skipwd
*
* skip over word and punctuation. anything but space,\t,\r,\n, and EOS
* is skipped. return ptr to the first of these found.
*/
char *
skipwd (register char *p) {
while (*p != EOS && *p != ' ' && *p != '\t' && *p != '\r' && *p != '\n') {
p++;
}
return (p);
}
/*
* nroffSpace
*
* space vertically n lines. this does header and footer also.
*/
void
nroffSpace (int n) {
robrk ();
if (pg.lineno > pg.bottom) {
return;
}
if (pg.lineno == 0) {
phead ();
}
skip (MIN(n, pg.bottom + 1 - pg.lineno));
pg.lineno += n;
set_ireg ("ln", pg.lineno, 0);
if (pg.lineno > pg.bottom) {
pfoot ();
}
}
/*
* getfield
* get field from title
*/
char *
getfield (register char *p, register char *q, char delim) {
while (*p != delim && *p != '\r' && *p != '\n' && *p != EOS) {
*q++ = *p++;
}
*q = EOS;
if (*p == delim) {
++p;
}
return p;
}
/*
* getwrd
*
* get non-blank word from p0 into p1.
* return number of characters processed.
*/
int
getwrd (register char *src, register char *dest) {
#if 0 /* gdr changes */
char *orgsrc, *orgdest;
orgsrc = src;
orgdest = dest;
/*
* skip leading whitespace
*/
while (*src == ' ' || *src == '\t') {
src++;
}
/* find end of word */
while (*src != '\0' && !isspace(*src)) {
*dest++ = *src++;
}
/* I don't understand what this is supposed to achieve */
#ifdef WHATTHEFUCK
assert (dest - orgdest >= 1); /* gdr */
c = *(dest - 1);
if (c == '"') {
asssert(dest - orgdest >= 2); /* gdr */
c = *(dest - 2);
}
if (c == '?' || c == '!') {
*dest++ = ' ';
}
if (c == '.' && (*src == '\n' || *src == '\r' || islower (*p))) {
*dest++ = ' ';
}
#endif /* WHATTHEFUCK */
*dest = EOS;
return src - orgsrc;
#elif 1
char c;
register int i;
register char *p;
char *orgsrc, *orgdest;
orgsrc = src;
orgdest = dest;
/*
* init counter...
*/
i = 0;
/*
* skip leading whitespace
*/
while (*src == ' ' || *src == '\t') {
++i;
++src;
}
/*
* set ptr and start to look for end of word
*/
p = src;
while (*src != ' ' && *src != EOS && *src != '\t') {
if (*src == '\n' || *src == '\r') {
break;
}
*dest = *src++;
++dest;
++i;
}
if (dest > orgdest) {
c = *(dest - 1);
if (c == '"' && (dest > orgdest + 1)) {
c = *(dest - 2);
}
if (c == '?' || c == '!') {
*dest++ = ' ';
++i;
}
if (c == '.' && (*src == '\n' || *src == '\r' || islower (*p))) {
*dest++ = ' ';
++i;
}
}
*dest = EOS;
return (i);
#else
char c;
register int i;
register char *p;
char *orgsrc, *orgdest;
orgsrc = src;
orgdest = dest;
/*
* init counter...
*/
i = 0;
/*
* skip leading whitespace
*/
while (*src == ' ' || *src == '\t') {
++i;
++src;
}
/*
* set ptr and start to look for end of word
*/
p = src;
while (*src != ' ' && *src != EOS && *src != '\t') {
if (*src == '\n' || *src == '\r') {
break;
}
*dest = *src++;
++dest;
++i;
}
if (dest > orgdest) {
c = *(dest - 1);
if (c == '"') {
ASSERT(dest > orgdest + 1,
("%s:%d: array indexing error", __FILE__, __LINE__));
c = *(dest - 2);
}
if (c == '?' || c == '!') {
*dest++ = ' ';
++i;
}
if (c == '.' && (*src == '\n' || *src == '\r' || islower (*p))) {
*dest++ = ' ';
++i;
}
}
*dest = EOS;
return (i);
#endif
}
/*
* countesc
* count atari escape sequence characters in given null-terminated
* string
*/
#define ESC 27
int
countesc (register char *p) {
register char *pp;
register int num;
pp = p;
num = 0;
while (*pp != EOS) {
if (*pp == ESC) {
/*
* count escape char (atari-specific, vt52)
* generally only p,q,b,and c will show up...
*/
switch (*(pp+1)) {
case 'A': /* ESC-a */
case 'B':
case 'C':
case 'D':
case 'E':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'd':
case 'e':
case 'f':
case 'j':
case 'k':
case 'l':
case 'o':
case 'p':
case 'q':
case 'v':
case 'w':
num += 2;
break;
case 'b': /* ESC-a-b */
case 'c':
num += 3;
break;
case 'Y': /* ESC-a-b-c */
case '[': /* Esc [ 7 m */
num += 4;
break;
default:
num += 1;
break;
}
}
pp++;
}
return num;
}
/*
* itoda
* convert integer to decimal ascii string
*
* Pre: <value> is the number to convert
* <p> is the output buffer
* <size> is the number of bytes in the output buffer
*
* Post: <p> contains an ascii representation of <value>
*
* Returns:
*/
int
itoda (int value, register char *p, register int size) {
#if 0
int len;
/*
* buffer must be big enough for representation of largest integer,
* plus 1 byte for sign, plus 1 byte for terminator. On a 32-bit
* machine this is 10+1+1 == 12 bytes.
*/
#define MAX_INT_LENGTH 15
char buffer[MAX_INT_LENGTH];
len = sprintf(buffer, "%d", value);
if (len == EOF) {
errx(1, "itoda failed with EOF");
}
if (len >= size) {
errx(1, "%s:%d: buffer overflow", __FILE__, __LINE__);
}
strncpy(p, buffer, len);
return len;
#else
int i, j, aval;
char c[20];
aval = abs (value);
c[0] = EOS;
i = 1;
do {
c[i++] = (aval % 10) + '0';
aval /= 10;
} while (aval > 0 && i <= size);
if (value < 0 && i <= size) {
c[i++] = '-';
}
for (j = 0; j < i; ++j) {
*p++ = c[i - j - 1];
}
return i;
#endif
}
/*
* itoROMAN
* convert integer to upper roman. must be positive
*/
int
itoROMAN (int value, register char *p, register int size) {
register int i;
register int j;
register int aval;
char c[100];
int rem;
aval = abs (value);
c[0] = EOS;
i = 1;
/*
* trivial case:
*/
if (aval == 0) {
c[i++] = '0';
goto done_100;
}
/*
* temporarily mod 100...
*/
aval = aval % 100;
if (aval > 0) {
/*
* build backward
*
* | I| 1
* | II| 2
* | III| 3
* | VI| 4
* | V| 5
* | IV| 6
* | IIV| 7
* | IIIV| 8
* | XI| 9
* | X| 0
* | IX| 11
* | IIX| 12
*/
if ((aval % 5 == 0) && (aval % 10 != 0)) { /* 5 */
c[i++] = 'V';
} else {
rem = aval % 10;
if (rem == 9) { /* 9 */
c[i++] = 'X';
c[i++] = 'I';
}else if (rem == 8) { /* 8 */
c[i++] = 'I';
c[i++] = 'I';
c[i++] = 'I';
c[i++] = 'V';
} else if (rem == 7) { /* 7 */
c[i++] = 'I';
c[i++] = 'I';
c[i++] = 'V';
} else if (rem == 6) { /* 6 */
c[i++] = 'I';
c[i++] = 'V';
} else if (rem == 4) { /* 4 */
c[i++] = 'V';
c[i++] = 'I';
} else { /* 3,2,1 */
for (j = 0; j < rem; j++) {
c[i++] = 'I';
}
}
}
aval /= 10;
if (aval == 0) {
goto done_100;
}
rem = aval % 10;
if (rem == 4) {
c[i++] = 'L';
c[i++] = 'X';
} else if (rem == 5) {
c[i++] = 'L';
} else if (rem < 4) {
for (j = 0; j < rem; j++) {
c[i++] = 'X';
}
} else {
for (j = 0; j < rem - 5; j++) {
c[i++] = 'X';
}
c[i++] = 'L';
}
}
done_100:
/*
* divide by 100 (they are done) and temp mod by another 10
*/
aval = abs (value);
aval /= 100;
if (aval > 0) {
rem = aval % 10;
if (rem == 4) {
c[i++] = 'D';
c[i++] = 'C';
}
if (rem == 5) {
c[i++] = 'D';
} else if (rem < 4) {
for (j = 0; j < rem; j++) {
c[i++] = 'C';
}
} else if (rem == 9) {
c[i++] = 'M';
c[i++] = 'C';
} else if (rem < 9) {
for (j = 0; j < rem - 5; j++) {
c[i++] = 'C';
}
c[i++] = 'D';
}
}
aval /= 10;
if (aval > 0) {
rem = aval % 10;
if (rem < 4) {
for (j = 0; j < rem; j++) {
c[i++] = 'M';
}
}
}
if (value < 0) {
c[i++] = '-';
}
for (j = 0; j < i; ++j) {
*p++ = c[i - j - 1];
}
return i;
}
/*
* itoroman
* convert integer to lower roman
*/
int
itoroman (int value, char *p, int size)
{
register int i;
register int len;
char c[100];
c[0] = EOS;
len = itoROMAN (value, c, size);
for (i = 0; i < len; i++) {
p[i] = c[i];
if (isalpha (p[i])) {
p[i] = tolower (c[i]);
}
}
return len;
}
/*
* itoLETTER
* convert integer to upper letter value: 0,A,B,C,...,AA,AB,AC,...
*/
int
itoLETTER (int value, register char *p, register int size) {
register int i;
register int j;
register int aval;
char c[20];
aval = abs (value);
c[0] = EOS;
i = 1;
/*
* 1 based:
*
* 0 0
* 1 A
* 25 Z
* 26 AA
* 51 AZ
* 52 AAA
* ...
*/
if (aval == 0) {
c[i++] = '0';
} else if (aval < 27) {
c[i++] = aval - 1 + 'A';
} else {
do {
c[i++] = ((aval - 1) % 26) + 'A';
aval = (aval - 1) / 26;
} while (aval > 0 && i <= size);
}
if (value < 0 && i <= size) {
c[i++] = '-';
}
for (j = 0; j < i; ++j) {
*p++ = c[i - j - 1];
}
return i;
}
/*
* itoletter
* convert integer to upper letter value: 0,a,b,c,...,aa,ab,ac,...
*/
int
itoletter (int value, register char *p, register int size) {
register int i;
register int j;
register int aval;
char c[20];
aval = abs (value);
c[0] = EOS;
i = 1;
/*
* 1 based:
*
* 0 0
* 1 A
* 25 Z
* 26 AA
* 51 AZ
* 52 AAA
* ...
*/
if (aval == 0) {
c[i++] = '0';
} else if (aval < 27) {
c[i++] = aval - 1 + 'a';
} else {
do {
c[i++] = ((aval - 1) % 26) + 'a';
aval = (aval - 1) / 26;
} while (aval > 0 && i <= size);
}
if (value < 0 && i <= size) {
c[i++] = '-';
}
for (j = 0; j < i; ++j) {
*p++ = c[i - j - 1];
}
return i;
}
#if 0 /* min, max not needed */
/*
* min
* find minimum of two integer ONLY
*/
#ifdef min
#undef min
#endif
int
min (register int v1, register int v2) {
return ((v1 < v2) ? v1 : v2);
}
/*
* max
* find maximum of two integers ONLY
*/
#ifdef max
#undef max
#endif
int
max (register int v1, register int v2) {
return ((v1 > v2) ? v1 : v2);
}
#endif /* 0 */
/*
* err_exit
* exit cleanly on fatal error (close files, etc). also handles normal
* exit.
*/
void
err_exit (int code) {
if (err_stream != stderr && err_stream != (FILE *) 0) {
/*
* not going to stderr (-o file)
*/
fflush (err_stream);
fclose (err_stream);
}
if (debugging && dbg_stream != stderr && dbg_stream != (FILE *) 0) {
fflush (dbg_stream);
fclose (dbg_stream);
}
if (out_stream != stdout && out_stream != (FILE *) 0) {
/*
* not going to stdout (-l)
*/
fflush (out_stream);
fclose (out_stream);
}
#ifdef GEMDOS
if (hold_screen) {
wait_for_char();
}
#endif
exit(code);
}
#ifdef GEMDOS
#include <osbind.h>
/*
* Wait for a character
*/
void
wait_for_char (void) {
printf ("enter any key..."); fflush (stdout);
Cconin ();
}
#endif
Reference in New Issue View Git Blame Copy Permalink