/*	$OpenBSD: sdiff.c,v 1.36 2015/12/29 19:04:46 gsoares Exp $ */

/*

 * Written by Raymond Lai <ray@cyth.net>.

 * Public domain.

 */

#include <sys/queue.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <sys/wait.h>

#include <ctype.h>

#include <err.h>

#include <errno.h>

#include <fcntl.h>

#include <getopt.h>

#include <limits.h>

#include <paths.h>

#include <stdint.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <util.h>

#include "common.h"

#include "extern.h"

#define WIDTH 130

/*

 * Each column must be at least one character wide, plus three

 * characters between the columns (space, [<|>], space).

 */

#define WIDTH_MIN 5

/* A single diff line. */

struct diffline {

	SIMPLEQ_ENTRY(diffline) diffentries;

	char	*left;

	char	 div;

	char	*right;

};

static void astrcat(char **, const char *);

static void enqueue(char *, char, char *);

static char *mktmpcpy(const char *);

static void freediff(struct diffline *);

static void int_usage(void);

static int parsecmd(FILE *, FILE *, FILE *);

static void printa(FILE *, size_t);

static void printc(FILE *, size_t, FILE *, size_t);

static void printcol(const char *, size_t *, const size_t);

static void printd(FILE *, size_t);

static void println(const char *, const char, const char *);

static void processq(void);

static void prompt(const char *, const char *);

__dead static void usage(void);

static char *xfgets(FILE *);

SIMPLEQ_HEAD(, diffline) diffhead = SIMPLEQ_HEAD_INITIALIZER(diffhead);

size_t	 line_width;	/* width of a line (two columns and divider) */

size_t	 width;		/* width of each column */

size_t	 file1ln, file2ln;	/* line number of file1 and file2 */

int	 Iflag = 0;	/* ignore sets matching regexp */

int	 lflag;		/* print only left column for identical lines */

int	 sflag;		/* skip identical lines */

FILE	*outfp;		/* file to save changes to */

const char *tmpdir;	/* TMPDIR or /tmp */

static struct option longopts[] = {

	{ "text",			no_argument,		NULL,	'a' },

	{ "ignore-blank-lines",		no_argument,		NULL,	'B' },

	{ "ignore-space-change",	no_argument,		NULL,	'b' },

	{ "minimal",			no_argument,		NULL,	'd' },

	{ "ignore-tab-expansion",	no_argument,		NULL,	'E' },

	{ "diff-program",		required_argument,	NULL,	'F' },

	{ "speed-large-files",		no_argument,		NULL,	'H' },

	{ "ignore-matching-lines",	required_argument,	NULL,	'I' },

	{ "ignore-case",		no_argument,		NULL,	'i' },

	{ "left-column",		no_argument,		NULL,	'l' },

	{ "output",			required_argument,	NULL,	'o' },

	{ "strip-trailing-cr",		no_argument,		NULL,	'S' },

	{ "suppress-common-lines",	no_argument,		NULL,	's' },

	{ "expand-tabs",		no_argument,		NULL,	't' },

	{ "ignore-all-space",		no_argument,		NULL,	'W' },

	{ "width",			required_argument,	NULL,	'w' },

	{ NULL,				0,			NULL,	 0  }

};

/*

 * Create temporary file if source_file is not a regular file.

 * Returns temporary file name if one was malloced, NULL if unnecessary.

 */

static char *

mktmpcpy(const char *source_file)

{

	struct stat sb;

	ssize_t rcount;

	int ifd, ofd;

	u_char buf[BUFSIZ];

	char *target_file;

	/* Open input and output. */

	/* File was opened successfully. */

		/* Regular file. */

		}

	} else {

		/* If ``-'' does not exist the user meant stdin. */

		else

	}

	/* Not a regular file, so copy input into temporary file. */

	}

	    rcount != 0) {

		ssize_t wcount;

		}

	}

	}

}

int

main(int argc, char **argv)

{

	FILE *diffpipe, *file1, *file2;

	int ch, fd[2], status;

	pid_t pid;

	    *tmp1, *tmp2, *s1, *s2;

	/*

	 * Process diff flags.

	 */

	/*

	 * Allocate memory for diff arguments and NULL.

	 * Each flag has at most one argument, so doubling argc gives an

	 * upper limit of how many diff args can be passed.  argv[0],

	 * file1, and file2 won't have arguments so doubling them will

	 * waste some memory; however we need an extra space for the

	 * NULL at the end, so it sort of works out.

	 */

	/* Add first argument, the program name. */

	    longopts, NULL)) != -1) {

		const char *errstr;

		case 'a':

		case 'B':

		case 'b':

		case 'd':

		case 'E':

		case 'F':

		case 'H':

		case 'I':

		case 'i':

		case 'l':

		case 'o':

		case 'S':

		case 's':

		case 't':

		case 'W':

		case 'w':

			    INT_MAX, &errstr);

			break;

		default:

		}

	}

	/*

	 * Create temporary files for diff and sdiff to share if file1

	 * or file2 are not regular files.  This allows sdiff and diff

	 * to read the same inputs if one or both inputs are stdin.

	 *

	 * If any temporary files were created, their names would be

	 * saved in tmp1 or tmp2.  tmp1 should never equal tmp2.

	 */

	/* file1 and file2 are the same, so copy to same temp file. */

	/* Copy file1 and file2 into separate temp files. */

	} else {

	}

	/* Add NULL to end of array to indicate end of array. */

	/* Subtract column divider and divide by two. */

	/* Make sure line_width can fit in size_t. */

	case 0:

		/* child */

		/* We don't read from the pipe. */

		/* Free unused descriptor. */

	case -1:

	}

	/* parent */

	/* We don't write to the pipe. */

	/* Open pipe to diff command. */

	/* Line numbers start at one. */

	/* Read and parse diff output. */

		;

	/* Wait for diff to exit. */

	    WEXITSTATUS(status) >= 2)

	/* Delete and free unneeded temporary files. */

	/* No more diffs, so print common lines. */

	else

		for (;;) {

			else

		}

	/* Process unmodified lines. */

	/* Return diff exit status. */

}

/*

 * Prints an individual column (left or right), taking into account

 * that tabs are variable-width.  Takes a string, the current column

 * the cursor is on the screen, and the maximum value of the column.

 * The column value is updated as we go along.

 */

static void

printcol(const char *s, size_t *col, const size_t col_max)

{

		size_t new_col;

		case '\t':

			/*

			 * If rounding to next multiple of eight causes

			 * an integer overflow, just return.

			 */

			/* Round to next multiple of eight. */

			/*

			 * If printing the tab goes past the column

			 * width, don't print it and just quit.

			 */

		default:

		}

	}

}

/*

 * Prompts user to either choose between two strings or edit one, both,

 * or neither.

 */

static void

prompt(const char *s1, const char *s2)

{

	char *cmd;

	/* Print command prompt. */

	/* Get user input. */

		const char *p;

		/* Skip leading whitespace. */

			;

		case 'e':

			/* Skip `e'. */

			break;

		case 'l':

		case '1':

			/* Choose left column as-is. */

			/* End of command parsing. */

			break;

		case 'q':

			goto QUIT;

		case 'r':

		case '2':

			/* Choose right column as-is. */

			/* End of command parsing. */

			break;

		case 's':

		case 'v':

			/* FALLTHROUGH */

		default:

			/* Interactive usage help. */

			/* Prompt user again. */

			continue;

		}

		return;

	}

	/*

	 * If there was no error, we received an EOF from stdin, so we

	 * should quit.

	 */

}

/*

 * Takes two strings, separated by a column divider.  NULL strings are

 * treated as empty columns.  If the divider is the ` ' character, the

 * second column is not printed (-l flag).  In this case, the second

 * string must be NULL.  When the second column is NULL, the divider

 * does not print the trailing space following the divider character.

 *

 * Takes into account that tabs can take multiple columns.

 */

static void

println(const char *s1, const char div, const char *s2)

{

	size_t col;

	/* Print first column.  Skips if s1 == NULL. */

		/* Skip angle bracket and space. */

	}

	/* Only print left column. */

		return;

	}

	/* Otherwise, we pad this column up to width. */

	/*

	 * Print column divider.  If there is no second column, we don't

	 * need to add the space for padding.

	 */

	}

	/* Skip angle bracket and space. */

}

/*

 * Reads a line from file and returns as a string.  If EOF is reached,

 * NULL is returned.  The returned string must be freed afterwards.

 */

static char *

xfgets(FILE *file)

{

	char *s;

	/* XXX - Is this necessary? */

	    ferror(file))

	}

}

/*

 * Parse ed commands from diffpipe and print lines from file1 (lines

 * to change or delete) or file2 (lines to add or change).

 * Returns EOF or 0.

 */

static int

parsecmd(FILE *diffpipe, FILE *file1, FILE *file2)

{

	size_t file1start, file1end, file2start, file2end, n;

	/* ed command line and pointer to characters in line */

	char *line, *p, *q;

	const char *errstr;

	char c, cmd;

	/* Read ed command. */

	/* Go to character after line number. */

	/* A range is specified for file1. */

		/* Go to character after file2end. */

	} else

	/* Check that cmd is valid. */

	/* Go to character after line number. */

	/*

	 * There should either be a comma signifying a second line

	 * number or the line should just end here.

	 */

	} else

	/* Appends happen _after_ stated line. */

			    line);

	}

	/*

	 * I'm not sure what the deal is with the line numbers for

	 * deletes, though.

	 */

			    line);

	}

	/*

	 * Continue reading file1 and file2 until we reach line numbers

	 * specified by diff.  Should only happen with -I flag.

	 */

		char *s1, *s2;

		/* If the -l flag was specified, print only left column. */

			/*

			 * XXX - If -l and -I are both specified, all

			 * unchanged or ignored lines are shown with a

			 * `(' divider.  This matches GNU sdiff, but I

			 * believe it is a bug.  Just check out:

			 * gsdiff -l -I '^$' samefile samefile.

			 */

			else

		} else

	}

	/* Ignore deleted lines. */

		char *s;

	}

	/* Ignore added lines. */

		char *s;

		/* If -l flag was given, don't print right column. */

		else

	}

	/* Process unmodified or skipped lines. */

	case 'a':

	case 'c':

	case 'd':

	default:

	}

	/* Skip to next ed line. */

	}

}

/*

 * Queues up a diff line.

 */

static void

enqueue(char *left, char div, char *right)

{

	struct diffline *diffp;

}

/*

 * Free a diffline structure and its elements.

 */

static void

freediff(struct diffline *diffp)

{

}

/*

 * Append second string into first.  Repeated appends to the same string

 * are cached, making this an O(n) function, where n = strlen(append).

 */

static void

astrcat(char **s, const char *append)

{

	/* Length of string in previous run. */

	static size_t offset = 0;

	size_t newsiz;

	/*

	 * String from previous run.  Compared to *s to see if we are

	 * dealing with the same string.  If so, we can use offset.

	 */

	static const char *oldstr = NULL;

	char *newstr;

	/*

	 * First string is NULL, so just copy append.

	 */

		/* Keep track of string. */

	}

	/*

	 * *s is a string so concatenate.

	 */

	/* Did we process the same string in the last run? */

	/*

	 * If this is a different string from the one we just processed

	 * cache new string.

	 */

	}

	/* Size = strlen(*s) + \n + strlen(append) + '\0'. */

	/* Resize *s to fit new string. */

	/* *s + offset should be end of string. */

	/* Concatenate. */

	/* New string length should be exactly newsiz - 1 characters. */

	/* Store generated string's values. */

}

/*

 * Process diff set queue, printing, prompting, and saving each diff

 * line stored in queue.

 */

static void

processq(void)

{

	struct diffline *diffp;

	char divc, *left, *right;

	/* Don't process empty queue. */

	/* Remember the divider. */

	/*

	 * Go through set of diffs, concatenating each line in left or

	 * right column into two long strings, `left' and `right'.

	 */

		/*

		 * Print changed lines if -s was given,

		 * print all lines if -s was not given.

		 */

		    diffp->div == '>')

		/* Append new lines to diff set. */

	}

	/* Empty queue and free each diff line and its elements. */

	}

	/* Write to outfp, prompting user if lines are different. */

		case ' ': case '(': case ')':

		case '|': case '<': case '>':

		default:

		}

	/* Free left and right. */

}

/*

 * Print lines following an (a)ppend command.

 */

static void

printa(FILE *file, size_t line2)

{

	char *line;

	}

}

/*

 * Print lines following a (c)hange command, from file1ln to file1end

 * and from file2ln to file2end.

 */

static void

printc(FILE *file1, size_t file1end, FILE *file2, size_t file2end)

{

	struct fileline {

		SIMPLEQ_ENTRY(fileline)	 fileentries;

		char			*line;

	};

	/* Read lines to be deleted. */

		struct fileline *linep;

		char *line1;

		/* Read lines from both. */

		/* Add to delete queue. */

	}

	/* Process changed lines.. */

		struct fileline *del;

		char *add;

		/* Get add line. */

		/*

		 * Free fileline structure but not its elements since

		 * they are queued up.

		 */

	}

	/* Process remaining lines to add. */

		char *add;

		/* Get add line. */

	}

	/* Process remaining lines to delete. */