/*	$OpenBSD: main.c,v 1.33 2016/07/14 08:31:18 semarie Exp $	*/

/*-

 * Copyright (c) 1992 Diomidis Spinellis.

 * Copyright (c) 1992, 1993

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

 *

 * This code is derived from software contributed to Berkeley by

 * Diomidis Spinellis of Imperial College, University of London.

 *

 * 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 <sys/types.h>

#include <sys/ioctl.h>

#include <sys/stat.h>

#include <ctype.h>

#include <errno.h>

#include <fcntl.h>

#include <limits.h>

#include <regex.h>

#include <stddef.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <libgen.h>

#include "defs.h"

#include "extern.h"

/*

 * Linked list of units (strings and files) to be compiled

 */

struct s_compunit {

	struct s_compunit *next;

	enum e_cut {CU_FILE, CU_STRING} type;

	char *s;			/* Pointer to string or fname */

};

/*

 * Linked list pointer to compilation units and pointer to current

 * next pointer.

 */

static struct s_compunit *script, **cu_nextp = &script;

/*

 * Linked list of files to be processed

 */

struct s_flist {

	char *fname;

	struct s_flist *next;

};

/*

 * Linked list pointer to files and pointer to current

 * next pointer.

 */

static struct s_flist *files, **fl_nextp = &files;

FILE *infile;			/* Current input file */

FILE *outfile;			/* Current output file */

int Eflag, aflag, eflag, nflag;

static int rval;	/* Exit status */

/*

 * Current file and line number; line numbers restart across compilation

 * units, but span across input files.  The latter is optional if editing

 * in place.

 */

const char *fname;		/* File name. */

const char *outfname;		/* Output file name */

static char oldfname[PATH_MAX];	/* Old file name (for in-place editing) */

static char tmpfname[PATH_MAX];	/* Temporary file name (for in-place editing) */

char *inplace;			/* Inplace edit file extension */

u_long linenum;

static void add_compunit(enum e_cut, char *);

static void add_file(char *);

static int next_files_have_lines(void);

int termwidth;

int

main(int argc, char *argv[])

	struct winsize win;

	int c, fflag;

	char *p;

		case 'E':

		case 'r':

		case 'a':

		case 'e':

		case 'f':

		case 'i':

		case 'n':

		case 'u':

		default:

		case '?':

			    "usage: sed [-aEnru] [-i[extension]] command [file ...]\n"

			    "       sed [-aEnru] [-e command] [-f command_file] [-i[extension]] [file ...]\n");

		}

	    win.ws_col > 0)

	} else {

	}

	/* First usage case; script is the first arg */

	}

	/* Continue with first and start second usage */

	else

}

/*

 * Like fgets, but go through the chain of compilation units chaining them

 * together.  Empty strings and files are ignored.

 */

char *

cu_fgets(char **outbuf, size_t *outsize)

	static enum {ST_EOF, ST_FILE, ST_STRING} state = ST_EOF;

	static FILE *f;		/* Current open file */

	static char *s;		/* Current pointer inside string */

	static char string_ident[30];

	size_t len;

	char *p;

	case ST_EOF:

		case CU_FILE:

				    "%s: %s", script->s, strerror(errno));

		case CU_STRING:

			    sizeof(string_ident), "\"%s\"", script->s)) >=

			    sizeof(string_ident))

				    sizeof(string_ident) - 6, " ...\"", 5);

		}

	case ST_FILE:

			}

		}

	case ST_STRING:

		for (;;) {

				    *outsize + _POSIX2_LINE_MAX);

			}

			case '\0':

				} else {

				}

			case '\n':

			default:

			}

	}

	/* NOTREACHED */

}

/*

 * Like fgets, but go through the list of files chaining them together.

 * Set len to the length of the line.

 */

int

mf_fgets(SPACE *sp, enum e_spflag spflag)

	struct stat sb;

	size_t len;

	char *p;

	int c, fd;

	static int firstfile;

		/* stdin? */

		}

	}

	for (;;) {

			break;

		}

		/* If we are here then either eof or no files are open yet */

		}

				}

			}

			}

		}

		else

		}

				    strerror(errno ? errno : EIO));

				    "in-place editing only",

				    "works for regular files");

				    sizeof(oldfname));

				    sizeof(oldfname));

			}

			    dirname(fname));

			}

		} else {

		}

		}

	}

	/*

	 * We are here only when infile is open and we still have something

	 * to read from it.

	 *

	 * Use fgetln so that we can handle essentially infinite input data.

	 * Can't use the pointer into the stdio buffer as the process space

	 * because the ungetc() can cause it to move.

	 */

	} else {

	}

}

/*

 * Add a compilation unit to the linked list

 */

static void

add_compunit(enum e_cut type, char *s)

	struct s_compunit *cu;

/*

 * Add a file to the linked list

 */

static void

add_file(char *s)

	struct s_flist *fp;

static int

next_files_have_lines()

	struct s_flist *file;

	FILE *file_fd;

	int ch;

			/*

			 * This next file has content, therefore current

			 * file doesn't contains the last line.

			 */

		}

	}

}

int

lastline(void)

	int ch;

		    (inplace == NULL) &&

		    next_files_have_lines());

	}

		    (inplace == NULL) &&

		    next_files_have_lines());

	}

}