/*	$OpenBSD: col.c,v 1.19 2015/10/09 01:37:06 deraadt Exp $	*/

/*	$NetBSD: col.c,v 1.7 1995/09/02 05:48:50 jtc Exp $	*/

/*-

 * Copyright (c) 1990, 1993, 1994

 *	The Regents of the University of California.  All rights reserved.

 *

 * This code is derived from software contributed to Berkeley by

 * Michael Rendell of the Memorial University of Newfoundland.

 *

 * 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.

 */

#include <ctype.h>

#include <err.h>

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <limits.h>

#define	BS	'\b'		/* backspace */

#define	TAB	'\t'		/* tab */

#define	SPACE	' '		/* space */

#define	NL	'\n'		/* newline */

#define	CR	'\r'		/* carriage return */

#define	ESC	'\033'		/* escape */

#define	SI	'\017'		/* shift in to normal character set */

#define	SO	'\016'		/* shift out to alternate character set */

#define	VT	'\013'		/* vertical tab (aka reverse line feed) */

/* build up at least this many lines before flushing them out */

#define	BUFFER_MARGIN		32

typedef char CSET;

typedef struct char_str {

#define	CS_NORMAL	1

#define	CS_ALTERNATE	2

	size_t		c_column;	/* column character is in */

	CSET		c_set;		/* character set (currently only 2) */

	char		c_char;		/* character in question */

} CHAR;

typedef struct line_str LINE;

struct line_str {

	CHAR	*l_line;		/* characters on the line */

	LINE	*l_prev;		/* previous line */

	LINE	*l_next;		/* next line */

	size_t	l_lsize;		/* allocated sizeof l_line */

	size_t	l_line_len;		/* strlen(l_line) */

	size_t	l_max_col;		/* max column in the line */

	int	l_needs_sort;		/* set if chars went in out of order */

};

void	addto_lineno(int *, int);

LINE   *alloc_line(void);

void	dowarn(int);

void	flush_line(LINE *);

void	flush_lines(int);

void	flush_blanks(void);

void	free_line(LINE *);

void	usage(void);

void   *xreallocarray(void *, size_t, size_t);

CSET	last_set;		/* char_set of last char printed */

LINE   *lines;

int	compress_spaces;	/* if doing space -> tab conversion */

int	fine;			/* if `fine' resolution (half lines) */

int	max_bufd_lines;		/* max # of half lines to keep in memory */

int	nblank_lines;		/* # blanks after last flushed line */

int	no_backspaces;		/* if not to output any backspaces */

#define	PUTC(ch) \

	if (putchar(ch) == EOF) \

		err(1, "stdout");

int

main(int argc, char *argv[])

{

	int ch;

	CHAR *c;

	CSET cur_set;			/* current character set */

	LINE *l;			/* current line */

	int extra_lines;		/* # of lines above first line */

	size_t cur_col;			/* current column */

	int cur_line;			/* line number of current position */

	int max_line;			/* max value of cur_line */

	int this_line;			/* line l points to */

	int nflushd_lines;		/* number of lines that were flushed */

	int adjust, opt, warned;

	const char *errstr;

		case 'b':		/* do not output backspaces */

		case 'f':		/* allow half forward line feeds */

		case 'h':		/* compress spaces into tabs */

		case 'l':		/* buffered line count */

			    (INT_MAX - BUFFER_MARGIN) / 2, &errstr) * 2;

					optarg);

			break;

		case 'x':		/* do not compress spaces into tabs */

		case '?':

		default:

		}

			case BS:		/* can't go back further */

			case CR:

			case ESC:		/* just ignore EOF */

				/*

				 * In the input stream, accept both the

				 * XPG5 sequences ESC-digit and the

				 * traditional BSD sequences ESC-ctrl.

				 */

				case '7':  /* reverse line feed */

					/* FALLTHROUGH */

				case '\007':

				case '8':  /* reverse half-line feed */

					/* FALLTHROUGH */

				case '\010':

				case '9':  /* forward half-line feed */

					/* FALLTHROUGH */

				case '\011':

				}

				continue;

			case NL:

			case SPACE:

			case SI:

			case SO:

			case TAB:		/* adjust column */

			case VT:

			}

			continue;

		}

		/* Must stuff ch in a line - are we at the right one? */

			LINE *lnew;

			/* round up to next line */

				    l->l_prev != NULL) {

				}

						/*

						 * Allow backup past first

						 * line if nothing has been

						 * flushed yet.

						 */

						    < this_line) {

						}

					} else {

					}

				}

			} else {

				/* may need to allocate here */

					}

				}

			}

			    this_line - nflushd_lines >=

			    max_bufd_lines + BUFFER_MARGIN) {

				}

				    max_bufd_lines);

			}

		}

		/* grow line's buffer? */

			size_t need;

			    need, 2 * sizeof(CHAR));

		}

		/*

		 * If things are put in out of order, they will need sorting

		 * when it is flushed.

		 */

		else

	}

	/* goto the last line that had a character on it */

	/* make sure we leave things in a sane state */

	/* flush out the last few blank lines */

}

void

flush_lines(int nflush)

{

	LINE *l;

		}

	}

}

/*

 * Print a number of newline/half newlines.  If fine flag is set, nblank_lines

 * is the number of half line feeds, otherwise it is the number of whole line

 * feeds.

 */

void

flush_blanks(void)

{

	int half, i, nb;

		else

	}

		/*

		 * In the output stream, always generate

		 * escape sequences conforming to XPG5.

		 */

	}

}

/*

 * Write a line to stdout taking care of space to tab conversion (-h flag)

 * and character set shifts.

 */

void

flush_line(LINE *l)

{

	CHAR *c, *endc;

	size_t nchars, last_col, this_col;

		static CHAR *sorted;

		static size_t count_size, i, sorted_size;

		static int *count, save, tot;

		/*

		 * Do an O(n) sort on l->l_line by column being careful to

		 * preserve the order of characters in the same column.

		 */

			    sorted_size, sizeof(CHAR));

		}

			    count_size, sizeof(int));

		}

		/*

		 * calculate running total (shifted down by 1) to use as

		 * indices into new line.

		 */

		}

	} else

		do {

		/* if -b only print last character */

				size_t ntabs;

				}

			}

		}

		for (;;) {

				case CS_NORMAL:

					break;

				case CS_ALTERNATE:

				}

			}

		}

	}

}

/*

 * Increment or decrement a line number, checking for overflow.

 * Stop one below INT_MAX such that the adjust variable is safe.

 */

void

addto_lineno(int *lno, int offset)

{

	} else {

	}

}

#define	NALLOC 64

static LINE *line_freelist;

LINE *

alloc_line(void)

{

	LINE *l;

	int i;

	}

}

void

free_line(LINE *l)

{

}

void *

xreallocarray(void *p, size_t n, size_t size)

{

}

void

usage(void)

{

}

void

dowarn(int line)

{

		line < 0 ? "past first line" : "-- line already flushed");

}