/* Check whether the file named by fs is an ASCII file which the user may
* access. If it is, return the opened file. Otherwise return NULL. */
static FILE *checkf(register char *fs, int *clearfirst)
{
struct stat stbuf;
register FILE *f;
int c;
if (stat(fs, &stbuf) == -1) {
fflush(stdout);
if (clreol)
cleareol();
warn(_("stat of %s failed"), fs);
return ((FILE *)NULL);
}
if ((stbuf.st_mode & S_IFMT) == S_IFDIR) {
printf(_("\n*** %s: directory ***\n\n"), fs);
return ((FILE *)NULL);
}
if ((f = Fopen(fs, "r")) == NULL) {
fflush(stdout);
warn(_("cannot open %s"), fs);
return ((FILE *)NULL);
}
if (magic(f, fs)) {
fclose(f);
return ((FILE *)NULL);
}
fcntl(fileno(f), F_SETFD, FD_CLOEXEC);
c = Getc(f);
*clearfirst = (c == '\f');
Ungetc(c, f);
if ((file_size = stbuf.st_size) == 0)
file_size = LONG_MAX;
return (f);
}
/*
* Check whether the file named by fs is an ASCII file which the user may
* access. If it is, return the opened file. Otherwise return NULL.
*/
FILE *
checkf(char *fs, int *clearfirst)
{
struct stat stbuf;
FILE *f;
int ch;
if (stat(fs, &stbuf) == -1) {
(void)fflush(stdout);
if (clreol)
cleareol();
perror(fs);
return (NULL);
}
if ((stbuf.st_mode & S_IFMT) == S_IFDIR) {
printf("\n*** %s: directory ***\n\n", fs);
return (NULL);
}
if ((f = Fopen(fs, "r")) == NULL) {
(void)fflush(stdout);
perror(fs);
return (NULL);
}
if (magic(f, fs))
return (NULL);
ch = Getc(f);
*clearfirst = (ch == '\f');
Ungetc(ch, f);
if ((file_size = stbuf.st_size) == 0)
file_size = LONG_MAX;
return (f);
}
static int
l_L(Void)
{
int ch;
if(f__lcount>0) return(0);
f__lcount = 1;
f__ltype=0;
GETC(ch);
if(isdigit(ch))
{
rd_count(ch);
if((GETC(ch)!='*')) {
if(!f__cf || !feof(f__cf))
errfl(f__elist->cierr,112,"no star");
else
err(f__elist->cierr,(EOF),"lread");
}
GETC(ch);
}
if(ch == '.') GETC(ch);
switch(ch)
{
case 't':
case 'T':
f__lx=1;
break;
case 'f':
case 'F':
f__lx=0;
break;
default:
if(isblnk(ch) || issep(ch) || ch==EOF)
{ (void) Ungetc(ch,f__cf);
return(0);
}
if (nml_read > 1) {
Ungetc(ch,f__cf);
f__lquit = 2;
return 0;
}
errfl(f__elist->cierr,112,"logical");
}
f__ltype=TYLONG;
while(!issep(GETC(ch)) && ch!=EOF);
(void) Ungetc(ch, f__cf);
return(0);
}
void
ncss_Ungetc(int c)
{
if (c == T_NCNULINE)
{
ncss_Line--;
}
Ungetc(c);
}
rd_count(register int ch)
#endif
{
if (ch < '0' || ch > '9')
return 1;
f__lcount = ch - '0';
while(GETC(ch) >= '0' && ch <= '9')
f__lcount = 10*f__lcount + ch - '0';
Ungetc(ch,f__cf);
return f__lcount <= 0;
}
static
follow(c1, r1, r2)
{
register int c;
if ((c = Getc()) == c1)
return r1;
else {
Ungetc(c);
return r2;
}
}
void retract(int n) {
int i;
for (i = 0; i < n; i++) {
yylen--;
if (yylen >= 0) {
Ungetc(yytext[yylen],LEX_in);
if (yytext[yylen] == '\n') {
cparse_line--;
}
}
}
if (yylen < 0) yylen = 0;
}
static
follow2(c1, c2, r1, r2, r3)
{
register int c;
if ((c = Getc()) == c1)
return r1;
else if (c == c2)
return r2;
else {
Ungetc(c);
return r3;
}
}
/*
* skip to the end of the current string and the beginning of the next one
*/
int
xpmNextString(xpmData *data)
{
if (!data->type)
data->cptr = (data->stream.data)[++data->line];
else if (data->type == XPMBUFFER) {
register char c;
/* get to the end of the current string */
if (data->Eos)
while ((c = *data->cptr++) && c != data->Eos);
/*
* then get to the beginning of the next string looking for possible
* comment
*/
if (data->Bos) {
while ((c = *data->cptr++) && c != data->Bos)
if (data->Bcmt && c == data->Bcmt[0])
ParseComment(data);
} else if (data->Bcmt) { /* XPM2 natural */
while ((c = *data->cptr++) == data->Bcmt[0])
ParseComment(data);
data->cptr--;
}
} else {
register int c;
FILE *file = data->stream.file;
/* get to the end of the current string */
if (data->Eos)
while ((c = Getc(data, file)) != data->Eos && c != EOF);
/*
* then get to the beginning of the next string looking for possible
* comment
*/
if (data->Bos) {
while ((c = Getc(data, file)) != data->Bos && c != EOF)
if (data->Bcmt && c == data->Bcmt[0])
ParseComment(data);
} else if (data->Bcmt) { /* XPM2 natural */
while ((c = Getc(data, file)) == data->Bcmt[0])
ParseComment(data);
Ungetc(data, c, file);
}
}
return 0;
}
Lfinish(int ch, int dot, int *rvp)
#endif
{
char *s, *se;
static char what[] = "namelist input";
s = nmLbuf + 2;
se = nmLbuf + sizeof(nmLbuf) - 1;
*s++ = ch;
while(!issep(GETC(ch)) && ch!=EOF) {
if (s >= se) {
nmLbuf_ovfl:
return *rvp = err__fl(f__elist->cierr,131,what);
}
*s++ = ch;
if (ch != '=')
continue;
if (dot)
return *rvp = err__fl(f__elist->cierr,112,what);
got_eq:
*s = 0;
nmL_getc_save = l_getc;
l_getc = nmL_getc;
nmL_ungetc_save = l_ungetc;
l_ungetc = nmL_ungetc;
nmLbuf[1] = *(nmL_next = nmLbuf) = ',';
*rvp = f__lcount = 0;
return 1;
}
if (dot)
goto done;
for(;;) {
if (s >= se)
goto nmLbuf_ovfl;
*s++ = ch;
if (!isblnk(ch))
break;
if (GETC(ch) == EOF)
goto done;
}
if (ch == '=')
goto got_eq;
done:
Ungetc(ch, f__cf);
return 0;
}
static int getname(register char *s, int slen)
{
register char *se = s + slen - 1;
register int ch;
GETC(ch);
if (!(*s++ = Alpha[ch & 0xff])) {
if (ch != EOF)
ch = 115;
errfl(f__elist->cierr, ch, "namelist read");
}
while(*s = Alphanum[GETC(ch) & 0xff])
if (s < se)
s++;
if (ch == EOF)
err(f__elist->cierr, EOF, "namelist read");
if (ch > ' ')
Ungetc(ch,f__cf);
return *s = 0;
}
String *Swig_string_ucase(String *s) {
String *ns;
int c;
int lastC = 0;
int nextC = 0;
int underscore = 0;
ns = NewStringEmpty();
/* We insert a underscore when:
1. Lower case char followed by upper case char
getFoo > get_foo; getFOo > get_foo; GETFOO > getfoo
2. Number proceded by char and not end of string
get2D > get_2d; get22D > get_22d; GET2D > get_2d
but:
asFloat2 > as_float2
*/
Seek(s, 0, SEEK_SET);
while ((c = Getc(s)) != EOF) {
nextC = Getc(s); Ungetc(nextC, s);
if (isdigit(c) && isalpha(lastC) && nextC != EOF)
underscore = 1;
else if (isupper(c) && isalpha(lastC) && !isupper(lastC))
underscore = 1;
lastC = c;
if (underscore) {
Putc('_', ns);
underscore = 0;
}
Putc(tolower(c), ns);
}
return ns;
}
int
main(int argc, char **argv)
{
FILE * volatile f;
char *s;
volatile int left;
volatile off_t initline;
volatile int prnames = 0;
volatile int initopt = 0;
volatile int srchopt = 0;
int clearit = 0;
int ch;
char initbuf[80];
if (pledge("stdio rpath tty", NULL) == -1) {
perror("pledge");
exit(1);
}
setlocale(LC_ALL, "");
/* all signals just use a stub handler and interrupt syscalls */
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sa.sa_handler = onsignal;
nfiles = argc;
fnames = argv;
initterm();
nscroll = Lpp/2 - 1;
if (nscroll <= 0)
nscroll = 1;
if ((s = getenv("MORE")) != NULL && *s != '\0')
argscan(s);
while (--nfiles > 0) {
if ((ch = (*++fnames)[0]) == '-')
argscan(*fnames + 1);
else if (ch == '+') {
s = *fnames;
if (*++s == '/') {
srchopt++;
(void)strlcpy(initbuf, ++s, sizeof(initbuf));
} else {
initopt++;
for (initline = 0; *s != '\0'; s++) {
if (isdigit((unsigned char)*s))
initline =
initline * 10 + *s - '0';
}
--initline;
}
} else
break;
}
/*
* Allow clreol only if Home and eraseln and EodClr strings are
* defined, and in that case, make sure we are in noscroll mode.
*/
if (clreol) {
if (Home == NULL || *Home == '\0' || eraseln == NULL ||
*eraseln == '\0' || EodClr == NULL || *EodClr == '\0')
clreol = 0;
else
noscroll = 1;
}
if (dlines == 0)
dlines = Lpp - 1;
left = dlines;
if (nfiles > 1)
prnames++;
if (!no_intty && nfiles == 0)
usage();
else
f = stdin;
if (!no_tty) {
struct sigaction osa;
(void)sigaction(SIGQUIT, &sa, NULL);
(void)sigaction(SIGINT, &sa, NULL);
(void)sigaction(SIGWINCH, &sa, NULL);
if (sigaction(SIGTSTP, &osa, NULL) == 0 &&
osa.sa_handler == SIG_DFL) {
(void)sigaction(SIGTSTP, &sa, NULL);
(void)sigaction(SIGTTIN, &sa, NULL);
(void)sigaction(SIGTTOU, &sa, NULL);
catch_susp++;
}
set_tty();
}
if (no_intty) {
if (no_tty)
copy_file(stdin);
else {
if ((ch = Getc(f)) == '\f')
doclear();
else {
Ungetc(ch, f);
if (noscroll && ch != EOF) {
if (clreol)
home();
else
doclear();
}
}
if (srchopt) {
if (search(initbuf, stdin, 1) == 0 && noscroll)
left--;
} else if (initopt)
skiplns(initline, stdin);
screen(stdin, left);
}
no_intty = 0;
dup2(STDERR_FILENO, STDIN_FILENO); /* stderr is a tty */
prnames++;
firstf = 0;
}
while (fnum < nfiles) {
if ((f = checkf(fnames[fnum], &clearit)) != NULL) {
context.line = context.chrctr = 0;
Currline = 0;
restart:
if (firstf) {
firstf = 0;
if (srchopt) {
if (search(initbuf, f, 1) < 0)
goto restart;
if (noscroll)
left--;
} else if (initopt)
skiplns(initline, f);
} else if (fnum < nfiles && !no_tty)
left = command(fnames[fnum], f);
if (left != 0) {
if ((noscroll || clearit) &&
(file_size != LONG_MAX)) {
if (clreol)
home();
else
doclear();
}
if (prnames) {
if (bad_so)
erasep(0);
if (clreol)
cleareol();
fputs("::::::::::::::", stdout);
if (promptlen > 14)
erasep(14);
putchar('\n');
if (clreol)
cleareol();
printf("%s\n", fnames[fnum]);
if (clreol)
cleareol();
fputs("::::::::::::::\n", stdout);
if (left > Lpp - 4)
left = Lpp - 4;
}
if (no_tty)
copy_file(f);
else {
within++;
screen(f, left);
within = 0;
}
}
fflush(stdout);
fclose(f);
screen_start.line = screen_start.chrctr = 0L;
context.line = context.chrctr = 0L;
}
fnum++;
firstf = 0;
}
reset_tty();
exit(0);
}
void Wrapper_pretty_print(String *str, File *f) {
String *ts;
int level = 0;
int c, i;
int empty = 1;
int indent = 2;
int plevel = 0;
int label = 0;
ts = NewStringEmpty();
Seek(str, 0, SEEK_SET);
while ((c = Getc(str)) != EOF) {
if (c == '\"') {
Putc(c, ts);
while ((c = Getc(str)) != EOF) {
if (c == '\\') {
Putc(c, ts);
c = Getc(str);
}
Putc(c, ts);
if (c == '\"')
break;
}
empty = 0;
} else if (c == '\'') {
Putc(c, ts);
while ((c = Getc(str)) != EOF) {
if (c == '\\') {
Putc(c, ts);
c = Getc(str);
}
Putc(c, ts);
if (c == '\'')
break;
}
empty = 0;
} else if (c == ':') {
Putc(c, ts);
if ((c = Getc(str)) == '\n') {
if (!empty && !strchr(Char(ts), '?'))
label = 1;
}
Ungetc(c, str);
} else if (c == '(') {
Putc(c, ts);
plevel += indent;
empty = 0;
} else if (c == ')') {
Putc(c, ts);
plevel -= indent;
empty = 0;
} else if (c == '{') {
Putc(c, ts);
Putc('\n', ts);
for (i = 0; i < level; i++)
Putc(' ', f);
Printf(f, "%s", ts);
Clear(ts);
level += indent;
while ((c = Getc(str)) != EOF) {
if (!isspace(c)) {
Ungetc(c, str);
break;
}
}
empty = 0;
} else if (c == '}') {
if (!empty) {
Putc('\n', ts);
for (i = 0; i < level; i++)
Putc(' ', f);
Printf(f, "%s", ts);
Clear(ts);
}
level -= indent;
Putc(c, ts);
empty = 0;
} else if (c == '\n') {
Putc(c, ts);
empty = 0;
if (!empty) {
int slevel = level;
if (label && (slevel >= indent))
slevel -= indent;
if ((Char(ts))[0] != '#') {
for (i = 0; i < slevel; i++)
Putc(' ', f);
}
Printf(f, "%s", ts);
for (i = 0; i < plevel; i++)
Putc(' ', f);
}
Clear(ts);
label = 0;
empty = 1;
} else if (c == '/') {
empty = 0;
Putc(c, ts);
c = Getc(str);
if (c != EOF) {
Putc(c, ts);
if (c == '/') { /* C++ comment */
while ((c = Getc(str)) != EOF) {
if (c == '\n') {
Ungetc(c, str);
break;
}
Putc(c, ts);
}
} else if (c == '*') { /* C comment */
int endstar = 0;
while ((c = Getc(str)) != EOF) {
if (endstar && c == '/') { /* end of C comment */
Putc(c, ts);
break;
}
endstar = (c == '*');
Putc(c, ts);
if (c == '\n') { /* multi-line C comment. Could be improved slightly. */
for (i = 0; i < level; i++)
Putc(' ', ts);
}
}
}
}
} else {
if (!empty || !isspace(c)) {
Putc(c, ts);
empty = 0;
}
}
}
if (!empty)
Printf(f, "%s", ts);
Delete(ts);
Printf(f, "\n");
}
void Wrapper_compact_print(String *str, File *f) {
String *ts, *tf; /*temp string & temp file */
int level = 0;
int c, i;
int empty = 1;
int indent = 2;
ts = NewStringEmpty();
tf = NewStringEmpty();
Seek(str, 0, SEEK_SET);
while ((c = Getc(str)) != EOF) {
if (c == '\"') { /* string 1 */
empty = 0;
Putc(c, ts);
while ((c = Getc(str)) != EOF) {
if (c == '\\') {
Putc(c, ts);
c = Getc(str);
}
Putc(c, ts);
if (c == '\"')
break;
}
} else if (c == '\'') { /* string 2 */
empty = 0;
Putc(c, ts);
while ((c = Getc(str)) != EOF) {
if (c == '\\') {
Putc(c, ts);
c = Getc(str);
}
Putc(c, ts);
if (c == '\'')
break;
}
} else if (c == '{') { /* start of {...} */
empty = 0;
Putc(c, ts);
if (Len(tf) == 0) {
for (i = 0; i < level; i++)
Putc(' ', tf);
} else if ((Len(tf) + Len(ts)) < Max_line_size) {
Putc(' ', tf);
} else {
Putc('\n', tf);
Printf(f, "%s", tf);
Clear(tf);
for (i = 0; i < level; i++)
Putc(' ', tf);
}
Append(tf, ts);
Clear(ts);
level += indent;
while ((c = Getc(str)) != EOF) {
if (!isspace(c)) {
Ungetc(c, str);
break;
}
}
} else if (c == '}') { /* end of {...} */
empty = 0;
if (Len(tf) == 0) {
for (i = 0; i < level; i++)
Putc(' ', tf);
} else if ((Len(tf) + Len(ts)) < Max_line_size) {
Putc(' ', tf);
} else {
Putc('\n', tf);
Printf(f, "%s", tf);
Clear(tf);
for (i = 0; i < level; i++)
Putc(' ', tf);
}
Append(tf, ts);
Putc(c, tf);
Clear(ts);
level -= indent;
} else if (c == '\n') { /* line end */
while ((c = Getc(str)) != EOF) {
if (!isspace(c))
break;
}
if (c == '#') {
Putc('\n', ts);
} else if (c == '}') {
Putc(' ', ts);
} else if ((c != EOF) || (Len(ts) != 0)) {
if (Len(tf) == 0) {
for (i = 0; i < level; i++)
Putc(' ', tf);
} else if ((Len(tf) + Len(ts)) < Max_line_size) {
Putc(' ', tf);
} else {
Putc('\n', tf);
Printf(f, "%s", tf);
Clear(tf);
for (i = 0; i < level; i++)
Putc(' ', tf);
}
Append(tf, ts);
Clear(ts);
}
Ungetc(c, str);
empty = 1;
} else if (c == '/') { /* comment */
empty = 0;
c = Getc(str);
if (c != EOF) {
if (c == '/') { /* C++ comment */
while ((c = Getc(str)) != EOF) {
if (c == '\n') {
Ungetc(c, str);
break;
}
}
} else if (c == '*') { /* C comment */
int endstar = 0;
while ((c = Getc(str)) != EOF) {
if (endstar && c == '/') { /* end of C comment */
break;
}
endstar = (c == '*');
}
} else {
Putc('/', ts);
Putc(c, ts);
}
}
} else if (c == '#') { /* Preprocessor line */
Putc('#', ts);
while ((c = Getc(str)) != EOF) {
Putc(c, ts);
if (c == '\\') { /* Continued line of the same PP */
c = Getc(str);
if (c == '\n')
Putc(c, ts);
else
Ungetc(c, str);
} else if (c == '\n')
break;
}
if (!empty) {
Append(tf, "\n");
}
Append(tf, ts);
Printf(f, "%s", tf);
Clear(tf);
Clear(ts);
for (i = 0; i < level; i++)
Putc(' ', tf);
empty = 1;
} else {
if (!empty || !isspace(c)) {
Putc(c, ts);
empty = 0;
}
}
}
if (!empty) {
Append(tf, ts);
}
if (Len(tf) != 0)
Printf(f, "%s", tf);
Delete(ts);
Delete(tf);
Printf(f, "\n");
}
static int
ParseComment(xpmData *data)
{
if (data->type == XPMBUFFER) {
register char c;
register unsigned int n = 0;
unsigned int notend;
char *s;
const char *s2;
s = data->Comment;
*s = data->Bcmt[0];
/* skip the string beginning comment */
s2 = data->Bcmt;
do {
c = *data->cptr++;
*++s = c;
n++;
s2++;
} while (c == *s2 && *s2 != '\0' && c);
if (*s2 != '\0') {
/* this wasn't the beginning of a comment */
data->cptr -= n;
return 0;
}
/* store comment */
data->Comment[0] = *s;
s = data->Comment;
notend = 1;
n = 0;
while (notend) {
s2 = data->Ecmt;
while (*s != *s2 && c) {
c = *data->cptr++;
if (n == XPMMAXCMTLEN - 1) { /* forget it */
s = data->Comment;
n = 0;
}
*++s = c;
n++;
}
data->CommentLength = n;
do {
c = *data->cptr++;
if (n == XPMMAXCMTLEN - 1) { /* forget it */
s = data->Comment;
n = 0;
}
*++s = c;
n++;
s2++;
} while (c == *s2 && *s2 != '\0' && c);
if (*s2 == '\0') {
/* this is the end of the comment */
notend = 0;
data->cptr--;
}
}
return 0;
} else {
FILE *file = data->stream.file;
register int c;
register unsigned int n = 0, a;
unsigned int notend;
char *s;
const char *s2;
s = data->Comment;
*s = data->Bcmt[0];
/* skip the string beginning comment */
s2 = data->Bcmt;
do {
c = Getc(data, file);
*++s = c;
n++;
s2++;
} while (c == *s2 && *s2 != '\0' && c != EOF);
if (*s2 != '\0') {
/* this wasn't the beginning of a comment */
/* put characters back in the order that we got them */
for (a = n; a > 0; a--, s--)
Ungetc(data, *s, file);
return 0;
}
/* store comment */
data->Comment[0] = *s;
s = data->Comment;
notend = 1;
n = 0;
while (notend) {
s2 = data->Ecmt;
while (*s != *s2 && c != EOF) {
c = Getc(data, file);
if (n == XPMMAXCMTLEN - 1) { /* forget it */
s = data->Comment;
n = 0;
}
*++s = c;
n++;
}
data->CommentLength = n;
do {
c = Getc(data, file);
if (n == XPMMAXCMTLEN - 1) { /* forget it */
s = data->Comment;
n = 0;
}
*++s = c;
n++;
s2++;
} while (c == *s2 && *s2 != '\0' && c != EOF);
if (*s2 == '\0') {
/* this is the end of the comment */
notend = 0;
Ungetc(data, *s, file);
}
}
return 0;
}
}
/*
* return end of string - WARNING: malloc!
*/
int
xpmGetString(
xpmData *data,
char **sptr,
unsigned int *l)
{
unsigned int i, n = 0;
int c;
char *p = NULL, *q, buf[BUFSIZ];
if (!data->type || data->type == XPMBUFFER) {
if (data->cptr) {
char *start = data->cptr;
while ((c = *data->cptr) && c != data->Eos)
data->cptr++;
n = data->cptr - start + 1;
p = (char *) XpmMalloc(n);
if (!p)
return (XpmNoMemory);
strncpy(p, start, n);
if (data->type) /* XPMBUFFER */
p[n - 1] = '\0';
}
} else {
FILE *file = data->stream.file;
if ((c = Getc(data, file)) == EOF)
return (XpmFileInvalid);
i = 0;
q = buf;
p = (char *) XpmMalloc(1);
while (c != data->Eos && c != EOF) {
if (i == BUFSIZ) {
/* get to the end of the buffer */
/* malloc needed memory */
q = (char *) XpmRealloc(p, n + i);
if (!q) {
XpmFree(p);
return (XpmNoMemory);
}
p = q;
q += n;
/* and copy what we already have */
strncpy(q, buf, i);
n += i;
i = 0;
q = buf;
}
*q++ = c;
i++;
c = Getc(data, file);
}
if (c == EOF) {
XpmFree(p);
return (XpmFileInvalid);
}
if (n + i != 0) {
/* malloc needed memory */
q = (char *) XpmRealloc(p, n + i + 1);
if (!q) {
XpmFree(p);
return (XpmNoMemory);
}
p = q;
q += n;
/* and copy the buffer */
strncpy(q, buf, i);
n += i;
p[n++] = '\0';
} else {
*p = '\0';
n = 1;
}
Ungetc(data, c, file);
}
*sptr = p;
*l = n;
return (XpmSuccess);
}
lex()
{
int c, d;
char *s;
if (regexflg)
return sym = scanreg();
next:
while ((c = Getc()) == ' ' || c == '\t')
;
while (c == '#')
for (c = Getc(); c != '\n'; c = Getc())
;
switch (c) {
case '\\':
if ((c = Getc()) == '\n') {
lineno++;
goto next;
}
break;
case '\n':
lineno++;
break;
}
switch (c) {
case EOF: return sym = 0;
case '+': return sym = follow2('=', '+', ADDEQ, INC, ADD);
case '-': return sym = follow2('=', '-', SUBEQ, DEC, SUB);
case '*': return sym = follow('=', MULTEQ, MULT);
case '/': return sym = follow('=', DIVEQ, DIV);
case '%': return sym = follow('=', MODEQ, MOD);
case '^': return sym = follow('=', POWEQ, POWER);
case '=': return sym = follow('=', EQ, ASSIGN);
case '!': return sym = follow2('=', '~', NE, NOMATCH, NOT);
case '&': return sym = follow('&', AND, BINAND);
case '|': sym = follow('|', OR, BINOR);
if (printflg && sym == BINOR)
sym = R_POUT;
return sym;
case '<': sym = follow2('=', '<', LE, SHIFTL, LT);
if (getlineflg && sym == LT)
sym = R_IN;
return sym;
case '>': sym = follow2('=', '>', GE, SHIFTR, GT);
if (printflg) {
switch (sym) {
case GT: sym = R_OUT; break;
case SHIFTR: sym = R_APD; break;
}
}
return sym;
case '~': return sym = MATCH; break;
case ';': case '\n': return sym = EOL;
}
if (isalpha(c) || c == '_') {
for (s = text; isalnum(c) || c == '_'; ) {
*s++ = c; c = Getc();
}
Ungetc(c);
*s = '\0';
if ((d = iskeywd(text)) == 0 &&
(d = isbuiltin(text, &sym1)) == 0) {
if (c == '(')
return sym = CALL;
else if (funflg) {
if ((sym1 = isarg(text)) != -1)
return sym = ARG;
}
}
return sym = d ? d : IDENT;
}
else if (c == '.' || (isdigit(c))) {
Ungetc(c);
return sym = scannum(text); /* NUMBER */
}
else if (c == '"')
return sym = scanstr(text); /* STRING */
return sym = c;
}
l_read(ftnint *number, char *ptr, ftnlen len, ftnint type)
#endif
{
#define Ptr ((flex *)ptr)
int i,n,ch;
doublereal *yy;
real *xx;
for(i=0;i<*number;i++)
{
if(f__lquit) return(0);
if(l_eof)
err(f__elist->ciend, EOF, "list in")
if(f__lcount == 0) {
f__ltype = 0;
for(;;) {
GETC(ch);
switch(ch) {
case EOF:
err(f__elist->ciend,(EOF),"list in")
case ' ':
case '\t':
case '\n':
continue;
case '/':
f__lquit = 1;
goto loopend;
case ',':
f__lcount = 1;
goto loopend;
default:
(void) Ungetc(ch, f__cf);
goto rddata;
}
}
}
rddata:
switch((int)type)
{
case TYINT1:
case TYSHORT:
case TYLONG:
#ifndef ALLOW_FLOAT_IN_INTEGER_LIST_INPUT
ERR(l_R(0,1));
break;
#endif
case TYREAL:
case TYDREAL:
ERR(l_R(0,0));
break;
#ifdef TYQUAD
case TYQUAD:
n = l_R(0,2);
if (n)
return n;
break;
#endif
case TYCOMPLEX:
case TYDCOMPLEX:
ERR(l_C());
break;
case TYLOGICAL1:
case TYLOGICAL2:
case TYLOGICAL:
ERR(l_L());
break;
case TYCHAR:
ERR(l_CHAR());
break;
}
while (GETC(ch) == ' ' || ch == '\t');
if (ch != ',' || f__lcount > 1)
Ungetc(ch,f__cf);
loopend:
if(f__lquit) return(0);
if(f__cf && ferror(f__cf)) {
clearerr(f__cf);
errfl(f__elist->cierr,errno,"list in");
}
if(f__ltype==0) goto bump;
switch((int)type)
{
case TYINT1:
case TYLOGICAL1:
Ptr->flchar = (char)f__lx;
break;
case TYLOGICAL2:
case TYSHORT:
Ptr->flshort = (short)f__lx;
break;
case TYLOGICAL:
case TYLONG:
Ptr->flint = (ftnint)f__lx;
break;
#ifdef Allow_TYQUAD
case TYQUAD:
if (!(Ptr->fllongint = f__llx))
Ptr->fllongint = f__lx;
break;
#endif
case TYREAL:
Ptr->flreal=f__lx;
break;
case TYDREAL:
Ptr->fldouble=f__lx;
break;
case TYCOMPLEX:
xx=(real *)ptr;
*xx++ = f__lx;
*xx = f__ly;
break;
case TYDCOMPLEX:
yy=(doublereal *)ptr;
*yy++ = f__lx;
*yy = f__ly;
break;
case TYCHAR:
b_char(f__lchar,ptr,len);
break;
}
bump:
if(f__lcount>0) f__lcount--;
ptr += len;
if (nml_read)
nml_read++;
}
int main(int argc, char **argv) {
FILE *f;
char *s;
char *p;
int ch;
int left;
int prnames = 0;
int initopt = 0;
int srchopt = 0;
int clearit = 0;
int initline = 0;
char initbuf[INIT_BUF];
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
nfiles = argc;
fnames = argv;
setlocale(LC_ALL, "");
initterm ();
/* Auto set no scroll on when binary is called page */
if (!(strcmp(program_invocation_short_name, "page")))
noscroll++;
prepare_line_buffer();
nscroll = Lpp/2 - 1;
if (nscroll <= 0)
nscroll = 1;
if ((s = getenv("MORE")) != NULL)
argscan(s);
while (--nfiles > 0) {
if ((ch = (*++fnames)[0]) == '-') {
argscan(*fnames+1);
}
else if (ch == '+') {
s = *fnames;
if (*++s == '/') {
srchopt++;
for (++s, p = initbuf; p < initbuf + (INIT_BUF - 1) && *s != '\0';)
*p++ = *s++;
*p = '\0';
}
else {
initopt++;
for (initline = 0; *s != '\0'; s++)
if (isdigit (*s))
initline = initline*10 + *s -'0';
--initline;
}
}
else break;
}
/* allow clreol only if Home and eraseln and EodClr strings are
* defined, and in that case, make sure we are in noscroll mode
*/
if (clreol) {
if((Home == NULL) || (*Home == '\0') ||
(eraseln == NULL) || (*eraseln == '\0') ||
(EodClr == NULL) || (*EodClr == '\0') )
clreol = 0;
else noscroll = 1;
}
if (dlines == 0)
dlines = Lpp - 1; /* was: Lpp - (noscroll ? 1 : 2) */
left = dlines;
if (nfiles > 1)
prnames++;
if (!no_intty && nfiles == 0)
usage(stderr);
else
f = stdin;
if (!no_tty) {
signal(SIGQUIT, onquit);
signal(SIGINT, end_it);
#ifdef SIGWINCH
signal(SIGWINCH, chgwinsz);
#endif /* SIGWINCH */
if (signal (SIGTSTP, SIG_IGN) == SIG_DFL) {
signal(SIGTSTP, onsusp);
catch_susp++;
}
stty (fileno(stderr), &otty);
}
if (no_intty) {
if (no_tty)
copy_file (stdin);
else {
if ((ch = Getc (f)) == '\f')
doclear();
else {
Ungetc (ch, f);
if (noscroll && (ch != EOF)) {
if (clreol)
home ();
else
doclear ();
}
}
if (srchopt)
{
search (initbuf, stdin, 1);
if (noscroll)
left--;
}
else if (initopt)
skiplns (initline, stdin);
screen (stdin, left);
}
no_intty = 0;
prnames++;
firstf = 0;
}
while (fnum < nfiles) {
if ((f = checkf (fnames[fnum], &clearit)) != NULL) {
context.line = context.chrctr = 0;
Currline = 0;
if (firstf) sigsetjmp (restore, 1);
if (firstf) {
firstf = 0;
if (srchopt) {
search (initbuf, f, 1);
if (noscroll)
left--;
}
else if (initopt)
skiplns (initline, f);
}
else if (fnum < nfiles && !no_tty) {
sigsetjmp (restore, 1);
left = command (fnames[fnum], f);
}
if (left != 0) {
if ((noscroll || clearit) && (file_size != LONG_MAX)) {
if (clreol)
home ();
else
doclear ();
}
if (prnames) {
if (bad_so)
erasep (0);
if (clreol)
cleareol ();
putsout("::::::::::::::");
if (promptlen > 14)
erasep (14);
putchar('\n');
if(clreol) cleareol();
puts(fnames[fnum]);
if(clreol) cleareol();
puts("::::::::::::::");
if (left > Lpp - 4)
left = Lpp - 4;
}
if (no_tty)
copy_file (f);
else {
within++;
screen(f, left);
within = 0;
}
}
sigsetjmp (restore, 1);
fflush(stdout);
fclose(f);
screen_start.line = screen_start.chrctr = 0L;
context.line = context.chrctr = 0L;
}
fnum++;
firstf = 0;
}
reset_tty ();
exit(EXIT_SUCCESS);
}
static int
l_CHAR(Void)
{ int ch,size,i;
static char rafail[] = "realloc failure";
char quote,*p;
if(f__lcount>0) return(0);
f__ltype=0;
if(f__lchar!=NULL) free(f__lchar);
size=BUFSIZE;
p=f__lchar = (char *)malloc((unsigned int)size);
if(f__lchar == NULL)
errfl(f__elist->cierr,113,"no space");
GETC(ch);
if(isdigit(ch)) {
/* allow Fortran 8x-style unquoted string... */
/* either find a repetition count or the string */
f__lcount = ch - '0';
*p++ = ch;
for(i = 1;;) {
switch(GETC(ch)) {
case '*':
if (f__lcount == 0) {
f__lcount = 1;
#ifndef F8X_NML_ELIDE_QUOTES
if (nml_read)
goto no_quote;
#endif
goto noquote;
}
p = f__lchar;
goto have_lcount;
case ',':
case ' ':
case '\t':
case '\n':
case '/':
Ungetc(ch,f__cf);
/* no break */
case EOF:
f__lcount = 1;
f__ltype = TYCHAR;
return *p = 0;
}
if (!isdigit(ch)) {
f__lcount = 1;
#ifndef F8X_NML_ELIDE_QUOTES
if (nml_read) {
no_quote:
errfl(f__elist->cierr,112,
"undelimited character string");
}
#endif
goto noquote;
}
*p++ = ch;
f__lcount = 10*f__lcount + ch - '0';
if (++i == size) {
f__lchar = (char *)realloc(f__lchar,
(unsigned int)(size += BUFSIZE));
if(f__lchar == NULL)
errfl(f__elist->cierr,113,rafail);
p = f__lchar + i;
}
}
}
else (void) Ungetc(ch,f__cf);
have_lcount:
if(GETC(ch)=='\'' || ch=='"') quote=ch;
else if(isblnk(ch) || (issep(ch) && ch != '\n') || ch==EOF) {
Ungetc(ch,f__cf);
return 0;
}
#ifndef F8X_NML_ELIDE_QUOTES
else if (nml_read > 1) {
Ungetc(ch,f__cf);
f__lquit = 2;
return 0;
}
#endif
else {
/* Fortran 8x-style unquoted string */
*p++ = ch;
for(i = 1;;) {
switch(GETC(ch)) {
case ',':
case ' ':
case '\t':
case '\n':
case '/':
Ungetc(ch,f__cf);
/* no break */
case EOF:
f__ltype = TYCHAR;
return *p = 0;
}
noquote:
*p++ = ch;
if (++i == size) {
f__lchar = (char *)realloc(f__lchar,
(unsigned int)(size += BUFSIZE));
if(f__lchar == NULL)
errfl(f__elist->cierr,113,rafail);
p = f__lchar + i;
}
}
}
f__ltype=TYCHAR;
for(i=0;;)
{ while(GETC(ch)!=quote && ch!='\n'
&& ch!=EOF && ++i<size) *p++ = ch;
if(i==size)
{
newone:
f__lchar= (char *)realloc(f__lchar,
(unsigned int)(size += BUFSIZE));
if(f__lchar == NULL)
errfl(f__elist->cierr,113,rafail);
p=f__lchar+i-1;
*p++ = ch;
}
else if(ch==EOF) return(EOF);
else if(ch=='\n')
{ if(*(p-1) != '\\') continue;
i--;
p--;
if(++i<size) *p++ = ch;
else goto newone;
}
else if(GETC(ch)==quote)
{ if(++i<size) *p++ = ch;
else goto newone;
}
else
{ (void) Ungetc(ch,f__cf);
*p = 0;
return(0);
}
}
}
int x_rsne(cilist *a)
{
int ch, got1, k, n, nd, quote, readall;
Namelist *nl;
static char where[] = "namelist read";
char buf[64];
hashtab *ht;
Vardesc *v;
dimen *dn, *dn0, *dn1;
ftnlen *dims, *dims1;
ftnlen b, b0, b1, ex, no, nomax, size, span;
ftnint no1, no2, type;
char *vaddr;
long iva, ivae;
dimen dimens[MAXDIM], substr;
if (!Alpha['a'])
nl_init();
f__reading=1;
f__formatted=1;
got1 = 0;
top:
for(;;) switch(GETC(ch)) {
case EOF:
eof:
err(a->ciend,(EOF),where0);
case '&':
case '$':
goto have_amp;
#ifndef No_Namelist_Questions
case '?':
print_ne(a);
continue;
#endif
default:
if (ch <= ' ' && ch >= 0)
continue;
#ifndef No_Namelist_Comments
while(GETC(ch) != '\n')
if (ch == EOF)
goto eof;
#else
errfl(a->cierr, 115, where0);
#endif
}
have_amp:
if (ch = getname(buf,sizeof(buf)))
return ch;
nl = (Namelist *)a->cifmt;
if (strcmp(buf, nl->name))
#ifdef No_Bad_Namelist_Skip
errfl(a->cierr, 118, where0);
#else
{
fprintf(stderr,
"Skipping namelist \"%s\": seeking namelist \"%s\".\n",
buf, nl->name);
fflush(stderr);
for(;;) switch(GETC(ch)) {
case EOF:
err(a->ciend, EOF, where0);
case '/':
case '&':
case '$':
if (f__external)
e_rsle();
else
z_rnew();
goto top;
case '"':
case '\'':
quote = ch;
more_quoted:
while(GETC(ch) != quote)
if (ch == EOF)
err(a->ciend, EOF, where0);
if (GETC(ch) == quote)
goto more_quoted;
Ungetc(ch,f__cf);
default:
continue;
}
}
#endif
ht = mk_hashtab(nl);
if (!ht)
errfl(f__elist->cierr, 113, where0);
for(;;) {
for(;;) switch(GETC(ch)) {
case EOF:
if (got1)
return 0;
err(a->ciend, EOF, where0);
case '/':
case '$':
case '&':
return 0;
default:
if (ch <= ' ' && ch >= 0 || ch == ',')
continue;
Ungetc(ch,f__cf);
if (ch = getname(buf,sizeof(buf)))
return ch;
goto havename;
}
havename:
v = hash(ht,buf);
if (!v)
errfl(a->cierr, 119, where);
while(GETC(ch) <= ' ' && ch >= 0);
vaddr = v->addr;
type = v->type;
if (type < 0) {
size = -type;
type = TYCHAR;
}
else
size = f__typesize[type];
ivae = size;
iva = readall = 0;
if (ch == '(' /*)*/ ) {
dn = dimens;
if (!(dims = v->dims)) {
if (type != TYCHAR)
errfl(a->cierr, 122, where);
if (k = getdimen(&ch, dn, (ftnlen)size,
(ftnlen)size, &b))
errfl(a->cierr, k, where);
if (ch != ')')
errfl(a->cierr, 115, where);
b1 = dn->extent;
if (--b < 0 || b + b1 > size)
return 124;
iva += b;
size = b1;
while(GETC(ch) <= ' ' && ch >= 0);
goto scalar;
}
nd = (int)dims[0];
nomax = span = dims[1];
ivae = iva + size*nomax;
colonseen = 0;
if (k = getdimen(&ch, dn, size, nomax, &b))
errfl(a->cierr, k, where);
no = dn->extent;
b0 = dims[2];
dims1 = dims += 3;
ex = 1;
for(n = 1; n++ < nd; dims++) {
if (ch != ',')
errfl(a->cierr, 115, where);
dn1 = dn + 1;
span /= *dims;
if (k = getdimen(&ch, dn1, dn->delta**dims,
span, &b1))
errfl(a->cierr, k, where);
ex *= *dims;
b += b1*ex;
no *= dn1->extent;
dn = dn1;
}
if (ch != ')')
errfl(a->cierr, 115, where);
readall = 1 - colonseen;
b -= b0;
if (b < 0 || b >= nomax)
errfl(a->cierr, 125, where);
iva += size * b;
dims = dims1;
while(GETC(ch) <= ' ' && ch >= 0);
no1 = 1;
dn0 = dimens;
if (type == TYCHAR && ch == '(' /*)*/) {
if (k = getdimen(&ch, &substr, size, size, &b))
errfl(a->cierr, k, where);
if (ch != ')')
errfl(a->cierr, 115, where);
b1 = substr.extent;
if (--b < 0 || b + b1 > size)
return 124;
iva += b;
b0 = size;
size = b1;
while(GETC(ch) <= ' ' && ch >= 0);
if (b1 < b0)
goto delta_adj;
}
if (readall)
goto delta_adj;
for(; dn0 < dn; dn0++) {
if (dn0->extent != *dims++ || dn0->stride != 1)
break;
no1 *= dn0->extent;
}
if (dn0 == dimens && dimens[0].stride == 1) {
no1 = dimens[0].extent;
dn0++;
}
delta_adj:
ex = 0;
for(dn1 = dn0; dn1 <= dn; dn1++)
ex += (dn1->extent-1)
* (dn1->delta *= dn1->stride);
for(dn1 = dn; dn1 > dn0; dn1--) {
ex -= (dn1->extent - 1) * dn1->delta;
dn1->delta -= ex;
}
}
else if (dims = v->dims) {
no = no1 = dims[1];
ivae = iva + no*size;
}
else
scalar:
no = no1 = 1;
if (ch != '=')
errfl(a->cierr, 115, where);
got1 = nml_read = 1;
f__lcount = 0;
readloop:
for(;;) {
if (iva >= ivae || iva < 0) {
f__lquit = 1;
goto mustend;
}
else if (iva + no1*size > ivae)
no1 = (ivae - iva)/size;
f__lquit = 0;
if (k = l_read(&no1, vaddr + iva, size, type))
return k;
if (f__lquit == 1)
return 0;
if (readall) {
iva += dn0->delta;
if (f__lcount > 0) {
no2 = (ivae - iva)/size;
if (no2 > f__lcount)
no2 = f__lcount;
if (k = l_read(&no2, vaddr + iva,
size, type))
return k;
iva += no2 * dn0->delta;
}
}
mustend:
GETC(ch);
if (readall)
if (iva >= ivae)
readall = 0;
else for(;;) {
switch(ch) {
case ' ':
case '\t':
case '\n':
GETC(ch);
continue;
}
break;
}
if (ch == '/' || ch == '$' || ch == '&') {
f__lquit = 1;
return 0;
}
else if (f__lquit) {
while(ch <= ' ' && ch >= 0)
GETC(ch);
Ungetc(ch,f__cf);
if (!Alpha[ch & 0xff] && ch >= 0)
errfl(a->cierr, 125, where);
break;
}
Ungetc(ch,f__cf);
if (readall && !Alpha[ch & 0xff])
goto readloop;
if ((no -= no1) <= 0)
break;
for(dn1 = dn0; dn1 <= dn; dn1++) {
if (++dn1->curval < dn1->extent) {
iva += dn1->delta;
goto readloop;
}
dn1->curval = 0;
}
break;
}
}
}
static int
l_C(Void)
{ int ch, nml_save;
double lz;
if(f__lcount>0) return(0);
f__ltype=0;
GETC(ch);
if(ch!='(')
{
if (nml_read > 1 && (ch < '0' || ch > '9')) {
Ungetc(ch,f__cf);
f__lquit = 2;
return 0;
}
if (rd_count(ch)) {
if(!f__cf || !feof(f__cf)) {
errfl(f__elist->cierr,112,"complex format");
}
else {
err(f__elist->cierr,(EOF),"lread");
}
}
if(GETC(ch)!='*')
{
if(!f__cf || !feof(f__cf))
errfl(f__elist->cierr,112,"no star");
else
err(f__elist->cierr,(EOF),"lread");
}
if(GETC(ch)!='(')
{ Ungetc(ch,f__cf);
return(0);
}
}
else
f__lcount = 1;
while(iswhit(GETC(ch)));
Ungetc(ch,f__cf);
nml_save = nml_read;
nml_read = 0;
if ((ch = l_R(1,0)))
return ch;
if (!f__ltype)
errfl(f__elist->cierr,112,"no real part");
lz = f__lx;
while(iswhit(GETC(ch)));
if(ch!=',')
{ (void) Ungetc(ch,f__cf);
errfl(f__elist->cierr,112,"no comma");
}
while(iswhit(GETC(ch)));
(void) Ungetc(ch,f__cf);
if ((ch = l_R(1,0)))
return ch;
if (!f__ltype)
errfl(f__elist->cierr,112,"no imaginary part");
while(iswhit(GETC(ch)));
if(ch!=')') errfl(f__elist->cierr,112,"no )");
f__ly = f__lx;
f__lx = lz;
#ifdef Allow_TYQUAD
f__llx = 0;
#endif
nml_read = nml_save;
return(0);
}
/*
* Print out the contents of the file f, one screenful at a time.
*/
void
screen(FILE *f, int num_lines)
{
int ch;
int nchars;
int length; /* length of current line */
static int prev_len = 1; /* length of previous line */
for (;;) {
while (num_lines > 0 && !Pause) {
if ((nchars = get_line(f, &length)) == EOF) {
if (clreol)
clreos();
return;
}
if (ssp_opt && length == 0 && prev_len == 0)
continue;
prev_len = length;
if (bad_so ||
(Senter && *Senter == ' ' && promptlen > 0))
erasep(0);
/*
* Must clear before drawing line since tabs on some
* terminals do not erase what they tab over.
*/
if (clreol)
cleareol();
prbuf(Line, length);
if (nchars < promptlen) {
/* erasep() sets promptlen to 0 */
erasep(nchars);
} else
promptlen = 0;
#if 0
/* XXX - is this needed? */
if (clreol) {
/* must clear again in case we wrapped * */
cleareol();
}
#endif
if (nchars < Mcol || !fold_opt) {
/* will turn off UL if necessary */
prbuf("\n", 1);
}
if (nchars == STOP)
break;
num_lines--;
}
if (pstate) {
tputs(ULexit, 1, putch);
pstate = 0;
}
fflush(stdout);
if ((ch = Getc(f)) == EOF) {
if (clreol)
clreos();
return;
}
if (Pause && clreol)
clreos();
Ungetc(ch, f);
Pause = 0;
startup = 0;
if ((num_lines = command(NULL, f)) == 0)
return;
if (hard && promptlen > 0)
erasep(0);
if (noscroll && num_lines >= dlines) {
if (clreol)
home();
else
doclear();
}
/*
* XXX - should store the *first* line on the screen,
* not the last (but we don't know the file position).
* Fixing this requires keeping an arry of dline off_ts
* and updating each one when a new line is started.
*/
screen_start.line = Currline;
screen_start.chrctr = Ftell(f);
}
}
/* Get a logical line */
static int get_line(register FILE *f, int *length)
{
int c;
char *p;
int column;
static int colflg;
#ifdef HAVE_WIDECHAR
size_t i;
wchar_t wc;
int wc_width;
mbstate_t state, state_bak; /* Current status of the stream. */
char mbc[MB_LEN_MAX]; /* Buffer for one multibyte char. */
size_t mblength; /* Byte length of multibyte char. */
size_t mbc_pos = 0; /* Position of the MBC. */
int use_mbc_buffer_flag = 0; /* If 1, mbc has data. */
int break_flag = 0; /* If 1, exit while(). */
long file_pos_bak = Ftell(f);
memset(&state, '\0', sizeof(mbstate_t));
#endif
prepare_line_buffer();
p = Line;
column = 0;
c = Getc(f);
if (colflg && c == '\n') {
Currline++;
c = Getc(f);
}
while (p < &Line[LineLen - 1]) {
#ifdef HAVE_WIDECHAR
if (fold_opt && use_mbc_buffer_flag && MB_CUR_MAX > 1) {
use_mbc_buffer_flag = 0;
state_bak = state;
mbc[mbc_pos++] = c;
process_mbc:
mblength = mbrtowc(&wc, mbc, mbc_pos, &state);
switch (mblength) {
case (size_t)-2: /* Incomplete multibyte character. */
use_mbc_buffer_flag = 1;
state = state_bak;
break;
case (size_t)-1: /* Invalid as a multibyte character. */
*p++ = mbc[0];
state = state_bak;
column++;
file_pos_bak++;
if (column >= Mcol) {
Fseek(f, file_pos_bak);
} else {
memmove(mbc, mbc + 1, --mbc_pos);
if (mbc_pos > 0) {
mbc[mbc_pos] = '\0';
goto process_mbc;
}
}
break;
default:
wc_width = wcwidth(wc);
if (column + wc_width > Mcol) {
Fseek(f, file_pos_bak);
break_flag = 1;
} else {
for (i = 0; p < &Line[LineLen - 1] &&
i < mbc_pos; i++)
*p++ = mbc[i];
if (wc_width > 0)
column += wc_width;
}
}
if (break_flag || column >= Mcol)
break;
c = Getc(f);
continue;
}
#endif /* HAVE_WIDECHAR */
if (c == EOF) {
if (p > Line) {
*p = '\0';
*length = p - Line;
return (column);
}
*length = p - Line;
return (EOF);
}
if (c == '\n') {
Currline++;
break;
}
*p++ = c;
#if 0
if (c == '\033') { /* ESC */
c = Getc(f);
while (c > ' ' && c < '0' && p < &Line[LineLen - 1]) {
*p++ = c;
c = Getc(f);
}
if (c >= '0' && c < '\177' && p < &Line[LineLen - 1]) {
*p++ = c;
c = Getc(f);
continue;
}
}
#endif /* 0 */
if (c == '\t') {
if (!hardtabs || (column < promptlen && !hard)) {
if (hardtabs && eraseln && !dumb) {
column = 1 + (column | 7);
putstring(eraseln);
promptlen = 0;
} else {
for (--p; p < &Line[LineLen - 1];) {
*p++ = ' ';
if ((++column & 7) == 0)
break;
}
if (column >= promptlen)
promptlen = 0;
}
} else
column = 1 + (column | 7);
} else if (c == '\b' && column > 0) {
column--;
} else if (c == '\r') {
int next = Getc(f);
if (next == '\n') {
p--;
Currline++;
break;
}
Ungetc(next, f);
column = 0;
} else if (c == '\f' && stop_opt) {
p[-1] = '^';
*p++ = 'L';
column += 2;
Pause++;
} else if (c == EOF) {
*length = p - Line;
return (column);
} else {
#ifdef HAVE_WIDECHAR
if (fold_opt && MB_CUR_MAX > 1) {
memset(mbc, '\0', MB_LEN_MAX);
mbc_pos = 0;
mbc[mbc_pos++] = c;
state_bak = state;
mblength = mbrtowc(&wc, mbc, mbc_pos, &state);
/* The value of mblength is always less than 2 here. */
switch (mblength) {
case (size_t)-2:
p--;
file_pos_bak = Ftell(f) - 1;
state = state_bak;
use_mbc_buffer_flag = 1;
break;
case (size_t)-1:
state = state_bak;
column++;
break;
default:
wc_width = wcwidth(wc);
if (wc_width > 0)
column += wc_width;
}
} else
#endif /* HAVE_WIDECHAR */
{
if (isprint(c))
column++;
}
}
if (column >= Mcol && fold_opt)
break;
#ifdef HAVE_WIDECHAR
if (use_mbc_buffer_flag == 0 && p >= &Line[LineLen - 1 - 4])
/* don't read another char if there is no space for
* whole multibyte sequence */
break;
#endif
c = Getc(f);
}
if (column >= Mcol && Mcol > 0) {
if (!Wrap) {
*p++ = '\n';
}
}
colflg = column == Mcol && fold_opt;
if (colflg && eatnl && Wrap) {
*p++ = '\n'; /* simulate normal wrap */
}
*length = p - Line;
*p = 0;
return (column);
}
l_R(int poststar)
#endif
{
char s[FMAX+EXPMAXDIGS+4];
register int ch;
register char *sp, *spe, *sp1;
long e, exp;
int havenum, havestar, se;
if (!poststar) {
if (f__lcount > 0)
return(0);
f__lcount = 1;
}
f__ltype = 0;
exp = 0;
havestar = 0;
retry:
sp1 = sp = s;
spe = sp + FMAX;
havenum = 0;
switch(GETC(ch)) {
case '-': *sp++ = ch; sp1++; spe++;
case '+':
GETC(ch);
}
while(ch == '0') {
++havenum;
GETC(ch);
}
while(isdigit(ch)) {
if (sp < spe) *sp++ = ch;
else ++exp;
GETC(ch);
}
if (ch == '*' && !poststar) {
if (sp == sp1 || exp || *s == '-') {
errfl(f__elist->cierr,112,"bad repetition count");
}
poststar = havestar = 1;
*sp = 0;
f__lcount = atoi(s);
goto retry;
}
if (ch == '.') {
GETC(ch);
if (sp == sp1)
while(ch == '0') {
++havenum;
--exp;
GETC(ch);
}
while(isdigit(ch)) {
if (sp < spe)
{ *sp++ = ch; --exp; }
GETC(ch);
}
}
havenum += sp - sp1;
se = 0;
if (issign(ch))
goto signonly;
if (havenum && isexp(ch)) {
GETC(ch);
if (issign(ch)) {
signonly:
if (ch == '-') se = 1;
GETC(ch);
}
if (!isdigit(ch)) {
bad:
errfl(f__elist->cierr,112,"exponent field");
}
e = ch - '0';
while(isdigit(GETC(ch))) {
e = 10*e + ch - '0';
if (e > EXPMAX)
goto bad;
}
if (se)
exp -= e;
else
exp += e;
}
(void) Ungetc(ch, f__cf);
if (sp > sp1) {
++havenum;
while(*--sp == '0')
++exp;
if (exp)
sprintf(sp+1, "e%ld", exp);
else
sp[1] = 0;
f__lx = atof(s);
}
else
f__lx = 0.;
if (havenum)
f__ltype = TYLONG;
else
switch(ch) {
case ',':
case '/':
break;
default:
if (havestar && ( ch == ' '
||ch == '\t'
||ch == '\n'))
break;
if (nml_read > 1) {
f__lquit = 2;
return 0;
}
errfl(f__elist->cierr,112,"invalid number");
}
return 0;
}
l_R(int poststar, int reqint)
#endif
{
char s[FMAX+EXPMAXDIGS+4];
register int ch;
register char *sp, *spe, *sp1;
long e, exp;
int havenum, havestar, se;
if (!poststar) {
if (f__lcount > 0)
return(0);
f__lcount = 1;
}
#ifdef Allow_TYQUAD
f__llx = 0;
#endif
f__ltype = 0;
exp = 0;
havestar = 0;
retry:
sp1 = sp = s;
spe = sp + FMAX;
havenum = 0;
switch(GETC(ch)) {
case '-': *sp++ = ch; sp1++; spe++;
case '+':
GETC(ch);
}
while(ch == '0') {
++havenum;
GETC(ch);
}
while(isdigit(ch)) {
if (sp < spe) *sp++ = ch;
else ++exp;
GETC(ch);
}
if (ch == '*' && !poststar) {
if (sp == sp1 || exp || *s == '-') {
errfl(f__elist->cierr,112,"bad repetition count");
}
poststar = havestar = 1;
*sp = 0;
f__lcount = atoi(s);
goto retry;
}
if (ch == '.') {
#ifndef ALLOW_FLOAT_IN_INTEGER_LIST_INPUT
if (reqint)
errfl(f__elist->cierr,115,"invalid integer");
#endif
GETC(ch);
if (sp == sp1)
while(ch == '0') {
++havenum;
--exp;
GETC(ch);
}
while(isdigit(ch)) {
if (sp < spe)
{ *sp++ = ch; --exp; }
GETC(ch);
}
}
havenum += sp - sp1;
se = 0;
if (issign(ch))
goto signonly;
if (havenum && isexp(ch)) {
#ifndef ALLOW_FLOAT_IN_INTEGER_LIST_INPUT
if (reqint)
errfl(f__elist->cierr,115,"invalid integer");
#endif
GETC(ch);
if (issign(ch)) {
signonly:
if (ch == '-') se = 1;
GETC(ch);
}
if (!isdigit(ch)) {
bad:
errfl(f__elist->cierr,112,"exponent field");
}
e = ch - '0';
while(isdigit(GETC(ch))) {
e = 10*e + ch - '0';
if (e > EXPMAX)
goto bad;
}
if (se)
exp -= e;
else
exp += e;
}
(void) Ungetc(ch, f__cf);
if (sp > sp1) {
++havenum;
while(*--sp == '0')
++exp;
if (exp)
sprintf(sp+1, "e%ld", exp);
else
sp[1] = 0;
f__lx = atof(s);
#ifdef Allow_TYQUAD
if (reqint&2 && (se = sp - sp1 + exp) > 14 && se < 20) {
/* Assuming 64-bit longint and 32-bit long. */
if (exp < 0)
sp += exp;
if (sp1 <= sp) {
f__llx = *sp1 - '0';
while(++sp1 <= sp)
f__llx = 10*f__llx + (*sp1 - '0');
}
while(--exp >= 0)
f__llx *= 10;
if (*s == '-')
f__llx = -f__llx;
}
#endif
}
else
f__lx = 0.;
if (havenum)
f__ltype = TYLONG;
else
switch(ch) {
case ',':
case '/':
break;
default:
if (havestar && ( ch == ' '
||ch == '\t'
||ch == '\n'))
break;
if (nml_read > 1) {
f__lquit = 2;
return 0;
}
errfl(f__elist->cierr,112,"invalid number");
}
return 0;
}