/usr/src/usr.bin/pr/pr.c

Bug Summary

File:	src/usr.bin/pr/pr.c
Warning:	line 1116, column 9 Potential leak of memory pointed to by 'rc'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name pr.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/usr.bin/pr/obj -resource-dir /usr/local/lib/clang/13.0.0 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/usr.bin/pr/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/usr.bin/pr/pr.c
1/*	$OpenBSD: pr.c,v 1.44 2020/12/13 15:36:36 jmc Exp $	*/

3/*-
* Copyright (c) 1991 Keith Muller.
* Copyright (c) 1993
*	The Regents of the University of California.  All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Keith Muller of the University of California, San Diego.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

36#include <sys/types.h>
37#include <sys/stat.h>

39#include <ctype.h>
40#include <errno(*__errno()).h>
41#include <limits.h>
42#include <signal.h>
43#include <stdio.h>
44#include <stdarg.h>
45#include <stdlib.h>
46#include <string.h>
47#include <time.h>
48#include <unistd.h>

50#include "pr.h"
51#include "extern.h"

53/*
* pr:	a printing and pagination filter. If multiple input files
*	are specified, each is read, formatted, and written to standard
*	output. By default, input is separated into 66-line pages, each
*	with a header that includes the page number, date, time and the
*	files pathname.
*
*	Complies with posix P1003.2/D11
*/

63/*
* pr: more boundary conditions than a four-legged porcupine
*
* the original version didn't support form-feeds, while many of the ad-hoc
* pr implementations out there do.  Adding this and making it work reasonably
* in all four output modes required quite a bit of hacking and a few minor
* bugs were noted and fixed in the process.  Some implementations have this
* as the as -f, some as -F so we accept either.
*
* The implementation of form feeds on top of the existing I/O structure is
* a bit idiosyncratic.  Basically they are treated as temporary end-of-file
* conditions and an additional level of "loop on form feed" is added to each
* of the output modes to continue after such a transient end-of-file's. This
* has the general benefit of making the existing header/trailer logic work
* and provides a usable framework for rational behavior in multi-column modes.
*
* The original "efficient" implementation of the "skip to page N" option was
* bogus and I substituted the basic inhibit printing until page N approach.
* This is still fairly bogus vis-a-vis numbering pages on multiple files
* restarting at one, but at least lets you consistently reprint some large
* document starting in the middle, in any of the output modes.
*
* Additional support for overprinting via <back-space> or <return> would
* be nice, but is not trivial across tab interpretation, output formatting
* and the different operating modes.  Support for line-wrapping, either
* strict or word-wrapped would be really useful and not all that hard to
* kludge into the inln() implementation.  The general notion is that -wc n
* would specify width and wrapping with a marker character c and -Wc n
* would add word wrapping with a minimum width n and delimiters c, defaulting
* to tab, blank, and -, and column width.  Word wrapping always involves
* painful policy questions which are difficult to specify unless you just
* hardwire in some fixed rules. Think quotes, punctuation and white-space
* elimination and whether you'd do the same thing with a C program and
* something like columninated newspaper text.
*
*				George Robbins <grr@tharsis.com> 4/22/97.
*/

101/*
* parameter variables
*/
104int	pgnm;		/* starting page number */
105int	skipping;	/* we're skipping to page pgnum */
106int	clcnt;		/* number of columns */
107int	colwd;		/* column data width - multiple columns */
108int	across;		/* mult col flag; write across page */
109int	dspace;		/* double space flag */
110char	inchar;		/* expand input char */
111int	ingap;		/* expand input gap */
112int	formfeed;	/* use formfeed as trailer */
113int	inform;		/* grok formfeeds in input */
114char	*header;	/* header name instead of file name */
115char	ochar;		/* contract output char */
116int	ogap;		/* contract output gap */
117int	lines;		/* number of lines per page */
118int	merge;		/* merge multiple files in output */
119char	nmchar;		/* line numbering append char */
120int	nmwd;		/* width of line number field */
121int	offst;		/* number of page offset spaces */
122int	nodiag;		/* do not report file open errors */
123char	schar;		/* text column separation character */
124int	sflag;		/* -s option for multiple columns */
125int	nohead;		/* do not write head and trailer */
126int	pgwd;		/* page width with multiple col output */

128/*
* misc globals
*/
131volatile sig_atomic_t	ferr;	/* error message delayed */
132int	addone = 0;	/* page length is odd with double space */
133int	errcnt = 0;	/* error count on file processing */
134int	beheaded = 0;	/* header / trailer link */
135char	digs[] = "0123456789";	/* page number translation map */

137int
138main(int argc, char *argv[])
139{
  int ret_val;

  if (pledge("stdio rpath", NULL((void *)0)) == -1) {
1
Assuming the condition is false→
2
←
Taking false branch→
perror("pledge");
exit(1);
  }

  if (signal(SIGINT2, SIG_IGN(void (*)(int))1) != SIG_IGN(void (*)(int))1)
3
←
Assuming the condition is false→
4
←
Taking false branch→
(void)signal(SIGINT2, terminate);
  ret_val = setup(argc, argv);
  if (!ret_val) {
5
←
Assuming 'ret_val' is 0→
6
←
Taking true branch→
/*
* select the output format based on options
*/
if (merge)
7
←
Assuming 'merge' is not equal to 0→
8
←
Taking true branch→
   ret_val = mulfile(argc, argv);
9
←
Calling 'mulfile'→
else if (clcnt == 1)
   ret_val = onecol(argc, argv);
else if (across)
   ret_val = horzcol(argc, argv);
else
   ret_val = vertcol(argc, argv);
  } else
usage();
  flsh_errs();
  if (errcnt || ret_val)
exit(1);
  return(0);
168}

170/*
* onecol:    print files with only one column of output.
*        Line length is unlimited.
*/
174int
175onecol(int argc, char *argv[])
176{
  int off;
  int lrgln;
  int linecnt;
  int num;
  int cnt;
  int rc;
  int lncnt;
  int pagecnt;
  int ips;
  int ops;
  int cps;
  char *obuf = NULL((void *)0);
  char *lbuf;
  char *nbuf;
  char *hbuf = NULL((void *)0);
  char *ohbuf;
  FILE *inf = NULL((void *)0);
  char *fname;
  int mor;
  int error = 1;

  if (nmwd)
num = nmwd + 1;
  else
num = 0;
  off = num + offst;

  /*
   * allocate line buffer
   */
  if ((obuf = malloc((unsigned)(LBUF8192 + off)*sizeof(char))) == NULL((void *)0))
goto oomem;

  /*
   * allocate header buffer
   */
  if ((hbuf = malloc((unsigned)(HDBUF512 + offst)*sizeof(char))) == NULL((void *)0))
goto oomem;

  ohbuf = hbuf + offst;
  nbuf = obuf + offst;
  lbuf = nbuf + num;

  if (num)
nbuf[--num] = nmchar;

  if (offst) {
(void)memset(obuf, (int)' ', offst);
(void)memset(hbuf, (int)' ', offst);
  }

  /*
   * loop by file
   */
  while ((inf = nxtfile(argc, argv, &fname, ohbuf, 0)) != NULL((void *)0)) {
pagecnt = 0;
lncnt = 0;

/*
* loop by "form"
*/
for(;;) {

   /*
    * loop by page
    */
   for(;;) {
linecnt = 0;
lrgln = 0;
ops = 0;
ips = 0;
cps = 0;

/*
 * loop by line
 */
while (linecnt < lines) {

    /*
     * input next line
     */
    rc = inln(inf,lbuf,LBUF8192,&cnt,&cps,0,&mor);
    if (cnt >= 0) {
	if (!lrgln)
	    if (!linecnt && prhead(hbuf, fname, ++pagecnt))
	         goto out;

	/*
	 * start new line or continue a long one
	 */
	if (!lrgln) {
	    if (num)
		addnum(nbuf, num, ++lncnt);
	    if (otln(obuf,cnt+off, &ips, &ops, mor))
		goto out;
	} else
	    if (otln(lbuf, cnt, &ips, &ops, mor))
		goto out;

	/*
	 * if line bigger than buffer, get more
	 */
	if (mor) {
	    lrgln = 1;
	} else {
	    /*
	     * whole line rcvd. reset tab proc. state
	     */
	    ++linecnt;
	    lrgln = 0;
	    ops = 0;
	    ips = 0;
	}
    }

    if (rc != NORMAL0)
	break;
}

/*
 * fill to end of page
 */
if (prtail(lines - linecnt, lrgln))
    goto out;

/*
 * unless END continue
 */
if (rc == END-1)
    break;
   }

   /*
    * On EOF go to next file
    */
   if (rc == END-1)
   break;
}

if (inf != stdin(&__sF[0]))
   (void)fclose(inf);
  }
  /*
   * If we didn't process all the files, return error
   */
  if (eoptind < argc) {
goto out;
  } else {
error = 0;
goto out;
  }

329oomem:
  mfail();
331out:
  free(obuf);
  free(hbuf);
  if (inf != NULL((void *)0) && inf != stdin(&__sF[0]))
(void)fclose(inf);
  return error;
337}

339/*
* vertcol:	print files with more than one column of output down a page
*		the general approach is to buffer a page of data, then print
*/
343int
344vertcol(int argc, char *argv[])
345{
  char *ptbf;
  char **lstdat = NULL((void *)0);
  int i;
  int j;
  int pln;
  int *indy = NULL((void *)0);
  int cnt;
  int rc;
  int cvc;
  int *lindy = NULL((void *)0);
  int lncnt;
  int stp;
  int pagecnt;
  int col = colwd + 1;
  int mxlen = pgwd + offst + 1;
  int mclcnt = clcnt - 1;
  struct vcol *vc = NULL((void *)0);
  int mvc;
  int tvc;
  int cw = nmwd + 1;
  int fullcol;
  char *buf = NULL((void *)0);
  char *hbuf = NULL((void *)0);
  char *ohbuf;
  char *fname;
  FILE *inf = NULL((void *)0);
  int ips = 0;
  int cps = 0;
  int ops = 0;
  int mor = 0;
  int error = 1;

  /*
   * allocate page buffer
   */
  if ((buf = calloc((unsigned)lines, mxlen)) == NULL((void *)0))
goto oomem;

  /*
   * allocate page header
   */
  if ((hbuf = malloc((unsigned)HDBUF512 + offst)) == NULL((void *)0))
goto oomem;

  ohbuf = hbuf + offst;
  if (offst)
(void)memset(hbuf, (int)' ', offst);

  /*
   * col pointers when no headers
   */
  mvc = lines * clcnt;
  if ((vc = calloc((unsigned)mvc, sizeof(struct vcol))) == NULL((void *)0))
goto oomem;

  /*
   * pointer into page where last data per line is located
   */
  if ((lstdat = calloc((unsigned)lines, sizeof(char *))) == NULL((void *)0))
goto oomem;

  /*
   * fast index lookups to locate start of lines
   */
  if ((indy = calloc((unsigned)lines, sizeof(int))) == NULL((void *)0))
goto oomem;
  if ((lindy = calloc((unsigned)lines, sizeof(int))) == NULL((void *)0))
goto oomem;

  if (nmwd)
fullcol = col + cw;
  else
fullcol = col;

  /*
   * initialize buffer lookup indexes and offset area
   */
  for (j = 0; j < lines; ++j) {
lindy[j] = j * mxlen;
indy[j] = lindy[j] + offst;
if (offst) {
   ptbf = buf + lindy[j];
   (void)memset(ptbf, (int)' ', offst);
   ptbf += offst;
} else
   ptbf = buf + indy[j];
lstdat[j] = ptbf;
  }

  /*
   * loop by file
   */
  while ((inf = nxtfile(argc, argv, &fname, ohbuf, 0)) != NULL((void *)0)) {
pagecnt = 0;
lncnt = 0;

/*
* loop by "form"
*/
for (;;) {

   /*
    * loop by page
    */
   for(;;) {

/*
 * loop by column
 */
cvc = 0;
for (i = 0; i < clcnt; ++i) {
    j = 0;
    /*
     * if last column, do not pad
     */
    if (i == mclcnt)
	stp = 1;
    else
	stp = 0;

    /*
     * loop by line
     */
    for(;;) {
	/*
	 * is this first column
	 */
	if (!i) {
	    ptbf = buf + indy[j];
	    lstdat[j] = ptbf;
	} else 
	    ptbf = lstdat[j];
	vc[cvc].pt = ptbf;

	/*
	 * add number
	 */
	if (nmwd) {
	    addnum(ptbf, nmwd, ++lncnt);
	    ptbf += nmwd;
	    *ptbf++ = nmchar;
	}

	/*
	 * input next line
	 */
	rc = inln(inf,ptbf,colwd,&cnt,&cps,1,&mor);
	vc[cvc++].cnt = cnt;
	if (cnt >= 0) {
	    ptbf += cnt;

	    /*
	     * pad all but last column on page
	     */
	    if (!stp) {
		/*
		 * pad to end of column
		 */
		if (sflag)
		    *ptbf++ = schar;
		else if ((pln = col-cnt) > 0) {
		    (void)memset(ptbf,
			(int)' ',pln);
		    ptbf += pln;
		}
	    }

	    /*
	     * remember last char in line
	     */
	    lstdat[j] = ptbf;
	    if (++j >= lines)
		break;
	} /* end of if cnt >= 0 */

	if (rc != NORMAL0)
	    break;
    } /* end of for line */

    if (rc != NORMAL0)
	break;
} /* end of for column */

/*
 * when -t (no header) is specified the spec requires
 * the min number of lines. The last page may not have
 * balanced length columns. To fix this we must reorder
 * the columns. This is a very slow technique so it is
 * only used under limited conditions. Without -t, the
 * balancing of text columns is unspecified. To NOT
 * balance the last page, add the global variable
 * nohead to the if statement below e.g.
 */

/*
 * print header iff we got anything on the first read
 */
if (vc[0].cnt >= 0) {
    if (prhead(hbuf, fname, ++pagecnt))
    	goto out;

    /*
     * check to see if "last" page needs to be reordered
     */
    --cvc;
    if ((rc != NORMAL0) && cvc && ((mvc-cvc) >= clcnt)){
	pln = cvc/clcnt;
	if (cvc % clcnt)
	    ++pln;

	for (i = 0; i < pln; ++i) {
	    ips = 0;
	    ops = 0;
	    if (offst && otln(buf,offst,&ips,&ops,1))
		goto out;
	    tvc = i;

	    for (j = 0; j < clcnt; ++j) {
		/*
		 * determine column length
		 */
		if (j == mclcnt) {
		    /*
		     * last column
		     */
		    cnt = vc[tvc].cnt;
		    if (nmwd)
			cnt += cw;
		} else if (sflag) {
		    /*
		     * single ch between
		     */
		    cnt = vc[tvc].cnt + 1;
		    if (nmwd)
			cnt += cw;
		} else
		    cnt = fullcol;

		if (otln(vc[tvc].pt, cnt, &ips, &ops, 1))
		    goto out;
		tvc += pln;
		if (tvc > cvc)
		    break;
	    }
	    /*
	     * terminate line
	     */
	    if (otln(buf, 0, &ips, &ops, 0))
		goto out;
	}

    } else {

	/*
	 * just a normal page...
	 * determine how many lines to output
	 */
	if (i > 0)
	    pln = lines;
	else
	    pln = j;

	/*
	 * output each line
	 */
	for (i = 0; i < pln; ++i) {
	    ptbf = buf + lindy[i];
	    if ((j = lstdat[i] - ptbf) <= offst)
		break;
	    else {
		ips = 0;
		ops = 0;
		if (otln(ptbf, j, &ips, &ops, 0))
		    goto out;
	    }
	}
    }
}

/*
 * pad to end of page
 */
if (prtail((lines - pln), 0))
    goto out;

/*
 * if FORM continue
 */
if (rc != NORMAL0)
    break;
   }

   /*
    * if EOF go to next file
    */
   if (rc == END-1)
break;
}

if (inf != stdin(&__sF[0]))
   (void)fclose(inf);
  }

  if (eoptind < argc){
goto out;
  } else {
error = 0;
goto out;
  }

656oomem:
  mfail();
658out:
  free(buf);
  free(hbuf);
  free(vc);
  free(lstdat);
  free(lindy);
  if (inf != NULL((void *)0) && inf != stdin(&__sF[0]))
(void)fclose(inf);
  return error;

668}

670/*
* horzcol:    print files with more than one column of output across a page
*/
673int
674horzcol(int argc, char *argv[])
675{
  char *ptbf;
  int pln;
  char *lstdat;
  int col = colwd + 1;
  int j;
  int i;
  int cnt;
  int rc;
  int lncnt;
  int pagecnt;
  char *buf = NULL((void *)0);
  char *hbuf = NULL((void *)0);
  char *ohbuf;
  char *fname;
  FILE *inf = NULL((void *)0);
  int cps = 0;
  int mor = 0;
  int ips = 0;
  int ops = 0;
  int error = 1;

  if ((buf = malloc((unsigned)pgwd + offst + 1)) == NULL((void *)0))
goto oomem;

  /*
   * page header
   */
  if ((hbuf = malloc((unsigned)HDBUF512 + offst)) == NULL((void *)0))
goto oomem;

  ohbuf = hbuf + offst;
  if (offst) {
(void)memset(buf, (int)' ', offst);
(void)memset(hbuf, (int)' ', offst);
  }

  /*
   * loop by file
   */
  while ((inf = nxtfile(argc, argv, &fname, ohbuf, 0)) != NULL((void *)0)) {
pagecnt = 0;
lncnt = 0;

/*
* loop by form
*/
for (;;) {

   /*
    * loop by page
    */
   for(;;) {

/*
 * loop by line
 */
for (i = 0; i < lines; ++i) {
    ptbf = buf + offst;
    lstdat = ptbf;
    j = 0;

    /*
     * loop by col
     */
    for(;;) {
	if (nmwd) {
	    /*
	     * add number to column
	     */
	    addnum(ptbf, nmwd, ++lncnt);
	    ptbf += nmwd;
	    *ptbf++ = nmchar;
	}
	/*
	 * input line
	 */
	rc = inln(inf,ptbf,colwd,&cnt,&cps,1, &mor);
	if (cnt >= 0) {
	    if (!i && !j && prhead(hbuf, fname, ++pagecnt))
	        goto out;

	    ptbf += cnt;
	    lstdat = ptbf;

	    /*
	     * if last line skip padding
	     */
	    if (++j >= clcnt)
		break;

	    /*
	     * pad to end of column
	     */
	    if (sflag)
		*ptbf++ = schar;
	    else if ((pln = col - cnt) > 0) {
		(void)memset(ptbf,(int)' ',pln);
		ptbf += pln;
	    }
	}
	if (rc != NORMAL0)
	    break;
    }

    /*
     * output line if any columns on it
     */
    if (j) {
	if (otln(buf, lstdat-buf, &ips, &ops, 0))
	    goto out;
    }

    if (rc != NORMAL0)
	break;
}

/*
 * pad to end of page
 */
if (prtail(lines - i, 0))
    return(1);

/*
 * if FORM continue
 */
if (rc == END-1)
    break;
   }
   /*
    * if EOF go to next file
    */
   if (rc == END-1)
break;
}
if (inf != stdin(&__sF[0]))
   (void)fclose(inf);
  }
  if (eoptind < argc){
goto out;
  } else {
error = 0;
goto out;
  }

820oomem:
  mfail();
822out:
  free(buf);
  free(hbuf);
  if (inf != NULL((void *)0) && inf != stdin(&__sF[0]))
(void)fclose(inf);
  return error;
828}

830struct ferrlist {
struct ferrlist *next;
char *buf;
833};
834struct ferrlist *ferrhead, *ferrtail;

836/*
* flsh_errs():    output saved up diagnostic messages after all normal
*        processing has completed
*/
840void
841flsh_errs(void)
842{
  struct ferrlist *f;

  if (ferr) {
for (f = ferrhead; f; f = f->next)
   (void)write(STDERR_FILENO2, f->buf, strlen(f->buf));
  }
849}

851static void ferrout(char *fmt, ...) __attribute__((format (printf, 1, 2)));
852static void
853ferrout(char *fmt, ...)
854{
  sigset_t block, oblock;
  struct ferrlist *f;
  va_list ap;
  char *p;

  va_start(ap, fmt)__builtin_va_start(ap, fmt);
  if (ferr == 0)
      vfprintf(stderr(&__sF[2]), fmt, ap);
  else {
sigemptyset(&block);
sigaddset(&block, SIGINT2);
sigprocmask(SIG_BLOCK1, &block, &oblock);

if (vasprintf(&p, fmt, ap) == -1 || (f = malloc(sizeof(*f))) == NULL((void *)0)) {
va_end(ap)__builtin_va_end(ap);
va_start(ap, fmt)__builtin_va_start(ap, fmt);
flsh_errs();
vfprintf(stderr(&__sF[2]), fmt, ap);
fputs("pr: memory allocation failed\n", stderr(&__sF[2]));
exit(1);
}

f->next = NULL((void *)0);
f->buf = p;
if (ferrhead == NULL((void *)0))
   ferrhead = f;
if (ferrtail)
ferrtail->next = f;
ferrtail = f;
sigprocmask(SIG_SETMASK3, &oblock, NULL((void *)0));
  }
  va_end(ap)__builtin_va_end(ap);
887}

889/*
* mulfile:    print files with more than one column of output and
*        more than one file concurrently
*/
893int
894mulfile(int argc, char *argv[])
895{
  char *ptbf;
  int j;
  int pln;
  int *rc;
  int cnt;
  char *lstdat;
  int i;
  FILE **fbuf = NULL((void *)0);
  int actf;
  int lncnt;
  int col;
  int pagecnt;
  int fproc;
  char *buf = NULL((void *)0);
  char *hbuf = NULL((void *)0);
  char *ohbuf;
  char *fname;
  int ips = 0;
  int cps = 0;
  int ops = 0;
  int mor = 0;
  int error = 1;

  /*
   * array of FILE *, one for each operand
   */
  if ((fbuf = calloc((unsigned)clcnt, sizeof(FILE *))) == NULL((void *)0))
10
←
Assuming the condition is false→
11
←
Taking false branch→
goto oomem;

  /*
   * array of int *, one for each operand
   */
  if ((rc = calloc((unsigned)clcnt, sizeof(int))) == NULL((void *)0))
12
←
Memory is allocated→
13
←
Assuming the condition is false→
14
←
Taking false branch→
goto oomem;

  /*
   * page header
   */
  if ((hbuf = malloc((unsigned)HDBUF512 + offst)) == NULL((void *)0))
15
←
Assuming the condition is false→
16
←
Taking false branch→
goto oomem;

  ohbuf = hbuf + offst;

  /*
   * do not know how many columns yet. The number of operands provide an
   * upper bound on the number of columns. We use the number of files
   * we can open successfully to set the number of columns. The operation
   * of the merge operation (-m) in relation to unsuccessful file opens
   * is unspecified by posix.
   *
   * XXX - this seems moderately bogus, you'd think that specifying
   * "pr -2 a b c d" would run though all the files in pairs, but
   * the existing code says up two files, or fewer if one is bogus.
   * fixing it would require modifying the looping structure, so be it.
   */
  j = 0;
  while (j < clcnt) {
17
←
Assuming 'j' is < 'clcnt'→
18
←
Loop condition is true.  Entering loop body→
20
←
Assuming 'j' is >= 'clcnt'→
21
←
Loop condition is false. Execution continues on line 962→
if ((fbuf[j] = nxtfile(argc, argv, &fname, ohbuf, 1)) != NULL((void *)0)) {
19
←
Taking false branch→
   rc[j] = NORMAL0;
   j++;
}
  }

  /*
   * if no files, exit
   */
  if (j21.1
'j' is 0
)
22
←
Taking false branch→
clcnt = j;
  else
goto out;
23
←
Control jumps to line 1116→

  /*
   * calculate page boundaries based on open file count
   */
  if (nmwd) {
colwd = (pgwd - clcnt - nmwd)/clcnt;
pgwd = ((colwd + 1) * clcnt) - nmwd - 2;
  } else {
colwd = (pgwd + 1 - clcnt)/clcnt;
pgwd = ((colwd + 1) * clcnt) - 1;
  }
  if (colwd < 1) {
ferrout("pr: page width too small for %d columns\n", clcnt);
goto out;
  }
  col = colwd + 1;

  /*
   * line buffer
   */
  if ((buf = malloc((unsigned)pgwd + offst + 1)) == NULL((void *)0))
goto oomem;

  if (offst) {
(void)memset(buf, (int)' ', offst);
(void)memset(hbuf, (int)' ', offst);
  }

  pagecnt = 0;
  lncnt = 0;
  actf = clcnt;

  /*
   * continue to loop while any file still has data
   */
  while (actf > 0) {

/*
* loop on "form"
*/
for (;;) {

   /*
    * loop by line
    */
   for (i = 0; i < lines; ++i) {
ptbf = buf + offst;
lstdat = ptbf;
if (nmwd) {
    /*
     * add line number to line
     */
    addnum(ptbf, nmwd, ++lncnt);
    ptbf += nmwd;
    *ptbf++ = nmchar;
}

fproc = 0;
/*
 * loop by column
 */
for (j = 0; j < clcnt; ++j) {
    if (rc[j] == NORMAL0 ) {
	rc[j] = inln(fbuf[j], ptbf, colwd, &cnt, &cps, 1, &mor);
	if (cnt >= 0) {
	    /*
	     * process file data
	     */
	    ptbf += cnt;
	    lstdat = ptbf;
	    fproc++;
	} else
	    cnt = 0;
	
	if (rc[j] == END-1) {
	    /*
	     * EOF close file
	     */
	    if (fbuf[j] != stdin(&__sF[0]))
		(void)fclose(fbuf[j]);
	    --actf;
	}
    } else
	cnt = 0;

    /*
     * if last ACTIVE column, done with line
     */
    if (fproc >= actf)
	break;

    /*
     * pad to end of column
     */
    if (sflag) {
	*ptbf++ = schar;
    } else {
	if (cnt >= 0)
	    pln = col - cnt;
	else
	    pln = col;
	if (pln > 0) {
	    (void)memset(ptbf, (int)' ', pln);
	    ptbf += pln;
	}
    }
}

/*
 * if there was anything to do, print it
 */
if (fproc != 0) {
    if (!i && prhead(hbuf, fname, ++pagecnt))
	goto out;

    /*
     * output line
     */
    if (otln(buf, lstdat-buf, &ips, &ops, 0))
	goto out;
} else
    break;
   }

   /*
    * pad to end of page
    */
   if (prtail(lines - i, 0))
return(1);

   for (j = 0; j < clcnt; ++j)
if (rc[j] != END-1)
    rc[j] = NORMAL0;

   if (actf <= 0)
break;
}
if (actf <= 0)
break;
  }
  if (eoptind < argc){
goto out;
  } else {
error = 0;
goto out;
  }

1113oomem:
mfail();
1115out:
  if (fbuf) {
24
←
Potential leak of memory pointed to by 'rc'
for (j = 0; j < clcnt; j++) {
   if (fbuf[j] && fbuf[j] != stdin(&__sF[0]))
(void)fclose(fbuf[j]);
}
free(fbuf);
  }
  free(hbuf);
  free(buf);
  return error;
1126}

1128/*
* inln():    input a line of data (unlimited length lines supported)
*        Input is optionally expanded to spaces
*        Returns 0 if normal LF, FORM on Formfeed, and END on EOF
*
*    inf:    file
*    buf:    buffer
*    lim:    buffer length
*    cnt:    line length or -1 if no line (EOF for example)
*    cps:    column position 1st char in buffer (large line support)
*    trnc:    throw away data more than lim up to \n 
*    mor:    set if more data in line (not truncated)
*/
1141int
1142inln(FILE *inf, char *buf, int lim, int *cnt, int *cps, int trnc, int *mor)
1143{
  int col;
  int gap = ingap;
  int ch = -1;
  char *ptbuf;
  int chk = (int)inchar;

  ptbuf = buf;

  if (gap) {
/*
* expanding input option
*/
while ((--lim >= 0) && ((ch = getc(inf)(!__isthreaded ? (--(inf)->_r < 0 ? __srget(inf) : (int
)(*(inf)->_p++)) : (getc)(inf))) != EOF(-1))) {
   /*
    * is this the input "tab" char
    */
   if (ch == chk) {
/*
 * expand to number of spaces
 */
col = (ptbuf - buf) + *cps;
col = gap - (col % gap);

/*
 * if more than this line, push back
 */
if ((col > lim) && (ungetc(ch, inf) == EOF(-1))) {
    *cnt = -1;
    return(END-1);    /* shouldn't happen */
}

/*
 * expand to spaces
 */
while ((--col >= 0) && (--lim >= 0))
    *ptbuf++ = ' ';
continue;
   }
   if (ch == '\n' || (inform && ch == INFF'\f'))
break;
   *ptbuf++ = ch;
}
  } else {
/*
* no expansion
*/
while ((--lim >= 0) && ((ch = getc(inf)(!__isthreaded ? (--(inf)->_r < 0 ? __srget(inf) : (int
)(*(inf)->_p++)) : (getc)(inf))) != EOF(-1))) {
   if (ch == '\n' || (inform && ch == INFF'\f'))
break;
   *ptbuf++ = ch;
}
  }
  col = ptbuf - buf;
  if (ch == EOF(-1)) {
*mor = 0;
*cps = 0;
*cnt = col ? col : -1;
return(END-1);
  }
  if (inform && ch == INFF'\f') {
*mor = 0;
*cps = 0;
*cnt = col;
return(FORM1);
  }
  if (ch == '\n') {
/*
* entire line processed
*/
*mor = 0;
*cps = 0;
*cnt = col;
return(NORMAL0);
  }

  /*
   * line was larger than limit
   */
  if (trnc) {
/*
* throw away rest of line
*/
while ((ch = getc(inf)(!__isthreaded ? (--(inf)->_r < 0 ? __srget(inf) : (int
)(*(inf)->_p++)) : (getc)(inf))) != EOF(-1)) {
   if (ch == '\n')
break;
}
*cps = 0;
*mor = 0;
  } else {
/*
* save column offset if not truncated
*/
*cps += col;
*mor = 1;
  }

  *cnt = col;
  return(NORMAL0);
1242}

1244/*
* otln():    output a line of data. (Supports unlimited length lines)
*        output is optionally contracted to tabs
*
*    buf:    output buffer with data
*    cnt:    number of chars of valid data in buf
*    svips:    buffer input column position (for large lines)
*    svops:    buffer output column position (for large lines)
*    mor:    output line not complete in this buf; more data to come.    
*        1 is more, 0 is complete, -1 is no \n's
*/
1255int
1256otln(char *buf, int cnt, int *svips, int *svops, int mor)
1257{
  int ops;        /* last col output */
  int ips;        /* last col in buf examined */
  int gap = ogap;
  int tbps;
  char *endbuf;

  /* skipping is only changed at header time not mid-line! */
  if (skipping)
return (0);

  if (ogap) {
/*
* contracting on output
*/
endbuf = buf + cnt;
ops = *svops;
ips = *svips;
while (buf < endbuf) {
   /*
    * count number of spaces and ochar in buffer
    */
   if (*buf == ' ') {
++ips;
++buf;
continue;
   }

   /*
    * simulate ochar processing
    */
   if (*buf == ochar) {
ips += gap - (ips % gap);
++buf;
continue;
   }

   /*
    * got a non space char; contract out spaces
    */
   while (ops < ips) {
/*
 * use one space if necessary
 */
if (ips - ops == 1) {
	putchar(' ')(!__isthreaded ? __sputc(' ', (&__sF[1])) : (putc)(' ', (
&__sF[1])));
	break;
}
/*
 * use as many ochar as will fit
 */
if ((tbps = ops + gap - (ops % gap)) > ips)
    break;
if (putchar(ochar)(!__isthreaded ? __sputc(ochar, (&__sF[1])) : (putc)(ochar
, (&__sF[1]))) == EOF(-1)) {
    pfail();
    return(1);
}
ops = tbps;
   }

   while (ops < ips) {
/*
 * finish off with spaces
 */
if (putchar(' ')(!__isthreaded ? __sputc(' ', (&__sF[1])) : (putc)(' ', (
&__sF[1]))) == EOF(-1)) {
    pfail();
    return(1);
}
++ops;
   }

   /*
    * output non space char
    */
   if (putchar(*buf++)(!__isthreaded ? __sputc(*buf++, (&__sF[1])) : (putc)(*buf
++, (&__sF[1]))) == EOF(-1)) {
pfail();
return(1);
   }
   ++ips;
   ++ops;
}

if (mor > 0) {
   /*
    * if incomplete line, save position counts
    */
   *svops = ops;
   *svips = ips;
   return(0);
}

if (mor < 0) {
   while (ops < ips) {
/*
 * use one space if necessary
 */
if (ips - ops == 1) {
	putchar(' ')(!__isthreaded ? __sputc(' ', (&__sF[1])) : (putc)(' ', (
&__sF[1])));
	break;
}
/*
 * use as many ochar as will fit
 */
if ((tbps = ops + gap - (ops % gap)) > ips)
    break;
if (putchar(ochar)(!__isthreaded ? __sputc(ochar, (&__sF[1])) : (putc)(ochar
, (&__sF[1]))) == EOF(-1)) {
    pfail();
    return(1);
}
ops = tbps;
   }

   while (ops < ips) {
/*
 * finish off with spaces
 */
if (putchar(' ')(!__isthreaded ? __sputc(' ', (&__sF[1])) : (putc)(' ', (
&__sF[1]))) == EOF(-1)) {
    pfail();
    return(1);
}
++ops;
   }
   return(0);
}
  } else {
/*
* output is not contracted
*/
if (cnt && (fwrite(buf, sizeof(char), cnt, stdout(&__sF[1])) < cnt)) {
   pfail();
   return(1);
}
if (mor != 0)
   return(0);
  }

  /*
   * process line end and double space as required
   */
  if ((putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1]))) == EOF(-1)) || (dspace && (putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1]))) == EOF(-1)))) {
pfail();
return(1);
  }
  return(0);
1401}

1403#ifdef notused
1404/*
* inskip():    skip over pgcnt pages with lncnt lines per page
*        file is closed at EOF (if not stdin).
*
*    inf    FILE * to read from
*    pgcnt    number of pages to skip
*    lncnt    number of lines per page
*/
1412int
1413inskip(FILE *inf, int pgcnt, int lncnt)
1414{
  int c;
  int cnt;

  while(--pgcnt > 0) {
cnt = lncnt;
while ((c = getc(inf)(!__isthreaded ? (--(inf)->_r < 0 ? __srget(inf) : (int
)(*(inf)->_p++)) : (getc)(inf))) != EOF(-1)) {
   if ((c == '\n') && (--cnt == 0))
break;
}
if (c == EOF(-1)) {
   if (inf != stdin(&__sF[0]))
(void)fclose(inf);
   return(1);
}
  }
  return(0);
1431}
1432#endif

1434/*
* nxtfile:    returns a FILE * to next file in arg list and sets the
*        time field for this file (or current date).
*
*    buf    array to store proper date for the header.
*    dt    if set skips the date processing (used with -m)
*/
1441FILE *
1442nxtfile(int argc, char *argv[], char **fname, char *buf, int dt)
1443{
  FILE *inf = NULL((void *)0);
  struct tm *timeptr = NULL((void *)0);
  struct stat statbuf;
  time_t curtime;
  static int twice = -1;

  ++twice;
  if (eoptind >= argc) {
/*
* no file listed; default, use standard input
*/
if (twice)
   return(NULL((void *)0));
clearerr(stdin)(!__isthreaded ? ((void)(((&__sF[0]))->_flags &= ~
(0x0040|0x0020))) : (clearerr)((&__sF[0])));
inf = stdin(&__sF[0]);
if (header != NULL((void *)0))
   *fname = header;
else
   *fname = FNAME"";
if (nohead)
   return(inf);
curtime = time(NULL((void *)0));
timeptr = localtime(&curtime);
  }
  for (; eoptind < argc; ++eoptind) {
if (strcmp(argv[eoptind], "-") == 0) {
   /*
    * process a "-" for filename
    */
   clearerr(stdin)(!__isthreaded ? ((void)(((&__sF[0]))->_flags &= ~
(0x0040|0x0020))) : (clearerr)((&__sF[0])));
   inf = stdin(&__sF[0]);
   if (header != NULL((void *)0))
*fname = header;
   else
*fname = FNAME"";
   ++eoptind;
   if (nohead || (dt && twice))
return(inf);
   curtime = time(NULL((void *)0));
   timeptr = localtime(&curtime);
} else {
   /*
    * normal file processing
    */
   if ((inf = fopen(argv[eoptind], "r")) == NULL((void *)0)) {
++errcnt;
if (nodiag)
    continue;
ferrout("pr: Cannot open %s, %s\n",
    argv[eoptind], strerror(errno(*__errno())));
continue;
   }
   if (header != NULL((void *)0))
*fname = header;
   else if (dt)
*fname = FNAME"";
   else
*fname = argv[eoptind];
   ++eoptind;
   if (nohead || (dt && twice))
return(inf);

   if (dt) {
curtime = time(NULL((void *)0));
timeptr = localtime(&curtime);
   } else {
if (fstat(fileno(inf)(!__isthreaded ? ((inf)->_file) : (fileno)(inf)), &statbuf) == -1) {
    ++errcnt;
    (void)fclose(inf);
    ferrout("pr: Cannot stat %s, %s\n",
	argv[eoptind], strerror(errno(*__errno())));
    return(NULL((void *)0));
}
timeptr = localtime(&(statbuf.st_mtimest_mtim.tv_sec));
   }
}
break;
  }
  if (inf == NULL((void *)0))
return(NULL((void *)0));

  /*
   * set up time field used in header
   */
  if (strftime(buf, HDBUF512, TIMEFMT"%b %e %H:%M %Y", timeptr) == 0) {
++errcnt;
if (inf != stdin(&__sF[0]))
   (void)fclose(inf);
ferrout("pr: time conversion failed\n");
return(NULL((void *)0));
  }
  return(inf);
1536}

1538/*
* addnum():    adds the line number to the column
*        Truncates from the front or pads with spaces as required.
*        Numbers are right justified.
*
*    buf    buffer to store the number
*    wdth    width of buffer to fill
*    line    line number
*
*        NOTE: numbers occupy part of the column. The posix
*        spec does not specify if -i processing should or should not
*        occur on number padding. The spec does say it occupies
*        part of the column. The usage of addnum    currently treats
*        numbers as part of the column so spaces may be replaced.
*/
1553void
1554addnum(char *buf, int wdth, int line)
1555{
  char *pt = buf + wdth;

  do {
*--pt = digs[line % 10];
line /= 10;
  } while (line && (pt > buf));

  /*
   * pad with space as required
   */
  while (pt > buf)
*--pt = ' ';
1568}

1570/*
* prhead():    prints the top of page header
*
*    buf    buffer with time field (and offset)
*    cnt    number of chars in buf
*    fname    fname field for header
*    pagcnt    page number
*
* prhead() should be used carefully, we don't want to print out headers
* for null input files or orphan headers at the end of files, and also
* trailer processing is typically conditional on whether you've called
* prhead() at least once for a file and incremented pagecnt.  Exactly
* how to determine whether to print a header is a little different in
* the context each output mode, but we let the caller figure that out.
*/
1585int
1586prhead(char *buf, char *fname, int pagcnt)
1587{
  int ips = 0;
  int ops = 0;

  beheaded = 1;

  if (skipping && pagcnt >= pgnm)
skipping = 0;

  if (nohead || skipping)
return (0);

  if ((putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1]))) == EOF(-1)) || (putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1]))) == EOF(-1))) {
pfail();
return(1);
  }
  /*
   * posix is not clear if the header is subject to line length
   * restrictions. The specification for header line format
   * in the spec clearly does not limit length. No pr currently
   * restricts header length. However if we need to truncate in
   * an reasonable way, adjust the length of the printf by
   * changing HDFMT to allow a length max as an argument printf.
   * buf (which contains the offset spaces and time field could
   * also be trimmed
   *
   * note only the offset (if any) is processed for tab expansion
   */
  if (offst && otln(buf, offst, &ips, &ops, -1))
return(1);
  (void)printf(HDFMT"%s %s Page %d\n\n\n",buf+offst, fname, pagcnt);
  return(0);
1619}

1621/*
* prtail():    pad page with empty lines (if required) and print page trailer
*        if requested
*
*    cnt    	number of lines of padding needed
*    incomp    was a '\n' missing from last line output
*
* prtail() can now be invoked unconditionally, with the notion that if
* we haven't printed a header, there is no need for a trailer
*/
1631int
1632prtail(int cnt, int incomp)
1633{
  /*
   * if were's skipping to page N or haven't put out anything yet just exit
   */
  if (skipping || beheaded == 0)
return (0);
  beheaded = 0;

  /*
   * if noheaders, only terminate an incomplete last line
   */
  if (nohead) {

if (incomp) {
   if (dspace)
if (putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1]))) == EOF(-1)) {
    pfail();
    return(1);
}
   if (putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1]))) == EOF(-1)) {
pfail();
return(1);
    }
}
/*
* but honor the formfeed request
*/
if (formfeed)
   if (putchar(OUTFF)(!__isthreaded ? __sputc('\f', (&__sF[1])) : (putc)('\f',
 (&__sF[1]))) == EOF(-1)) {
pfail();
return(1);
   }

  } else {

/*
* if double space output two \n
*
	 * XXX this all seems bogus, why are we doing it here???
* page length is in terms of output lines and only the input is
* supposed to be double spaced...  otln() users should be doing
* something like linect+=(dspace ? 2:1).
*/
if (dspace)
   cnt *= 2;

/*
* if an odd number of lines per page, add an extra \n
*/
if (addone)
   ++cnt;

/*
* either put out a form-feed or pad page with blanks
*/
if (formfeed) {
   if (incomp)
if (putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1]))) == EOF(-1)) {
    pfail();
    return(1);
}
   if (putchar(OUTFF)(!__isthreaded ? __sputc('\f', (&__sF[1])) : (putc)('\f',
 (&__sF[1]))) == EOF(-1)) {
    pfail();
    return(1);
   }

} else {

   if (incomp)
cnt++;

   cnt += TAILLEN5;
   while (--cnt >= 0) {
if (putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1]))) == EOF(-1)) {
    pfail();
    return(1);
}
   }
}
  }

  return(0);
1715}

1717/*
* terminate():    when a SIGINT is recvd
*/
1720/*ARGSUSED*/
1721void
1722terminate(int which_sig)
1723{
  flsh_errs();
  _exit(1);
1726}

1728void
1729mfail(void)
1730{
  ferrout("pr: memory allocation failed\n");
1732}

1734void
1735pfail(void)
1736{
  ferrout("pr: write failure, %s\n", strerror(errno(*__errno())));
1738}

1740void
1741usage(void)
1742{
  ferrout(
   "usage: pr [+page] [-column] [-adFfmrt] [-e[char][gap]] [-h header]\n");
  ferrout(
   "\t[-i[char][gap]] [-l lines] [-n[char][width]] [-o offset] [-s[char]]\n");
  ferrout(
   "\t[-w width] [file ...]\n");
1749}

1751/*
* setup:    Validate command args, initialize and perform sanity 
*        checks on options
*/
1755int
1756setup(int argc, char *argv[])
1757{
  int c;
  int eflag = 0;
  int iflag = 0;
  int wflag = 0;
  int cflag = 0;
  const char *errstr;

  if (isatty(fileno(stdout)(!__isthreaded ? (((&__sF[1]))->_file) : (fileno)((&
__sF[1])))))
ferr = 1;

  while ((c = egetopt(argc, argv, "#adfFmrte?h:i?l:n?o:s?w:")) != -1) {
switch (c) {
case '+':
   pgnm = strtonum(eoptarg, 1, INT_MAX2147483647, &errstr);
   if (errstr) {
ferrout("pr: +page number is %s: %s\n", errstr, eoptarg);
return(1);
   }
   skipping = 1;
   break;
case '-':
   clcnt = strtonum(eoptarg, 1, INT_MAX2147483647, &errstr);
   if (errstr) {
ferrout("pr: -columns number is %s: %s\n", errstr, eoptarg);
return(1);
   }
   if (clcnt > 1)
cflag = 1;
   break;
case 'a':
   across = 1;
   break;
case 'd':
   dspace = 1;
   break;
case 'e':
   eflag = 1;
   if ((eoptarg != NULL((void *)0)) && !isdigit((unsigned char)*eoptarg))
inchar = *eoptarg++;
   else
inchar = INCHAR'\t';
   if ((eoptarg != NULL((void *)0)) && isdigit((unsigned char)*eoptarg)) {
ingap = strtonum(eoptarg, 0, INT_MAX2147483647, &errstr);
if (errstr) {
    ferrout("pr: -e gap is %s: %s\n", errstr, eoptarg);
    return(1);
}
if (ingap == 0)
    ingap = INGAP8;
   } else if ((eoptarg != NULL((void *)0)) && (*eoptarg != '\0')) {
ferrout("pr: invalid value for -e %s\n", eoptarg);
return(1);
   } else
ingap = INGAP8;
   break;
case 'f':
case 'F':
   formfeed = 1;
   break;
case 'h':
   header = eoptarg;
   break;
case 'i':
   iflag = 1;
   if ((eoptarg != NULL((void *)0)) && !isdigit((unsigned char)*eoptarg))
ochar = *eoptarg++;
   else
ochar = OCHAR'\t';
   if ((eoptarg != NULL((void *)0)) && isdigit((unsigned char)*eoptarg)) {
ogap = strtonum(eoptarg, 0, INT_MAX2147483647, &errstr);
if (errstr) {
    ferrout("pr: -i gap is %s: %s\n", errstr, eoptarg);
    return(1);
}
if (ogap == 0)
    ogap = OGAP8;
   } else if ((eoptarg != NULL((void *)0)) && (*eoptarg != '\0')) {
ferrout("pr: invalid value for -i %s\n", eoptarg);
return(1);
   } else
ogap = OGAP8;
   break;
case 'l':
   lines = strtonum(eoptarg, 1, INT_MAX2147483647, &errstr);
   if (errstr) {
ferrout("pr: number of lines is %s: %s\n", errstr, eoptarg);
return(1);
   }
   break;
case 'm':
   merge = 1;
   break;
case 'n':
   if ((eoptarg != NULL((void *)0)) && !isdigit((unsigned char)*eoptarg))
nmchar = *eoptarg++;
   else
nmchar = NMCHAR'\t';
   if ((eoptarg != NULL((void *)0)) && isdigit((unsigned char)*eoptarg)) {
nmwd = strtonum(eoptarg, 1, INT_MAX2147483647, &errstr);
if (errstr) {
    ferrout("pr: -n width is %s: %s\n", errstr, eoptarg);
    return(1);
}
   } else if ((eoptarg != NULL((void *)0)) && (*eoptarg != '\0')) {
ferrout("pr: invalid value for -n %s\n", eoptarg);
return(1);
   } else
nmwd = NMWD5;
   break;
case 'o':
   offst = strtonum(eoptarg, 1, INT_MAX2147483647, &errstr);
   if (errstr) {
ferrout("pr: -o offset is %s: %s\n", errstr, eoptarg);
return(1);
   }
   break;
case 'r':
   nodiag = 1;
   break;
case 's':
   sflag = 1;
   if (eoptarg == NULL((void *)0))
schar = SCHAR'\t';
   else {
schar = *eoptarg++;
if (*eoptarg != '\0') {
    ferrout("pr: invalid value for -s %s\n", eoptarg);
    return(1);
}
   }
   break;
case 't':
   nohead = 1;
   break;
case 'w':
   wflag = 1;
   pgwd = strtonum(eoptarg, 1, INT_MAX2147483647, &errstr);
   if (errstr) {
ferrout("pr: -w width is %s: %s\n", errstr, eoptarg);
return(1);
   }
   break;
default:
   return(1);
}
  }

  /*
   * default and sanity checks
   */
  inform++;

  if (!clcnt) {
if (merge) {
   if ((clcnt = argc - eoptind) <= 1) {
clcnt = CLCNT1;
1914#ifdef stupid
merge = 0;
1916#endif
   }
} else
   clcnt = CLCNT1;
  }
  if (across) {
if (clcnt == 1) {
   ferrout("pr: -a flag requires multiple columns\n");
   return(1);
}
if (merge) {
   ferrout("pr: -m cannot be used with -a\n");
   return(1);
}
  }
  if (!wflag) {
if (sflag)
   pgwd = SPGWD512;
else
   pgwd = PGWD72;
  }
  if (cflag || merge) {
if (!eflag) {
   inchar = INCHAR'\t';
   ingap = INGAP8;
}
if (!iflag) {
   ochar = OCHAR'\t';
   ogap = OGAP8;
}
  }
  if (cflag) {
if (merge) {
   ferrout("pr: -m cannot be used with multiple columns\n");
   return(1);
}
if (nmwd) {
   colwd = (pgwd + 1 - (clcnt * (nmwd + 2)))/clcnt;
   pgwd = ((colwd + nmwd + 2) * clcnt) - 1;
} else {
   colwd = (pgwd + 1 - clcnt)/clcnt;
   pgwd = ((colwd + 1) * clcnt) - 1;
}
if (colwd < 1) {
   ferrout("pr: page width is too small for %d columns\n",clcnt);
   return(1);
}
  }
  if (!lines)
lines = LINES66;

  /*
   * make sure long enough for headers. if not disable
   */
  if (lines <= HEADLEN5 + TAILLEN5)
nohead = 1;
  else if (!nohead)
lines -= HEADLEN5 + TAILLEN5;

  /*
   * adjust for double space on odd length pages
   */
  if (dspace) {
if (lines == 1)
   dspace = 0;
else {
   if (lines & 1)
++addone;
   lines /= 2;
}
  }

  return(0);
1989}